@demicodes/host-local 0.1.0 → 0.2.1

package/dist/index.d.mts

@@ -1,5 +1,50 @@
-import { Host, HostFileSystem, HostProcess, HostStore } from "@demicodes/shell";
-
+import { AgentHarness, AgentServer, AgentServerSessionOptions } from "@demicodes/agent";
+import { resolveDemiHome } from "@demicodes/provider/credentials-pool";
+import { BashEnvironmentOptions, Host, HostFileSystem, HostProcess, HostStore } from "@demicodes/shell";
+import { Provider } from "@demicodes/provider";
+//#region src/command-bridge.d.ts
+/**
+ * Dispatch script shared by every generated command-name symlink.
+ * Reads the invoked name from the symlink path, applies the stdin grace
+ * contract from docs/command-bridge.md, and POSTs /run on the UDS socket.
+ */
+declare const COMMAND_BRIDGE_SHIM_SOURCE = "#!/usr/bin/env node\nconst { request } = require('node:http')\nconst { basename } = require('node:path')\n\n// Stdin policy (docs/command-bridge.md): if no byte arrives within the grace\n// window, proceed with empty stdin. Once any byte arrives, clear the timer\n// and read until EOF with no time cap. Late data after empty-stdin dispatch\n// is reported on stderr and not pretended to have been delivered.\nconst STDIN_GRACE_MS = 300\n\nfunction readStdin() {\n  if (process.stdin.isTTY) return Promise.resolve('')\n  return new Promise((resolve, reject) => {\n    const chunks = []\n    let resolved = false\n    let timedOut = false\n    let timer\n    const cleanup = () => {\n      clearTimeout(timer)\n      process.stdin.removeListener('data', onData)\n      process.stdin.removeListener('end', onEnd)\n      process.stdin.removeListener('error', onError)\n    }\n    const onData = (chunk) => {\n      if (timedOut) {\n        process.stderr.write(\n          'command bridge: ' + chunk.length + ' byte(s) of stdin arrived after the ' + STDIN_GRACE_MS +\n            'ms grace period elapsed; the command already ran with empty stdin\\n',\n        )\n        cleanup()\n        return\n      }\n      clearTimeout(timer)\n      chunks.push(chunk)\n    }\n    const onEnd = () => {\n      if (timedOut) {\n        cleanup()\n        return\n      }\n      resolved = true\n      cleanup()\n      resolve(Buffer.concat(chunks).toString('utf8'))\n    }\n    const onError = (error) => {\n      if (resolved || timedOut) return\n      resolved = true\n      cleanup()\n      reject(error)\n    }\n    timer = setTimeout(() => {\n      timedOut = true\n      resolved = true\n      resolve('')\n    }, STDIN_GRACE_MS)\n    process.stdin.on('data', onData)\n    process.stdin.on('end', onEnd)\n    process.stdin.on('error', onError)\n  })\n}\n\nfunction postRun(socketPath, body) {\n  return new Promise((resolve, reject) => {\n    const req = request(\n      { socketPath, path: '/run', method: 'POST', headers: { 'content-type': 'application/json' } },\n      (res) => {\n        const chunks = []\n        res.on('data', (chunk) => chunks.push(chunk))\n        res.on('end', () => resolve({ statusCode: res.statusCode || 0, body: Buffer.concat(chunks).toString('utf8') }))\n      },\n    )\n    req.on('error', reject)\n    req.end(body)\n  })\n}\n\nasync function main() {\n  const socketPath = process.env.DEMI_COMMAND_BRIDGE_SOCK\n  // Shell sessions export DEMI_SESSION_ID as the command scope id (the agent\n  // session id for agent-owned shells).\n  const commandScopeId = process.env.DEMI_SESSION_ID\n  if (!socketPath || !commandScopeId) {\n    process.stderr.write('command bridge: DEMI_COMMAND_BRIDGE_SOCK / session id not set in this shell\\n')\n    process.exit(1)\n  }\n  const name = basename(process.argv[1] || '')\n  const args = process.argv.slice(2)\n  const stdin = await readStdin()\n  const body = JSON.stringify({ commandScopeId, name, args, cwd: process.cwd(), stdin })\n\n  const response = await postRun(socketPath, body)\n  if (response.statusCode !== 200) {\n    let message = response.body\n    try {\n      message = JSON.parse(response.body).error || message\n    } catch {}\n    process.stderr.write('command bridge: ' + message + '\\n')\n    process.exit(1)\n  }\n  const result = JSON.parse(response.body)\n  if (result.stdout) {\n    // Binary final streams arrive base64-encoded; write raw bytes so external\n    // pipes (demi read a.png | ffmpeg -i - ...) stay byte-clean.\n    process.stdout.write(result.stdoutEncoding === 'base64' ? Buffer.from(result.stdout, 'base64') : result.stdout)\n  }\n  if (result.stderr) process.stderr.write(result.stderr)\n  process.exit(result.exitCode)\n}\n\nmain().catch((error) => {\n  process.stderr.write('command bridge: ' + (error && error.message ? error.message : String(error)) + '\\n')\n  process.exit(1)\n})\n";
+interface CommandBridgeOptions {
+  socketPath: string;
+}
+interface CommandBridgeHandle {
+  close(): Promise<void>;
+}
+/**
+ * Starts the process-wide UDS listener for command-bridge shims.
+ * Each POST /run is dispatched to `AgentServer.runCommandLine`.
+ */
+declare function startCommandBridge(server: AgentServer, options: CommandBridgeOptions): CommandBridgeHandle;
+//#endregion
+//#region src/command-bridge-shim.d.ts
+interface MaterializeCommandBridgeShimsOptions {
+  host: Host;
+  agentSessionId: string;
+  commandNames: readonly string[];
+  shimSource: string;
+  /**
+   * Absolute Demi state root (`~/.demi` or `$DEMI_HOME` / `stateDir`).
+   * Shims always go to `<stateDir>/bridge-bin/<agentSessionId>/`.
+   */
+  stateDir: string;
+}
+/** Fixed relative layout under stateDir. */
+declare function bridgeBinDirFor(stateDir: string): string;
+/**
+ * Writes the command bridge shim directory for one session and returns its
+ * resolved absolute path for PATH injection. Idempotent: safe on every open().
+ */
+declare function materializeCommandBridgeShims(options: MaterializeCommandBridgeShimsOptions): Promise<string>;
+//#endregion
+//#region src/demi-home.d.ts
+/** Fixed layout: `<stateDir>/bridges/<id>.sock` (short id for macOS AF_UNIX limits). */
+declare function defaultBridgeSocketPath(stateDir: string, serverId?: string): string;
+//#endregion
 //#region src/local-host.d.ts
 interface LocalHostOptions {
   storeRoot?: string;
@@ -12,4 +57,50 @@ declare class LocalHost implements Host {
   constructor(defaultCwd: string, options?: LocalHostOptions);
 }
 //#endregion
-export { LocalHost, LocalHostOptions };
+//#region src/local-agent-server.d.ts
+interface CreateLocalAgentServerOptions {
+  /** Same LocalHost instance the harness was built with. */
+  host: LocalHost;
+  agent: AgentHarness<unknown>;
+  providers: Provider[];
+  shell?: Omit<BashEnvironmentOptions, 'host' | 'commands'>;
+  session?: AgentServerSessionOptions;
+  /**
+   * Command bridge for real OS subprocesses. **Default true** (open box).
+   * Pass `false` only to disable.
+   */
+  commandBridge?: boolean;
+  /**
+   * Demi state root (default `$DEMI_HOME` or `~/.demi`).
+   * Bridge socket and `bridge-bin/` always live under this tree — never under workspace cwd.
+   * Layout is fixed: `bridges/*.sock`, `bridge-bin/<sessionId>/`.
+   */
+  stateDir?: string;
+  /** Override UDS path when bridge is enabled (default under `stateDir/bridges/`). */
+  commandBridgeSocketPath?: string;
+}
+interface LocalAgentServerHandle {
+  server: AgentServer;
+  host: LocalHost;
+  /** Resolved state root used for bridge artifacts when bridge is enabled. */
+  stateDir: string | null;
+  /** Stops the bridge listener (if any) then closes the server. */
+  close(): Promise<void>;
+}
+/**
+ * Open-box local agent assembly: `LocalHost` + `AgentServer` with command
+ * bridge **on by default**.
+ *
+ * Owns the Node-only bridge transport (UDS + PATH shims under `stateDir`).
+ * AgentServer only receives a generic `prepareSessionShell` hook and exposes
+ * `runCommandLine` — it never sees bin dirs or sockets.
+ *
+ * Default layout under `stateDir` (`~/.demi` or `$DEMI_HOME`):
+ * ```
+ * bridges/<id>.sock
+ * bridge-bin/<sessionId>/…
+ * ```
+ */
+declare function createLocalAgentServer(options: CreateLocalAgentServerOptions): LocalAgentServerHandle;
+//#endregion
+export { COMMAND_BRIDGE_SHIM_SOURCE, CommandBridgeHandle, CommandBridgeOptions, CreateLocalAgentServerOptions, LocalAgentServerHandle, LocalHost, LocalHostOptions, MaterializeCommandBridgeShimsOptions, bridgeBinDirFor, createLocalAgentServer, defaultBridgeSocketPath, materializeCommandBridgeShims, resolveDemiHome, startCommandBridge };

package/dist/index.mjs

@@ -1,9 +1,273 @@
+import { existsSync, mkdirSync, unlinkSync } from "node:fs";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { createServer } from "node:http";
+import { AgentServer, RunCommandLineCommandNotRegisteredError, RunCommandLineSessionNotFoundError, RunCommandLineTimeoutError } from "@demicodes/agent";
+import { encodeUtf8, errorMessage, isFileNotFoundError, parsePortableJson, stringifyPortableJson } from "@demicodes/utils";
+import { createHash, randomUUID } from "node:crypto";
+import { resolveDemiHome } from "@demicodes/provider/credentials-pool";
 import { spawn } from "node:child_process";
-import { createHash } from "node:crypto";
 import { homedir } from "node:os";
-import { dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { appendFile, chmod, cp, link, lstat, mkdir, readFile, readdir, readlink, realpath, rename, rm, stat, symlink, utimes, writeFile } from "node:fs/promises";
-import { isFileNotFoundError } from "@demicodes/utils";
+//#region src/command-bridge.ts
+/**
+* Dispatch script shared by every generated command-name symlink.
+* Reads the invoked name from the symlink path, applies the stdin grace
+* contract from docs/command-bridge.md, and POSTs /run on the UDS socket.
+*/
+const COMMAND_BRIDGE_SHIM_SOURCE = `#!/usr/bin/env node
+const { request } = require('node:http')
+const { basename } = require('node:path')
+
+// Stdin policy (docs/command-bridge.md): if no byte arrives within the grace
+// window, proceed with empty stdin. Once any byte arrives, clear the timer
+// and read until EOF with no time cap. Late data after empty-stdin dispatch
+// is reported on stderr and not pretended to have been delivered.
+const STDIN_GRACE_MS = 300
+
+function readStdin() {
+  if (process.stdin.isTTY) return Promise.resolve('')
+  return new Promise((resolve, reject) => {
+    const chunks = []
+    let resolved = false
+    let timedOut = false
+    let timer
+    const cleanup = () => {
+      clearTimeout(timer)
+      process.stdin.removeListener('data', onData)
+      process.stdin.removeListener('end', onEnd)
+      process.stdin.removeListener('error', onError)
+    }
+    const onData = (chunk) => {
+      if (timedOut) {
+        process.stderr.write(
+          'command bridge: ' + chunk.length + ' byte(s) of stdin arrived after the ' + STDIN_GRACE_MS +
+            'ms grace period elapsed; the command already ran with empty stdin\\n',
+        )
+        cleanup()
+        return
+      }
+      clearTimeout(timer)
+      chunks.push(chunk)
+    }
+    const onEnd = () => {
+      if (timedOut) {
+        cleanup()
+        return
+      }
+      resolved = true
+      cleanup()
+      resolve(Buffer.concat(chunks).toString('utf8'))
+    }
+    const onError = (error) => {
+      if (resolved || timedOut) return
+      resolved = true
+      cleanup()
+      reject(error)
+    }
+    timer = setTimeout(() => {
+      timedOut = true
+      resolved = true
+      resolve('')
+    }, STDIN_GRACE_MS)
+    process.stdin.on('data', onData)
+    process.stdin.on('end', onEnd)
+    process.stdin.on('error', onError)
+  })
+}
+
+function postRun(socketPath, body) {
+  return new Promise((resolve, reject) => {
+    const req = request(
+      { socketPath, path: '/run', method: 'POST', headers: { 'content-type': 'application/json' } },
+      (res) => {
+        const chunks = []
+        res.on('data', (chunk) => chunks.push(chunk))
+        res.on('end', () => resolve({ statusCode: res.statusCode || 0, body: Buffer.concat(chunks).toString('utf8') }))
+      },
+    )
+    req.on('error', reject)
+    req.end(body)
+  })
+}
+
+async function main() {
+  const socketPath = process.env.DEMI_COMMAND_BRIDGE_SOCK
+  // Shell sessions export DEMI_SESSION_ID as the command scope id (the agent
+  // session id for agent-owned shells).
+  const commandScopeId = process.env.DEMI_SESSION_ID
+  if (!socketPath || !commandScopeId) {
+    process.stderr.write('command bridge: DEMI_COMMAND_BRIDGE_SOCK / session id not set in this shell\\n')
+    process.exit(1)
+  }
+  const name = basename(process.argv[1] || '')
+  const args = process.argv.slice(2)
+  const stdin = await readStdin()
+  const body = JSON.stringify({ commandScopeId, name, args, cwd: process.cwd(), stdin })
+
+  const response = await postRun(socketPath, body)
+  if (response.statusCode !== 200) {
+    let message = response.body
+    try {
+      message = JSON.parse(response.body).error || message
+    } catch {}
+    process.stderr.write('command bridge: ' + message + '\\n')
+    process.exit(1)
+  }
+  const result = JSON.parse(response.body)
+  if (result.stdout) {
+    // Binary final streams arrive base64-encoded; write raw bytes so external
+    // pipes (demi read a.png | ffmpeg -i - ...) stay byte-clean.
+    process.stdout.write(result.stdoutEncoding === 'base64' ? Buffer.from(result.stdout, 'base64') : result.stdout)
+  }
+  if (result.stderr) process.stderr.write(result.stderr)
+  process.exit(result.exitCode)
+}
+
+main().catch((error) => {
+  process.stderr.write('command bridge: ' + (error && error.message ? error.message : String(error)) + '\\n')
+  process.exit(1)
+})
+`;
+/**
+* Starts the process-wide UDS listener for command-bridge shims.
+* Each POST /run is dispatched to `AgentServer.runCommandLine`.
+*/
+function startCommandBridge(server, options) {
+	mkdirSync(dirname(options.socketPath), { recursive: true });
+	if (existsSync(options.socketPath)) unlinkSync(options.socketPath);
+	const httpServer = createServer((req, res) => {
+		handleRun(server, req, res);
+	});
+	httpServer.listen(options.socketPath);
+	return { close: () => closeServer(httpServer, options.socketPath) };
+}
+async function handleRun(server, req, res) {
+	if (req.method !== "POST" || req.url !== "/run") {
+		sendJson(res, 404, { error: "not found" });
+		return;
+	}
+	let body;
+	try {
+		body = await readJsonBody(req);
+	} catch (error) {
+		sendJson(res, 400, { error: `bad request: ${errorMessage(error)}` });
+		return;
+	}
+	if (!isRunRequestBody(body)) {
+		sendJson(res, 400, { error: "bad request: expected { commandScopeId, name, args, cwd, stdin }" });
+		return;
+	}
+	const controller = new AbortController();
+	let responded = false;
+	const onClosedEarly = () => {
+		if (!responded) controller.abort();
+	};
+	req.on("close", onClosedEarly);
+	try {
+		const result = await server.runCommandLine(body.commandScopeId, body.name, body.args, {
+			cwd: body.cwd,
+			stdin: body.stdin,
+			signal: controller.signal
+		});
+		responded = true;
+		sendJson(res, 200, result);
+	} catch (error) {
+		responded = true;
+		sendJson(res, statusForError(error), { error: errorMessage(error) });
+	} finally {
+		req.off("close", onClosedEarly);
+	}
+}
+function statusForError(error) {
+	if (error instanceof RunCommandLineSessionNotFoundError) return 404;
+	if (error instanceof RunCommandLineCommandNotRegisteredError) return 404;
+	if (error instanceof RunCommandLineTimeoutError) return 504;
+	return 500;
+}
+function isRunRequestBody(value) {
+	if (value === null || typeof value !== "object") return false;
+	const record = value;
+	return typeof record.commandScopeId === "string" && typeof record.name === "string" && Array.isArray(record.args) && record.args.every((arg) => typeof arg === "string") && typeof record.cwd === "string" && typeof record.stdin === "string";
+}
+function readJsonBody(req) {
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		req.on("data", (chunk) => chunks.push(chunk));
+		req.on("end", () => {
+			try {
+				resolve(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+			} catch (error) {
+				reject(error);
+			}
+		});
+		req.on("error", reject);
+	});
+}
+function sendJson(res, status, body) {
+	const text = JSON.stringify(body);
+	res.writeHead(status, { "content-type": "application/json; charset=utf-8" });
+	res.end(text);
+}
+function closeServer(httpServer, socketPath) {
+	return new Promise((resolve) => {
+		httpServer.close(() => {
+			try {
+				if (existsSync(socketPath)) unlinkSync(socketPath);
+			} catch {}
+			resolve();
+		});
+	});
+}
+//#endregion
+//#region src/command-bridge-shim.ts
+const BRIDGE_BIN = "bridge-bin";
+const DISPATCH_FILE = ".dispatch";
+const DISPATCH_PACKAGE_JSON = "{\"type\":\"commonjs\"}\n";
+/**
+* Rejects an `agentSessionId` that cannot be used as one filesystem path
+* segment. `agentSessionId` is client-supplied and becomes a real path
+* component under Host.fs, so it is validated here rather than trusted.
+*/
+function assertPathSafeSessionId(agentSessionId) {
+	if (agentSessionId.length === 0 || agentSessionId.includes("\0") || agentSessionId.includes("/") || agentSessionId.includes("\\") || agentSessionId === "." || agentSessionId === "..") throw new Error(`Command bridge: agentSessionId "${agentSessionId}" is not safe to use as a path segment`);
+}
+/** Fixed relative layout under stateDir. */
+function bridgeBinDirFor(stateDir) {
+	return `${stateDir.replace(/\/+$/, "")}/${BRIDGE_BIN}`;
+}
+/**
+* Writes the command bridge shim directory for one session and returns its
+* resolved absolute path for PATH injection. Idempotent: safe on every open().
+*/
+async function materializeCommandBridgeShims(options) {
+	const { host, agentSessionId, commandNames, shimSource, stateDir } = options;
+	assertPathSafeSessionId(agentSessionId);
+	if (!stateDir || stateDir.includes("\0")) throw new Error("Command bridge: stateDir must be a non-empty absolute path");
+	const dir = `${bridgeBinDirFor(stateDir)}/${agentSessionId}`;
+	await host.fs.mkdir(dir, { recursive: true });
+	await host.fs.writeFile(`${dir}/package.json`, encodeUtf8(DISPATCH_PACKAGE_JSON));
+	await host.fs.writeFile(`${dir}/${DISPATCH_FILE}`, encodeUtf8(shimSource));
+	await host.fs.chmod(`${dir}/${DISPATCH_FILE}`, 493);
+	const wanted = new Set(commandNames);
+	const existing = await host.fs.readdir(dir);
+	for (const entry of existing) {
+		if (entry === DISPATCH_FILE || entry === "package.json" || wanted.has(entry)) continue;
+		await host.fs.rm(`${dir}/${entry}`, { force: true });
+	}
+	for (const name of wanted) {
+		const linkPath = `${dir}/${name}`;
+		await host.fs.rm(linkPath, { force: true });
+		await host.fs.symlink(DISPATCH_FILE, linkPath);
+	}
+	return host.fs.realpath(dir);
+}
+//#endregion
+//#region src/demi-home.ts
+/** Fixed layout: `<stateDir>/bridges/<id>.sock` (short id for macOS AF_UNIX limits). */
+function defaultBridgeSocketPath(stateDir, serverId = randomUUID().replace(/-/g, "").slice(0, 12)) {
+	return join(stateDir, "bridges", `${serverId}.sock`);
+}
+//#endregion
 //#region src/local-store.ts
 var LocalHostStore = class {
 	root;
@@ -12,8 +276,7 @@ var LocalHostStore = class {
 	}
 	async readJson(key) {
 		try {
-			const content = await readFile(this.pathForKey(key), "utf8");
-			return JSON.parse(content);
+			return parsePortableJson(await readFile(this.pathForKey(key), "utf8"));
 		} catch (error) {
 			if (isFileNotFoundError(error)) return null;
 			throw error;
@@ -22,7 +285,7 @@ var LocalHostStore = class {
 	async writeJson(key, value) {
 		const path = this.pathForKey(key);
 		await mkdir(dirname(path), { recursive: true });
-		await writeFile(path, JSON.stringify(value, null, 2), "utf8");
+		await writeFile(path, stringifyPortableJson(value, 2), "utf8");
 	}
 	async delete(key) {
 		await rm(this.pathForKey(key), {
@@ -235,16 +498,16 @@ var LocalHostFileSystem = class {
 		return readdir(target);
 	}
 	async mkdir(path, options) {
-		await mkdir(this.resolvePath(path, options?.cwd), { recursive: options?.recursive });
+		await mkdir(this.resolvePath(path, options?.cwd), { recursive: options?.recursive === true });
 	}
 	async rm(path, options) {
 		await rm(this.resolvePath(path, options?.cwd), {
-			recursive: options?.recursive,
-			force: options?.force
+			recursive: options?.recursive === true,
+			force: options?.force === true
 		});
 	}
 	async cp(path, destination, options) {
-		await cp(this.resolvePath(path, options?.cwd), this.resolvePath(destination, options?.cwd), { recursive: options?.recursive });
+		await cp(this.resolvePath(path, options?.cwd), this.resolvePath(destination, options?.cwd), { recursive: options?.recursive === true });
 	}
 	async mv(path, destination, options) {
 		await rename(this.resolvePath(path, options?.cwd), this.resolvePath(destination, options?.cwd));
@@ -310,4 +573,79 @@ async function* streamBytes(stream) {
 	else yield Buffer.from(String(chunk));
 }
 //#endregion
-export { LocalHost };
+//#region src/local-agent-server.ts
+/**
+* Open-box local agent assembly: `LocalHost` + `AgentServer` with command
+* bridge **on by default**.
+*
+* Owns the Node-only bridge transport (UDS + PATH shims under `stateDir`).
+* AgentServer only receives a generic `prepareSessionShell` hook and exposes
+* `runCommandLine` — it never sees bin dirs or sockets.
+*
+* Default layout under `stateDir` (`~/.demi` or `$DEMI_HOME`):
+* ```
+* bridges/<id>.sock
+* bridge-bin/<sessionId>/…
+* ```
+*/
+function createLocalAgentServer(options) {
+	const bridgeEnabled = options.commandBridge !== false;
+	const stateDir = bridgeEnabled ? resolveDemiHome(options.stateDir) : null;
+	let socketPath = null;
+	if (bridgeEnabled && stateDir) {
+		socketPath = options.commandBridgeSocketPath ?? defaultBridgeSocketPath(stateDir);
+		mkdirSync(dirname(socketPath), { recursive: true });
+	}
+	const initialEnv = {
+		PATH: process.env.PATH ?? "",
+		...options.shell?.initialEnv
+	};
+	const serverOptions = {
+		agent: options.agent,
+		providers: options.providers,
+		session: options.session,
+		shell: {
+			...options.shell,
+			initialEnv
+		}
+	};
+	if (bridgeEnabled && socketPath && stateDir) {
+		const bridgeStateDir = stateDir;
+		const bridgeSocketPath = socketPath;
+		serverOptions.prepareSessionShell = async ({ host, agentSessionId, commandNames, shell }) => {
+			const shimDir = await materializeCommandBridgeShims({
+				host,
+				agentSessionId,
+				commandNames,
+				shimSource: COMMAND_BRIDGE_SHIM_SOURCE,
+				stateDir: bridgeStateDir
+			});
+			const existingPath = shell.initialEnv?.PATH;
+			return {
+				...shell,
+				initialEnv: {
+					...shell.initialEnv,
+					DEMI_COMMAND_BRIDGE_SOCK: bridgeSocketPath,
+					PATH: existingPath ? `${shimDir}:${existingPath}` : shimDir
+				}
+			};
+		};
+	}
+	const server = new AgentServer(serverOptions);
+	let bridge = null;
+	if (bridgeEnabled && socketPath) bridge = startCommandBridge(server, { socketPath });
+	return {
+		server,
+		host: options.host,
+		stateDir,
+		async close() {
+			if (bridge) {
+				await bridge.close();
+				bridge = null;
+			}
+			await server.close();
+		}
+	};
+}
+//#endregion
+export { COMMAND_BRIDGE_SHIM_SOURCE, LocalHost, bridgeBinDirFor, createLocalAgentServer, defaultBridgeSocketPath, materializeCommandBridgeShims, resolveDemiHome, startCommandBridge };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@demicodes/host-local",
-  "description": "Node Host adapter for the Demi shell.",
-  "version": "0.1.0",
+  "description": "Node LocalHost and open-box local AgentServer assembly (command bridge on by default).",
+  "version": "0.2.1",
   "private": false,
   "type": "module",
   "exports": {
@@ -12,8 +12,10 @@
     }
   },
   "dependencies": {
-    "@demicodes/shell": "workspace:*",
-    "@demicodes/utils": "workspace:*"
+    "@demicodes/agent": "^0.2.1",
+    "@demicodes/provider": "^0.2.1",
+    "@demicodes/shell": "^0.2.1",
+    "@demicodes/utils": "^0.2.1"
   },
   "license": "Apache-2.0",
   "main": "./dist/index.mjs",