@fungi.computer/truffle 0.0.0-stage → 0.1.1

package/dist/private-local-service-contract.d.ts

@@ -0,0 +1,90 @@
+import type { PrivateFungiMcpSelection } from "./private-fungi-mcp-selection.js";
+import type { AuthInteraction } from "@earendil-works/pi-ai";
+import type { PrivateLocalAuthRequest } from "./private-local-auth-rpc.js";
+import type { LocalAuthResult } from "./auth-cli.js";
+import type { SessionSnapshot, ShiitakeAgent, ShiitakeSession } from "@fungi.computer/shiitake";
+import type { PrivateLocalModelChoice } from "./local-models.js";
+import type { PrivateLocalEffectiveModel } from "./private-local-effective-model.js";
+/** Service identity is checked by handshake, never inferred from a discovery PID. */
+export type PrivateLocalServiceStatus = Readonly<{
+    serviceId: string;
+    baseUrl: string;
+    /** Captured from the packed CLI at service launch. */
+    buildId?: string | undefined;
+}>;
+export type PrivateLocalServiceStopResult = Readonly<{
+    kind: "stopped";
+}> | Readonly<{
+    kind: "not-running";
+    recordCleaned: boolean;
+}> | Readonly<{
+    kind: "replaced";
+}>;
+/** Selection addresses an existing Agent store; Session identity is not a new store. */
+export type PrivateLocalServiceSelection = Readonly<{
+    invocationRoot: string;
+    clientPath?: string | undefined;
+    databasePath?: string | undefined;
+    sessionId?: string | undefined;
+    fungiMcp?: PrivateFungiMcpSelection | undefined;
+}>;
+export type PrivateLocalSessionCreation = Readonly<{
+    invocationRoot: string;
+    clientPath?: string | undefined;
+    databasePath: string;
+    requestId: string;
+    fungiMcp?: PrivateFungiMcpSelection | undefined;
+}>;
+export type PrivateLocalServiceRequestOptions = Readonly<{
+    signal?: AbortSignal | undefined;
+}>;
+export type PrivateLocalSessionInspection = Readonly<{
+    session: ShiitakeSession;
+    snapshot: SessionSnapshot;
+    close: () => Promise<void>;
+}>;
+export type PrivateLocalServiceConnection = Readonly<{
+    service: PrivateLocalServiceStatus;
+    agentId: string;
+    databasePath: string;
+    sessionId: string;
+    client: ShiitakeAgent;
+    session: ShiitakeSession;
+    effectiveModel: (options?: PrivateLocalServiceRequestOptions) => Promise<PrivateLocalEffectiveModel>;
+    /** Releases this client's watches only. Work and service ownership remain alive. */
+    close: () => Promise<void>;
+}>;
+export type PrivateLocalSessionChoice = Readonly<{
+    databasePath: string;
+    sessionId: string;
+    title: string;
+    createdAt: number;
+    updatedAt: number;
+    /** Reopen this saved store through the persistent service connection. */
+    resume: (options?: PrivateLocalServiceRequestOptions & {
+        fungiMcp?: PrivateFungiMcpSelection | undefined;
+    }) => Promise<PrivateLocalServiceConnection>;
+}>;
+export type PrivateLocalSessionProblem = Readonly<{
+    kind: "corrupt" | "in_use" | "unreadable";
+}>;
+export type PrivateLocalSessionDiscovery = Readonly<{
+    agentCount: number;
+    sessions: readonly PrivateLocalSessionChoice[];
+    problems: readonly PrivateLocalSessionProblem[];
+}>;
+/** Local process management stays outside the shared Session HTTP contract. */
+export type PrivateLocalServiceManager = Readonly<{
+    status: () => Promise<PrivateLocalServiceStatus | undefined>;
+    start: (options?: PrivateLocalServiceRequestOptions) => Promise<PrivateLocalServiceStatus>;
+    createSession: (creation: PrivateLocalSessionCreation, options?: PrivateLocalServiceRequestOptions) => Promise<PrivateLocalServiceConnection>;
+    connect: (selection: PrivateLocalServiceSelection, options?: PrivateLocalServiceRequestOptions) => Promise<PrivateLocalServiceConnection>;
+    discover: (invocationRoot: string, options?: PrivateLocalServiceRequestOptions) => Promise<PrivateLocalSessionDiscovery>;
+    inspect: (selection: Omit<PrivateLocalServiceSelection, "clientPath">, options?: PrivateLocalServiceRequestOptions & Readonly<{
+        limit?: number | undefined;
+    }>) => Promise<PrivateLocalSessionInspection>;
+    auth: (request: PrivateLocalAuthRequest, interaction: AuthInteraction) => Promise<LocalAuthResult>;
+    models: (options?: PrivateLocalServiceRequestOptions) => Promise<readonly PrivateLocalModelChoice[]>;
+    /** An expected identity avoids stopping a replacement started by another client. */
+    stop: (expectedServiceId?: string) => Promise<PrivateLocalServiceStopResult>;
+}>;

