@nimbus-sh/worker 0.7.0 → 0.9.0

package/dist/hosted/runtime.d.ts

@@ -0,0 +1,135 @@
+import type { NimbusWorkspace } from '@nimbus-sh/core/workspace';
+import type { PortRegistry } from '@nimbus-sh/core/runtime/port-registry.js';
+import type { ProcessLogReadOptions } from '@nimbus-sh/core/runtime/process-logs.js';
+import type { VfsCred } from '@nimbus-sh/core/runtime/os-contracts.js';
+import type { SandboxFs } from '@nimbus-sh/core/substrate/lifo/sandbox/types.js';
+import { type SupervisorOpEnvelope } from '@nimbus-sh/core/workspace/supervisor-op.js';
+import type { FacetManagerHostHooks } from '../facets/compose.js';
+import { WebSocketTerminal } from '../facets/ws-terminal.js';
+import * as operations from '../session/programmatic.js';
+import * as services from './services.js';
+import { z } from 'zod/v4';
+declare const HostedTask: z.ZodEnum<{
+    "resident-launch": "resident-launch";
+    "log-flush": "log-flush";
+    "log-janitor": "log-janitor";
+}>;
+export type HostedRuntimeTask = z.infer<typeof HostedTask>;
+export interface HostedRuntimeLifecycle {
+    waitUntil(task: Promise<void>): void;
+    schedule(reason: HostedRuntimeTask, at: number): Promise<void>;
+    cancel(reason: HostedRuntimeTask): Promise<void>;
+}
+export interface HostedRuntimeOptions {
+    workspace: NimbusWorkspace;
+    ctx: DurableObjectState;
+    env: services.HostedRuntimeEnv;
+    ports: PortRegistry;
+    lifecycle: HostedRuntimeLifecycle;
+    resolveWorkerLaunch?: FacetManagerHostHooks['resolveWorkerLaunch'];
+    basePath?: string;
+    origin?: string;
+}
+export interface RuntimeFiles extends SandboxFs {
+    as(cred: VfsCred): RuntimeFiles;
+}
+export declare function composeHostedRuntime(options: HostedRuntimeOptions): Promise<{
+    workspace: NimbusWorkspace;
+    terminal: WebSocketTerminal;
+    files: RuntimeFiles;
+    runtimes: import("@nimbus-sh/core/runtime/runtime-manager.js").RuntimeManager;
+    ready: (options?: operations.ProgrammaticReadyOptions | undefined) => Promise<{
+        ok: true;
+        preinstalled: string[];
+    }>;
+    exec: (command: string, options?: operations.ProgrammaticExecOptions | undefined) => Promise<operations.ProgrammaticExecResult>;
+    runCode: (code: string, options?: (operations.ProgrammaticExecOptions & {
+        language?: "javascript" | "typescript" | "python" | "ruby" | "shell";
+        install?: "never" | "ifMissing";
+    }) | undefined) => Promise<operations.ProgrammaticExecResult>;
+    startProcess: (command: string, options?: operations.ProgrammaticExecOptions | undefined) => Promise<operations.ProgrammaticStartResult>;
+    listProcesses: () => Promise<operations.SerializedProcess[]>;
+    killProcess: (pid: number) => Promise<{
+        ok: boolean;
+        pid: number;
+    }>;
+    writeProcessInput: (pid: number, data: string) => Promise<{
+        ok: boolean;
+        pid: number;
+    }>;
+    endProcessInput: (pid: number) => Promise<{
+        ok: boolean;
+        pid: number;
+    }>;
+    resizeProcess: (pid: number, size: {
+        columns: number;
+        rows: number;
+    }) => Promise<{
+        ok: boolean;
+        pid: number;
+    }>;
+    signalProcess: (pid: number, signal: string) => Promise<{
+        ok: boolean;
+        pid: number;
+    }>;
+    processLogs: (pid: number, options?: ProcessLogReadOptions) => Promise<{
+        pid: number;
+        chunks: import("@nimbus-sh/core/runtime/process-logs.js").SequencedLogChunk[];
+        text: string;
+        cursor: number;
+        truncated: boolean;
+        exit: import("@nimbus-sh/core/runtime/process-logs.js").ProcessExitInfo | null;
+    }>;
+    listPorts: () => Promise<operations.SerializedPort[]>;
+    listApps: () => Promise<operations.ListedApp[]>;
+    ensureDurableApp: (input: {
+        owner: string;
+        preferredPort?: number;
+        visibility?: "scoped" | "public";
+        name?: string;
+    }) => Promise<{
+        port: number;
+        capability: string | null;
+        visibility: "scoped" | "public";
+    }>;
+    unexposePort: (port: number) => Promise<{
+        port: number;
+        ok: boolean;
+    }>;
+    removeDurableApp: (owner: string) => Promise<{
+        owner: string;
+        removed: boolean;
+        port: number | null;
+    }>;
+    exposeApp: (target: operations.AppTarget, options?: {
+        visibility?: "scoped" | "public";
+        name?: string;
+    } | undefined) => Promise<operations.ExposedAppResult>;
+    removeApp: (target: operations.AppTarget) => Promise<{
+        owner: string;
+        removed: boolean;
+        port: number | null;
+    }>;
+    rotateLink: (target: operations.AppTarget) => Promise<operations.ExposedAppResult>;
+    installRuntime: (spec: string, options?: {
+        force?: boolean;
+    } | undefined) => Promise<import("../runtime/package-manager.js").RuntimeInstallSummary>;
+    ensureRuntimes: (specs: string[], options?: {
+        force?: boolean;
+    } | undefined) => Promise<import("../runtime/package-manager.js").RuntimeInstallSummary[]>;
+    listRuntimes: () => Promise<{
+        installed: import("@nimbus-sh/core/runtime/installed-runtimes.js").RuntimeSummary[];
+        available: import("@nimbus-sh/core/runtime/runtime-package.js").RuntimeAvailability[];
+    }>;
+    spawnWorker: (workerCode: string, command: string, cwd: string, opts?: import("../facets/manager.js").LongRunningWorkerSpawnOptions | undefined) => Promise<import("../facets/manager.js").SpawnedWorker>;
+    routeCapabilityPort: (port: number, capability: string, request: Request<unknown, CfProperties<unknown>>, innerPath: string) => Promise<Response>;
+    supervisorOp: (envelope: SupervisorOpEnvelope) => Promise<unknown>;
+    onScheduled: (task: HostedRuntimeTask) => Promise<void>;
+    attachTerminal: (ws: WebSocket) => Promise<void>;
+    terminalFrame: (ws: WebSocket, message: string | ArrayBuffer) => Promise<void>;
+    terminalClose: (ws: WebSocket) => void;
+    close: () => Promise<void>;
+}>;
+export type HostedRuntime = Awaited<ReturnType<typeof composeHostedRuntime>>;
+export {};
+//# sourceMappingURL=runtime.d.ts.map

