Skip to content
CAI
Software that uses CAICheck a score

nolabs-ai/nono

71.1

Strong · 14 November 2026

240.6k

lines of production code

Rust

primary language

5

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add automated AUR publishing and COPR source RPM packaging

Users on Arch Linux can now install the pre-built \nono-ai-bin\ package from the Arch User Repository, which is automatically published to the AUR on each upstream release via a new CI workflow. Additionally, Fedora users and maintainers can build source RPMs for COPR using the new \nono-cli.spec.in\ template and helper scripts, enabling reproducible builds from source with offline Cargo dependency vendoring.

packaging · high confidence

Added Linux development container and update-check test server

Developers can now use a dedicated Dockerfile for a consistent Linux development environment and a new Python script to locally simulate the update-check service, enabling easier testing of version discovery and update availability logic without relying on the live server.

tools · high confidence

Declarative OAuth2 credential capture and built-in profile consolidation

Users can now define declarative OAuth2 credential providers in their profiles to capture tokens from specific endpoints and inject them into API requests via configurable headers and formats, with validation ensuring required fields are present. Additionally, built-in profiles like claude-code and opencode are no longer embedded in the binary; they are now resolved from the policy configuration or registry packs, simplifying the built-in profile surface and centralizing profile definitions.

crates/nono-cli/src/profile · high confidence

Expanded Linux sandbox API with ABI-aware Landlock and seccomp fallbacks

The sandbox module now exposes granular control over Linux sandboxing, allowing users to detect the kernel's Landlock ABI version and choose between pure Landlock enforcement or a Landlock-with-seccomp fallback for network restrictions. New methods like \apply\_auto\, \apply\_landlock\, and \apply\_seccomp\ replace the previous single \apply\ entry point, enabling more precise configuration of network and filesystem policies. The module also re-exports low-level primitives for supervisor use, such as \PreparedLandlockSandbox\ for child-safe sandboxing and various seccomp notification helpers, while maintaining macOS Seatbelt extension support.

crates/nono/src/sandbox · high confidence

HTTP/2 support for TLS-intercepted CONNECT routes

The proxy now supports intercepting and forwarding HTTP/2 traffic over CONNECT tunnels. When a client negotiates the \h2\ ALPN protocol, the proxy probes the upstream to confirm HTTP/2 support, then establishes a dedicated HTTP/2 connection to forward requests with per-stream credential injection. This enables full visibility and credential management for gRPC and other HTTP/2 workloads that previously could not be intercepted.

_crates/nono-proxy/src/tls\intercept · high confidence

Initial C FFI bindings for capability-based sandboxing

This change introduces the C Foreign Function Interface (FFI) bindings, allowing C and C++ applications to interact with the nono sandboxing engine. The diff adds the build script and configuration for generating headers via cbindgen, resulting in the new \bindings/c/include/nono.h\ header. This header exposes core sandboxing concepts as C-compatible types, including access modes (read, write, read-write), network modes (blocked, allow-all, proxy-only), and a comprehensive set of error and diagnostic codes. It also defines capability source tags and query result structures, enabling callers to configure sandbox capabilities, execute commands, and inspect permission decisions or errors.

bindings · high confidence

Initial repository scaffolding and contributor guidance

The repository is initialized with essential project infrastructure, including a \.dockerignore\ to exclude build artifacts and IDE files from container contexts, and a \.gitattributes\ file to enforce consistent LF line endings for source and documentation files while preserving CRLF for Windows batch scripts. Additionally, comprehensive contributor documentation is added: \AGENTS.md\ defines security-critical coding standards and architecture boundaries for AI agents, \CONTRIBUTING.md\ outlines the development workflow and commit conventions, \GOVERNANCE.md\ establishes the maintainer council and decision-making processes, and \NOGENT.md\ provides a code review guide focused on security posture. The project also includes standard open-source governance files such as \CODE\_OF\_CONDUCT.md\, \CONTRIBUTORS.md\, \MAINTAINERS.md\, and the Apache 2.0 \LICENSE\.

