@botbotgo/agent-harness 0.0.308 → 0.0.310

package/dist/cli/managed-service.d.ts

@@ -0,0 +1,27 @@
+export type ManagedCliService = "acp" | "a2a" | "mcp";
+export type ManagedCliServiceState = {
+    pid: number;
+    service: ManagedCliService;
+    workspaceRoot: string;
+    transport: "http" | "streamable-http";
+    hostname?: string;
+    port?: number;
+    startedAt: string;
+    stdoutPath: string;
+    stderrPath: string;
+};
+export declare function managedServiceLogPath(workspaceRoot: string, service: ManagedCliService, stream: "stdout" | "stderr"): string;
+export declare function readManagedServiceState(workspaceRoot: string, service: ManagedCliService): Promise<ManagedCliServiceState | null>;
+export declare function writeManagedServiceState(state: ManagedCliServiceState): Promise<void>;
+export declare function clearManagedServiceState(workspaceRoot: string, service: ManagedCliService): Promise<void>;
+export declare function defaultIsManagedProcessRunning(pid: number): boolean;
+export declare function defaultSignalManagedProcess(pid: number, signal?: NodeJS.Signals): void;
+export declare function defaultSpawnManagedCliProcess(input: {
+    args: string[];
+    cwd: string;
+    stdoutPath: string;
+    stderrPath: string;
+}): Promise<{
+    pid?: number;
+}>;
+export declare function sleep(ms: number): Promise<void>;

package/dist/cli/managed-service.js