package/dist/hosted/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../src/hosted/runtime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAEjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0CAA0C,CAAC;AAC7E,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,yCAAyC,CAAC;AACrF,OAAO,KAAK,EAA6B,OAAO,EAAE,MAAM,yCAAyC,CAAC;AAIlG,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iDAAiD,CAAC;AACjF,OAAO,EAAqD,KAAK,oBAAoB,EAAE,MAAM,4CAA4C,CAAC;AAE1I,OAAO,KAAK,EAAwB,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AASxF,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAO7D,OAAO,KAAK,UAAU,MAAM,4BAA4B,CAAC;AACzD,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAC;AAE1C,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAI3B,QAAA,MAAM,UAAU;;;;EAA0D,CAAC;AAC3E,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAE3D,MAAM,WAAW,sBAAsB;IACrC,SAAS,CAAC,IAAI,EAAE,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IACrC,QAAQ,CAAC,MAAM,EAAE,iBAAiB,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/D,MAAM,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAClD;AAED,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,eAAe,CAAC;IAC3B,GAAG,EAAE,kBAAkB,CAAC;IACxB,GAAG,EAAE,QAAQ,CAAC,gBAAgB,CAAC;IAC/B,KAAK,EAAE,YAAY,CAAC;IACpB,SAAS,EAAE,sBAAsB,CAAC;IAClC,mBAAmB,CAAC,EAAE,qBAAqB,CAAC,qBAAqB,CAAC,CAAC;IACnE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,YAAa,SAAQ,SAAS;IAC7C,EAAE,CAAC,IAAI,EAAE,OAAO,GAAG,YAAY,CAAC;CACjC;AAqRD,wBAAsB,oBAAoB,CAAC,OAAO,EAAE,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAkBjD,MAAM,YAAY,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAiBjC,oBAAoB;wBACzB,iBAAiB;yBAChB,SAAS;wBACV,SAAS,WAAW,MAAM,GAAG,WAAW;wBACxC,SAAS;;GAGhC;AAED,MAAM,MAAM,aAAa,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC,CAAC"}

