@botbotgo/agent-harness 0.0.309 → 0.0.311

package/dist/cli/workspace.js

@@ -0,0 +1,71 @@
+import { existsSync, readdirSync, statSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+export function resolveCliWorkspaceRoot(cwd, inputPath) {
+    const resolved = path.resolve(cwd, inputPath ?? ".");
+    if (existsSync(path.join(resolved, "config", "runtime", "workspace.yaml"))) {
+        return resolved;
+    }
+    if (path.basename(resolved) === "config" && hasCliConfigYaml(resolved)) {
+        return path.dirname(resolved);
+    }
+    return resolved;
+}
+export function getWorkspaceConfigPath(workspaceRoot) {
+    return path.join(workspaceRoot, "config", "runtime", "workspace.yaml");
+}
+export function hasCliConfigYaml(configRoot) {
+    if (!existsSync(configRoot) || !statSync(configRoot).isDirectory()) {
+        return false;
+    }
+    const pending = [configRoot];
+    while (pending.length > 0) {
+        const current = pending.pop();
+        for (const entry of readdirSync(current, { withFileTypes: true })) {
+            if (entry.isDirectory()) {
+                if (entry.name === "node_modules") {
+                    continue;
+                }
+                pending.push(path.join(current, entry.name));
+                continue;
+            }
+            if (entry.isFile() && /\.ya?ml$/i.test(entry.name)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+export function validateCliWorkspaceRoot(workspaceRoot, inputPath) {
+    if (!existsSync(workspaceRoot)) {
+        return undefined;
+    }
+    if (!statSync(workspaceRoot).isDirectory()) {
+        const workspaceLabel = inputPath ? "Workspace path" : "Current directory";
+        return `${workspaceLabel} is not a directory: ${workspaceRoot}`;
+    }
+    return undefined;
+}
+export function resolveCliConfigRoot(workspaceRoot) {
+    if (path.basename(workspaceRoot) === "config") {
+        return workspaceRoot;
+    }
+    return path.join(workspaceRoot, "config");
+}
+export function frameworkCliWorkspaceRoot() {
+    const resolved = fileURLToPath(new URL("../..", import.meta.url));
+    const distSegment = `${path.sep}dist`;
+    if (!resolved.endsWith(distSegment)) {
+        return resolved;
+    }
+    const sourceRoot = resolved.slice(0, -distSegment.length);
+    if (!existsSync(sourceRoot)) {
+        return resolved;
+    }
+    try {
+        return statSync(sourceRoot).mtimeMs >= statSync(resolved).mtimeMs ? sourceRoot : resolved;
+    }
+    catch {
+        return sourceRoot;
+    }
+}

package/dist/cli.d.ts

@@ -1,78 +1,2 @@
 #!/usr/bin/env node
-import { type ChildProcessWithoutNullStreams } from "node:child_process";
-import { createInterface as createReadlineInterface } from "node:readline";
-import type { Readable } from "node:stream";
-import { createAgentHarness } from "./api.js";
-import { type HarnessClient } from "./client.js";
-import { serveA2aOverHttp } from "./protocol/a2a/http.js";
-import { serveAgUiOverHttp } from "./protocol/ag-ui/http.js";
-import { serveAcpOverHttp } from "./protocol/acp/http.js";
-import { serveAcpOverStdio } from "./protocol/acp/stdio.js";
-import { serveRuntimeMcpOverStdio, serveRuntimeMcpOverStreamableHttp } from "./mcp.js";
-type CliIo = {
-    cwd?: string;
-    stdin?: Readable;
-    stdout?: (message: string) => void;
-    stderr?: (message: string) => void;
-};
-type CliDeps = {
-    createChatClient?: (input: {
-        workspaceRoot: string;
-        transport: "stdio" | "http";
-        hostname?: string;
-        port?: number;
-        stderr?: (message: string) => void;
-    }) => Promise<HarnessClient>;
-    probeChatWorkspace?: (input: {
-        workspaceRoot: string;
-        agentId?: string;
-    }) => Promise<string | undefined>;
-    createReadlineInterface?: typeof createReadlineInterface;
-    createAgentHarness?: typeof createAgentHarness;
-    serveA2aOverHttp?: typeof serveA2aOverHttp;
-    serveAgUiOverHttp?: typeof serveAgUiOverHttp;
-    serveAcpOverHttp?: typeof serveAcpOverHttp;
-    serveAcpOverStdio?: typeof serveAcpOverStdio;
-    serveRuntimeMcpOverStdio?: typeof serveRuntimeMcpOverStdio;
-    serveRuntimeMcpOverStreamableHttp?: typeof serveRuntimeMcpOverStreamableHttp;
-    spawnManagedCliProcess?: (input: {
-        args: string[];
-        cwd: string;
-        stdoutPath: string;
-        stderrPath: string;
-    }) => Promise<{
-        pid?: number;
-    }>;
-    isManagedProcessRunning?: (pid: number) => boolean;
-    signalManagedProcess?: (pid: number, signal?: NodeJS.Signals) => void;
-};
-export declare function renderChatPromptLine(input: {
-    agentId?: string;
-    sessionId?: string;
-    requestId?: string;
-    color: boolean;
-}): string;
-export declare function renderChatBanner(input: {
-    workspacePath: string;
-    transport: "stdio" | "http";
-    agentId?: string;
-    sessionId?: string;
-    /** When true (TTY + default stdout), paint logo and accents in ANSI color */
-    color?: boolean;
-}): string;
-type ChatWorkspaceModelInfo = {
-    provider?: string;
-    model?: string;
-    baseUrl?: string;
-};
-export declare function renderChatRuntimeFailure(output: string, modelInfo?: ChatWorkspaceModelInfo): string;
-export declare function probeChatWorkspace(input: {
-    workspaceRoot: string;
-    agentId?: string;
-}): Promise<string | undefined>;
-export declare function isChatServerNoiseLine(line: string): boolean;
-type ProcessExitHookHost = Pick<NodeJS.Process, "on" | "off">;
-export declare function installChatSubprocessExitGuard(child: ChildProcessWithoutNullStreams, host?: ProcessExitHookHost): () => void;
-export declare function runCli(argv: string[], io?: CliIo, deps?: CliDeps): Promise<number>;
-export declare function resolveInvokedCliHref(argvPath?: string): string;
-export {};
+export * from "./cli/main.js";