@abot-ai/runtime 1.3.1 → 1.4.0

package/dist/src/capabilities/file-output-presentation.js

@@ -0,0 +1,133 @@
+import { createHash } from "node:crypto";
+export function hasStableFileOutputRootIdentity(identity) {
+    if (!identity.isDirectory())
+        return false;
+    if (typeof identity.dev !== "bigint")
+        return false;
+    if (identity.dev < 0n)
+        return false;
+    if (typeof identity.ino !== "bigint")
+        return false;
+    if (identity.ino <= 0n)
+        return false;
+    if (typeof identity.birthtimeNs !== "bigint")
+        return false;
+    return identity.birthtimeNs > 0n;
+}
+/**
+ * The caller supplies the canonical rootPath returned by the host resolver.
+ * Encoding: SHA-256 of UTF-8 JSON [v3 domain, location, canonical root, decimal
+ * device, inode, birthtimeNs, root marker token], with a sha256: prefix. The
+ * random marker distinguishes roots even if an inode and birth time are reused.
+ * Child changes must not invalidate the root, so mtime/ctime are never included.
+ * Older path-only hashes cannot match; unavailable birth identity fails closed.
+ */
+export function createFileOutputRootId(location, canonicalRoot, identity, markerToken) {
+    if (!hasStableFileOutputRootIdentity(identity))
+        throw new Error("Stable file-output root identity is unavailable.");
+    if (!/^[a-f0-9]{64}$/u.test(markerToken))
+        throw new Error("Stable file-output root marker is unavailable.");
+    const encoded = JSON.stringify([
+        "abot-file-output-root-v3",
+        location,
+        canonicalRoot,
+        identity.dev.toString(),
+        identity.ino.toString(),
+        identity.birthtimeNs.toString(),
+        markerToken,
+    ]);
+    return `sha256:${createHash("sha256").update(encoded, "utf8").digest("hex")}`;
+}
+export function isToolFileOutputLocation(value) {
+    return value === "agent_work" || value === "workspace";
+}
+function isFileOutputRecord(value) {
+    if (value === null)
+        return false;
+    if (typeof value !== "object")
+        return false;
+    return !Array.isArray(value);
+}
+function isRootIdentityInteger(value) {
+    if (typeof value !== "string")
+        return false;
+    return /^(?:0|[1-9][0-9]{0,63})$/u.test(value);
+}
+/** A detached host report binding; filesystem authority is verified separately. */
+export function parseToolFileOutputRootIdentity(value) {
+    if (!isFileOutputRecord(value))
+        return undefined;
+    if (!isRootIdentityInteger(value.device))
+        return undefined;
+    if (!isRootIdentityInteger(value.inode))
+        return undefined;
+    if (value.inode === "0")
+        return undefined;
+    if (!isRootIdentityInteger(value.birthtimeNs))
+        return undefined;
+    if (value.birthtimeNs === "0")
+        return undefined;
+    return Object.freeze({
+        device: value.device,
+        inode: value.inode,
+        birthtimeNs: value.birthtimeNs,
+    });
+}
+function isFileOutputRelativePath(value) {
+    if (typeof value !== "string")
+        return false;
+    if (value.length === 0)
+        return false;
+    if (value.length > 4096)
+        return false;
+    if (value.includes("\0"))
+        return false;
+    if (value.includes("\\"))
+        return false;
+    if (/^[A-Za-z]:/u.test(value))
+        return false;
+    return value.split("/").every(isFileOutputPathSegment);
+}
+function isFileOutputPathSegment(value) {
+    if (value.length === 0)
+        return false;
+    if (value === ".")
+        return false;
+    return value !== "..";
+}
+function isFileOutputOperation(value) {
+    return value === "created" || value === "updated";
+}
+function isFileOutputRootId(value) {
+    if (typeof value !== "string")
+        return false;
+    return /^sha256:[a-f0-9]{64}$/u.test(value);
+}
+/** Structural validation is not authorization; the server must verify origin. */
+export function parseToolFileOutputReceipt(value) {
+    if (!isFileOutputRecord(value))
+        return undefined;
+    if (value.version !== 1)
+        return undefined;
+    if (!isToolFileOutputLocation(value.location))
+        return undefined;
+    if (!isFileOutputRelativePath(value.relativePath))
+        return undefined;
+    if (!isFileOutputOperation(value.operation))
+        return undefined;
+    if (!isFileOutputRootId(value.rootId))
+        return undefined;
+    const logicalPath = value.location === "workspace"
+        ? `workspace/${value.relativePath}`
+        : value.relativePath;
+    if (value.logicalPath !== logicalPath)
+        return undefined;
+    return Object.freeze({
+        version: 1,
+        location: value.location,
+        rootId: value.rootId,
+        relativePath: value.relativePath,
+        logicalPath,
+        operation: value.operation,
+    });
+}