package/dist/hosted/runtime.js

@@ -0,0 +1,344 @@
+import { requireVfsCred } from '@nimbus-sh/core/runtime/os-contracts.js';
+import { SandboxFsImpl } from '@nimbus-sh/core/substrate/lifo/sandbox/SandboxFs.js';
+import { ExecutionFs } from '@nimbus-sh/core/shell/execution-fs.js';
+import { SUPERVISOR_OP_ROUTES, createSupervisorBridgeStore } from '@nimbus-sh/core/workspace/supervisor-op.js';
+import { WebSocketTerminal } from '../facets/ws-terminal.js';
+import { buildSessionSupervisorOps } from '../session/supervisor-op.js';
+import { installLogPersistence } from '../session/hibernation.js';
+import { appendScrollback, ensureSessionStateSchema, loadScrollback, loadShellState, persistShellState } from '../session/state-store.js';
+import { wireProcessLogSocketBroadcast } from '../runtime/process-logs-api.js';
+import { routeRuntimeLoopback } from '../session/loopback.js';
+import * as rpc from '../session/rpc.js';
+import * as operations from '../session/programmatic.js';
+import * as services from './services.js';
+import { registerHostedCommands } from './commands.js';
+import { z } from 'zod/v4';
+import { adoptCtxExports, supervisorEntrypoint } from '@nimbus-sh/fabric/composition.js';
+import { hostNamespaceBinding } from '@nimbus-sh/fabric/host-dispatch.js';
+const HostedTask = z.enum(['resident-launch', 'log-flush', 'log-janitor']);
+const InputFrame = z.discriminatedUnion('type', [
+    z.object({ type: z.literal('input'), data: z.string() }),
+    z.object({ type: z.literal('resize'), cols: z.number().int().positive(), rows: z.number().int().positive() }),
+]);
+class RuntimeOwner {
+    options;
+    terminal;
+    _cpRegistry;
+    _programmaticShellQueues = new Map();
+    _hostedProcesses = new Map();
+    _hostedProcessWaiters = new Map();
+    _cirrusHmrWsClients = new Map();
+    closing = null;
+    _w9PersistWired = false;
+    _w9SchemaInit = false;
+    _viteShimPid = null;
+    _viteShimPort = null;
+    wranglerAliasBannerShown = false;
+    facetManagerComposed = null;
+    facetProcessManager = null;
+    esbuildService = null;
+    bundlePool = null;
+    npmInstaller = null;
+    fetchProxyEntrypoint = null;
+    viteDevServer = null;
+    cirrusReal = null;
+    nimbusWrangler = null;
+    webSocketRelay = null;
+    readyPromise = null;
+    supervisor = null;
+    flushScheduled = false;
+    janitorScheduled = false;
+    recoveryNotice = false;
+    scheduling = new Set();
+    fileLeases = new Map();
+    services;
+    constructor(options) {
+        this.options = options;
+        hostNamespaceBinding(options.env, 'HostedRuntime');
+        const exports = Reflect.get(options.ctx, 'exports');
+        if (!supervisorEntrypoint(exports)) {
+            throw new Error('Export the configured supervisor entrypoint and call composeFabric before composing a hosted runtime');
+        }
+        adoptCtxExports(exports);
+        ensureSessionStateSchema(options.ctx);
+        this.terminal = new WebSocketTerminal(null, (data) => {
+            appendScrollback(options.ctx, data, Date.now());
+            persistShellState(options.ctx, { cwd: this.shell.getCwd(), env: this.shell.getEnv() });
+        });
+        this._cpRegistry = options.workspace.registry;
+        this.services = services.bindRuntimeServices(this, {
+            ctx: options.ctx,
+            env: options.env,
+            notify: (line) => this._notifySession(line),
+            requestLaunchTurn: (at) => this._scheduleLaunchTurn(at),
+            resolveWorkerLaunch: options.resolveWorkerLaunch,
+            filesystem: () => options.workspace.filesystem,
+        });
+        options.workspace.shell.bindTerminal(this.terminal);
+        installLogPersistence(this, options.ctx, () => this.scheduleLogs());
+        wireProcessLogSocketBroadcast(this.processes, options.ctx);
+    }
+    get ctx() { return this.options.ctx; }
+    get _w1SessionDestroyed() { return this.closing !== null; }
+    get env() { return this.options.env; }
+    get sqliteFs() { return this.options.workspace.vfs; }
+    get kernel() { return this.options.workspace.kernel; }
+    get shell() { return this.options.workspace.shell; }
+    get shellProcessPid() { return this.options.workspace.shellProcessPid; }
+    get runtimeManager() { return this.options.workspace.runtimes; }
+    get processes() { return this.options.workspace.processes; }
+    get portRegistry() { return this.options.ports; }
+    get facetManager() { return this.facetManagerComposed?.manager ?? null; }
+    get sessionBasePath() { return this.options.basePath ?? ''; }
+    get sessionOrigin() { return this.options.origin ?? ''; }
+    get viteBasePath() { return `${this.sessionBasePath}/preview`; }
+    get nimbusDebug() { return Reflect.get(this.env, 'NIMBUS_DEBUG') === '1'; }
+    assertOpen() {
+        if (this._w1SessionDestroyed)
+            throw new Error('Nimbus runtime is closed');
+    }
+    ensureRuntimeReady() {
+        this.assertOpen();
+        this.readyPromise ??= (async () => {
+            const saved = loadShellState(this.ctx);
+            this.recoveryNotice = saved.hasPersistedState;
+            if (saved.cwd)
+                this.shell.setCwd(saved.cwd);
+            if (saved.env)
+                Object.assign(this.shell.getEnv(), saved.env);
+            await registerHostedCommands(this, this.options.workspace);
+            await this.options.workspace.start();
+        })();
+        return this.readyPromise;
+    }
+    ensureSqliteFs() { return this.sqliteFs; }
+    routeLoopback(port, request) { return routeRuntimeLoopback(this.portRegistry, port, request); }
+    ensureBundlePool() { this.assertOpen(); return this.services.ensureBundlePool(); }
+    ensureFacetManager() { this.assertOpen(); return this.services.ensureFacetManager(); }
+    ensureFetchProxy(log) { return this.services.ensureFetchProxy(log); }
+    buildFetchFn(log) { return this.services.buildFetchFn(log); }
+    ensureNpmInstaller(onProgress) { this.assertOpen(); return this.services.ensureNpmInstaller(onProgress); }
+    ensureGlobalPrefixDirs(prefix) { return this.services.ensureGlobalPrefixDirs(prefix); }
+    _envFlagDefaultOn(name) { return this.services._envFlagDefaultOn(name); }
+    _ensureFacetProcessManager() { this.assertOpen(); return this.services._ensureFacetProcessManager(); }
+    _ensureWebSocketRelay() { this.assertOpen(); return this.services._ensureWebSocketRelay(); }
+    _setCpRegistry(registry) {
+        if (registry !== this._cpRegistry)
+            throw new Error('Nimbus runtime cannot replace the workspace registry');
+    }
+    _notifySession(line) { this.terminal.write(`${line}\r\n`); }
+    _scheduleLaunchTurn(notBefore = Date.now()) {
+        const pending = this.schedule('resident-launch', Math.max(Date.now(), notBefore));
+        this.options.lifecycle.waitUntil(pending);
+        return pending;
+    }
+    schedule(reason, at) {
+        if (this._w1SessionDestroyed)
+            return Promise.reject(new Error('Nimbus runtime is closed'));
+        // Registered before the deferred call runs, so close() waits for a turn
+        // issued in the same tick; the second closed check keeps that turn from
+        // arming an alarm the shutdown has already decided against.
+        const pending = Promise.resolve().then(() => {
+            if (this._w1SessionDestroyed)
+                return;
+            return this.options.lifecycle.schedule(reason, at);
+        });
+        this.scheduling.add(pending);
+        void pending.then(() => this.scheduling.delete(pending), () => this.scheduling.delete(pending));
+        return pending;
+    }
+    _reportExternalExit(pid, code, reason) { return rpc._reportExternalExit(this, pid, code, reason); }
+    _emitExitDump(pid, code) { return rpc._emitExitDump(this, pid, code); }
+    _emitShellExecDone(pid, command, code, duration) { return rpc._emitShellExecDone(this, pid, command, code, duration); }
+    _rpcStdout(pid, data) { return rpc._rpcStdout(this, pid, data); }
+    _rpcStderr(pid, data) { return rpc._rpcStderr(this, pid, data); }
+    supervisorOps() {
+        this.supervisor ??= buildSessionSupervisorOps(this, createSupervisorBridgeStore({
+            vfs: this.options.workspace.vfs,
+            filesystem: this.options.workspace.filesystem,
+            processes: this.processes,
+        }), Object.fromEntries(Object.values(SUPERVISOR_OP_ROUTES).map(({ method }) => {
+            const handler = Reflect.get(rpc, method);
+            if (typeof handler !== 'function')
+                throw new Error(`Missing Nimbus supervisor implementation: ${method}`);
+            return [method, (...args) => Reflect.apply(handler, undefined, [this, ...args])];
+        })));
+        return this.supervisor;
+    }
+    supervisorOp(envelope) {
+        this.assertOpen();
+        return this.supervisorOps().dispatch(envelope);
+    }
+    supervisorBridge(pid) { return this.supervisorOps().bridge(pid); }
+    supervisorForgetBridge(pid) { this.supervisorOps().forget(pid); }
+    scheduleLogs() {
+        if (this._w1SessionDestroyed)
+            return;
+        if (!this.flushScheduled) {
+            this.flushScheduled = true;
+            this.options.lifecycle.waitUntil(this.schedule('log-flush', Date.now() + 250).catch((error) => {
+                this.flushScheduled = false;
+                throw error;
+            }));
+        }
+        if (!this.janitorScheduled) {
+            this.janitorScheduled = true;
+            this.options.lifecycle.waitUntil(this.schedule('log-janitor', Date.now() + 60_000).catch((error) => {
+                this.janitorScheduled = false;
+                throw error;
+            }));
+        }
+    }
+    async onScheduled(task) {
+        if (this._w1SessionDestroyed)
+            return;
+        if (task === 'resident-launch') {
+            await this.ensureFacetManager().pumpLaunches();
+        }
+        else if (task === 'log-flush') {
+            this.flushScheduled = false;
+            this.processes.flushLogs();
+        }
+        else {
+            this.janitorScheduled = false;
+            this.processes.dropLogsOlderThan(undefined, (pid) => !this.processes.get(pid));
+            if (this.processes.stats.running > 0 || this.processes.logStats.totalPids > 0)
+                this.scheduleLogs();
+        }
+    }
+    async attachTerminal(ws, resume = 'reconnect') {
+        await this.ensureRuntimeReady();
+        if (this.terminal.ws === ws)
+            return;
+        this.terminal.attach(ws);
+        if (resume === 'reconnect')
+            this.terminal.write(loadScrollback(this.ctx));
+        if (this.recoveryNotice) {
+            this.terminal.write('\r\n[Runtime resumed; files and shell settings restored. Previous interpreter state was not retained.]\r\n');
+            this.recoveryNotice = false;
+        }
+        if (!this.shell.running)
+            this.shell.printPrompt();
+        this.terminal.flushNow();
+        ws.send(JSON.stringify({ type: 'ready' }));
+    }
+    async terminalFrame(ws, frame) {
+        await this.attachTerminal(ws, 'wake');
+        const text = typeof frame === 'string' ? frame : new TextDecoder().decode(frame);
+        const input = InputFrame.parse(JSON.parse(text));
+        this.terminal.handleMessage(input);
+        persistShellState(this.ctx, { cwd: this.shell.getCwd(), env: this.shell.getEnv() });
+    }
+    terminalClose(ws) {
+        if (this.terminal.ws !== ws)
+            return;
+        this.terminal.flushNow();
+        persistShellState(this.ctx, { cwd: this.shell.getCwd(), env: this.shell.getEnv() });
+        this.terminal.detach();
+        this.processes.flushLogs();
+    }
+    files(cred) {
+        this.assertOpen();
+        const workspace = this.options.workspace;
+        const identity = requireVfsCred(cred, 'runtime files');
+        // One host lease per credential, not per `.as()` call: the descriptor
+        // scope behind a lease lives until close(), so re-deriving a view for an
+        // identity the runtime already opened must reuse that scope.
+        const key = `${identity.uid}:${identity.gid}:${identity.groups.join(',')}:${identity.umask}`;
+        let lease = this.fileLeases.get(key);
+        if (!lease) {
+            lease = workspace.filesystem.openHost(identity);
+            this.fileLeases.set(key, lease);
+        }
+        const view = new SandboxFsImpl(new ExecutionFs(lease.fs), () => workspace.shell.getCwd());
+        return Object.assign(view, { as: (next) => this.files(next) });
+    }
+    close() {
+        this.closing ??= Promise.resolve().then(async () => {
+            const failures = [];
+            const clean = async (action) => {
+                try {
+                    await action();
+                }
+                catch (error) {
+                    failures.push(error instanceof Error ? error : new Error(String(error)));
+                }
+            };
+            await clean(() => this.terminal.disposeRepl());
+            await clean(() => this.terminal.sendData('\x03'));
+            for (const process of this.processes.getAll()) {
+                await clean(() => this.webSocketRelay?.closeForPid(process.pid));
+                if (process.state !== 'running')
+                    continue;
+                await clean(() => { if (!this.facetManager?.kill(process.pid))
+                    this.processes.kill(process.pid); });
+                await clean(() => { this.portRegistry.unregisterByPid(process.pid); });
+            }
+            await clean(() => this.viteDevServer?.stop());
+            await clean(() => this.cirrusReal?.stop(this.ctx));
+            await clean(() => this.nimbusWrangler?.stop());
+            await clean(() => this.bundlePool?.dispose());
+            await clean(() => this.processes.flushLogs());
+            this.terminal.flushNow();
+            this.terminal.close();
+            for (const ws of this.ctx.getWebSockets('process-logs')) {
+                await clean(() => ws.close(1000, 'runtime closed'));
+            }
+            await clean(() => this.facetManager?.closeLaunches());
+            await Promise.allSettled(this.scheduling);
+            await clean(() => this.supervisor?.dispose());
+            for (const lease of this.fileLeases.values())
+                await clean(() => lease.dispose());
+            this.fileLeases.clear();
+            await clean(() => this.options.workspace.close());
+            for (const task of HostedTask.options)
+                await clean(() => this.options.lifecycle.cancel(task));
+            if (failures.length > 0)
+                throw new AggregateError(failures, 'Nimbus runtime cleanup failed');
+        });
+        return this.closing;
+    }
+}
+export async function composeHostedRuntime(options) {
+    const owner = new RuntimeOwner(options);
+    await owner.ensureRuntimeReady();
+    return {
+        workspace: options.workspace,
+        terminal: owner.terminal,
+        files: owner.files(owner.processes.cred(owner.shellProcessPid)),
+        runtimes: owner.runtimeManager,
+        ready: operations.ensureProgrammaticReady.bind(null, owner),
+        exec: operations.rpcExec.bind(null, owner),
+        runCode: operations.rpcRunCode.bind(null, owner),
+        startProcess: operations.rpcStartProcess.bind(null, owner),
+        listProcesses: operations.rpcListProcesses.bind(null, owner),
+        killProcess: operations.rpcKillProcess.bind(null, owner),
+        writeProcessInput: operations.rpcWriteProcessInput.bind(null, owner),
+        endProcessInput: operations.rpcEndProcessInput.bind(null, owner),
+        resizeProcess: operations.rpcResizeProcess.bind(null, owner),
+        signalProcess: operations.rpcSignalProcess.bind(null, owner),
+        processLogs: (pid, options) => operations.rpcProcessLogs(owner, pid, options),
+        listPorts: operations.rpcListPorts.bind(null, owner),
+        listApps: operations.rpcListApps.bind(null, owner),
+        ensureDurableApp: operations.rpcEnsureDurableApp.bind(null, owner),
+        unexposePort: operations.rpcUnexposePort.bind(null, owner),
+        removeDurableApp: operations.rpcRemoveDurableApp.bind(null, owner),
+        exposeApp: operations.rpcExposeApp.bind(null, owner),
+        removeApp: operations.rpcRemoveApp.bind(null, owner),
+        rotateLink: operations.rpcRotateLink.bind(null, owner),
+        installRuntime: operations.rpcInstallRuntime.bind(null, owner),
+        ensureRuntimes: operations.rpcEnsureRuntimes.bind(null, owner),
+        listRuntimes: operations.rpcListRuntimes.bind(null, owner),
+        spawnWorker: operations.rpcSpawnWorker.bind(null, owner),
+        routeCapabilityPort: async (...args) => {
+            await operations.ensureProgrammaticReady(owner);
+            return owner.ensureFacetManager().apps.routeCapabilityPort(...args);
+        },
+        supervisorOp: (envelope) => owner.supervisorOp(envelope),
+        onScheduled: (task) => owner.onScheduled(task),
+        attachTerminal: (ws) => owner.attachTerminal(ws),
+        terminalFrame: (ws, message) => owner.terminalFrame(ws, message),
+        terminalClose: (ws) => owner.terminalClose(ws),
+        close: () => owner.close(),
+    };
+}