(repo-wide) · high confidence

Introduce content-addressable undo system with Merkle integrity and exclusion filters

The \crates/nono/src/undo\ module now provides a filesystem snapshot and rollback capability. It captures baseline and incremental snapshots of tracked directories, storing file contents in a content-addressable object store that deduplicates identical files and uses APFS \clonefile()\ for efficient copy-on-write storage. To ensure data integrity, every snapshot computes a Merkle root over file paths and hashes, cryptographically committing to the captured state. The system supports configurable exclusion filters (including \.gitignore\ integration and glob patterns) to omit transient or generated files, and enforces walk budgets to prevent runaway directory traversals during snapshot creation.

crates/nono/src/undo · high confidence

Introduce file attestation and trust policy verification

The trust module now provides a complete pipeline for verifying the provenance and integrity of instruction files. Users can sign files using keyed ECDSA P-256 or keyless Sigstore bundles, and the system will automatically verify these signatures against a configurable trust policy. Policies define trusted publishers, blocklists of malicious digests, and file inclusion patterns, with enforcement modes (Deny, Warn, Audit) to control how violations are handled. The verification process checks file digests against blocklists, validates cryptographic signatures in Sigstore bundles, and matches signer identities against trusted publishers before allowing file consumption.

crates/nono/src/trust · high confidence

Introduce platform-specific tool-sandbox implementations for Linux and macOS

Added new platform-specific source files (linux.rs and macos.rs) under crates/nono-cli/src/tool-sandbox/platform to implement the core tool-sandbox runtime logic. These files provide the concrete execution environment for sandboxed commands, handling process launching, credential resolution, environment variable injection, and IPC protocol communication via Unix sockets. The Linux implementation includes specific handling for Landlock filesystem restrictions and cgroup-based lineage tracking, while the macOS implementation utilizes FFI calls to process information APIs for similar ancestry and identity tracking. This change establishes the foundational platform adapters required for the tool-sandbox feature to operate correctly on supported operating systems.

crates/nono-cli/src/tool-sandbox/platform · high confidence

Introduce structured network audit logging and approval backend routing

The proxy now records structured network audit events for every request, capturing details such as the proxy mode (CONNECT, reverse, or external), authentication mechanism, injection mode, and endpoint policy actions. This audit trail is stored in an in-memory buffer and can be exposed via diagnostics. Additionally, the proxy supports configurable approval backends, allowing endpoint-policy approvals to be routed to named handlers (with a default fallback) rather than using a single hardcoded implementation. Also in this area: OAuth token response capture now supports form-urlencoded bodies and handles upstream connection drops safely.

_crates/nono-proxy/src, crates/nono-proxy/src/oauth\capture · high confidence

Introduce supervised-mode approval backends and durable audit delivery

Users can now configure non-interactive approval backends (webhooks, chains, and platform integrations) for supervised-mode prompts, allowing automated or remote decision-making instead of relying solely on terminal interaction. Additionally, the CLI now features a durable audit delivery system that queues session audit logs to a local outbox and syncs them to a platform endpoint, ensuring audit integrity and availability even if the session ends abruptly or network connectivity is intermittent.

crates/nono-cli/src · high confidence

Introduce supervisor IPC for runtime capability expansion

Added a new supervisor module that enables sandboxed child processes to request additional capabilities (filesystem access, network access, and command execution) from an unsandboxed parent process at runtime. This change introduces a Unix domain socket-based IPC protocol with length-prefixed JSON framing and file descriptor passing via SCM\_RIGHTS, along with peer authentication (UID checks) and configurable approval backends (interactive, webhook, or policy-based) to grant or deny these requests securely.

crates/nono/src/supervisor · high confidence

Introduces core library modules for audit logging, capability manifests, and security hardening