@@ -0,0 +1,61 @@
+import { spawn } from "node:child_process";
+import { existsSync, openSync } from "node:fs";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+function resolveManagedServiceRoot(workspaceRoot) {
+    return path.join(workspaceRoot, ".botbotgo", "services");
+}
+function managedServiceStatePath(workspaceRoot, service) {
+    return path.join(resolveManagedServiceRoot(workspaceRoot), `${service}.json`);
+}
+export function managedServiceLogPath(workspaceRoot, service, stream) {
+    return path.join(resolveManagedServiceRoot(workspaceRoot), `${service}.${stream}.log`);
+}
+export async function readManagedServiceState(workspaceRoot, service) {
+    const statePath = managedServiceStatePath(workspaceRoot, service);
+    if (!existsSync(statePath)) {
+        return null;
+    }
+    try {
+        return JSON.parse(await readFile(statePath, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeManagedServiceState(state) {
+    const statePath = managedServiceStatePath(state.workspaceRoot, state.service);
+    await mkdir(path.dirname(statePath), { recursive: true });
+    await writeFile(statePath, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+}
+export async function clearManagedServiceState(workspaceRoot, service) {
+    await rm(managedServiceStatePath(workspaceRoot, service), { force: true });
+}
+export function defaultIsManagedProcessRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function defaultSignalManagedProcess(pid, signal) {
+    process.kill(pid, signal);
+}
+export async function defaultSpawnManagedCliProcess(input) {
+    await mkdir(path.dirname(input.stdoutPath), { recursive: true });
+    const stdoutFd = openSync(input.stdoutPath, "a");
+    const stderrFd = openSync(input.stderrPath, "a");
+    const child = spawn(process.execPath, [fileURLToPath(import.meta.url), ...input.args], {
+        cwd: input.cwd,
+        detached: true,
+        stdio: ["ignore", stdoutFd, stderrFd],
+    });
+    child.unref();
+    return { pid: child.pid };
+}
+export async function sleep(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/cli/options-init-chat.d.ts

@@ -0,0 +1,16 @@
+import type { InitProjectOptions } from "../init-project.js";
+export declare function parseInitOptions(args: string[]): {
+    options?: InitProjectOptions;
+    error?: string;
+};
+export declare function parseChatOptions(args: string[]): {
+    workspaceRoot?: string;
+    agentId?: string;
+    sessionId?: string;
+    message?: string;
+    requestEvents: boolean;
+    transport: "stdio" | "http";
+    hostname?: string;
+    port?: number;
+    error?: string;
+};

package/dist/cli/options-init-chat.js

@@ -0,0 +1,108 @@
+function isTemplate(value) {
+    return value === "deep-research" || value === "single-agent";
+}
+export function parseInitOptions(args) {
+    const options = {};
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--with-web-search") {
+            options.withWebSearch = true;
+            continue;
+        }
+        if (arg === "--no-web-search") {
+            options.withWebSearch = false;
+            continue;
+        }
+        if (arg === "--template" || arg === "--provider" || arg === "--model") {
+            const value = args[index + 1];
+            if (!value) {
+                return { error: `Missing value for ${arg}` };
+            }
+            if (arg === "--template") {
+                if (!isTemplate(value)) {
+                    return { error: `Unsupported template: ${value}` };
+                }
+                options.template = value;
+            }
+            else if (arg === "--provider") {
+                options.provider = value;
+            }
+            else {
+                options.model = value;
+            }
+            index += 1;
+            continue;
+        }
+        return { error: `Unknown option: ${arg}` };
+    }
+    return { options };
+}
+export function parseChatOptions(args) {
+    let workspaceRoot;
+    let agentId;
+    let sessionId;
+    let message;
+    let requestEvents = false;
+    let transport = "stdio";
+    let hostname;
+    let port;
+    const positional = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--workspace"
+            || arg === "-w"
+            || arg === "--agent"
+            || arg === "--session"
+            || arg === "--message"
+            || arg === "--transport"
+            || arg === "--host"
+            || arg === "--port") {
+            const value = args[index + 1];
+            if (!value) {
+                return { workspaceRoot, agentId, sessionId, message, requestEvents, transport, hostname, port, error: `Missing value for ${arg}` };
+            }
+            if (arg === "--workspace" || arg === "-w") {
+                workspaceRoot = value;
+            }
+            else if (arg === "--agent") {
+                agentId = value;
+            }
+            else if (arg === "--session") {
+                sessionId = value;
+            }
+            else if (arg === "--message") {
+                message = value;
+            }
+            else if (arg === "--transport") {
+                if (value !== "stdio" && value !== "http") {
+                    return { workspaceRoot, agentId, sessionId, message, requestEvents, transport, hostname, port, error: `Unsupported chat transport: ${value}` };
+                }
+                transport = value;
+            }
+            else if (arg === "--host") {
+                hostname = value;
+            }
+            else {
+                const parsedPort = Number.parseInt(value, 10);
+                if (!Number.isFinite(parsedPort) || parsedPort <= 0) {
+                    return { workspaceRoot, agentId, sessionId, message, requestEvents, transport, hostname, port, error: `Invalid chat port: ${value}` };
+                }
+                port = parsedPort;
+            }
+            index += 1;
+            continue;
+        }
+        if (arg === "--request-events") {
+            requestEvents = true;
+            continue;
+        }
+        if (arg.startsWith("-")) {
+            return { workspaceRoot, agentId, sessionId, message, requestEvents, transport, hostname, port, error: `Unknown option: ${arg}` };
+        }
+        positional.push(arg);
+    }
+    if (!message && positional.length > 0) {
+        message = positional.join(" ");
+    }
+    return { workspaceRoot, agentId, sessionId, message, requestEvents, transport, hostname, port };
+}

package/dist/cli/options-runtime.d.ts

@@ -0,0 +1,27 @@
+export declare function parseRuntimeInspectOptions(args: string[]): {
+    workspaceRoot?: string;
+    json: boolean;
+    once: boolean;
+    pollMs: number;
+    limit: number;
+    status?: string;
+    state?: string;
+    agentId?: string;
+    sessionId?: string;
+    error?: string;
+};
+export declare function parseRuntimeExportOptions(args: string[]): {
+    workspaceRoot?: string;
+    sessionId?: string;
+    requestId?: string;
+    includeArtifacts: boolean;
+    includeArtifactContents: boolean;
+    includeRuntimeHealth: boolean;
+    json: boolean;
+    error?: string;
+};
+export declare function parseScheduledRunOptions(args: string[]): {
+    workspaceRoot?: string;
+    scheduleId?: string;
+    error?: string;
+};

package/dist/cli/options-runtime.js

@@ -0,0 +1,158 @@
+export function parseRuntimeInspectOptions(args) {
+    let workspaceRoot;
+    let json = false;
+    let once = false;
+    let pollMs = 1000;
+    let limit = 5;
+    let status;
+    let state;
+    let agentId;
+    let sessionId;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--workspace" || arg === "--status" || arg === "--state" || arg === "--agent" || arg === "--session" || arg === "--poll-ms" || arg === "--limit") {
+            const value = args[index + 1];
+            if (!value) {
+                return { json, once, pollMs, limit, status, state, agentId, sessionId, error: `Missing value for ${arg}` };
+            }
+            if (arg === "--workspace") {
+                workspaceRoot = value;
+            }
+            else if (arg === "--status") {
+                status = value;
+            }
+            else if (arg === "--state") {
+                state = value;
+            }
+            else if (arg === "--agent") {
+                agentId = value;
+            }
+            else if (arg === "--session") {
+                sessionId = value;
+            }
+            else if (arg === "--limit") {
+                const parsedLimit = Number.parseInt(value, 10);
+                if (!Number.isFinite(parsedLimit) || parsedLimit <= 0) {
+                    return { json, once, pollMs, limit, status, state, agentId, sessionId, error: `Invalid limit: ${value}` };
+                }
+                limit = parsedLimit;
+            }
+            else {
+                const parsedPoll = Number.parseInt(value, 10);
+                if (!Number.isFinite(parsedPoll) || parsedPoll <= 0) {
+                    return { json, once, pollMs, limit, status, state, agentId, sessionId, error: `Invalid poll interval: ${value}` };
+                }
+                pollMs = parsedPoll;
+            }
+            index += 1;
+            continue;
+        }
+        if (arg === "--json") {
+            json = true;
+            continue;
+        }
+        if (arg === "--once") {
+            once = true;
+            continue;
+        }
+        return { workspaceRoot, json, once, pollMs, limit, status, state, agentId, sessionId, error: `Unknown option: ${arg}` };
+    }
+    return { workspaceRoot, json, once, pollMs, limit, status, state, agentId, sessionId };
+}
+export function parseRuntimeExportOptions(args) {
+    let workspaceRoot;
+    let sessionId;
+    let requestId;
+    let includeArtifacts = false;
+    let includeArtifactContents = false;
+    let includeRuntimeHealth = false;
+    let json = false;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--artifacts") {
+            includeArtifacts = true;
+            continue;
+        }
+        if (arg === "--artifact-contents") {
+            includeArtifacts = true;
+            includeArtifactContents = true;
+            continue;
+        }
+        if (arg === "--health") {
+            includeRuntimeHealth = true;
+            continue;
+        }
+        if (arg === "--json") {
+            json = true;
+            continue;
+        }
+        if (arg === "--workspace" || arg === "--session" || arg === "--request") {
+            const value = args[index + 1];
+            if (!value) {
+                return {
+                    workspaceRoot,
+                    sessionId,
+                    requestId,
+                    includeArtifacts,
+                    includeArtifactContents,
+                    includeRuntimeHealth,
+                    json,
+                    error: `Missing value for ${arg}`,
+                };
+            }
+            if (arg === "--workspace") {
+                workspaceRoot = value;
+            }
+            else if (arg === "--session") {
+                sessionId = value;
+            }
+            else {
+                requestId = value;
+            }
+            index += 1;
+            continue;
+        }
+        return {
+            workspaceRoot,
+            sessionId,
+            requestId,
+            includeArtifacts,
+            includeArtifactContents,
+            includeRuntimeHealth,
+            json,
+            error: `Unknown option: ${arg}`,
+        };
+    }
+    return {
+        workspaceRoot,
+        sessionId,
+        requestId,
+        includeArtifacts,
+        includeArtifactContents,
+        includeRuntimeHealth,
+        json,
+    };
+}
+export function parseScheduledRunOptions(args) {
+    let workspaceRoot;
+    let scheduleId;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--workspace" || arg === "--schedule") {
+            const value = args[index + 1];
+            if (!value) {
+                return { workspaceRoot, scheduleId, error: `Missing value for ${arg}` };
+            }
+            if (arg === "--workspace") {
+                workspaceRoot = value;
+            }
+            else {
+                scheduleId = value;
+            }
+            index += 1;
+            continue;
+        }
+        return { workspaceRoot, scheduleId, error: `Unknown option: ${arg}` };
+    }
+    return { workspaceRoot, scheduleId };
+}

