ArcBox gives Docker containers local DNS names and routes their web services through ports 80 and 443. The daemon keeps the root private key in the user's macOS Keychain. The guest keeps leaf private keys and requests signatures from the daemon. The privileged helper handles public certificates only.
On macOS, Runtime initialization removes the legacy shared tls/ca-key.pem before either System VM or machine operation becomes available. The check also runs with System VM autostart disabled. Removal failure blocks initialization; public certificates and unrelated files remain intact.
Containers and HTTP services can run without local CA trust. Enable local HTTPS from Desktop settings or run abctl tls trust in the login session. macOS controls authorization for changes to system trust. Existing correct trust does not require another authorization.
Run abctl tls status --json to inspect the current root's fingerprint, validity, publication, and trust. Public inspection reads Keychain metadata and the certificate without invoking the private key. It rejects missing or ambiguous identities and a certificate that differs from the profile's record. Run abctl tls untrust to remove system trust without stopping containers. Trust status does not prove that DNS, a route, or an upstream service works.
On macOS, abctl doctor includes the daemon's cached CA status for production and development profiles. It reports untrusted, missing, inactive, renewal-due, failed, or unavailable CA states as warnings, with repair guidance when available. Warnings appear as [WARN] in text and warning in JSON, with a separate summary.warnings count. They do not fail runtime health because HTTPS trust is optional. An incomplete status or a failed daemon query is unknown. The command never authorizes trust or sends application requests. A passing certificate check establishes only the daemon's last CA assessment; DNS, routes, upstreams, and proxy traffic require separate checks.
The certificate_state field distinguishes missing, valid, renewal_due, expired, and not_yet_valid independently of trust. Renewal is due when a valid root expires within 30 days. A root in that renewal window can remain trusted. Check the Mac's date and time when a certificate is not yet valid. Desktop does not request trust authorization for a missing or inactive certificate. Browser observation also requires a valid certificate; restoring validity starts a new observation cycle for the same root.
Run abctl tls repair to restore a missing or damaged tls/ca.pem from the profile's existing Keychain CA. Repair does not create a key or change trust. The optional --expected-fingerprint pins the current root. Repair rejects an inactive root, multiple matching Keychain items, and a publication containing a recoverable different certificate or multiple PEM objects. A repaired file does not establish that trust in an unknown previous root was removed.
Run abctl tls rotate to replace the root while the daemon is running, including in --no-linux-vm mode. The daemon creates the replacement private key. The login-session CLI authorizes the replacement, verifies native trust, and revokes the exact previous root. The daemon then publishes the replacement, switches its signer, and deletes the retired identity. The optional --expected-fingerprint pins the current root before authorization. Repeated preparation reuses the pending candidate. Desktop exposes the same operation as Settings → System → Local HTTPS → Renew Certificate for valid or expired roots, including interrupted rotation retries.
Canceling replacement authorization preserves the previous publication. If an interruption occurs after revocation, HTTPS can remain unavailable until abctl tls rotate completes the pending operation. The journal retains both public certificates for recovery. Rotation does not update the trust stores of already-running containers; their client trust requires a separate refresh.
Trust, repair, rotation, and revocation are exclusive per profile through native authorization. A concurrent command fails until the active command completes or the user cancels authorization. Status remains read-only and does not take that lock.
The authorization decision separates HTTPS from Docker readiness. The installed validation log covers the earlier startup-authorization flow. That evidence does not validate the new on-demand flow.
The daemon's --dns-domain option takes precedence over ARCBOX_DNS_DOMAIN; the default is arcbox.local. Host DNS receives the validated suffix before VM startup. The System VM receives the same suffix through arcbox.dns_domain= on the kernel command line. DNS replies, HTTP Host and TLS SNI probes, service URLs, and HTTPS ownership checks use that suffix. A changed suffix participates in the existing VM boot-configuration drift check.
The guest reports typed installed routes through ListGuestWebServices. The snapshot includes only names that resolve to the selected container address. The host validates route identities, addresses, names, and ports, then checks every name against its current Registry owner and address. Stale and conflicting names disappear from SystemService.ListWebServices and WatchWebServices. A managed backend produces separate directory entries for .local aliases with HTTPS and other aliases with HTTP only. Native TLS retains all currently owned aliases.
Both List RPCs accept a concrete hostname; an empty value lists exact aliases. A concrete lookup resolves current ownership, including wildcard claims, and returns at most one installed service with a matching owner and address. Desktop queries this endpoint before opening and after authorization, including browser-observed names absent from its cached directory. Reconnects invalidate pending results. The paired source and focused tests pass; installed browser acceptance remains pending. An unavailable container exact claim outside a reserved resource tree can still permit a broader wildcard to match.
Host DNS and both VMM datapaths share the live Registry and the configured suffix for exact relative aliases. Wildcard resolution uses the Registry directly. Concrete mDNS projections cannot override conflicts, reservations, or delegated names. This source wiring still requires installed VM validation.
Host and guest use one constructor to reserve host, host.<configured suffix>, host.docker.internal, gateway.docker.internal, and the configured index apex before resource registration. Exact reservations persist when their address is unavailable; containers cannot claim these names through exact or wildcard aliases. The guest forwards these exact builtin names to its existing gateway for the host's answer. Descendants remain separate names.
Machines use <name>.machine.<suffix> and sandboxes use <id>.sandbox.<suffix>. These resource trees stay reserved after address loss or resource removal. Container aliases cannot enter either tree. The guest forwards machine queries to the host; sandbox queries remain inside the sandbox reservation. Flat and bare resource aliases are removed.
The shared Registry selects the longest instance root before resource claims. Unavailable roots terminate lookup; effective authority changes invalidate asynchronous DNS/TLS revisions. Host and VMM DNS forward other-instance queries only to the explicit loopback endpoint, without ordinary cache or public-upstream fallback, and recheck authority before returning the response. The daemon projects helper authority snapshots into this Registry and delivers complete snapshots to the captured physical System VM through one retained connection. Only authority revisions trigger replacements; resource-only changes do not. The host checks physical identity after Open and each acknowledgment, monitors idle EOF and VM identity, and joins transport workers before reconnecting. Profiles without host DNS ownership deliver an empty snapshot without activating the helper.
The guest applies complete snapshots before acknowledgment and synchronously withdraws known roots when the connection ends. Later source revisions invalidate pinned routes even when the roots are unchanged. Source socket tests cover both host transports, cancellation, physical VM replacement, idle EOF, and complete replay. Installed multi-instance DNS and browser acceptance remain pending.
Machine configuration connections own their streams and route actors through shutdown. Open first sweeps owned rules with /usr/lib/arcbox/iptables and binds the HTTPS frontend and signing listener, then publishes the private DNS claim. Replacements update the session's in-memory CA and await route tracking before Ack. Canceling the RPC caller synchronously withdraws the claim, public root, and installed publication. Admission remains occupied until both stream shutdown and actor cleanup finish. The frontend rejects a missing session root before cache reuse. Independent host startup is integrated and passes host tests. The new boot image requires a matching candidate build and installed machine acceptance.
The NetworkManager Registry watch reports effective ownership changes even when wildcards, unavailable resources, or custom suffixes produce no mDNS record. Resolver lease reconciliation subscribes before reading the complete Registry snapshot and publishes configured and custom .local roots, including unavailable and conflicting claims.
The helper provides connection-bound resolver leases with verified daemon identity, exclusive exact roots, complete-set publication, and exact-content cleanup. Startup recovery removes only recognized orphan lease files. A bounded authority watch reports complete connection-relative roots, active ports, accepted revisions, and retained unavailable roots. Transport EOF retires authority and cancels watches before request drain and file cleanup. Failed cleanup retains ownership until helper restart. The daemon owns the lease/watch transport and mDNS future; it withdraws authority and joins the mirror before closing that transport. Bonjour publishes only granted concrete .local records, including custom roots and apexes, and resyncs the latest snapshot after notifications. Thirteen resolver tests cover snapshot confirmation, real Unix-socket cancellation, EOF, watch updates, physical VM changes, cleanup ordering, error retention, and complete replay after reconnection. Installed cutover remains pending.
Guest reconnects validate the complete container list and every inspect response before changing DNS. Snapshot and event updates wait for the route task to invalidate previous service publications before replacing ownership. Failed rule cleanup retains an unavailable owner for retry. This ordering protects managed HTTPS publication; kernel NAT rules and DNS do not change atomically. Twelve event tests and two route tests cover these transitions, including a late scan and unchanged-address namespace replacement. Installed guest NAT validation remains pending.
Domain actor shutdown withdraws installed service entries and index ownership before cancelling the frontend. It joins every frontend task before sweeping domain and index redirects, awaits both cleanups, and reports all failures. Task abort also invalidates installed entries and pinned TLS routes; the next agent startup sweeps remaining redirects. Docker retains ownership of container DNS registrations. The isolated legacy-kernel machine test verifies domain-rule replacement and cleanup, unrelated-rule preservation, and frontend release. Production-kernel and installed shutdown validation remain pending.
Host rename and network refresh replace Registry ownership without first deregistering the container. An unchanged refresh preserves the signing revision, and a rename removes the old display alias. Start, restart, stop, kill, remove, and rename share Runtime's lock for the full container ID through the guest mutation and host publication. Each request resolves its token before acquiring the lock and preserves the original query when forwarding the canonical ID. Network connect and disconnect hold the same lock and replace only the request's Container field. A forced disconnect after an explicit container 404 can remove an orphan endpoint without changing host ownership. Cold recovery and periodic reconciliation capture an idle host generation and physical VM before querying every running container. They reject stale snapshots and publish Registry ownership and aliases together after port work. An ordinary bind failure preserves untouched healthy listeners; successful earlier listener work may remain.
Host port refresh preserves equivalent healthy listeners and removes listeners when bindings become empty. Equality includes the effective host address, host port, guest port, protocol, and machine. Canceled or exited listeners complete cleanup before recovery. Host socket tests cover refresh, conflicting destinations, TCP/UDP sharing, and cancellation; installed forwarding validation remains pending.
Each macOS machine retains its current listener manager and any manager awaiting retirement in Runtime. Adoption takes the VMM's next manager only after acquiring the rules and listener locks and completing prior retirement. Engine tags each physical start or reboot with a VmIncarnation; manager transfer validates that expected live incarnation under the VM lock, and cached listener reuse requires the same tag. Cancellation preserves cleanup ownership during replacement, System VM retirement, and shutdown. Docker lifecycle admission captures the ready physical VM before inspect and validates it after taking the canonical container lock. Its activity lease ends synchronously on cancellation, without holding the global commit lock through guest I/O. Request-driven and snapshot publication share the global commit lock, pin port cleanup to the expected VM, and publish aliases/DNS under the final synchronous Engine guard. Shared DNS and port writers invalidate earlier snapshots; DNS registration propagates closed-admission errors. Publication from a replacement VM first retires the previous VM's container state. The reconciler also checks physical identity on every notification and timer tick. A 30-second whole-query deadline prevents unanswered guest requests from blocking those checks indefinitely. Graceful and forced Runtime shutdown close admission before storage cleanup, then clear host network state under the existing locks. Late snapshots and shared writers cannot republish after cleanup.
Serial Runtime validation passed 83 tests, followed by one additional canceled-retirement socket regression. Coverage includes manager cancellation, stale snapshots, healthy listeners, shared-writer admission, physical VM replacement, and shutdown closure. Eleven reconciler tests cover coalesced notifications, unannounced physical changes, whole-query deadlines, and stopped-VM checks. Strict all-target Core/Docker Clippy and scoped formatting pass; computer/API/daemon gates passed in the preceding shared-writer slice. Two earlier parallel runs exposed bind and post-teardown connection failures; the isolated teardown regression passes. Parallel socket behavior remains under investigation, so these results do not establish concurrent socket-test stability.
For a container attached to multiple networks, host DNS, guest DNS, service discovery, and published-port mirrors select the first valid IPv4 address in network-name order. They ignore the deprecated top-level NetworkSettings.IPAddress. Domain NAT retains all distinct container IPv4 addresses.
Clients use the supplied URLs. Upstream port fields describe the application listener, not the public URL port. A managed HTTPS endpoint requires ArcBox CA trust. A passthrough endpoint uses the application's own TLS and must not request ArcBox CA authorization. A directory error ends the stream; clients must clear stale entries.
Managed HTTPS checks the actual requested name against current ownership and the .local CA namespace before observation or certificate generation. A custom .local alias can use the guest proxy even when the configured suffix is containers.test. Other names support HTTP and native TLS. New roots permit concrete names under .local; existing roots retain their actual scope until explicit rotation. Independent custom aliases participate in resolver leases and Bonjour projection; native macOS resolution still requires installed validation.
The CA scope decision preserves the public-DNS and IP restrictions. The broader scope includes other LAN .local services, so a compromised root key has authority beyond ArcBox's own namespace. Ordinary signing still requires current host ownership. The broader certificate constraint does not grant resolver ownership over all .local.
The daemon pins each signing connection to a captured machine name and physical VM run. The native connection holds the Engine VM-entry guard. The signer checks that guest’s current DNS authority before signing and certificate delivery. System guests retain container and built-in index scope. Machine authority permits only the exact canonical machine name at its current bridge address while Running. System and machine signing workers run independently, including in --no-linux-vm mode. Lifecycle events and periodic rescans cancel retired sessions. Each machine host hold remains active until native connection and signing work finish. Unavailable signing listeners retry after one second. Shutdown cancels socket waits and joins every worker before stopping Runtime.
The host verifies each CSR's signature and single DNS name before signing. The name must belong to the captured guest’s current container, built-in index, or canonical machine authority and resolve to that authority’s address. Index authorization requires one exact apex claim, the configured gateway, and current instance authority. The host rechecks the registration after signing, so deletion, ownership transfer, or registration replacement discards an in-flight result. The guest pins the selected owner, registration revision, and installed route identity at the connection's original destination. The guest rechecks that route after authorization, certificate configuration, TLS handshake, and upstream connection before forwarding application bytes. Failed connections atomically invalidate only their pinned route; an old failure cannot withdraw its replacement.
Managed HTTPS negotiates HTTP/2 or HTTP/1.1 with ALPN and forwards either protocol to a verified cleartext backend. Discovery prefers HTTP/2 on an independent bounded socket before probing HTTP/1.1. An explicit HTTP port remains published when probes fail, but application forwarding requires a verified protocol. Application requests are never replayed for protocol discovery.
The relay replaces X-Forwarded-Proto with https and preserves authority, path/query, Location, and repeated Set-Cookie values. Bodies remain streaming. With HTTP/2 on both sides, native gRPC preserves unary and streaming calls, status, binary metadata, trailers, and compressed message bytes. Streams share the HTTP/2 upstream connection. Cancellation remains observable after response completion while a request upload is active. HTTP/2 streams use independent HTTP/1 upstream connections when required. Each additional connection rechecks the original route before and after connecting. HTTP/1 WebSocket upgrades preserve buffered frames, including on a backend that also supports HTTP/2. Listener shutdown joins all internal tasks. Native TLS passes through unchanged.
When converting an HTTP/2 body to HTTP/1.1, the relay uses chunked framing and requires trailer names in the initial Trailer header. HTTP/1.1 clients must send TE: trailers to receive response trailers. Declared, supported trailer fields retain repeated values. Undeclared, forbidden, or unaccepted trailers fail the HTTP/1.1 message. Arbitrary HTTP/2 trailer sets are not supported across the HTTP/1.1 boundary.
Browser HTTPS observation starts before Runtime initialization, including with System VM autostart disabled. System and running distro machine observers operate independently while Desktop watches a valid untrusted root. Each guest reports installed managed HTTPS access only from the supplied host source addresses. Before publishing evidence, the daemon checks the captured guest's current DNS claim and destination address. Desktop performs login-session trust authorization. Machine route activation, signing listeners, and installed browser authorization remain pending.
The configured apex serves an index on ports 80 and 443. Managed HTTPS requires a .local apex and the trusted ArcBox CA. The HTTPS index supports HTTP/2 and HTTP/1.1. Every request must match the current apex and port through its authority or Host field. The guest binds the shared frontend before installing exact gateway redirects. Both redirects must precede Docker's PREROUTING jump before the guest publishes system:index. The host publishes that endpoint only after validating the guest response for the current physical VM.
Failed guest publication withdraws the index and retries after one second, even without containers. Shutdown withdraws the registration before canceling and joining the frontend, then sweeps only arcbox-index: redirects. The page uses current service URLs and distinguishes unavailable Docker discovery from an empty list. The signed Production candidate passed native DNS, trusted 443, HTTP/2 200, and browser index access on 2026-10-10.
The daemon delivers its current public root to the System VM's system CA bundle once the agent is ready. It repeats delivery after a VM replacement or published-root change. CA preparation failures preserve the installed root. Unrelated roots and user additions remain intact. Already-running containers require separate trust updates. Installed VM HTTPS validation remains pending.
Run abctl machine web NAME to read the saved HTTP and HTTPS backend policies. Set --http-port or --https-port to auto, off, or a port from 1 through 65535. Omitted options preserve the current value. Both protocols default to auto; an explicit HTTPS port selects native TLS. Inspect, clone, and archive transfer retain these settings. The daemon observes saved policies every second and sends complete replacements over a retained connection to the captured machine, independently of System VM startup. Identity changes close and drain the connection before reopening. Guest configuration acknowledgement confirms stored policy; guest routing and installed machine HTTPS remain pending.
Each replacement also carries the current public CA or explicit absence. Root-only updates use the same connection and revision sequence. The guest validates a present root before changing any accepted policy, stores the parsed certificate in session memory, and clears it before connection shutdown. This proxy authority is independent of distro client trust and does not read the writable guest share. The session frontend consumes that root; successful signing and installed route acceptance remain pending.
Each NAT rule owner retains one explicit executable path for checks, changes, listings, and cleanup. System VM owners use /sbin/iptables. The boot-assets machine shim now stages the static tool at /usr/lib/arcbox/iptables before user mounts, with atomic replacement and protected mount destinations. This boot change is not yet released or selected in assets.lock; installed distro availability remains unverified. Machine route activation must select that product-owned path.
Host service snapshots query running distro machines independently of System VM readiness. Exact machine hostnames select only their captured guest. Responses must match the raw machine name, canonical hostname, bridge IPv4 address, and current DNS claim revision. Queries run concurrently; any failure cancels and drains the remaining work before failing the complete snapshot.
Machine List, Inspect, and Events are available when Runtime is constructed, before System VM initialization finishes. Loaded machine metadata can include saved addresses; only validated web-service snapshots establish installed endpoints. Host admission follows local asset seeding, shared private-key removal, and host listener setup. System startup and its readiness are independent. The integration passes compilation, focused host tests, and strict Clippy; native acceptance remains pending. Storage-recovery gates remain enforced.
Desktop loads machine lists and details before System VM setup completes. Creation, lifecycle controls, and terminals wait for host readiness; Docker, Kubernetes, and sandbox controls wait for System readiness. Readiness changes preserve list selection and update controls, including an already-open creation sheet.
Container and machine lists, details, and the menu bar open authoritative directory URLs through the same approval flow. Machine entries match the raw owner name, which can differ from the canonical hostname. List actions reject a renamed, stopped, or removed machine and a withdrawn endpoint before opening. The menu bar reads the existing service directory without another machine-list subscription. Directory failures show an unavailable message.
The machine agent accepts authenticated public-root snapshots on Debian, Ubuntu, and Alpine. It updates only /usr/local/share/ca-certificates/arcbox-local-ca.crt, invokes the installed update-ca-certificates, and verifies and syncs the rebuilt system PEM bundle before acknowledging installation or explicit removal. Updater failure leaves reconciliation pending until replay. Missing tools or stores and other distributions return an error.
The distro updater preserves other source anchors and may replace direct edits to its generated bundle. The daemon automatically delivers its current public root to running machines, including when the System VM is disabled. Each machine reconciles independently after startup, root replacement, and physical VM replacement. Stopping or removing a machine cancels delivery and waits for its connection and request before releasing the host hold. Failed CA preparation preserves installed trust. Installed machine web routes remain unverified. Debian and Alpine updater behavior has isolated container evidence; Ubuntu and installed machine client trust remain unverified.
The Docker API proxy injects the current public CA into supported regular PEM system bundles before container start. Set dev.arcbox.add-ca-certificates=false to disable injection. Injection preserves unrelated roots and does not execute image code. The host checks the published certificate against the active Keychain identity.
Injection skips running containers, read-only roots, caller-mounted bundles, symbolic bundle paths, and containers with custom certificate environment variables. A restart of a running container does not refresh trust. Java keystores and Node's bundled roots are not managed; runtimes configured to use the system bundle can use the injected root. Image builds and Docker requests made directly inside the VM bypass this hook. A package manager that rebuilds the bundle can remove the injected root.
The opt-in real Docker regression verifies default curl trust, opt-out, repeat injection, and preservation of unrelated roots. Rerun instructions and scope distinguish this test from installed ArcBox validation.
The feature objective includes the complete local-domain experience across Docker, Compose, machines, and Kubernetes. A unit test or a published protocol field does not establish product completion. Each row needs evidence at its stated scope.
| Requirement | Required evidence | Audit state on 2026-10-10 |
|---|---|---|
| Container and Compose names | Access fresh container and service/project names from macOS without resolver overrides or published ports. | Basic macOS HTTPS path verified; current dynamic changes need another VM run. |
| Instance DNS suffix | Start with a custom suffix; verify host and guest DNS, probe Host/SNI, service URLs, TLS ownership, and restart after changing it. | Shared validation and host/guest propagation are implemented. VM and browser acceptance remain pending. |
Custom .local names and implicit/default/custom wildcards |
Resolve and serve exact and nested names; reject collisions or ambiguous ownership; verify certificate names. | Canonical claims, permanent machine/sandbox trees, concrete wildcard lookup, helper leases, and complete host-to-guest authority delivery are implemented. Guest sandbox claims share the injected Registry with containers and authority. Signer, access observer, directory, and DNS use current Registry ownership. Shared DNS, directory, framed guest, and host socket regressions pass. Installed macOS resolver cutover and browser validation remain pending. |
| HTTP and HTTPS discovery | Use actual protocol responses; exercise multiple listeners, explicit overrides, late listeners, same-port replacement, and network changes. | Selection tests exist; current installed NAT path needs validation. |
| Native HTTPS | Preserve the application's certificate on 443, 8443, and explicit ports; cover HTTP/2-only and mTLS listeners. | HTTP/1.1 and HTTP/2 discovery pass real TLS socket tests. Explicit native ports bypass discovery for mTLS; installed NAT and mTLS validation remain pending. |
| First HTTPS access | A browser request causes one login-session authorization; concurrent requests and reconnects do not repeat the prompt. | Guest observation, independent System/machine relays, and Desktop Watch/acknowledgement are connected. Source regressions cover stopped or stalled System observers, current guest authority, and joined cancellation before lease disable. The daemon retains and joins every observer before Runtime stops. Machine routes, signing listeners, and independent host startup are integrated. Host checks pass, and the matching signed Development and Production candidates pass artifact verification. Real browser validation remains pending. |
| Cancellation and existing trust | Cancel authorization while Docker stays usable; retry explicitly; restart with existing trust without another mutation. | Independent state tests exist; new combined native flow needs validation. |
| Desktop service entry points | Open the same authoritative URL from the list, details, and menu bar; handle deletion during authorization and directory disconnects. | Container and machine lists, details, and the menu bar share the opener. Machine entries match raw owner names and use authoritative URLs. Lists and details load before System VM setup completes; Machine management and terminals use host readiness gates. The final independent-readiness integration passes 65 focused Desktop tests and formatting/lint checks across 347 files. Native host startup with System disabled passed; the Machines list and creation control remained available. Installed machine routes and the service-opening authorization flow remain pending. |
| Browser index | Serve an index at arcbox.local with current service links and useful failure states. |
Host publication validates the configured apex, gateway, current claim, and physical VM. Guest publication requires a bound frontend and exact gateway redirects before Docker's PREROUTING jump. Guest tests cover rule order, retry deadlines, and withdrawal before frontend shutdown. HTTP/TLS frontend and daemon lifecycle tests pass. Typed index discovery remains available when Docker discovery is unavailable. The signed Production candidate passed native DNS, port 443, certificate SAN/chain validation, HTTP/2 200, and browser access against the candidate kernel. Existing trust was used; container forwarding and first-use authorization remain separate checks. |
| System VM client trust | Verify default HTTPS trust inside the System VM after startup, restart, and root replacement. | Public-root installation and daemon lifecycle reconciliation are implemented. Installed VM HTTPS validation remains pending. |
| Container client trust | Verify container-to-container HTTPS without custom CA flags; verify opt-out and preservation of unrelated roots. | Real Docker archive injection passes default curl, opt-out, idempotence, and root-preservation checks in isolated Colima containers. The fixture bypasses the host Keychain and VM lifecycle. Native candidate validation exposed an archive teardown race with indexed overlayfs. The boot-assets Docker patch passes native archive/start cycles and 20 rounds of actual CA reconciliation, rotation, idempotence, and immediate start in an isolated engine. Diagnosis and rerun steps. Installed candidate revalidation remains pending. |
| Unsupported trust stores | State behavior for read-only roots, mounted stores, Java, Node, image builds, and containers created inside the VM. | Boundaries are documented above. Guard tests cover running, read-only, mounted, symbolic, and custom-environment cases; installed runtime coverage remains pending. |
| Machine integration | Verify machine names, HTTP/HTTPS port configuration, managed/native TLS, and client trust from inside a machine. | Machine DNS, saved policies, public-root delivery, and Debian/Ubuntu/Alpine trust reconciliation exist. Host workers pin the physical VM and exact DNS authority. Guest sessions now own route activation and a frontend with an in-memory CA source. Open requires a successful owned-rule sweep and frontend/signing listener binds. Both stream and route cleanup retain admission. Boot tool installation and selected-tool cleanup pass isolated checks. On 2026-10-10, the new ARM64 boot image built successfully and its packaged scripts and tool passed the artifact-content probe; the image remains unpublished and is pinned only in the isolated signed candidate. Independent host startup is integrated; 269 focused Rust tests and strict Clippy pass. Source/socket and isolated legacy-kernel evidence do not establish production boot, signing, packet forwarding, or installed client HTTPS. |
| macOS SSL trust in machines | Verify that HTTPS clients in machines accept certificates marked as SSL-trusted in macOS. | ArcBox-root delivery alone does not cover this requirement. The portability audit shows that ordinary PEM loses native purpose constraints and chain distrust. Broader macOS trust integration remains missing. |
| Kubernetes integration | Verify cluster.local, Service reachability, LoadBalancer/Ingress wildcard names, and intended HTTPS behavior from macOS. |
LoadBalancer forwarding pins listings and port outcomes to the captured physical VM. The daemon retains and joins the poller before stopping Runtime. Service DNS, direct Service/Pod network routes, wildcard names, and HTTPS integration remain missing. The current snapshot omits Service UID and ClusterIP; container Web discovery requires a PID/network namespace and cannot discover a Service VIP. |
| Domain ownership | Reject a TLS SNI name that does not belong to the actual destination; validate the same ownership at signing and routing boundaries. | Guest routing checks owner, revision, address, and installed backend across each handshake stage. The host signer independently verifies current container DNS ownership before and after signing. Real wrong-SNI rejection remains pending. |
| Private-key boundary | Verify signed creator access and rejection of unrelated identities; confirm no private root bytes reach disk exports, helper, or guest. | The native identity matrix passes creator and relocated same-identity signing, rejects same-team different-identifier and ad-hoc same-identifier signing with native error -25293, and verifies exact untrusted cleanup. The public inspection follow-up permits all four identities to read the exact public certificate without authorizing signing. Installed daemon upgrade acceptance remains pending. |
| Root and leaf lifecycle | Verify actual leaf expiry, concurrent issuance, root renewal, rotation, repair, revocation, migration, and uninstall without removing unrelated roots. | Leaf validation, publication repair, certificate lifetime status, and journal-based rotation are implemented. CLI and Desktop renewal use the daemon's serialized mutation worker. Host tests, four isolated rotation tests, and the paired signed development build pass. The Admin trust rotation test was canceled during revocation and did not pass; cleanup of its three trusted test roots awaits explicit authorization. Browser and full native lifecycle acceptance remain pending. |
| Application protocols | Verify forwarded scheme, redirects, secure cookies, WebSocket, SSE, HTTP/2, and gRPC on supported modes. | Real socket tests cover managed HTTP/1.1 and HTTP/2 translation, early responses, streaming bodies, declared HTTP/1 trailers, rejection of unsupported HTTP/1 trailers, WebSocket frames, concurrent streams, cancellation, and native gRPC calls. TLS index tests cover ALPN, authority, and route replacement. Arbitrary HTTP/2 trailer sets remain unsupported across HTTP/1 boundaries. Installed protocol and gRPC evidence remain pending. |
| Diagnostics and recovery | Distinguish DNS, route, upstream, proxy, and trust failures; recover after daemon/guest restart and event-stream gaps. | Doctor includes the daemon's cached CA status alongside existing DNS and route checks. Optional HTTPS warnings preserve runtime exit semantics. Per-service upstream/proxy diagnosis and combined recovery evidence remain missing. |
| Performance | Measure first request, cached requests, concurrent handshakes, route changes, and idle cost at increasing service counts. | No comparable HTTPS measurements. |
| Release integration | Validate the paired signed app/runtime, then publish the runtime before changing the Desktop release pin. | The matching Development and Production candidates pass signatures, identities, binary provenance, resource hashes, and DMG verification. Production generation 2 passed native helper replacement, host admission with System disabled, subsequent System startup, and trusted HTTPS index access. Container CA injection failed before start. Public CA inspection now avoids private-key operations and passes native checks; complete TLS status revalidation requires the matching candidate helper. The local package lacks sign-in service configuration. First-use authorization, native lifecycle coverage, updated Development packaging, published pins, and notarization remain pending. Release is not authorized by this document. |
The comparison uses public product behavior. Do not infer undocumented implementation details or claim coverage for an unsupported protocol or trust store.
OrbStack's Kubernetes documentation establishes Service DNS, direct Service/Pod access, and LoadBalancer/Ingress wildcard names. Its HTTPS documentation describes automatic container HTTPS; it does not establish managed HTTPS for every Kubernetes Service.
- Container domains: naming, custom domains, wildcards, index, and protocol discovery.
- HTTPS: first-use installation, container CA injection, private-key protection, and native HTTPS forwarding.
- Forwarded scheme clarification: OrbStack sets
X-Forwarded-Protofor proxied HTTPS; direct HTTP does not receive that header. - Linux networking: machine names, port configuration, and macOS trust integration.
- Kubernetes: Service addresses,
cluster.local, and LoadBalancer/Ingress domains. - Menu bar: service discovery and opening.