This change adds several foundational modules to the \nono\ library crate. It introduces \audit.rs\ to record append-only, cryptographically chained NDJSON events for sessions, capabilities, and network activity. It adds \manifest.rs\ and \manifest\_convert.rs\ to define and validate capability manifests via JSON Schema and convert them into internal enforcement sets. Security is strengthened with \broker\_path.rs\, which sanitizes the PATH environment for host-side credential brokers to prevent trojan injection, and \net\_filter.rs\, which provides hostname filtering with cloud metadata protection. Additionally, \env\_glob.rs\ provides a shared glob-matching engine for environment variable patterns, \path.rs\ adds robust symlink-aware path canonicalization, and \resource/mod.rs\ defines resource limits for memory and process counts.

crates/nono/src · high confidence

Introduces the tool-sandbox command mediation runtime

Adds the core implementation for the tool-sandbox feature in \crates/nono-cli/src/tool-sandbox\, providing the runtime infrastructure for command mediation on Linux and macOS. This includes the audit context and decision vocabulary for logging, credential resolution (local sockets, raw files, proxies, and ambient credentials), and dynamic path token expansion (e.g., \@git:\*\ tokens for git config paths). The module also handles environment variable management (including \export\_env\ pass-through and proxy override), launch specification preparation, and the IPC protocol between the shim and the supervisor. It establishes the foundation for isolating and mediating specific tool commands within the sandbox.

crates/nono-cli/src/tool-sandbox · high confidence

Introduction of nono capability-based sandboxing library

The nono crate has been added to provide OS-enforced process-level sandboxing using Landlock on Linux (kernel 5.13+) and Seatbelt on macOS. It allows applications to restrict filesystem access, network access, and process execution for themselves and child processes through a CapabilitySet API. The library includes a build script that generates Rust types from a JSON Schema for capability manifests, ensuring type safety for sandbox policies.

crates/nono · high confidence

New C FFI bindings for sandbox capabilities and diagnostics

The \bindings/c\ module now provides a stable C ABI for the nono sandboxing library, enabling integration with languages like Go, Swift, and Java. Users can create and manage capability sets (allowing specific file paths or blocking network access), query permission decisions before execution, and inspect platform support details. The bindings also expose structured session diagnostics, allowing callers to retrieve JSON reports on sandbox denials and remediation advice, while ensuring memory safety by returning caller-owned strings and handling NULL pointers gracefully.

bindings/c · high confidence

New Dockerfiles for headless, musl, and cross-compilation builds

The docker directory now includes dedicated Dockerfiles for building the application in environments without a system keyring or D-Bus. The new Dockerfile-headless and Dockerfile-musl (along with Dockerfile-musl-cross for x86\_64 cross-compilation) build the CLI with the 'no-default-features' flag, removing the libdbus dependency and allowing credentials to be supplied via environment, file, or operator references instead. These images also enforce running as a non-root 'nono' user and set a /work directory, providing secure, portable options for CI runners, serverless functions, and static Linux environments.

docker · high confidence

New build, release, and diagnostic scripts for RPM packaging and integration testing

Added build scripts to generate RPM and source RPM (SRPM) packages for Linux distributions, including support for Fedora COPR via vendored Cargo dependencies. Introduced a release preparation script that validates version consistency across the workspace, calculates SemVer bumps based on conventional commits, and generates changelogs. Added diagnostic and cleanup utilities for macOS browser-opening behavior, Claude authentication state management, and integration test isolation, alongside a mock SPIFFE/SPIRE server for testing upstream workload identity authentication.

scripts · high confidence

The CLI now displays a dedicated diagnostic footer when sandboxed commands fail, helping users identify whether the failure was due to sandbox restrictions. This new module parses command stderr output to detect path access issues, network denials, and protected file writes, then provides actionable guidance such as specific \--allow\ flags or \nono run\ suggestions. The output is structured to distinguish diagnostic information from command output and includes policy explanations for denied paths.