package/dist/src/capabilities/tool-definition-validator/definition-parser.js

@@ -1,3 +1,4 @@
+import { parseRequiredToolPermissionMode } from "../tool-permission-mode.js";
 import { isDevelopmentRole, isExecutionEffect, isRoutingCapability, parseParamsByCommand, parseRuntimePathBindings, parseToolCatalogGroups, } from "./definition-fields.js";
 import { parseEventPresentation } from "./event-presentation.js";
 import { parsePayloadChannelSpec } from "./payload-channel-spec.js";
@@ -48,6 +49,7 @@ export function parseToolDefinition(raw) {
     const parsedEventPresentation = parseEventPresentation(name, eventPresentation);
     return {
         name,
+        requiredPermissionMode: parseRequiredToolPermissionMode(raw.requiredPermissionMode, `${name}.requiredPermissionMode`),
         ...(typeof description === "string" ? { description } : {}),
         routingCapability,
         ...(controlsRefinement === "mechanical_when_complete"

package/dist/src/capabilities/tool-definition-validator/event-input-text-options.d.ts

@@ -0,0 +1,5 @@
+import type { ToolEventMetadataProjection } from "../tool-types.js";
+type InputTextOptions = Pick<ToolEventMetadataProjection, "maxLength" | "preserveWhitespace">;
+/** The same optional input-text contract applies to manifests and tool modules. */
+export declare function parseEventInputTextOptions(projection: Record<string, unknown>, path: string): InputTextOptions;
+export {};

package/dist/src/capabilities/tool-definition-validator/event-input-text-options.js

@@ -0,0 +1,37 @@
+/** The same optional input-text contract applies to manifests and tool modules. */
+export function parseEventInputTextOptions(projection, path) {
+    const { maxLength, preserveWhitespace } = projection;
+    if (maxLength === undefined && preserveWhitespace === undefined)
+        return {};
+    if (!supportsInputTextOptions(projection.kind)) {
+        throw new Error(`${path} text options require kind string or string_array`);
+    }
+    if (maxLength !== undefined && projection.kind !== "string") {
+        throw new Error(`${path}.maxLength requires kind string`);
+    }
+    if (!hasSupportedInputTextLength(maxLength)) {
+        throw new Error(`${path}.maxLength must be an integer from 1 to 4096`);
+    }
+    if (!hasSupportedWhitespaceOption(preserveWhitespace)) {
+        throw new Error(`${path}.preserveWhitespace must be a boolean`);
+    }
+    return {
+        ...(maxLength !== undefined ? { maxLength } : {}),
+        ...(preserveWhitespace !== undefined ? { preserveWhitespace } : {}),
+    };
+}
+function hasSupportedInputTextLength(value) {
+    if (value === undefined)
+        return true;
+    if (typeof value !== "number" || !Number.isInteger(value))
+        return false;
+    return value >= 1 && value <= 4_096;
+}
+function hasSupportedWhitespaceOption(value) {
+    if (value === undefined)
+        return true;
+    return typeof value === "boolean";
+}
+function supportsInputTextOptions(kind) {
+    return kind === "string" || kind === "string_array";
+}

package/dist/src/capabilities/tool-definition-validator/event-presentation.js

@@ -1,8 +1,10 @@
 import { isToolDefinitionRecordValue } from "./definition-shape.js";
 import { parseEventResultMetadata } from "./event-result-metadata.js";
+import { parseEventInputTextOptions } from "./event-input-text-options.js";
 const EVENT_PROJECTION_KINDS = [
     "string",
     "number",
+    "boolean",
     "string_array",
     "length",
 ];
@@ -45,6 +47,7 @@ function parseEventMetadataProjection(toolName, key, raw) {
         {
             param: param.trim(),
             kind,
+            ...parseEventInputTextOptions(raw, `eventPresentation.metadata.${key} (${toolName})`),
             ...(fallback !== undefined ? { default: fallback } : {}),
         },
     ];

package/dist/src/capabilities/tool-definition-validator/module-registry.js

@@ -51,6 +51,9 @@ export function validateToolModuleDeclarations(modules) {
             implementation: tool.implementation,
             ...(tool.adapter ? { adapter: tool.adapter } : {}),
             normalInvocation: tool.normalInvocation,
+            ...(source.prepareRequest
+                ? { prepareRequest: source.prepareRequest }
+                : {}),
         };
     });
 }