package/dist/cli/options-serve.d.ts

@@ -0,0 +1,24 @@
+export declare function parseAcpServeOptions(args: string[], defaultTransport?: "stdio" | "http"): {
+    workspaceRoot?: string;
+    transport: "stdio" | "http";
+    hostname?: string;
+    port?: number;
+    error?: string;
+};
+export declare function parseWorkspaceOnlyOptions(args: string[]): {
+    workspaceRoot?: string;
+    error?: string;
+};
+export declare function parseHttpServeOptions(args: string[], serviceLabel?: string): {
+    workspaceRoot?: string;
+    hostname?: string;
+    port?: number;
+    error?: string;
+};
+export declare function parseRuntimeMcpServeOptions(args: string[], defaultTransport?: "stdio" | "streamable-http"): {
+    workspaceRoot?: string;
+    transport: "stdio" | "streamable-http";
+    hostname?: string;
+    port?: number;
+    error?: string;
+};

package/dist/cli/options-serve.js

@@ -0,0 +1,166 @@
+export function parseAcpServeOptions(args, defaultTransport = "stdio") {
+    let workspaceRoot;
+    let transport = defaultTransport;
+    let hostname;
+    let port;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--workspace") {
+            const value = args[index + 1];
+            if (!value) {
+                return { transport, hostname, port, error: "Missing value for --workspace" };
+            }
+            workspaceRoot = value;
+            index += 1;
+            continue;
+        }
+        if (arg === "--transport") {
+            const value = args[index + 1];
+            if (!value) {
+                return { transport, hostname, port, error: "Missing value for --transport" };
+            }
+            if (value !== "stdio" && value !== "http") {
+                return { transport, hostname, port, error: `Unsupported ACP transport: ${value}` };
+            }
+            transport = value;
+            index += 1;
+            continue;
+        }
+        if (arg === "--host") {
+            const value = args[index + 1];
+            if (!value) {
+                return { transport, hostname, port, error: "Missing value for --host" };
+            }
+            hostname = value;
+            index += 1;
+            continue;
+        }
+        if (arg === "--port") {
+            const value = args[index + 1];
+            if (!value) {
+                return { transport, hostname, port, error: "Missing value for --port" };
+            }
+            const parsedPort = Number.parseInt(value, 10);
+            if (!Number.isFinite(parsedPort) || parsedPort < 0) {
+                return { transport, hostname, port, error: `Invalid ACP port: ${value}` };
+            }
+            port = parsedPort;
+            index += 1;
+            continue;
+        }
+        return { transport, hostname, port, error: `Unknown option: ${arg}` };
+    }
+    return { workspaceRoot, transport, hostname, port };
+}
+export function parseWorkspaceOnlyOptions(args) {
+    let workspaceRoot;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--workspace") {
+            const value = args[index + 1];
+            if (!value) {
+                return { error: "Missing value for --workspace" };
+            }
+            workspaceRoot = value;
+            index += 1;
+            continue;
+        }
+        return { error: `Unknown option: ${arg}` };
+    }
+    return { workspaceRoot };
+}
+export function parseHttpServeOptions(args, serviceLabel = "HTTP") {
+    let workspaceRoot;
+    let hostname;
+    let port;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--workspace") {
+            const value = args[index + 1];
+            if (!value) {
+                return { hostname, port, error: "Missing value for --workspace" };
+            }
+            workspaceRoot = value;
+            index += 1;
+            continue;
+        }
+        if (arg === "--host") {
+            const value = args[index + 1];
+            if (!value) {
+                return { workspaceRoot, port, error: "Missing value for --host" };
+            }
+            hostname = value;
+            index += 1;
+            continue;
+        }
+        if (arg === "--port") {
+            const value = args[index + 1];
+            if (!value) {
+                return { workspaceRoot, hostname, error: "Missing value for --port" };
+            }
+            const parsedPort = Number.parseInt(value, 10);
+            if (!Number.isFinite(parsedPort) || parsedPort < 0) {
+                return { workspaceRoot, hostname, error: `Invalid ${serviceLabel} port: ${value}` };
+            }
+            port = parsedPort;
+            index += 1;
+            continue;
+        }
+        return { workspaceRoot, hostname, port, error: `Unknown option: ${arg}` };
+    }
+    return { workspaceRoot, hostname, port };
+}
+export function parseRuntimeMcpServeOptions(args, defaultTransport = "stdio") {
+    let workspaceRoot;
+    let transport = defaultTransport;
+    let hostname;
+    let port;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--workspace") {
+            const value = args[index + 1];
+            if (!value) {
+                return { transport, hostname, port, error: "Missing value for --workspace" };
+            }
+            workspaceRoot = value;
+            index += 1;
+            continue;
+        }
+        if (arg === "--transport") {
+            const value = args[index + 1];
+            if (!value) {
+                return { transport, hostname, port, error: "Missing value for --transport" };
+            }
+            if (value !== "stdio" && value !== "streamable-http") {
+                return { transport, hostname, port, error: `Unsupported runtime MCP transport: ${value}` };
+            }
+            transport = value;
+            index += 1;
+            continue;
+        }
+        if (arg === "--host") {
+            const value = args[index + 1];
+            if (!value) {
+                return { transport, hostname, port, error: "Missing value for --host" };
+            }
+            hostname = value;
+            index += 1;
+            continue;
+        }
+        if (arg === "--port") {
+            const value = args[index + 1];
+            if (!value) {
+                return { transport, hostname, port, error: "Missing value for --port" };
+            }
+            const parsedPort = Number.parseInt(value, 10);
+            if (!Number.isFinite(parsedPort) || parsedPort < 0) {
+                return { transport, hostname, port, error: `Invalid runtime MCP port: ${value}` };
+            }
+            port = parsedPort;
+            index += 1;
+            continue;
+        }
+        return { transport, hostname, port, error: `Unknown option: ${arg}` };
+    }
+    return { workspaceRoot, transport, hostname, port };
+}