package/dist/private-local-service-contract.js

@@ -0,0 +1 @@
+export {};

package/dist/private-local-service-discovery.d.ts

@@ -0,0 +1,101 @@
+import { z } from "zod";
+declare const serviceRecordSchema: z.ZodObject<{
+    serviceId: z.ZodString & z.ZodType<import("@fungi.computer/cairn").CairnId<"local-service", "service", 1>, string, z.core.$ZodTypeInternals<import("@fungi.computer/cairn").CairnId<"local-service", "service", 1>, string>>;
+    baseUrl: z.ZodURL;
+}, z.core.$strict>;
+declare const serviceStatusSchema: z.ZodObject<{
+    serviceId: z.ZodString & z.ZodType<import("@fungi.computer/cairn").CairnId<"local-service", "service", 1>, string, z.core.$ZodTypeInternals<import("@fungi.computer/cairn").CairnId<"local-service", "service", 1>, string>>;
+    baseUrl: z.ZodURL;
+    buildId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type ServiceRecord = z.infer<typeof serviceRecordSchema>;
+export declare const selectionSchema: z.ZodObject<{
+    invocationRoot: z.ZodString;
+    clientPath: z.ZodString;
+    databasePath: z.ZodOptional<z.ZodString>;
+    sessionId: z.ZodOptional<z.ZodString>;
+    fungiMcp: z.ZodOptional<z.ZodObject<{
+        endpoint: z.ZodPipe<z.ZodURL, z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const sessionCreationSchema: z.ZodObject<{
+    invocationRoot: z.ZodString;
+    clientPath: z.ZodString;
+    databasePath: z.ZodString;
+    requestId: z.ZodString;
+    fungiMcp: z.ZodOptional<z.ZodObject<{
+        endpoint: z.ZodPipe<z.ZodURL, z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const sessionInspectionSchema: z.ZodObject<{
+    fungiMcp: z.ZodOptional<z.ZodObject<{
+        endpoint: z.ZodPipe<z.ZodURL, z.ZodString>;
+    }, z.core.$strict>>;
+    invocationRoot: z.ZodString;
+    databasePath: z.ZodOptional<z.ZodString>;
+    sessionId: z.ZodString;
+    limit: z.ZodNumber;
+}, z.core.$strict>;
+export declare const selectedSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    databasePath: z.ZodString;
+    sessionId: z.ZodString;
+    routePath: z.ZodString;
+}, z.core.$strict>;
+export declare const sessionDiscoverySchema: z.ZodObject<{
+    root: z.ZodString;
+    agentCount: z.ZodNumber;
+    sessions: z.ZodArray<z.ZodObject<{
+        databasePath: z.ZodString;
+        sessionId: z.ZodString;
+        title: z.ZodString;
+        createdAt: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+    }, z.core.$strict>>;
+    problems: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            corrupt: "corrupt";
+            in_use: "in_use";
+            unreadable: "unreadable";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const modelChoicesSchema: z.ZodArray<z.ZodObject<{
+    providerId: z.ZodString;
+    providerName: z.ZodString;
+    id: z.ZodString;
+    name: z.ZodString;
+    reasoning: z.ZodArray<z.ZodEnum<{
+        minimal: "minimal";
+        low: "low";
+        medium: "medium";
+        high: "high";
+        xhigh: "xhigh";
+        max: "max";
+    }>>;
+}, z.core.$strict>>;
+export declare function serviceDirectory(directory?: string): Promise<string>;
+export declare const recordPath: (directory: string) => string;
+export declare function readServiceRecord(directory: string): Promise<ServiceRecord | undefined>;
+/** An older listener must not erase its successor's discovery record. */
+export declare function removeOwnedServiceRecord(directory: string, serviceId: string): Promise<void>;
+/** Legacy owners have no SQLite lease, so their file lock must not be stolen. */
+export declare function assertNoUntrackedServiceOwner(directory: string): Promise<void>;
+/** Startup and shutdown serialize with the native listener and lifetime owner lock. */
+export declare function acquireServiceLock(directory: string, name: "startup" | "owner"): Promise<() => Promise<void>>;
+/**
+ * Whether a service process holds this directory's lifetime lease. A held
+ * lease is a live owner even when it is too busy to answer its handshake.
+ */
+export declare function serviceOwnerIsLive(directory: string): boolean;
+export type ServiceProbe = Readonly<{
+    kind: "running";
+    service: z.infer<typeof serviceStatusSchema>;
+}> | Readonly<{
+    kind: "not-running";
+}> | Readonly<{
+    kind: "unavailable";
+}>;
+export declare function readLiveServiceStatus(record: ServiceRecord, timeoutMs?: number): Promise<ServiceProbe>;
+export declare function handshake(record: ServiceRecord): Promise<boolean>;
+export {};

package/dist/private-local-service-discovery.js

@@ -0,0 +1,221 @@
+import { fungiMcpSelectionSchema } from "./private-fungi-mcp-selection.js";
+import { privateLocalExecPathSchema } from "./private-local-exec-path.js";
+import { chmod, mkdir, readFile, realpath, rm, rmdir, stat, writeFile, } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { homedir } from "node:os";
+import lockfile from "proper-lockfile";
+import { z } from "zod";
+import { localServiceIds } from "./private-local-service-ids.js";
+import { acquireNodeStoreLease } from "@fungi.computer/shiitake/node";
+import { privateSqliteFailureCode } from "./private-sqlite-owner.js";
+const serviceRecordSchema = z.strictObject({
+    serviceId: z.string().refine((value) => localServiceIds.service.is(value)),
+    baseUrl: z.url().refine((value) => {
+        const url = new URL(value);
+        return (url.protocol === "http:" &&
+            url.hostname === "127.0.0.1" &&
+            url.port !== "" &&
+            url.username === "" &&
+            url.password === "" &&
+            url.pathname === "/" &&
+            url.search === "" &&
+            url.hash === "");
+    }),
+});
+const serviceStatusSchema = serviceRecordSchema.safeExtend({
+    buildId: z
+        .string()
+        .regex(/^[a-f0-9]{64}$/u)
+        .optional(),
+});
+export const selectionSchema = z.strictObject({
+    invocationRoot: z.string().min(1),
+    clientPath: privateLocalExecPathSchema,
+    databasePath: z.string().min(1).optional(),
+    sessionId: z.string().min(1).optional(),
+    fungiMcp: fungiMcpSelectionSchema.optional(),
+});
+export const sessionCreationSchema = z.strictObject({
+    invocationRoot: z.string().min(1),
+    clientPath: privateLocalExecPathSchema,
+    databasePath: z.string().min(1),
+    requestId: z.string().min(1),
+    fungiMcp: fungiMcpSelectionSchema.optional(),
+});
+export const sessionInspectionSchema = selectionSchema
+    .omit({ clientPath: true })
+    .extend({
+    sessionId: z.string().min(1),
+    limit: z.number().int().min(1).max(200),
+});
+export const selectedSchema = z.strictObject({
+    agentId: z.string().min(1),
+    databasePath: z.string().min(1),
+    sessionId: z.string().min(1),
+    routePath: z.string().regex(/^\/agents\/[0-9]+$/),
+});
+export const sessionDiscoverySchema = z.strictObject({
+    root: z.string().min(1),
+    agentCount: z.number().int().nonnegative(),
+    sessions: z.array(z.strictObject({
+        databasePath: z.string().min(1),
+        sessionId: z.string().min(1),
+        title: z.string(),
+        createdAt: z.number(),
+        updatedAt: z.number(),
+    })),
+    problems: z.array(z.strictObject({ kind: z.enum(["corrupt", "in_use", "unreadable"]) })),
+});
+const reasoningLevels = [
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max",
+];
+export const modelChoicesSchema = z.array(z.strictObject({
+    providerId: z.string().min(1),
+    providerName: z.string().min(1),
+    id: z.string().min(1),
+    name: z.string().min(1),
+    reasoning: z.array(z.enum(reasoningLevels)),
+}));
+export async function serviceDirectory(directory) {
+    const path = resolve(directory ?? join(homedir(), ".fungi", "service"));
+    await mkdir(path, { recursive: true, mode: 0o700 });
+    await chmod(path, 0o700);
+    return realpath(path);
+}
+export const recordPath = (directory) => join(directory, "service.json");
+export async function readServiceRecord(directory) {
+    try {
+        return serviceRecordSchema.parse(JSON.parse(await readFile(recordPath(directory), "utf8")));
+    }
+    catch (cause) {
+        if (cause instanceof Error && "code" in cause && cause.code === "ENOENT")
+            return undefined;
+        throw cause;
+    }
+}
+/** An older listener must not erase its successor's discovery record. */
+export async function removeOwnedServiceRecord(directory, serviceId) {
+    if ((await readServiceRecord(directory))?.serviceId === serviceId)
+        await rm(recordPath(directory), { force: true });
+}
+const ownerLeaseMarker = (directory) => join(directory, "owner.lock", "sqlite-owner");
+async function pathExists(path) {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch (cause) {
+        if (cause instanceof Error && "code" in cause && cause.code === "ENOENT")
+            return false;
+        throw cause;
+    }
+}
+/** Legacy owners have no SQLite lease, so their file lock must not be stolen. */
+export async function assertNoUntrackedServiceOwner(directory) {
+    if ((await pathExists(join(directory, "owner.lock"))) &&
+        !(await pathExists(ownerLeaseMarker(directory))))
+        throw new Error("A previous Fungi service may still own this directory. Stop that service before starting Fungi again; its owner lock was not released.");
+}
+/** Startup and shutdown serialize with the native listener and lifetime owner lock. */
+export async function acquireServiceLock(directory, name) {
+    if (name === "startup")
+        return lockfile.lock(join(directory, name), {
+            realpath: false,
+            lockfilePath: join(directory, `${name}.lock`),
+            retries: { retries: 100, minTimeout: 100, maxTimeout: 100 },
+            onCompromised(error) {
+                throw error;
+            },
+        });
+    // The SQLite lease is the lifetime guard. proper-lockfile cannot heartbeat
+    // a directory containing the marker: writing the marker changes its mtime
+    // and makes its own heartbeat declare the live lock compromised.
+    const lease = acquireNodeStoreLease(join(directory, "owner.sqlite"));
+    const lockPath = join(directory, "owner.lock");
+    let created = false;
+    try {
+        await assertNoUntrackedServiceOwner(directory);
+        // A dead updated owner can leave a marked directory behind. The SQLite
+        // lease is already free, so removing it does not trust a heartbeat.
+        if (await pathExists(ownerLeaseMarker(directory)))
+            await rm(lockPath, { recursive: true });
+        await mkdir(lockPath);
+        created = true;
+        await writeFile(ownerLeaseMarker(directory), "", {
+            flag: "wx",
+            mode: 0o600,
+        });
+    }
+    catch (cause) {
+        try {
+            if (created)
+                await rm(lockPath, { recursive: true });
+        }
+        finally {
+            lease.release();
+        }
+        throw cause;
+    }
+    return async () => {
+        try {
+            await rm(ownerLeaseMarker(directory), { force: true });
+            await rmdir(lockPath);
+        }
+        finally {
+            lease.release();
+        }
+    };
+}
+/**
+ * Whether a service process holds this directory's lifetime lease. A held
+ * lease is a live owner even when it is too busy to answer its handshake.
+ */
+export function serviceOwnerIsLive(directory) {
+    let lease;
+    try {
+        lease = acquireNodeStoreLease(join(directory, "owner.sqlite"));
+    }
+    catch (cause) {
+        if (privateSqliteFailureCode(cause) === "busy")
+            return true;
+        throw cause;
+    }
+    lease.release();
+    return false;
+}
+const transportFailureSchema = z.looseObject({
+    code: z.string().optional(),
+    cause: z.looseObject({ code: z.string().optional() }).optional(),
+});
+export async function readLiveServiceStatus(record, timeoutMs = 2000) {
+    try {
+        const response = await fetch(`${record.baseUrl}/service/${record.serviceId}/status`, {
+            redirect: "error",
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        if (!response.ok)
+            return { kind: "unavailable" };
+        const actual = serviceStatusSchema.parse(await response.json());
+        return actual.serviceId === record.serviceId &&
+            actual.baseUrl === record.baseUrl
+            ? { kind: "running", service: actual }
+            : { kind: "unavailable" };
+    }
+    catch (cause) {
+        const failure = transportFailureSchema.safeParse(cause);
+        if (failure.success) {
+            const codes = [failure.data.code, failure.data.cause?.code];
+            if (codes.includes("ECONNREFUSED") || codes.includes("ConnectionRefused"))
+                return { kind: "not-running" };
+        }
+        return { kind: "unavailable" };
+    }
+}
+export async function handshake(record) {
+    return (await readLiveServiceStatus(record)).kind === "running";
+}

package/dist/private-local-service-ids.d.ts

@@ -0,0 +1,3 @@
+export declare const localServiceIds: Readonly<{
+    readonly service: import("@fungi.computer/cairn").IdCodec<"local-service", "service", 1>;
+}>;

package/dist/private-local-service-ids.js

@@ -0,0 +1,8 @@
+import { defineIdFamily } from "@fungi.computer/cairn";
+export const localServiceIds = defineIdFamily({
+    family: "local-service",
+    version: 1,
+    kinds: {
+        service: { prefix: "local_service" },
+    },
+});

package/dist/private-local-service-listener.d.ts

@@ -0,0 +1,15 @@
+import { runLocalAuthCli } from "./auth-cli.js";
+import { listPrivateModels } from "./local-models.js";
+import { type OpenLocalServiceRuntime } from "./private-local-service-owner.js";
+export declare function createPrivateLocalServiceShutdown(input: {
+    closeOwners: () => Promise<void>;
+    closeServer: () => Promise<void>;
+    removeRecord: () => Promise<void>;
+    releaseOwner: () => Promise<void>;
+}): {
+    drain: () => Promise<void>;
+    finish: () => Promise<void>;
+    isDraining: () => boolean;
+};
+/** Native Bun listener retained from TUI; service owns both listener and stores. */
+export declare function runPrivateLocalService(directory: string, openRuntime?: OpenLocalServiceRuntime, listModels?: typeof listPrivateModels, runAuth?: typeof runLocalAuthCli): Promise<void>;

package/dist/private-local-service-listener.js

@@ -0,0 +1,211 @@
+import { FungiMcpSelectionConflict } from "./private-fungi-mcp-selection.js";
+import { PrivateLocalAuthTarget } from "./private-local-auth-rpc.js";
+import { runLocalAuthCli } from "./auth-cli.js";
+import { Hono } from "hono";
+import { localServiceIds } from "./private-local-service-ids.js";
+import writeFileAtomic from "write-file-atomic";
+import { z } from "zod";
+import { listPrivateModels } from "./local-models.js";
+import { privateSqliteFailureCode } from "./private-sqlite-owner.js";
+import { openPrivateLocalBunServer } from "./private-bun-shiitake-host.js";
+import { readPrivateLocalSessionDiscovery } from "./private-local-session-discovery.js";
+import { createLocalServiceOwners, LocalSessionPathConflict, } from "./private-local-service-owner.js";
+import { acquireServiceLock, recordPath, removeOwnedServiceRecord, selectionSchema, sessionCreationSchema, sessionInspectionSchema, } from "./private-local-service-discovery.js";
+export function createPrivateLocalServiceShutdown(input) {
+    let draining;
+    let finishing;
+    const drain = () => {
+        draining ??= input.closeOwners();
+        return draining;
+    };
+    const finish = () => {
+        finishing ??= (async () => {
+            // Failed owner drain leaves the live listener, discovery, and owner lock
+            // intact. A caller must never observe this service as stopped.
+            await drain();
+            await input.closeServer();
+            try {
+                await input.removeRecord();
+            }
+            finally {
+                await input.releaseOwner();
+            }
+        })();
+        return finishing;
+    };
+    return { drain, finish, isDraining: () => draining !== undefined };
+}
+/** Native Bun listener retained from TUI; service owns both listener and stores. */
+export async function runPrivateLocalService(directory, openRuntime, listModels = listPrivateModels, runAuth = runLocalAuthCli) {
+    const release = await acquireServiceLock(directory, "owner");
+    const owners = createLocalServiceOwners(openRuntime, directory);
+    const serviceId = localServiceIds.service.generate();
+    const buildId = z
+        .string()
+        .regex(/^[a-f0-9]{64}$/u)
+        .optional()
+        .parse(process.env.FUNGI_BUNDLED_BUILD_ID);
+    const prefix = `/service/${serviceId}`;
+    const app = new Hono();
+    app.onError((error, context) => {
+        if (error instanceof z.ZodError)
+            return context.json({
+                code: "invalid_selection",
+                issues: error.issues.map((issue) => ({
+                    field: issue.path.join("."),
+                    reason: issue.message,
+                })),
+            }, 400);
+        if (error instanceof LocalSessionPathConflict)
+            return context.json({ code: "session_path_conflict", error: error.message }, 409);
+        if (error instanceof FungiMcpSelectionConflict)
+            return context.json({ error: error.message }, 409);
+        const sqliteFailure = privateSqliteFailureCode(error);
+        if (sqliteFailure === "busy" || sqliteFailure === "locked")
+            return context.json({ code: "store_in_use" }, 409);
+        console.error(error);
+        return context.text("Internal Server Error", 500);
+    });
+    const routes = new Map();
+    const stopped = Promise.withResolvers();
+    let server;
+    let recordWritten = false;
+    const mount = (selected, sessionId) => {
+        let mounted = routes.get(selected.databasePath);
+        if (!mounted) {
+            const path = `/agents/${String(routes.size)}`;
+            const routePrefix = prefix + path;
+            mounted = {
+                path,
+                fetch: (request) => {
+                    const url = new URL(request.url);
+                    url.pathname = url.pathname.slice(routePrefix.length) || "/";
+                    return selected.routes.fetch(new Request(url.toString(), request));
+                },
+                effectiveModel: selected.effectiveModel,
+            };
+            routes.set(selected.databasePath, mounted);
+        }
+        return {
+            agentId: selected.agentId,
+            databasePath: selected.databasePath,
+            sessionId,
+            routePath: mounted.path,
+        };
+    };
+    const shutdown = createPrivateLocalServiceShutdown({
+        closeOwners: owners.close,
+        closeServer: async () => {
+            await server?.close();
+        },
+        removeRecord: async () => {
+            if (recordWritten)
+                await removeOwnedServiceRecord(directory, serviceId);
+        },
+        releaseOwner: release,
+    });
+    const finish = () => {
+        const finishing = shutdown.finish();
+        void finishing.then(() => {
+            stopped.resolve(undefined);
+        }, (cause) => {
+            stopped.reject(cause);
+        });
+        return finishing;
+    };
+    const onSignal = () => {
+        void finish();
+    };
+    const isLocalRequest = (request) => !request.headers.has("origin") &&
+        new URL(request.url).hostname === "127.0.0.1";
+    try {
+        await owners.restore();
+        app.use("*", async (context, next) => {
+            const request = context.req.raw;
+            // Local client only: no browser-origin admission or DNS rebinding authority.
+            if (!isLocalRequest(request))
+                return context.body(null, 403);
+            const path = new URL(request.url).pathname;
+            if (shutdown.isDraining() &&
+                path !== `${prefix}/status` &&
+                path !== `${prefix}/stop`)
+                return context.body(null, 503);
+            await next();
+            return;
+        });
+        app.get(`${prefix}/status`, (context) => context.json({ serviceId, baseUrl: server?.baseUrl, buildId }));
+        app.get(`${prefix}/models`, async (context) => context.json(await listModels()));
+        app.post(`${prefix}/discover`, async (context) => {
+            const input = selectionSchema
+                .pick({ invocationRoot: true })
+                .parse(await context.req.json());
+            return context.json(await readPrivateLocalSessionDiscovery(input.invocationRoot, {
+                signal: context.req.raw.signal,
+            }));
+        });
+        app.get(`${prefix}/agents/:route/sessions/:sessionId/effective-model`, async (context) => {
+            const route = [...routes.values()].find((entry) => entry.path === `/agents/${context.req.param("route")}`);
+            if (route === undefined)
+                return context.body(null, 404);
+            return context.json(await route.effectiveModel(context.req.param("sessionId"), context.req.raw.signal));
+        });
+        app.post(`${prefix}/sessions`, async (context) => {
+            const input = sessionCreationSchema.parse(await context.req.json());
+            const selected = await owners.createSession(input);
+            return context.json(mount(selected, selected.sessionId));
+        });
+        app.post(`${prefix}/select`, async (context) => {
+            const input = selectionSchema.parse(await context.req.json());
+            const selected = await owners.select(input);
+            return context.json(mount(selected, selected.sessionId));
+        });
+        app.post(`${prefix}/inspect`, async (context) => {
+            const input = sessionInspectionSchema.parse(await context.req.json());
+            const selected = await owners.select(input);
+            return context.json({
+                selected: mount(selected, selected.sessionId),
+                snapshot: await selected.session.read({
+                    limit: input.limit,
+                    includeSandboxFailures: true,
+                }),
+            });
+        });
+        app.post(`${prefix}/stop`, async (context) => {
+            try {
+                await shutdown.drain();
+            }
+            catch {
+                // Preserve failed owner drain as an observable service failure. The
+                // listener remains discoverable for explicit diagnosis.
+                return context.json({ error: "Local service resources failed to close" }, 500);
+            }
+            setTimeout(() => {
+                void finish();
+            }, 0);
+            return context.body(null, 202);
+        });
+        app.all(`${prefix}/agents/*`, (context) => {
+            const path = new URL(context.req.url).pathname;
+            for (const route of routes.values()) {
+                if (path.startsWith(`${prefix}${route.path}/`))
+                    return route.fetch(context.req.raw);
+            }
+            return context.body(null, 404);
+        });
+        server = openPrivateLocalBunServer((request) => app.fetch(request), undefined, {
+            path: `${prefix}/auth`,
+            admit: (request) => isLocalRequest(request) && !shutdown.isDraining(),
+            createTarget: () => new PrivateLocalAuthTarget(runAuth),
+        });
+        await writeFileAtomic(recordPath(directory), JSON.stringify({ serviceId, baseUrl: server.baseUrl }), { mode: 0o600 });
+        recordWritten = true;
+        process.on("SIGINT", onSignal);
+        process.on("SIGTERM", onSignal);
+        await stopped.promise;
+    }
+    finally {
+        process.off("SIGINT", onSignal);
+        process.off("SIGTERM", onSignal);
+        await finish();
+    }
+}