@nimbus-sh/worker 0.4.0 → 0.6.0

package/dist/runtime/node-shims.js

@@ -9,7 +9,10 @@
  *   - events: full EventEmitter
  *   - stream: real Readable/Writable/Transform/Duplex with backpressure
  *   - crypto: createHash (FNV-1a sync, SubtleCrypto async), randomBytes/UUID
- *   - zlib: real gzip/gunzip/deflate via CompressionStream/DecompressionStream
+ *   - zlib: forward to workerd's native node:zlib when the facet real-import
+ *     block materialised (full sync/brotli/stream surface; results are the
+ *     host realm's own Buffers, recognized by the widened isBuffer);
+ *     CompressionStream fallback with honest sync refusal
  *   - dns: real DNS resolution via Cloudflare DNS-over-HTTPS
  *   - http: virtual server with port registry for supervisor routing
  *   - https: fetch()-backed request/get
@@ -386,7 +389,19 @@ const __BufferMod = (() => {
 
   function alloc(n, fill) { const a = new Uint8Array(n); if (fill !== undefined) a.fill(typeof fill === "number" ? fill : 0); return _wrap(a); }
   function allocUnsafe(n) { return _wrap(new Uint8Array(Number(n) || 0)); }
-  function isBuffer(o) { return o instanceof Uint8Array && typeof o.toString === "function" && o.__isBuffer; }
+  // Marker check plus native-brand recognition: forwarded node:* builtins
+  // (zlib streams and results, crypto) hand back the host realm's own Buffer
+  // instances, which carry no __isBuffer marker. Their constructor brand is
+  // the closest cross-realm equivalent of Node's instanceof check, so
+  // Buffer.isBuffer stays truthful across the shim/native boundary instead
+  // of rejecting genuine host Buffers. Always returns a boolean (the old
+  // single-expression form leaked an undefined when the marker was absent).
+  function isBuffer(o) {
+    if (!(o instanceof Uint8Array)) return false;
+    if (o.__isBuffer) return true;
+    const ctor = o.constructor;
+    return typeof ctor === "function" && ctor.name === "Buffer";
+  }
   function concat(bufs, len) {
     const total = len ?? bufs.reduce((s, b) => s + b.length, 0);
     const r = new Uint8Array(total); let off = 0;
@@ -5593,6 +5608,21 @@ const __processMod = {
   },
   platform: "linux", arch: "x64",
   version: ${NODE_VERSION_LITERAL}, versions: ${NODE_VERSIONS_LITERAL},
+  features: Object.freeze({
+    inspector: false,
+    debug: false,
+    uv: false,
+    ipv6: true,
+    tls_alpn: true,
+    tls_sni: true,
+    tls_ocsp: false,
+    tls: true,
+    openssl_is_boringssl: true,
+  }),
+  getBuiltinModule: (specifier) => {
+    const key = String(specifier).replace(/^node:/, "");
+    return Object.prototype.hasOwnProperty.call(builtins, key) ? builtins[key] : undefined;
+  },
   execPath: "/usr/local/bin/node",
   execArgv: [],
   pid: 1, ppid: 0, title: "node",
@@ -6152,10 +6182,295 @@ const __nimbusFacetProvidedPackages = new Set(${FACET_PROVIDED_PACKAGES_LITERAL}
 // timers.setInterval(...)), which clack's spinner — used by
 // create-cloudflare — triggers.
 builtins.timers = { setTimeout: globalThis.setTimeout.bind(globalThis), setInterval: globalThis.setInterval.bind(globalThis), clearTimeout: globalThis.clearTimeout.bind(globalThis), clearInterval: globalThis.clearInterval.bind(globalThis), setImmediate: (fn,...a) => globalThis.setTimeout(fn,0,...a), clearImmediate: globalThis.clearTimeout.bind(globalThis) };
+// ──  zlib ───────────────────────────────────────────────────────────
+//
+// Two runtimes, one surface:
+//   1. Facet templates prepend the static import block
+//      (_shared/real-node-imports.ts), which carries workerd's native
+//      node:zlib — complete at the production compat date: every *Sync
+//      variant, brotli/zstd, crc32, constants, and real streaming create*
+//      factories. Forward verbatim: results are the host realm's own Buffer
+//      instances, and __BufferMod.isBuffer recognizes that brand (see the
+//      Buffer shim), so Buffer checks stay truthful without copying every
+//      result or intercepting stream chunks.
+//   2. Scopes without the import block keep the CompressionStream fallback.
+//      It is async-only by nature; the sync names refuse with an honest,
+//      actionable error instead of pretending.
 builtins.zlib = (() => {
-  function _c(d,a) { const i=typeof d==="string"?new TextEncoder().encode(d):d; return new Response(new Blob([i]).stream().pipeThrough(new CompressionStream(a))).arrayBuffer().then(ab=>__BufferMod.from(new Uint8Array(ab))); }
-  function _d(d,a) { const i=d instanceof Uint8Array?d:new Uint8Array(d); return new Response(new Blob([i]).stream().pipeThrough(new DecompressionStream(a))).arrayBuffer().then(ab=>__BufferMod.from(new Uint8Array(ab))); }
-  return { gzip:(d,o,cb)=>{if(typeof o==="function")cb=o;_c(d,"gzip").then(r=>cb(null,r)).catch(e=>cb(e));}, gunzip:(d,o,cb)=>{if(typeof o==="function")cb=o;_d(d,"gzip").then(r=>cb(null,r)).catch(e=>cb(e));}, deflate:(d,o,cb)=>{if(typeof o==="function")cb=o;_c(d,"deflate").then(r=>cb(null,r)).catch(e=>cb(e));}, inflate:(d,o,cb)=>{if(typeof o==="function")cb=o;_d(d,"deflate").then(r=>cb(null,r)).catch(e=>cb(e));}, gzipSync:()=>{throw new Error("use async gzip()");}, gunzipSync:()=>{throw new Error("use async gunzip()");}, createGzip:()=>new __streamMod.Transform({transform(c,e,cb){_c(c,"gzip").then(r=>cb(null,r)).catch(e=>cb(e));}}), createGunzip:()=>new __streamMod.Transform({transform(c,e,cb){_d(c,"gzip").then(r=>cb(null,r)).catch(e=>cb(e));}}), createDeflate:()=>new __streamMod.Transform({transform(c,e,cb){_c(c,"deflate").then(r=>cb(null,r)).catch(e=>cb(e));}}), createInflate:()=>new __streamMod.Transform({transform(c,e,cb){_d(c,"deflate").then(r=>cb(null,r)).catch(e=>cb(e));}}), constants:{Z_NO_FLUSH:0,Z_PARTIAL_FLUSH:1,Z_SYNC_FLUSH:2,Z_FULL_FLUSH:3,Z_FINISH:4,Z_BEST_COMPRESSION:9,Z_DEFAULT_COMPRESSION:-1} };
+  const __real = (typeof __real_zlib !== "undefined") ? (__real_zlib.default ?? __real_zlib) : null;
+  if (__real && typeof __real.gzipSync === "function") {
+    const mod = {};
+    // Constants, lookup tables, crc32, and the stream factories/classes pass
+    // through bound to the native module (capitalized names are classes —
+    // binding would strip their prototype and break \`new\`).
+    for (const k of Object.keys(__real)) {
+      const v = __real[k];
+      mod[k] = (typeof v === "function" && /^[a-z]/.test(k)) ? v.bind(__real) : v;
+    }
+    if (__real.promises) mod.promises = __real.promises;
+    mod.default = mod;
+    return mod;
+  }
+  function _c(i,a) { return new Response(new Blob([i]).stream().pipeThrough(new CompressionStream(a))).arrayBuffer().then(ab=>__BufferMod.from(new Uint8Array(ab))); }
+  // Decompression is driven by hand rather than piped: feeding and draining
+  // run together, because a write only completes while somebody reads.
+  async function _d(i,a) {
+    const codec = _openCodec("decompress", a);
+    const chunks = [];
+    let failure = null;
+    const record = (reason) => { if (!failure) failure = { reason }; };
+    const drain = (async () => {
+      for (;;) {
+        const next = await codec.reader.read();
+        if (next.done) return;
+        chunks.push(next.value);
+      }
+    })().catch(record);
+    const feed = (async () => {
+      await codec.writer.write(i);
+      await codec.writer.close();
+    })().catch(record);
+    await Promise.all([drain, feed]);
+    if (failure) throw _decompressFailure(failure.reason);
+    return __BufferMod.from(_concat(chunks));
+  }
+  function _syncRefusal(name, asyncName) {
+    const e = new Error("zlib." + name + ": synchronous compression is not available on this runtime (no native node:zlib in scope). Use the async zlib." + asyncName + "(data, callback) form.");
+    e.code = "ERR_ZLIB_SYNC_UNAVAILABLE";
+    throw e;
+  }
+  // Node accepts strings, ArrayBuffers, and any ArrayBufferView; one funnel
+  // yields a byte-addressed Uint8Array over the caller's own region —
+  // byteOffset/byteLength preserved, element values never reinterpreted.
+  function _u8(d) {
+    if (typeof d === "string") return new TextEncoder().encode(d);
+    if (d instanceof Uint8Array) return d;
+    if (ArrayBuffer.isView(d)) return new Uint8Array(d.buffer, d.byteOffset, d.byteLength);
+    return new Uint8Array(d);
+  }
+  // Node splits decompression failures two ways, and the engine's own
+  // failure is the only thing that can tell them apart: an input that ran
+  // out is Z_BUF_ERROR / errno -5, everything else — bad header, bad block,
+  // and a checksum or length trailer that only fails once the member is
+  // complete — is Z_DATA_ERROR / errno -3. Which side of a write or close
+  // the failure lands on says nothing about that, so it is not consulted.
+  function _zdata(e) {
+    const err = new Error(e instanceof Error && e.message ? e.message : String(e));
+    err.code = "Z_DATA_ERROR";
+    err.errno = -3;
+    err.cause = e;
+    return err;
+  }
+  function _zbuf(e) {
+    const err = new Error("unexpected end of file");
+    err.code = "Z_BUF_ERROR";
+    err.errno = -5;
+    if (e != null) err.cause = e;
+    return err;
+  }
+  function _isUnexpectedEnd(e) {
+    const m = e instanceof Error && typeof e.message === "string" ? e.message : String(e);
+    return /unexpected end|end of (?:file|input|stream)|premature|truncated|\\bEOF\\b/i.test(m);
+  }
+  function _decompressFailure(e) { return _isUnexpectedEnd(e) ? _zbuf(e) : _zdata(e); }
+  function _destroyedWrite() {
+    const e = new Error("Cannot call write after a stream was destroyed");
+    e.code = "ERR_STREAM_DESTROYED";
+    return e;
+  }
+  // Node throws synchronously rather than deferring a callback that is not
+  // there; this surface has no promise form to fall back on.
+  function _invalidCallback(v) {
+    const got = v === undefined ? "undefined"
+      : v === null ? "null"
+      : typeof v === "object" ? "an instance of " + ((v.constructor && v.constructor.name) || "Object")
+      : "type " + typeof v + " (" + String(v) + ")";
+    const e = new TypeError('The "callback" argument must be of type function. Received ' + got);
+    e.code = "ERR_INVALID_ARG_TYPE";
+    return e;
+  }
+  // Node's Unzip contract sniffs the wrapper itself: gzip magic or zlib.
+  function _isGzip(u8) { return u8.length >= 2 && u8[0] === 0x1f && u8[1] === 0x8b; }
+  function _concat(chunks) {
+    let n = 0;
+    for (const c of chunks) n += c.length;
+    const out = new Uint8Array(n);
+    let o = 0;
+    for (const c of chunks) { out.set(c, o); o += c.length; }
+    return out;
+  }
+  function _process(mode, fmt, input) {
+    const algo = mode === "compress" ? fmt : (fmt || (_isGzip(input) ? "gzip" : "deflate"));
+    return mode === "compress" ? _c(input, algo) : _d(input, algo);
+  }
+  function _async(mode, fmt) {
+    return (d, o, cb) => {
+      const callback = typeof o === "function" ? o : cb;
+      if (typeof callback !== "function") throw _invalidCallback(callback);
+      // Two arms, not .then().catch(): a callback that throws on success must
+      // not be handed its own exception as a second, failed invocation.
+      _process(mode, fmt, _u8(d)).then(
+        (r) => callback(null, r),
+        (e) => callback(e instanceof Error ? e : new Error(String(e))),
+      );
+    };
+  }
+  // Live codec per Transform lifetime: every write feeds one real
+  // CompressionStream/DecompressionStream writer (its queue serializes
+  // ordering; the write promise settles before the callback), a reader pump
+  // relays output as it is produced instead of accumulating the payload,
+  // and flush closes the writer then awaits full drain before completing.
+  // Chunks are copied so later caller mutations cannot reach the codec, and
+  // createUnzip holds copies only until two bytes decide the wrapper.
+  function _openCodec(openMode, openAlgo) {
+    const cs = openMode === "compress" ? new CompressionStream(openAlgo) : new DecompressionStream(openAlgo);
+    return { writer: cs.writable.getWriter(), reader: cs.readable.getReader() };
+  }
+  // The legacy Readable has no resume notification, so room below the
+  // high-water mark is observed by yielding to the task queue until the
+  // consumer drains or the stream is destroyed.
+  async function _drainRoom(stream) {
+    while (
+      stream._readableState &&
+      !stream._readableState.destroyed &&
+      stream.readableLength >= stream._readableState.highWaterMark
+    ) {
+      await new Promise((tick) => setTimeout(tick, 0));
+    }
+    // True when the wait ended because the stream went away, not because
+    // the consumer made room.
+    return !!(stream._readableState && stream._readableState.destroyed);
+  }
+  function _streamFactory(factoryMode, fmt) {
+    return () => {
+      let writer = null;
+      let reader = null;
+      let drained = Promise.resolve();
+      let pumpFailure = null;
+      let algo = fmt;
+      let held = [];
+      let heldLen = 0;
+      let destroyed = false;
+      const t = new __streamMod.Transform({
+        transform: async (chunk, _enc, cb) => {
+          try {
+            if (destroyed) return cb(_destroyedWrite());
+            const bytes = _u8(chunk).slice();
+            let feed = bytes;
+            if (!writer) {
+              if (fmt === null && heldLen + bytes.length < 2) {
+                held.push(bytes);
+                heldLen += bytes.length;
+                return cb();
+              }
+              if (heldLen > 0) feed = _concat([...held, bytes]);
+              held = [];
+              heldLen = 0;
+              if (fmt === null) algo = _isGzip(feed) ? "gzip" : "deflate";
+              start();
+            }
+            await writer.write(feed);
+            cb();
+          } catch (e) {
+            cb(destroyed ? _destroyedWrite() : factoryMode === "decompress" ? _decompressFailure(e) : e);
+          }
+        },
+        flush: async (cb) => {
+          try {
+            if (destroyed) return cb(_destroyedWrite());
+            if (!writer) {
+              if (factoryMode !== "compress") {
+                // Nothing was ever fed: the input ended before a member
+                // began, which is Node's unexpected-end buffer error rather
+                // than corrupt data. No codec is invented to hide it.
+                return cb(_zbuf(null));
+              }
+              start();
+            }
+            await writer.close();
+            await drained;
+            cb(pumpFailure);
+          } catch (e) {
+            if (pumpFailure) return cb(pumpFailure);
+            if (destroyed) return cb(_destroyedWrite());
+            cb(factoryMode === "decompress" ? _decompressFailure(e) : e);
+          }
+        },
+      });
+      // Every destroy exit fires 'close' on the custom Transform — even when
+      // the pump sits parked inside reader.read() on truncated input that can
+      // never decode. Waking there is immediate: cancel settles the parked
+      // read, abort fails queued writes, and writes arriving after destroy
+      // report ERR_STREAM_DESTROYED instead of silent acceptance.
+      t.on("close", () => {
+        destroyed = true;
+        _releaseCodec();
+      });
+      // One cleanup path for every destroy exit: cancel the readable side,
+      // abort the writable side, and stop the pump.
+      function _releaseCodec() {
+        if (reader) reader.cancel().catch(() => {});
+        if (writer) writer.abort().catch(() => {});
+      }
+      function start() {
+        const opened = _openCodec(factoryMode, algo);
+        writer = opened.writer;
+        reader = opened.reader;
+        drained = (async () => {
+          try {
+            for (;;) {
+              // A destroy can land while a read is in flight; check on both
+              // sides so nothing buffers after the stream went away.
+              if (destroyed) return _releaseCodec();
+              const next = await reader.read();
+              if (destroyed) return _releaseCodec();
+              if (next.done) {
+                return;
+              }
+              // Backpressure: once push reports pressure, park the pump and
+              // do not read again until the consumer drains below the
+              // high-water mark. The pending writer.write promise then holds
+              // the transform callback, so producer writes stop resolving
+              // instead of accumulating. A destroy while parked releases the
+              // codec through the close hook above.
+              if (!t.push(__BufferMod.from(next.value))) {
+                if (await _drainRoom(t)) return _releaseCodec();
+              }
+            }
+          } catch (e) {
+            pumpFailure = factoryMode === "decompress"
+              ? _decompressFailure(e)
+              : (e instanceof Error ? e : new Error(String(e)));
+          }
+        })();
+      }
+      return t;
+    };
+  }
+  return {
+    gzip: _async("compress", "gzip"),
+    gunzip: _async("decompress", "gzip"),
+    deflate: _async("compress", "deflate"),
+    inflate: _async("decompress", "deflate"),
+    deflateRaw: _async("compress", "deflate-raw"),
+    inflateRaw: _async("decompress", "deflate-raw"),
+    unzip: _async("decompress", null),
+    gzipSync: (d, o) => _syncRefusal("gzipSync", "gzip"),
+    gunzipSync: (d, o) => _syncRefusal("gunzipSync", "gunzip"),
+    deflateSync: (d, o) => _syncRefusal("deflateSync", "deflate"),
+    inflateSync: (d, o) => _syncRefusal("inflateSync", "inflate"),
+    deflateRawSync: (d, o) => _syncRefusal("deflateRawSync", "deflateRaw"),
+    inflateRawSync: (d, o) => _syncRefusal("inflateRawSync", "inflateRaw"),
+    unzipSync: (d, o) => _syncRefusal("unzipSync", "unzip"),
+    createGzip: _streamFactory("compress", "gzip"),
+    createGunzip: _streamFactory("decompress", "gzip"),
+    createDeflate: _streamFactory("compress", "deflate"),
+    createInflate: _streamFactory("decompress", "deflate"),
+    createDeflateRaw: _streamFactory("compress", "deflate-raw"),
+    createInflateRaw: _streamFactory("decompress", "deflate-raw"),
+    createUnzip: _streamFactory("decompress", null),
+    constants: { Z_NO_FLUSH: 0, Z_PARTIAL_FLUSH: 1, Z_SYNC_FLUSH: 2, Z_FULL_FLUSH: 3, Z_FINISH: 4, Z_BEST_COMPRESSION: 9, Z_DEFAULT_COMPRESSION: -1 },
+  };
 })();
 builtins.readline = (() => {
   function emitKeypressEvents(stream) {
@@ -6880,9 +7195,11 @@ function __resolveImportsField(name, fromDir) {
 function __mkCompiledFn(code) {
   const reFn = /(?:^|\\n|;)\\s*(?:const|let|var)\\s+__filename\\s*=/m;
   const reDn = /(?:^|\\n|;)\\s*(?:const|let|var)\\s+__dirname\\s*=/m;
+  const reRequire = /(?:^|\\n|;)\\s*(?:const|let|var)\\s+require\\s*=/m;
   const fnName = reFn.test(code) ? "__filename__nimbus_unused" : "__filename";
   const dnName = reDn.test(code) ? "__dirname__nimbus_unused"  : "__dirname";
-  return new Function("exports", "require", "module", fnName, dnName, code);
+  const requireName = reRequire.test(code) ? "require__nimbus_unused" : "require";
+  return new Function("exports", requireName, "module", fnName, dnName, code);
 }
 
 function __exportsTarget(mod) {
@@ -6961,6 +7278,7 @@ function __loadModule(resolvedPath) {
   };
   scopedRequire.cache = __moduleCache;
   scopedRequire.main = __require.main;
+  mod.require = scopedRequire;
 
   // X.5-M3: thread currently-loading module path through globalThis so the
   // URL shim null-base fallback (in node-shims url module) can compose

package/dist/runtime/package-manager.d.ts

@@ -93,9 +93,50 @@ export declare function ensureRuntimesProgrammatic(deps: {
 }, specs: string[], opts?: {
     force?: boolean;
 }): Promise<RuntimeInstallSummary[]>;
+/**
+ * The session's application verbs, as the shell reaches them — the SAME
+ * session methods the SDK and the Agent call (session/programmatic.ts), so
+ * there is one policy for what an exposure, a rotation or a removal is.
+ */
+export interface NimbusAppVerbs {
+    expose(target: number | string, options: {
+        visibility?: 'scoped' | 'public';
+        name?: string;
+    }): Promise<{
+        owner: string;
+        name: string | null;
+        port: number;
+        capability: string | null;
+        visibility: 'scoped' | 'public';
+        url: string | null;
+    }>;
+    list(): Promise<Array<{
+        owner: string;
+        name: string | null;
+        port: number | null;
+        pid: number | null;
+        status: string;
+        visibility: string;
+        restart: string;
+        diagnostic: string | null;
+        url: string | null;
+    }>>;
+    rotateLink(target: number | string): Promise<{
+        name: string | null;
+        port: number;
+        url: string | null;
+        capability: string | null;
+    }>;
+    remove(target: number | string): Promise<{
+        owner: string;
+        removed: boolean;
+        port: number | null;
+    }>;
+}
 /**
  * Build the shell-command handler that implements `nimbus install …`,
- * `nimbus uninstall …`. Registered under the name `nimbus`.
+ * `nimbus uninstall …`, `nimbus expose …`, `nimbus app …` and
+ * `nimbus start …`. Registered under the name `nimbus`.
  */
 export declare function makeNimbusVerbHandler(deps: {
     env: RuntimeCatalogEnv;
@@ -105,5 +146,7 @@ export declare function makeNimbusVerbHandler(deps: {
      *  caller (init.ts) from the shell env. */
     getHome(): string;
     warmRuntime?: RuntimeWarmHook;
+    /** The application verbs; absent on a host with no session (tests). */
+    apps?: NimbusAppVerbs;
 }): (ctx: any) => Promise<number>;
 //# sourceMappingURL=package-manager.d.ts.map

package/dist/runtime/package-manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"package-manager.d.ts","sourceRoot":"","sources":["../../src/runtime/package-manager.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"package-manager.d.ts","sourceRoot":"","sources":["../../src/runtime/package-manager.ts"],"names":[],"mappings":"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"}

package/dist/runtime/package-manager.js

@@ -200,12 +200,19 @@ export async function ensureRuntimesProgrammatic(deps, specs, opts = {}) {
     }
     return results;
 }
+const NIMBUS_USAGE = [
+    'usage: nimbus install <name>[@<version>] | nimbus install --list | nimbus install --available | nimbus uninstall <name>',
+    '       nimbus expose <port|pid> [--public] [--name <name>]',
+    '       nimbus app list | url <name|port> | rotate <name|port> | remove <name|port>',
+    '       nimbus start [--restart never|on-failure] <command> [args...]',
+].join('\n');
 /**
  * Build the shell-command handler that implements `nimbus install …`,
- * `nimbus uninstall …`. Registered under the name `nimbus`.
+ * `nimbus uninstall …`, `nimbus expose …`, `nimbus app …` and
+ * `nimbus start …`. Registered under the name `nimbus`.
  */
 export function makeNimbusVerbHandler(deps) {
-    const { env, registry, getHome, warmRuntime } = deps;
+    const { env, registry, getHome, warmRuntime, apps } = deps;
     const vfs = deps.vfs.as(CRED_KERNEL);
     return async function nimbus(ctx) {
         const argv = ctx.args || [];
@@ -217,12 +224,170 @@ export function makeNimbusVerbHandler(deps) {
         if (verb === 'uninstall') {
             return runUninstall(rest, ctx, { vfs, registry, getHome });
         }
+        if (verb === 'expose' || verb === 'app' || verb === 'start') {
+            if (verb === 'start')
+                return runStart(rest, ctx, registry);
+            if (!apps) {
+                ctx.stderr.write(`nimbus ${verb}: this host has no session to address applications on\n`);
+                return 1;
+            }
+            try {
+                return verb === 'expose' ? await runExpose(rest, ctx, apps) : await runApp(rest, ctx, apps);
+            }
+            catch (e) {
+                ctx.stderr.write(`nimbus ${verb}: ${e instanceof Error ? e.message : String(e)}\n`);
+                return 1;
+            }
+        }
         // Unknown verb.
         ctx.stderr.write(`nimbus: unknown subcommand '${verb || '(none)'}'\n`);
-        ctx.stderr.write(`usage: nimbus install <name>[@<version>] | nimbus install --list | nimbus install --available | nimbus uninstall <name>\n`);
+        ctx.stderr.write(`${NIMBUS_USAGE}\n`);
         return 2;
     };
 }
+// ── expose / app / start ─────────────────────────────────────────────
+/** `<port|pid|name>` as the verbs take it: digits are a port or pid, anything else a name. */
+function appTargetArg(raw) {
+    return /^\d+$/.test(raw) ? Number(raw) : raw;
+}
+async function runExpose(args, ctx, apps) {
+    let target;
+    let name;
+    let visibility;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--public')
+            visibility = 'public';
+        else if (arg === '--scoped')
+            visibility = 'scoped';
+        else if (arg === '--name') {
+            name = args[++i];
+        }
+        else if (arg.startsWith('--name='))
+            name = arg.slice('--name='.length);
+        else if (arg.startsWith('--')) {
+            ctx.stderr.write(`nimbus expose: unknown flag ${arg}\n`);
+            return 2;
+        }
+        else if (target === undefined)
+            target = arg;
+        else {
+            ctx.stderr.write('nimbus expose: one target only\n');
+            return 2;
+        }
+    }
+    if (target === undefined) {
+        ctx.stderr.write('usage: nimbus expose <port|pid> [--public] [--name <name>]\n');
+        return 2;
+    }
+    const exposed = await apps.expose(appTargetArg(target), {
+        ...(visibility !== undefined ? { visibility } : {}),
+        ...(name !== undefined ? { name } : {}),
+    });
+    ctx.stdout.write(`${exposed.url ?? `(no URL: port ${exposed.port}, capability ${exposed.capability ?? 'none'})`}\n`);
+    ctx.stdout.write(`  ${exposed.visibility} · ${exposed.name ?? exposed.owner} · port ${exposed.port}\n`);
+    return 0;
+}
+async function runApp(args, ctx, apps) {
+    const [sub, target] = args;
+    if (sub === 'list' || sub === 'ls') {
+        const rows = await apps.list();
+        if (rows.length === 0) {
+            ctx.stdout.write('(no applications)\n');
+            return 0;
+        }
+        for (const app of rows) {
+            const label = app.name ?? app.owner;
+            const where = app.port === null ? '-' : String(app.port);
+            const pid = app.pid === null ? '-' : String(app.pid);
+            const status = app.diagnostic ? `${app.status} (${app.diagnostic})` : app.status;
+            ctx.stdout.write(`${label}\t${where}\t${pid}\t${status}\t${app.visibility}\t${app.restart}\t${app.url ?? '-'}\n`);
+        }
+        return 0;
+    }
+    if (target === undefined || (sub !== 'url' && sub !== 'rotate' && sub !== 'remove')) {
+        ctx.stderr.write('usage: nimbus app list | url <name|port> | rotate <name|port> | remove <name|port>\n');
+        return 2;
+    }
+    const t = appTargetArg(target);
+    if (sub === 'url') {
+        const app = (await apps.list()).find((row) => row.name === t || row.owner === t || row.port === t || row.pid === t);
+        if (!app) {
+            ctx.stderr.write(`nimbus app url: no application matches ${target}\n`);
+            return 1;
+        }
+        ctx.stdout.write(`${app.url ?? `(no URL: port ${app.port ?? '-'})`}\n`);
+        return 0;
+    }
+    if (sub === 'rotate') {
+        const rotated = await apps.rotateLink(t);
+        ctx.stdout.write(`${rotated.url ?? `(no URL: port ${rotated.port}, capability ${rotated.capability ?? 'none'})`}\n`);
+        return 0;
+    }
+    const removed = await apps.remove(t);
+    ctx.stdout.write(removed.removed
+        ? `removed ${removed.owner}${removed.port !== null ? ` (port ${removed.port} released)` : ''}\n`
+        : `nothing to remove for ${removed.owner}\n`);
+    return removed.removed ? 0 : 1;
+}
+/**
+ * `nimbus start [--restart <policy>] <command> [args...]` — run a
+ * registered command with the restart policy in its environment, which is
+ * where the resident it starts reads the policy from (`NIMBUS_RESTART`),
+ * exactly as the SDK's `startProcess({ restart })` carries it.
+ */
+async function runStart(args, ctx, registry) {
+    let restart = 'never';
+    let i = 0;
+    for (; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--restart') {
+            const policy = args[++i];
+            if (policy !== 'never' && policy !== 'on-failure') {
+                ctx.stderr.write(`nimbus start: --restart must be never or on-failure, got ${policy ?? '(none)'}\n`);
+                return 2;
+            }
+            restart = policy;
+        }
+        else if (arg.startsWith('--restart=')) {
+            const policy = arg.slice('--restart='.length);
+            if (policy !== 'never' && policy !== 'on-failure') {
+                ctx.stderr.write(`nimbus start: --restart must be never or on-failure, got ${policy}\n`);
+                return 2;
+            }
+            restart = policy;
+        }
+        else if (arg === '--') {
+            i += 1;
+            break;
+        }
+        else if (arg.startsWith('--')) {
+            ctx.stderr.write(`nimbus start: unknown flag ${arg}\n`);
+            return 2;
+        }
+        else
+            break;
+    }
+    const [command, ...commandArgs] = args.slice(i);
+    if (!command) {
+        ctx.stderr.write('usage: nimbus start [--restart never|on-failure] <command> [args...]\n');
+        return 2;
+    }
+    const handler = registry.resolve ? await registry.resolve(command) : null;
+    if (!handler) {
+        ctx.stderr.write(`nimbus start: ${command}: command not found\n`);
+        return 127;
+    }
+    // The shell hands `nimbus` its full CommandContext; ShellCtx is only the
+    // slice this module reads, so the spread carries everything the command
+    // needs (signal, vfs, stdin, ...) through untouched.
+    const full = ctx;
+    return handler({
+        ...full,
+        args: commandArgs,
+        env: { ...full.env, NIMBUS_RESTART: restart },
+    });
+}
 // ── install ──────────────────────────────────────────────────────────
 async function runInstall(args, ctx, deps) {
     // Flag parsing.

package/dist/runtime/ruby-resident.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ruby-resident.d.ts","sourceRoot":"","sources":["../../src/runtime/ruby-resident.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,EAIL,KAAK,iBAAiB,EACvB,MAAM,wCAAwC,CAAC;AAEhD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAezD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,YAAY,GAAG,iBAAiB,CA8E3E;AAED,wBAAgB,4BAA4B,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAiLrE"}
+{"version":3,"file":"ruby-resident.d.ts","sourceRoot":"","sources":["../../src/runtime/ruby-resident.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,EAIL,KAAK,iBAAiB,EACvB,MAAM,wCAAwC,CAAC;AAEhD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAezD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,YAAY,GAAG,iBAAiB,CAgF3E;AAED,wBAAgB,4BAA4B,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAiLrE"}

package/dist/runtime/ruby-resident.js

@@ -28,6 +28,8 @@ export function rubyResidentStart(facetMgr) {
         const command = args.command;
         const workerCode = buildRubySocketProcessWorker(buildRubyPreamble());
         const spawned = await facetMgr.spawnWorker(workerCode, command, args.cwd, {
+            resident: { argv: args.argv, runtime: 'ruby' },
+            restart: args.startArgs.userEnv.NIMBUS_RESTART === 'on-failure' ? 'on-failure' : 'never',
             compatibilityFlags: ['nodejs_compat'],
             // By path, not by value: the image is 34.3 MiB — more than a single RPC
             // value may carry — so whichever host runs this process reads it itself.