package/dist/cli/options.d.ts

@@ -0,0 +1,5 @@
+export declare function renderUsage(): string;
+export declare function isTopLevelCliCommand(value?: string): boolean;
+export { parseChatOptions, parseInitOptions } from "./options-init-chat.js";
+export { parseAcpServeOptions, parseHttpServeOptions, parseRuntimeMcpServeOptions, parseWorkspaceOnlyOptions, } from "./options-serve.js";
+export { parseRuntimeExportOptions, parseRuntimeInspectOptions, parseScheduledRunOptions, } from "./options-runtime.js";

package/dist/cli/options.js

@@ -0,0 +1,47 @@
+export function renderUsage() {
+    return `Usage:
+  agent-harness init <project-name> [--template deep-research|single-agent] [--provider <provider>] [--model <model>] [--with-web-search|--no-web-search]
+  agent-harness chat [-w <path>] [--transport stdio|http] [--host <hostname>] [--port <port>] [--agent <agentId>] [--session <sessionId>] [--message <text>]
+  agent-harness [-w <path>] [prompt]
+  botbotgo [-w <path>] [prompt]
+  agent-harness acp serve [--workspace <path>] [--transport stdio|http] [--host <hostname>] [--port <port>]
+  agent-harness acp start [--workspace <path>] [--host <hostname>] [--port <port>]
+  agent-harness acp stop [--workspace <path>]
+  agent-harness a2a serve [--workspace <path>] [--host <hostname>] [--port <port>]
+  agent-harness a2a start [--workspace <path>] [--host <hostname>] [--port <port>]
+  agent-harness a2a stop [--workspace <path>]
+  agent-harness ag-ui serve [--workspace <path>] [--host <hostname>] [--port <port>]
+  agent-harness runtime overview [--workspace <path>] [--limit <n>] [--json]
+  agent-harness runtime health [--workspace <path>] [--json]
+  agent-harness runtime approvals list [--workspace <path>] [--status <pending|approved|edited|rejected|expired>] [--json]
+  agent-harness runtime approvals watch [--workspace <path>] [--status <pending|approved|edited|rejected|expired>] [--poll-ms <ms>] [--once] [--json]
+  agent-harness runtime requests list [--workspace <path>] [--agent <agentId>] [--session <sessionId>] [--state <state>] [--json]
+  agent-harness runtime requests tail [--workspace <path>] [--agent <agentId>] [--session <sessionId>] [--state <state>] [--poll-ms <ms>] [--once] [--json]
+  agent-harness runtime scheduled-run --workspace <path> --schedule <scheduleId>
+  agent-harness runtime export request --workspace <path> --session <sessionId> --request <requestId> [--artifacts] [--artifact-contents] [--health] [--json]
+  agent-harness runtime export session --workspace <path> --session <sessionId> [--artifacts] [--artifact-contents] [--health] [--json]
+  agent-harness runtime-mcp serve [--workspace <path>] [--transport stdio|streamable-http] [--host <hostname>] [--port <port>]
+  agent-harness runtime-mcp start [--workspace <path>] [--host <hostname>] [--port <port>]
+  agent-harness runtime-mcp stop [--workspace <path>]
+  agent-harness mcp serve [--workspace <path>] [--transport stdio|streamable-http] [--host <hostname>] [--port <port>]
+  agent-harness mcp start [--workspace <path>] [--host <hostname>] [--port <port>]
+  agent-harness mcp stop [--workspace <path>]
+
+Run botbotgo or agent-harness from any folder.
+If ./config/ is absent, the runtime falls back to the bundled system defaults and bundled resources.
+Chat defaults to the current directory as the workspace. Use -w to point at another workspace.
+`;
+}
+export function isTopLevelCliCommand(value) {
+    return value === "init"
+        || value === "chat"
+        || value === "acp"
+        || value === "a2a"
+        || value === "ag-ui"
+        || value === "mcp"
+        || value === "runtime"
+        || value === "runtime-mcp";
+}
+export { parseChatOptions, parseInitOptions } from "./options-init-chat.js";
+export { parseAcpServeOptions, parseHttpServeOptions, parseRuntimeMcpServeOptions, parseWorkspaceOnlyOptions, } from "./options-serve.js";
+export { parseRuntimeExportOptions, parseRuntimeInspectOptions, parseScheduledRunOptions, } from "./options-runtime.js";

package/dist/cli/process-guards.d.ts

@@ -0,0 +1,14 @@
+import type { ChildProcessWithoutNullStreams } from "node:child_process";
+import type { Writable as WritableStream } from "node:stream";
+type ProcessExitHookHost = Pick<NodeJS.Process, "on" | "off">;
+type ListenerCapHost = WritableStream & {
+    getMaxListeners?: () => number;
+    setMaxListeners?: (n: number) => void;
+};
+export declare function isChatServerNoiseLine(line: string): boolean;
+export declare function installCliWriteListenerGuard(streams: Array<ListenerCapHost | undefined>, minimum?: number): () => void;
+export declare function installCliEmitterListenerGuard(minimum?: number): () => void;
+export declare function installCliStderrNoiseFilter(enabled: boolean): () => void;
+export declare function installCliWarningFilter(): () => void;
+export declare function installChatSubprocessExitGuard(child: ChildProcessWithoutNullStreams, host?: ProcessExitHookHost): () => void;
+export {};