@@ -62,6 +65,7 @@ function parseToolAdapter(toolName, raw) {
     }
     const normalizeCall = raw.normalizeCall;
     const validateCall = raw.validateCall;
+    const executionBinding = raw.executionBinding;
     if (normalizeCall !== undefined && typeof normalizeCall !== "function") {
         throw new Error(`Invalid tool module for ${toolName} (adapter.normalizeCall)`);
     }
@@ -69,6 +73,14 @@ function parseToolAdapter(toolName, raw) {
         throw new Error(`Invalid tool module for ${toolName} (adapter.validateCall)`);
     }
     const adapter = {};
+    if (executionBinding !== undefined &&
+        typeof executionBinding !== "function") {
+        throw new Error(`Invalid tool module for ${toolName} (adapter.executionBinding)`);
+    }
+    if (typeof executionBinding === "function") {
+        adapter.executionBinding =
+            executionBinding;
+    }
     if (typeof normalizeCall === "function") {
         adapter.normalizeCall = normalizeCall;
     }

package/dist/src/capabilities/tool-event-input-text.d.ts

@@ -0,0 +1,9 @@
+import type { ToolEventMetadataProjection } from "./tool-types.js";
+/** Opt-in exact text stays display-only and never replaces the accepted input. */
+export declare function projectDeclaredInputText(raw: unknown, projection: ToolEventMetadataProjection): Readonly<{
+    text: string;
+    truncated: boolean;
+}> | undefined;
+export declare function hasDeclaredInputTextOptions(projection: ToolEventMetadataProjection): boolean;
+/** Preserve array positions, empty values and whitespace in opt-in arguments. */
+export declare function projectDeclaredInputFields(key: string, raw: unknown, projection: ToolEventMetadataProjection): [string, unknown][];

package/dist/src/capabilities/tool-event-input-text.js

@@ -0,0 +1,64 @@
+/** Opt-in exact text stays display-only and never replaces the accepted input. */
+export function projectDeclaredInputText(raw, projection) {
+    if (typeof raw !== "string")
+        return undefined;
+    const text = projection.preserveWhitespace === true ? raw : raw.trim();
+    if (text.length === 0)
+        return undefined;
+    const limit = Math.min(4_096, projection.maxLength ?? 500);
+    let end = Math.min(text.length, limit);
+    if (splitsInputTextSurrogatePair(text, end))
+        end -= 1;
+    return { text: text.slice(0, end), truncated: end < text.length };
+}
+export function hasDeclaredInputTextOptions(projection) {
+    if (projection.kind !== "string" && projection.kind !== "string_array")
+        return false;
+    if (projection.maxLength !== undefined)
+        return true;
+    return projection.preserveWhitespace !== undefined;
+}
+function splitsInputTextSurrogatePair(text, end) {
+    if (end <= 0 || end >= text.length)
+        return false;
+    const before = text.charCodeAt(end - 1);
+    const after = text.charCodeAt(end);
+    if (before < 0xd800 || before > 0xdbff)
+        return false;
+    return after >= 0xdc00 && after <= 0xdfff;
+}
+/** Preserve array positions, empty values and whitespace in opt-in arguments. */
+export function projectDeclaredInputFields(key, raw, projection) {
+    if (projection.kind === "string_array") {
+        return projectDeclaredInputArray(key, raw, projection);
+    }
+    const text = projectDeclaredInputText(raw, projection);
+    return text
+        ? [
+            [key, text.text],
+            [`${key}Truncated`, text.truncated],
+        ]
+        : [];
+}
+function projectDeclaredInputArray(key, raw, projection) {
+    if (!hasOnlyStringArguments(raw))
+        return [];
+    const omittedCount = Math.max(0, raw.length - 32);
+    let truncated = omittedCount > 0;
+    const values = raw.slice(0, 32).map((argument) => {
+        const text = projectDeclaredInputText(argument, projection);
+        if (text?.truncated)
+            truncated = true;
+        return text?.text ?? "";
+    });
+    return [
+        [key, values],
+        [`${key}Truncated`, truncated],
+        [`${key}OmittedCount`, omittedCount],
+    ];
+}
+function hasOnlyStringArguments(raw) {
+    if (!Array.isArray(raw))
+        return false;
+    return raw.every((value) => typeof value === "string");
+}