package/dist/hosted/services.d.ts

@@ -0,0 +1,44 @@
+import { type ComposedFacetManager, type FacetManagerHostHooks } from "../facets/compose.js";
+import { type NimbusFilesystemAuthority } from "@nimbus-sh/core/runtime/os-contracts.js";
+import { EsbuildBundlePool } from "../facets/esbuild-bundle-pool.js";
+import type { NpmInstaller } from "../npm/installer.js";
+import { WebSocketRelay } from "../session/ws-relay.js";
+import type { SessionInternal } from '../session/internal.js';
+import type { RuntimeCatalogEnv } from '../runtime/runtime-catalog.js';
+import type { IsolatePoolEnv } from '@nimbus-sh/fabric/isolate-pool.js';
+export interface HostedRuntimeEnv extends RuntimeCatalogEnv, IsolatePoolEnv {
+    ASSETS?: Fetcher;
+}
+export type RuntimeServiceHost = Pick<SessionInternal, '_cpRegistry' | '_envFlagDefaultOn' | '_reportExternalExit' | 'buildFetchFn' | 'bundlePool' | 'ensureBundlePool' | 'ensureFacetManager' | 'ensureFetchProxy' | 'ensureSqliteFs' | 'esbuildService' | 'facetManagerComposed' | 'facetProcessManager' | 'fetchProxyEntrypoint' | 'npmInstaller' | 'portRegistry' | 'processes' | 'shell' | 'sqliteFs' | 'terminal'> & {
+    webSocketRelay: WebSocketRelay | null;
+};
+export interface RuntimeServiceContext {
+    readonly ctx: DurableObjectState;
+    readonly env: HostedRuntimeEnv;
+    notify(line: string): void;
+    requestLaunchTurn(notBefore?: number): Promise<void>;
+    resolveWorkerLaunch?: FacetManagerHostHooks['resolveWorkerLaunch'];
+    /** The host's own authority: a session has exactly one, and this is it. */
+    filesystem: () => NimbusFilesystemAuthority;
+}
+export declare function ensureBundlePool(self: RuntimeServiceHost, runtimeContext: RuntimeServiceContext): EsbuildBundlePool;
+export declare function ensureFacetManager(self: RuntimeServiceHost, runtimeContext: RuntimeServiceContext): ComposedFacetManager;
+export declare function _ensureWebSocketRelay(self: RuntimeServiceHost, runtimeContext: RuntimeServiceContext): WebSocketRelay;
+export declare function _ensureFacetProcessManager(self: RuntimeServiceHost, runtimeContext: RuntimeServiceContext): any;
+export declare function ensureFetchProxy(self: RuntimeServiceHost, runtimeContext: RuntimeServiceContext, log?: (msg: string) => void): any | null;
+export declare function buildFetchFn(self: RuntimeServiceHost, runtimeContext: RuntimeServiceContext, log?: (msg: string) => void): ((url: string, init?: RequestInit) => Promise<Response>) | undefined;
+export declare function ensureNpmInstaller(self: RuntimeServiceHost, runtimeContext: RuntimeServiceContext, onProgress?: (msg: string) => void): Promise<NpmInstaller>;
+export declare function _envFlagDefaultOn(self: RuntimeServiceHost, runtimeContext: RuntimeServiceContext, name: string): boolean;
+export declare function ensureGlobalPrefixDirs(self: RuntimeServiceHost, runtimeContext: RuntimeServiceContext, prefix: string): void;
+export declare function bindRuntimeServices(host: RuntimeServiceHost, context: RuntimeServiceContext): {
+    ensureBundlePool: () => EsbuildBundlePool;
+    ensureFacetManager: () => ComposedFacetManager;
+    _ensureWebSocketRelay: () => WebSocketRelay;
+    _ensureFacetProcessManager: () => any;
+    ensureFetchProxy: (log?: ((msg: string) => void) | undefined) => any;
+    buildFetchFn: (log?: ((msg: string) => void) | undefined) => ((url: string, init?: RequestInit) => Promise<Response>) | undefined;
+    ensureNpmInstaller: (onProgress?: ((msg: string) => void) | undefined) => Promise<NpmInstaller>;
+    _envFlagDefaultOn: (name: string) => boolean;
+    ensureGlobalPrefixDirs: (prefix: string) => void;
+};
+//# sourceMappingURL=services.d.ts.map

package/dist/hosted/services.d.ts.map

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