crates/nono-cli/src/diagnostic · high confidence

New tool sandbox examples for credential brokering and command policies

Added a new \tool-sandbox-examples\ directory containing practical demonstrations of nono's security features. These include an AWS CLI demo showing host-side SigV4 credential brokering with read-only S3 access, a GitHub CLI demo for token proxying and endpoint policy, a git-SSH demo using ssh-agent socket brokering with read-only git operations, an npm demo for env-var credential brokering, and a Docker-based prototype for nested command policies. The set also includes a local approval webhook demo for Kubernetes operations and a comprehensive README with setup instructions and safety notes for all examples.

tool-sandbox-examples · high confidence

Structured sandbox diagnostics for library and FFI clients

The \crates/nono/src/diagnostic\ module now exposes a stable, serializable diagnostic system for library and FFI consumers. This includes defined codes (e.g., \SandboxDeniedPath\, \CommandFailedLikelySandbox\), severity levels, and structured remediation actions (such as \GrantPath\ or \GrantNetwork\). The module provides \SessionDiagnosticReport\ for aggregating session denials and violations into JSON, and \SessionObservationInput\ to convert stderr heuristics into structured warnings. This change enables external clients to programmatically interpret sandbox denials and present actionable remediation steps.

crates/nono/src/diagnostic · high confidence

Removals

Removal of Claude Code sandbox diagnostic hook

The \nono-hook.sh\ script, which was automatically installed for the \claude-code\ profile to inject sandbox capability information upon tool failures, has been removed. Users relying on this specific integration will no longer receive the automated diagnostic context and permission-denied instructions previously provided by this hook.

crates/nono-cli/data/hooks · high confidence

Behavioural changes

8 commits (1 fix) modifying crates/nono-proxy/src/aws