package/dist/src/capabilities/tool-event-metadata.js

@@ -1,4 +1,5 @@
 import { projectToolResultEventMetadata } from "./tool-result-event-projection.js";
+import { hasDeclaredInputTextOptions, projectDeclaredInputFields, } from "./tool-event-input-text.js";
 function safeTrim(value) {
     return typeof value === "string" ? value.trim() : "";
 }
@@ -99,6 +100,9 @@ function buildDeclaredCallMeta(call, definition) {
     if (!projections)
         return undefined;
     const values = Object.fromEntries(Object.entries(projections).flatMap(([key, projection]) => {
+        if (hasDeclaredInputTextOptions(projection)) {
+            return projectDeclaredInputFields(key, call.params[projection.param] ?? projection.default, projection);
+        }
         let value;
         switch (projection.kind) {
             case "string":
@@ -107,6 +111,12 @@ function buildDeclaredCallMeta(call, definition) {
             case "number":
                 value = readNumberParam(call.params, projection.param);
                 break;
+            case "boolean":
+                value =
+                    typeof call.params[projection.param] === "boolean"
+                        ? call.params[projection.param]
+                        : undefined;
+                break;
             case "string_array":
                 value = readStringArrayParam(call.params, projection.param);
                 break;

package/dist/src/capabilities/tool-executor.d.ts

@@ -5,6 +5,7 @@ type ToolExecutorOptions = {
     sharedState?: ToolExecutionContext["sharedState"];
     modelInvoker?: ToolExecutionContext["modelInvoker"];
     runtimePathResolver?: ToolExecutionContext["runtimePathResolver"];
+    reportFileOutput?: ToolExecutionContext["reportFileOutput"];
 };
 export declare function executeToolCall(call: ToolCall, options?: ToolExecutorOptions): Promise<ToolExecutionResult>;
 export {};

package/dist/src/capabilities/tool-executor.js

@@ -101,6 +101,7 @@ export async function executeToolCall(call, options = {}) {
             sharedState: options.sharedState,
             modelInvoker: options.modelInvoker,
             runtimePathResolver: options.runtimePathResolver,
+            reportFileOutput: options.reportFileOutput,
         });
         const rawOutput = options.abortSignal
             ? await raceWithAbort(execution, options.abortSignal)

package/dist/src/capabilities/tool-permission-mode.d.ts

@@ -0,0 +1,7 @@
+/** User-selected request authority. Never infer this value from model content. */
+export type ToolPermissionMode = "ask" | "full_access" | "full_plus";
+export type ToolRequiredPermissionMode = "full_plus";
+export declare function resolveToolPermissionMode(value: unknown): ToolPermissionMode;
+export declare function permitsRequiredToolMode(mode: ToolPermissionMode, requiredMode: ToolRequiredPermissionMode | undefined): boolean;
+export declare function requiresToolActionApproval(mode: ToolPermissionMode, force: boolean): boolean;
+export declare function parseRequiredToolPermissionMode(value: unknown, path: string): ToolRequiredPermissionMode | undefined;

package/dist/src/capabilities/tool-permission-mode.js

@@ -0,0 +1,27 @@
+export function resolveToolPermissionMode(value) {
+    if (value === "full_plus")
+        return "full_plus";
+    const mode = typeof value === "string" ? value.trim().toLowerCase() : "";
+    if (mode === "full_access" || mode === "full")
+        return "full_access";
+    return "ask";
+}
+export function permitsRequiredToolMode(mode, requiredMode) {
+    if (requiredMode === undefined)
+        return true;
+    return mode === requiredMode;
+}
+export function requiresToolActionApproval(mode, force) {
+    if (mode === "full_plus")
+        return false;
+    if (force)
+        return true;
+    return mode === "ask";
+}
+export function parseRequiredToolPermissionMode(value, path) {
+    if (value === undefined)
+        return undefined;
+    if (value === "full_plus")
+        return value;
+    throw new Error(`${path} must be full_plus when declared`);
+}

package/dist/src/capabilities/tool-types.d.ts

@@ -1,6 +1,8 @@
+import type { ToolPermissionMode, ToolRequiredPermissionMode } from "./tool-permission-mode.js";
 import type { ModelStep } from "../shared/types.js";
 import type { RuntimeAttachmentKind } from "../shared/attachments.js";
 import type { ToolNormalInvocationContract } from "./normal-invocation/contracts.js";
+import type { ToolFileOutputReporter } from "./file-output-presentation.js";
 export type { ToolNormalInvocationApproval, ToolNormalInvocationArrayInput, ToolNormalInvocationBooleanInput, ToolNormalInvocationBoundedStringInput, ToolNormalInvocationContract, ToolNormalInvocationEnumInput, ToolNormalInvocationEffect, ToolNormalInvocationFixedValue, ToolNormalInvocationInput, ToolNormalInvocationInputValidation, ToolNormalInvocationNumberInput, ToolNormalInvocationOperation, ToolNormalInvocationPayload, ToolNormalInvocationPropertyInput, ToolNormalInvocationScalarInput, ToolNormalInvocationUnboundedStringInput, } from "./normal-invocation/contracts.js";
 export type ToolRoutingCapability = "filesystem_inspection" | "filesystem_mutation" | "semantic_lookup" | "semantic_mutation" | "web_lookup";
 export type ToolDevelopmentRole = "inspect" | "establish" | "mutate" | "verify" | "auxiliary";
@@ -11,7 +13,9 @@ export type ToolExecutionEffect = "read_only" | "mutating" | "mixed";
 export type ToolControlsRefinement = "mechanical_when_complete";
 export type ToolEventMetadataProjection = Readonly<{
     param: string;
-    kind: "string" | "number" | "string_array" | "length";
+    kind: "string" | "number" | "boolean" | "string_array" | "length";
+    maxLength?: number;
+    preserveWhitespace?: boolean;
     default?: string | number | boolean;
 }>;
 export type ToolEventLifecycleCopy = Readonly<{
@@ -86,6 +90,7 @@ export type ToolRuntimePathBinding = Readonly<{
     default?: ".";
 }>;
 export type ToolDefinition = {
+    requiredPermissionMode?: ToolRequiredPermissionMode;
     name: string;
     description?: string;
     routingCapability: ToolRoutingCapability;
@@ -106,7 +111,7 @@ export type CanonicalToolDefinitionDeclaration = Omit<ToolDefinition, "params" |
 export type ToolDefinitionDeclaration = CanonicalToolDefinitionDeclaration;
 export type ToolExecutionRequestContext = Readonly<{
     agentMode: "fast" | "reasoning" | "deep";
-    toolPermissionMode: "ask" | "full_access";
+    toolPermissionMode: ToolPermissionMode;
     modelPreference?: Readonly<{
         profileId: string;
         scope?: "main" | "all";
@@ -181,6 +186,8 @@ export type ToolExecutionContext = {
     sharedState?: ToolExecutionSharedState;
     /** Runtime-owned path interpretation and containment authority. */
     runtimePathResolver?: RuntimeToolPathResolver;
+    /** Optional host presentation channel; never add its data to tool results. */
+    reportFileOutput?: ToolFileOutputReporter;
     /** Trusted request-bound service for tools whose own implementation uses a model. */
     modelInvoker?: ToolModelInvoker;
 };
@@ -195,6 +202,12 @@ export type ToolCallAdapter = {
         error: string;
         repairHint?: string;
     } | null;
+    /** Request-captured execution authority; never projected into model controls. */
+    executionBinding?: (input: ToolCallAdapterInput) => Readonly<{
+        identity: string;
+        /** Human approval/activity disclosure only, never tool-result evidence. */
+        metadata?: Readonly<Record<string, unknown>>;
+    }>;
 };
 export type ToolModule = {
     definition: ToolDefinition;
@@ -206,7 +219,10 @@ type ToolModuleDeclarationBase = Omit<ToolModule, "definition" | "normalInvocati
 export type ToolModuleDeclaration = ToolModuleDeclarationBase & {
     definition: CanonicalToolDefinitionDeclaration;
     normalInvocation: ToolNormalInvocationContract;
+    /** Shared callback identity groups already selected modules for one request. */
+    prepareRequest?: ToolModuleRequestPreparation;
 };
+export type ToolModuleRequestPreparation = (modules: readonly ToolModuleDeclaration[]) => Promise<readonly ToolModuleDeclaration[]>;
 export type RegisteredToolNormalInvocation = Readonly<{
     toolName: string;
     definition: ToolDefinition;

package/dist/src/cli/abot.js

@@ -2,11 +2,13 @@ import { join, resolve } from "node:path";
 import { runAddRuntimeModel } from "../../scripts/add-runtime-model.js";
 import { runInitRuntime } from "../../scripts/init-runtime.js";
 import { runConfigureLongTermMemory } from "../../scripts/configure-long-term-memory.js";
-import { createModelGatewayServer, resolveProviderAdapters, resolveModelGatewayPort, } from "../model-gateway/server.js";
+import { resolveProviderAdapters } from "../model-gateway/server.js";
 import { loadDotEnvFile } from "../shared/load-dotenv.js";
-import { closeHttpServerImmediately } from "../shared/http-server-shutdown.js";
+import { closeRuntimeSetupServices } from "../web-ui/runtime-setup-shutdown.js";
+import { RuntimeSetupGateway } from "../web-ui/runtime-setup-gateway.js";
 import { startWebUiServer } from "../web-ui/server.js";
 import { resolveWebUiAddress } from "../web-ui/web-ui-address.js";
+import { runHostCompanionCli } from "./host-companion.js";
 function printHelp() {
     console.log([
         "ABot Runtime",
@@ -16,12 +18,14 @@ function printHelp() {
         "  abot add-model --profile <profile-id> --provider <provider> --model <model-id> [options]",
         "  abot memory <status|models|enable|disable> [options]",
         "  abot start",
+        "  abot host <connect|status|disconnect|uninstall|run>",
         "",
         "Commands:",
         "  init       Create the first machine-local runtime configuration.",
         "  add-model  Add a provider/model profile without replacing existing ones.",
         "  memory     Configure passive long-term memory embeddings.",
         "  start      Start the local model gateway and Web UI.",
+        "  host       Pair this computer with a local Docker Runtime.",
     ].join("\n"));
 }
 async function runStart(args) {
@@ -37,17 +41,12 @@ async function runStart(args) {
     const webAddress = resolveWebUiAddress(process.env);
     const appDir = resolve(import.meta.dirname, "../web-ui/app");
     const providerAdapters = resolveProviderAdapters({});
-    let gateway;
+    const gateway = new RuntimeSetupGateway({ rootDir, providerAdapters });
     try {
-        gateway = createModelGatewayServer({ providerAdapters });
-        const gatewayPort = resolveModelGatewayPort();
-        gateway.listen(gatewayPort, "127.0.0.1", () => {
-            console.log(`model gateway listening on http://127.0.0.1:${gatewayPort}`);
-        });
+        await gateway.activate(process.env.LLM_RUNTIME_CONFIG_FILE);
     }
-    catch (error) {
-        console.warn(`model gateway not started: ${error instanceof Error ? error.message : String(error)}`);
-        console.warn("Complete model setup, stop ABot, and run abot start again.");
+    catch {
+        console.log("Complete model setup in the Web UI to start the model gateway.");
     }
     const webUi = startWebUiServer({
         appDir,
@@ -56,6 +55,9 @@ async function runStart(args) {
         port: webAddress.port,
         setupCommandMode: "package",
         providerAdapters,
+        onRuntimeSetup: (configPath) => gateway.activate(configPath),
+        createRuntimeSetupRestorePoint: () => gateway.createRestorePoint(),
+        checkRuntimeSetupActivation: (configPath) => gateway.checkActivation(configPath),
     });
     console.log(`Open ${webAddress.browserUrl}`);
     await new Promise((resolveExit, rejectExit) => {
@@ -64,10 +66,7 @@ async function runStart(args) {
             if (closing)
                 return;
             closing = true;
-            void Promise.all([
-                webUi.close(),
-                ...(gateway ? [closeHttpServerImmediately(gateway)] : []),
-            ]).then(() => resolveExit(), rejectExit);
+            void closeRuntimeSetupServices(() => webUi.close(), () => gateway.close()).then(() => resolveExit(), rejectExit);
         };
         process.once("SIGINT", shutdown);
         process.once("SIGTERM", shutdown);
@@ -98,5 +97,9 @@ export async function runAbotCli(argv = process.argv.slice(2)) {
         await runStart(args);
         return;
     }
+    if (command === "host") {
+        await runHostCompanionCli(args);
+        return;
+    }
     throw new Error(`unknown command: ${command}`);
 }