A change to existing behaviour in crates/nono-proxy/src/aws — 8 commits (1 fix), 5 files: “feat: implement aws authentication for the MiTM proxy (\#1195)”; “feat(proxy): accept AWS GovCloud regions and s3 bucket-subdomain wildcards (\#2302)”; “feat(proxy): match AWS operations in endpoint\_policy on aws\_auth routes (\#2279)”; and 5 more (refs \#1195, \#2302, \#2279, \#2293, \#1430, …).

crates/nono-proxy/src/aws · medium confidence · unverified

Build script updates to embed network policy, profile schema, and authoring guide

The build process for nono-cli now embeds the network policy JSON, the profile JSON schema, and the profile authoring guide into the binary, replacing the previous logic that embedded security lists, built-in profiles, and hook scripts. Additionally, the build script now respects the NONO\_INSTALL\_SOURCE environment variable, enabling the CLI to emit install source information during update checks.

crates/nono-cli · high confidence

New Linux execution strategies: CLONE\_FILES bootstrap and environment sanitization

The CLI now introduces a new \CLONE\_FILES\ execution strategy for Linux that shares only the file descriptor table with the child process before detaching, improving isolation and performance for supervised sessions. Additionally, a dedicated environment sanitization module is added to block dangerous environment variables (such as \LD\_PRELOAD\, \PYTHONPATH\, and \NODE\_OPTIONS\) from being inherited into sandboxed children, preventing injection attacks from untrusted parent shells. These changes are part of a broader effort to harden the sandbox supervisor and execution boundaries on Linux.

_crates/nono-cli/src/exec\strategy · high confidence

Test coverage

Added SPIRE test configuration files; Added integration tests for SPIFFE/SPIRE workload identity authentication; Added tests for capability manifest schema validation and type conversion; Expanded integration test coverage for CLI, sandbox, and audit features; Expanded integration test coverage for sandbox security and execution features; New shared integration test harness for nono-cli.

Dependencies

Introduce network proxy, C FFI bindings, and upgrade to Rust 2024

This release adds a new \nono-proxy\ crate that provides a network filtering proxy with HTTP/2 support, TLS interception, credential injection, and AWS SigV4 signing. It also introduces \nono-ffi\, a new C FFI bindings crate for the sandboxing library, and a shared \nono-test-support\ crate for integration tests. Under the hood, the project has migrated to the Rust 2024 edition (requiring Rust 1.95+), centralized workspace dependencies, and updated numerous core libraries including \tokio\, \hyper\, \serde\, and \clap\.

(dependencies) · high confidence

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 71 → 71 (-0.2)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 64 → 59 (-5.2)
  • Architecture 90 → 89 (-1.4)
  • Maturity 75 → 89 (+13.3)
  • Readiness 75 → 83 (+7.7)
  • Security 77 → 75 (-2.0)
  • Event Sourcing 100 (new)
  • Performance 100 → 100 (+0.0)

Resolved (141)

  • Change coupling: main.rs ↔ snapshot.rs (crates/nono-cli/src/main.rs)
  • Change coupling: network_policy.rs ↔ credential.rs (crates/nono-cli/src/network_policy.rs)
  • Classify ADR enforcement: Move macOS keychain authorisation to nono-cli (neps/0003-keychain-authorisation-to-cli.md)
  • Classify ADR enforcement: NEP process (neps/0000-nep-process.md)
  • Classify ADR enforcement: Opt-in Linux namespace isolation (neps/0004-opt-in-linux-namespace-isolation.md)
  • Classify ADR enforcement: Supervisor decisions, audit and credentials outside a microVM guest (neps/0007-remote-supervisor-decisions-over-vsock.md)
  • Classify ADR enforcement: Tool Sandbox invocation-scoped filesystem approvals (neps/0002-invocation-scoped-commands.md)
  • Classify ADR enforcement: Windows enforcement backend (neps/0005-windows-enforcement-backend.md)
  • CredentialStore::load_with_diagnostics (cognitive 45) (crates/nono-proxy/src/credential.rs)
  • CredentialStore::load_with_diagnostics (cyclomatic 19) (crates/nono-proxy/src/credential.rs)
  • Duplicated block (10 lines × 2) (crates/nono-cli/src/tool-sandbox/platform/linux.rs)
  • Duplicated block (10 lines × 2) (crates/nono-cli/src/tool-sandbox/platform/linux.rs)
  • Duplicated block (10 lines × 2) (crates/nono-cli/src/tool-sandbox/platform/macos.rs)
  • Duplicated block (10 lines × 2) (crates/nono-proxy/src/connect.rs)
  • Duplicated block (10 lines × 2) (crates/nono-proxy/src/credential.rs)
  • Duplicated block (10 lines × 2) (crates/nono-proxy/src/tls_intercept/h2_forward.rs)
  • Duplicated block (10 lines × 4) (crates/nono-cli/src/trust_keystore.rs)
  • Duplicated block (10–11 lines × 2) (crates/nono-cli/src/command_policy.rs)
  • Duplicated block (10–11 lines × 2) (crates/nono-cli/src/tool-sandbox/platform/linux.rs)
  • Duplicated block (10–11 lines × 2) (crates/nono-cli/src/tool-sandbox/platform/linux.rs)
  • …and 121 more

New (349)

  • Change coupling: audit_commands.rs ↔ rollback_commands.rs (crates/nono-cli/src/audit_commands.rs)
  • Change coupling: proxy_runtime.rs ↔ h2_forward.rs (crates/nono-cli/src/proxy_runtime.rs)
  • CredentialStore::load_with_registry (cognitive 65) (crates/nono-proxy/src/credential.rs)
  • CredentialStore::load_with_registry (cyclomatic 26) (crates/nono-proxy/src/credential.rs)
  • DetachMatcher::push (cyclomatic 16) (crates/nono-cli/src/connect_client.rs)
  • Duplicated block (10 lines × 2) (crates/nono-cli/src/query_ext.rs)
  • Duplicated block (10 lines × 2) (crates/nono-cli/src/tool-sandbox/platform/linux.rs)
  • Duplicated block (10 lines × 2) (crates/nono-cli/src/tool-sandbox/platform/macos.rs)
  • Duplicated block (10 lines × 2) (crates/nono-proxy/src/tls_intercept/h2_forward.rs)
  • Duplicated block (10 lines × 3) (crates/nono-cli/src/connect_client.rs)
  • Duplicated block (10 lines × 3) (crates/nono/src/keystore.rs)
  • Duplicated block (10 lines × 4) (crates/nono-cli/src/trust_keystore.rs)
  • Duplicated block (11 lines × 2) (crates/nono-cli/src/proxy_command.rs)
  • Duplicated block (11 lines × 2) (crates/nono-cli/src/trust_keystore.rs)
  • Duplicated block (11 lines × 4) (crates/nono-proxy/src/tls_intercept/handle.rs)
  • Duplicated block (11–13 lines × 2) (crates/nono-cli/src/profile/mod.rs)
  • Duplicated block (12 lines × 2) (crates/nono-cli/src/proxy_command.rs)
  • Duplicated block (12 lines × 2) (crates/nono-proxy/src/tls_intercept/handle.rs)
  • Duplicated block (12 lines × 3) (crates/nono-proxy/src/tls_intercept/handle.rs)
  • Duplicated block (12 lines × 4) (crates/nono-cli/src/tool-sandbox/platform/linux.rs)
  • …and 329 more

Changes since last survey

  • 56 commits — 34 feature/other, 22 fixes

By area

  • crates/nono-cli — 20 commits
  • crates/nono-proxy — 15 commits
  • (root) — 9 commits
  • (repo) — 5 commits
  • docs/cli — 4 commits
  • .github/workflows — 1 commit
  • crates/nono — 1 commit
  • docker/Dockerfile — 1 commit

Notable commits

  • fix: Merge branch 'main' into fix/2286-skip-ep-env-vars-forkbase
  • fix: Merge pull request #2191 from wincent/fix/credential-capture-diagnostics
  • fix: Merge pull request #2287 from bharathvemula/fix/2286-skip-ep-env-vars-forkbase
  • fix: Merge pull request #2295 from rnestler/fix/2292-normalize-allow-domains
  • fix: fix(cli): allow mise to read ~/.tool-versions (#2307)
  • fix: fix(cli): pause the PTY relay for network approval prompts (#2234)
  • fix: fix(cli): support kitty release and repeat events in detach matcher (#2239)
  • fix: fix(deps): upgrade aws-config and remove crypto-bigint audit exception
  • fix: fix(docker): create home directory for nono user (#2278)
  • fix: fix(policy): keep exact-file directory bypasses literal (#2142)
  • fix: fix(proxy): distinguish credential capture failures in HTTP responses
  • fix: fix(proxy): enforce endpoint rules on plain-HTTP forward requests (#2184)
  • fix: fix(proxy): explain unavailable managed credentials to clients
  • fix: fix(proxy): fail upstream connections that go silent (#2237)
  • fix: fix(proxy): normalize trailing slash in endpoint rule paths
  • fix: fix(proxy): omit credential failure bodies for HTTP/1.1 HEAD
  • fix: fix(proxy): redeem phantoms inside Basic credentials on token endpoints (#2225)
  • fix: fix(proxy): skip synthetic EP env vars for endpoint-filtered routes (#2286)
  • fix: fix(proxy): strip hop headers when the colon is spaced (#2254)
  • fix: fix(sandbox): scope macOS process-exec to the read set (#2282)
  • …and 36 more

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Survey your own repository

nolabs-ai/nono was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 14 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 165e2f7a4cc44552577c7ac649e069b0233c62b2 — the exact code this score is about.
  • Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-3c33c1882dc1.