nolo-cli 0.1.30 → 0.1.32

package/client/agentRunTaskRunRecorder.ts

@@ -0,0 +1,176 @@
+import { join } from "node:path";
+
+import type { EnvLike } from "../cliEnvHelpers";
+import type { OutputLike } from "../cliIoTypes";
+import {
+  classifyTaskRunReviewStatus,
+  type TaskRunToolEvidence,
+} from "./agentRunLocalExecution";
+import type { TaskRunPromptContext } from "./taskRunPrompt";
+
+type TaskRunAgentRole = "pm" | "frontend" | "fullstack" | "reviewer" | "codex";
+type TaskRunStatus = "running" | "completed" | "failed";
+
+type TaskRunRecorderOptionShape = {
+  agentName: string;
+  agentKey: string;
+  serverUrl: string;
+  scriptDir: string;
+  env: EnvLike;
+  output: OutputLike;
+  taskRunContext?: TaskRunPromptContext;
+  taskRunRecorder?: unknown;
+};
+
+export type TaskRunRecorderArgs<
+  TOptions extends TaskRunRecorderOptionShape = TaskRunRecorderOptionShape,
+> = {
+  options: TOptions;
+  status: TaskRunStatus;
+  dialogId?: string;
+  resultSummary?: string;
+  errorCode?: string;
+  toolEvidence?: TaskRunToolEvidence;
+};
+
+export type TaskRunRecorder<
+  TOptions extends TaskRunRecorderOptionShape = TaskRunRecorderOptionShape,
+> = (args: TaskRunRecorderArgs<TOptions>) => Promise<void>;
+
+export function inferTaskRunAgentRole(agentRef: string): TaskRunAgentRole {
+  const normalized = agentRef.toLowerCase();
+  if (normalized.includes("project-manager") || normalized.includes("manager")) return "pm";
+  if (normalized.includes("frontend")) return "frontend";
+  if (normalized.includes("fullstack")) return "fullstack";
+  if (normalized.includes("review")) return "reviewer";
+  return "codex";
+}
+
+export async function runTaskRunCli<TOptions extends TaskRunRecorderOptionShape>(args: {
+  options: TOptions;
+  cliArgs: string[];
+}) {
+  const scriptPath = join(args.options.scriptDir, "taskRun.ts");
+  const proc = Bun.spawn({
+    cmd: [process.execPath, scriptPath, ...args.cliArgs],
+    stdout: "pipe",
+    stderr: "pipe",
+    env: {
+      ...process.env,
+      ...args.options.env,
+      BASE_URL: args.options.serverUrl,
+    },
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited,
+  ]);
+  if (exitCode !== 0) {
+    throw new Error((stderr || stdout || `taskRun.ts exited ${exitCode}`).trim());
+  }
+}
+
+export async function defaultTaskRunRecorder<TOptions extends TaskRunRecorderOptionShape>(
+  args: TaskRunRecorderArgs<TOptions>
+) {
+  const context = args.options.taskRunContext;
+  if (!context?.rowDbKey) return;
+  const role = inferTaskRunAgentRole(args.options.agentName || args.options.agentKey);
+  if (role === "reviewer" && args.status !== "running") {
+    await runTaskRunCli({
+      options: args.options,
+      cliArgs: [
+        "request-review",
+        "--row-dbkey",
+        context.rowDbKey,
+        "--base-url",
+        args.options.serverUrl,
+        "--reviewer-agent-key",
+        args.options.agentKey,
+        ...(context.artifactIds?.length ? ["--artifact-ids", context.artifactIds.join(",")] : []),
+        ...(args.dialogId ? ["--dialog-id", args.dialogId] : []),
+      ],
+    });
+  }
+  await runTaskRunCli({
+    options: args.options,
+    cliArgs: [
+      "record-agent-run",
+      "--row-dbkey",
+      context.rowDbKey,
+      "--base-url",
+      args.options.serverUrl,
+      "--agent-key",
+      args.options.agentKey,
+      "--role",
+      role,
+      "--run-status",
+      args.status,
+      ...(context.workItemId ? ["--work-item-id", context.workItemId] : []),
+      ...(args.dialogId ? ["--dialog-id", args.dialogId] : []),
+      ...(args.resultSummary ? ["--result-summary", args.resultSummary.slice(0, 240)] : []),
+      ...(args.errorCode ? ["--error-code", args.errorCode] : []),
+      ...(args.toolEvidence?.toolsUsed?.length
+        ? ["--tools-used", args.toolEvidence.toolsUsed.join(",")]
+        : []),
+      ...(args.toolEvidence?.summary
+        ? ["--tool-trace-summary", JSON.stringify(args.toolEvidence.summary)]
+        : []),
+    ],
+  });
+  if (context.workItemId && args.dialogId) {
+    await runTaskRunCli({
+      options: args.options,
+      cliArgs: [
+        "update-work-item",
+        "--row-dbkey",
+        context.rowDbKey,
+        "--base-url",
+        args.options.serverUrl,
+        "--id",
+        context.workItemId,
+        "--dialog-ids",
+        args.dialogId,
+      ],
+    });
+  }
+  if (role === "reviewer" && args.status !== "running") {
+    const reviewStatus =
+      args.status === "failed" ? "blocked" : classifyTaskRunReviewStatus(args.resultSummary);
+    if (reviewStatus) {
+      await runTaskRunCli({
+        options: args.options,
+        cliArgs: [
+          "review-result",
+          "--row-dbkey",
+          context.rowDbKey,
+          "--base-url",
+          args.options.serverUrl,
+          "--review-status",
+          reviewStatus,
+          "--reviewer-agent-key",
+          args.options.agentKey,
+          ...(context.artifactIds?.length ? ["--artifact-ids", context.artifactIds.join(",")] : []),
+          ...(args.dialogId ? ["--dialog-id", args.dialogId] : []),
+        ],
+      });
+    }
+  }
+}
+
+export async function recordTaskRunOutcome<TOptions extends TaskRunRecorderOptionShape>(
+  args: TaskRunRecorderArgs<TOptions>
+) {
+  if (!args.options.taskRunContext?.rowDbKey) return;
+  try {
+    const recorder =
+      (args.options.taskRunRecorder as TaskRunRecorder<TOptions> | undefined) ??
+      ((nextArgs: TaskRunRecorderArgs<TOptions>) => defaultTaskRunRecorder(nextArgs));
+    await recorder(args);
+  } catch (error) {
+    args.options.output.write(
+      `[nolo] task-run writeback failed: ${error instanceof Error ? error.message : String(error)}\n`
+    );
+  }
+}

package/client/localRuntimeAdapter.test.ts

@@ -3,6 +3,7 @@ import { mkdtempSync, readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
+import { createHostRuntimeConfig } from "../agent-runtime";
 import { runLocalAgentTurn } from "../agent-runtime/localLoop";
 import { createCliLocalRuntimeAdapter } from "./localRuntimeAdapter";
 
@@ -22,7 +23,9 @@ describe("CLI local runtime adapter", () => {
     "searchFiles",
   ];
   const SHELL_LOCAL_CODING_TOOL_NAMES = [
-    ...DEFAULT_LOCAL_CODING_TOOL_NAMES,
+    "readFile",
+    "writeFile",
+    "editFile",
     "execShell",
   ];
 
@@ -30,6 +33,14 @@ describe("CLI local runtime adapter", () => {
     return request?.body?.tools?.map((tool: any) => tool.function.name) ?? [];
   }
 
+  function createCliHostRuntimeConfig(allowShell = false, workspaceBinding: "explicit-cwd" | "default-cwd" = "explicit-cwd") {
+    return createHostRuntimeConfig({
+      surface: "cli-local",
+      workspaceBinding,
+      allowShell,
+    });
+  }
+
   test("loads agent/history from LevelDB and saves dialog/message records back to LevelDB", async () => {
     const requests: Array<{ url: string; body: any; auth: string | null }> = [];
     const store = new Map<string, any>([
@@ -278,6 +289,57 @@ describe("CLI local runtime adapter", () => {
     });
   });
 
+  test("runs apiSource=cli agents through the local CLI executor even when direct provider env is present", async () => {
+    const executions: Array<{ provider: string; prompt: string; options: any }> = [];
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        OPENAI_API_KEY: "sk-local",
+        NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
+      },
+      cwd: import.meta.dir,
+      db: {
+        get: async () => ({
+          dbKey: "agent-local-frontend",
+          id: "frontend",
+          apiSource: "cli",
+          cliProvider: "agy",
+          prompt: "Fix UI",
+          model: "",
+        }),
+        put: async () => {},
+        batch: async () => {},
+        iterator: () => (async function* () {})(),
+      },
+      fetchImpl: async () => {
+        throw new Error("OpenAI-compatible fetch should not run for local CLI agents");
+      },
+      executeCli: async (provider, prompt, options) => {
+        executions.push({ provider, prompt, options });
+        return { text: "cli local ok", raw: "cli local ok", elapsed: 10 };
+      },
+    });
+
+    const result = await runLocalAgentTurn({
+      adapter,
+      agentRef: "frontend",
+      input: "make it cleaner",
+    });
+
+    expect(result).toMatchObject({
+      content: "cli local ok",
+      model: "agy",
+    });
+    expect(executions).toEqual([{
+      provider: "agy",
+      prompt: "make it cleaner",
+      options: expect.objectContaining({
+        cwd: import.meta.dir,
+        yolo: true,
+        systemPrompt: "Fix UI",
+      }),
+    }]);
+  });
+
   test("uses agent customProviderUrl for local OpenAI-compatible requests", async () => {
     const requests: Array<{ url: string; auth: string | null; body: any }> = [];
     const store = new Map<string, any>([
@@ -353,6 +415,74 @@ describe("CLI local runtime adapter", () => {
     expect(toolNamesFromRequest(requests[0])).toEqual(DEFAULT_LOCAL_CODING_TOOL_NAMES);
   });
 
+  test("uses loopback transport for localhost custom providers when the default fetch path cannot connect", async () => {
+    const store = new Map<string, any>([
+      ["agent-user-1-localhost", {
+        dbKey: "agent-user-1-localhost",
+        id: "localhost",
+        prompt: "Use localhost provider.",
+        model: "Qwen3.6-27B-MTP-Q3_K_M.gguf",
+        provider: "custom-openai-compatible",
+        apiSource: "custom",
+        customProviderUrl: "http://127.0.0.1:8080/v1/chat/completions",
+      }],
+    ]);
+    const loopbackRequests: Array<{ url: string; body: any }> = [];
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_LOCAL_USER_ID: "user-1",
+      },
+      db: {
+        get: async (key) => {
+          if (!store.has(key)) throw new Error(`not found: ${key}`);
+          return store.get(key);
+        },
+        put: async (key, value) => {
+          store.set(key, value);
+        },
+        batch: async (ops) => {
+          for (const op of ops) {
+            if (op.type === "put") store.set(op.key, op.value);
+          }
+        },
+        iterator: () => (async function* () {})(),
+      },
+      fetchImpl: async () => {
+        throw new TypeError("Unable to connect. Is the computer able to access the url?");
+      },
+      loopbackRequest: async (url, init) => {
+        loopbackRequests.push({
+          url: String(url),
+          body: JSON.parse(String(init?.body)),
+        });
+        return Response.json({
+          choices: [{ message: { content: "loopback ok" } }],
+        });
+      },
+    });
+
+    const result = await runLocalAgentTurn({
+      adapter,
+      agentRef: "localhost",
+      input: "hello",
+    });
+
+    expect(result.content).toBe("loopback ok");
+    expect(loopbackRequests).toHaveLength(1);
+    expect(loopbackRequests[0]).toMatchObject({
+      url: "http://127.0.0.1:8080/v1/chat/completions",
+      body: {
+        model: "Qwen3.6-27B-MTP-Q3_K_M.gguf",
+        messages: [
+          { role: "system", content: "Use localhost provider." },
+          { role: "user", content: "hello" },
+        ],
+        stream: false,
+      },
+    });
+    expect(toolNamesFromRequest(loopbackRequests[0])).toEqual(DEFAULT_LOCAL_CODING_TOOL_NAMES);
+  });
+
   test("uses the Nolo chat proxy when local provider keys are absent", async () => {
     const requests: Array<{ url: string; auth: string | null; body: any }> = [];
     const store = new Map<string, any>([
@@ -616,6 +746,10 @@ describe("CLI local runtime adapter", () => {
         id: "shell",
         prompt: "Use shell.",
         model: "gpt-4.1-mini",
+        runtimeToolPolicy: {
+          version: 1,
+          runtimeTools: ["execShell"],
+        },
       }],
     ]);
     const adapter = createCliLocalRuntimeAdapter({
@@ -920,17 +1054,28 @@ describe("CLI local runtime adapter", () => {
     });
   });
 
-  test("rejects tools unless the local tool policy allows and registers them", async () => {
+  test("rejects execShell when the host disables shell even if the agent requested it", async () => {
     const adapter = createCliLocalRuntimeAdapter({
-      env: {},
+      env: { NOLO_LOCAL_USER_ID: "user-1" },
+      hostRuntimeConfig: createCliHostRuntimeConfig(),
+      db: {
+        get: async () => ({
+          dbKey: "agent-user-1-shell",
+          toolNames: ["execShell"],
+        }),
+        put: async () => {},
+        batch: async () => {},
+        iterator: () => (async function* () {})(),
+      },
       fetchImpl: async () => Response.json({}),
     });
 
+    await adapter.loadAgentConfig("shell");
     await expect(adapter.executeTool({
       id: "call-1",
       name: "execShell",
       arguments: "{}",
-    })).rejects.toThrow("execShell requires NOLO_LOCAL_SHELL_MODE");
+    })).rejects.toThrow("execShell is not requested by this agent runtime.");
   });
 
   test("executes explicitly allowed registered local tools declared by the agent", async () => {
@@ -972,19 +1117,22 @@ describe("CLI local runtime adapter", () => {
     expect(result.content).toContain("README.md");
   });
 
-  test("advertises execShell to OpenAI-compatible providers when shell mode is enabled", async () => {
+  test("defaults the CLI local host runtime to shell-on when runtimeToolPolicy requests execShell", async () => {
     const requests: Array<{ body: any }> = [];
     const adapter = createCliLocalRuntimeAdapter({
       env: {
         OPENAI_API_KEY: "sk-local",
         NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
-        NOLO_LOCAL_SHELL_MODE: "worktree",
       },
       db: {
         get: async () => ({
           dbKey: "agent-local-shell",
           prompt: "Use shell.",
           model: "gpt-4.1-mini",
+          runtimeToolPolicy: {
+            version: 1,
+            runtimeTools: ["execShell"],
+          },
         }),
         put: async () => {},
         batch: async () => {},
@@ -1007,6 +1155,81 @@ describe("CLI local runtime adapter", () => {
     expect(toolNamesFromRequest(requests[0])).toEqual(SHELL_LOCAL_CODING_TOOL_NAMES);
   });
 
+  test("keeps advertised fallback workspace tools executable when shell is explicitly disabled", async () => {
+    const workspaceRoot = mkdtempSync(join(tmpdir(), "nolo-cli-runtime-shell-off-"));
+    try {
+      const adapter = createCliLocalRuntimeAdapter({
+        env: {},
+        hostRuntimeConfig: createCliHostRuntimeConfig(false),
+        db: {
+          get: async () => ({
+            dbKey: "agent-local-shell-off",
+            runtimeToolPolicy: {
+              version: 1,
+              runtimeTools: ["execShell"],
+            },
+          }),
+          put: async () => {},
+          batch: async () => {},
+          iterator: () => (async function* () {})(),
+        },
+        cwd: workspaceRoot,
+        fetchImpl: async () => Response.json({}),
+      });
+
+      await adapter.loadAgentConfig("shell-off");
+      const result = await adapter.executeTool({
+        id: "call-list-files",
+        name: "listFiles",
+        arguments: JSON.stringify({ path: "." }),
+      });
+
+      expect(result.metadata).toMatchObject({ path: ".", count: 0 });
+      expect(result.content).toBe("");
+    } finally {
+      rmSync(workspaceRoot, { recursive: true, force: true });
+    }
+  });
+
+  test("does not advertise execShell when only a legacy runtimeToolPolicy.shell block is present", async () => {
+    const requests: Array<{ body: any }> = [];
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        OPENAI_API_KEY: "sk-local",
+        NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
+      },
+      hostRuntimeConfig: createCliHostRuntimeConfig(true),
+      db: {
+        get: async () => ({
+          dbKey: "agent-local-legacy-shell",
+          prompt: "Do not get shell from legacy policy.",
+          model: "gpt-4.1-mini",
+          runtimeToolPolicy: {
+            version: 1,
+            shell: { enabled: true, mode: "worktree" },
+          },
+        }),
+        put: async () => {},
+        batch: async () => {},
+        iterator: () => (async function* () {})(),
+      },
+      fetchImpl: async (_url, init) => {
+        requests.push({ body: JSON.parse(String(init?.body)) });
+        return Response.json({
+          choices: [{ message: { content: "done" } }],
+        });
+      },
+    });
+
+    await runLocalAgentTurn({
+      adapter,
+      agentRef: "legacy-shell",
+      input: "pwd",
+    });
+
+    expect(toolNamesFromRequest(requests[0])).not.toContain("execShell");
+  });
+
   test("allows default semantic workspace tools without legacy agent tool declarations", async () => {
     const workspaceRoot = mkdtempSync(join(tmpdir(), "nolo-cli-runtime-"));
     try {
@@ -1168,13 +1391,17 @@ describe("CLI local runtime adapter", () => {
     }
   });
 
-  test("runs execShell locally in explicit worktree shell mode", async () => {
+  test("runs execShell locally when the host grants shell capability", async () => {
     const adapter = createCliLocalRuntimeAdapter({
-      env: { NOLO_LOCAL_SHELL_MODE: "worktree" },
+      env: {},
+      hostRuntimeConfig: createCliHostRuntimeConfig(true),
       db: {
         get: async () => ({
           dbKey: "agent-local-shell",
-          toolNames: ["execShell"],
+          runtimeToolPolicy: {
+            version: 1,
+            runtimeTools: ["execShell"],
+          },
         }),
         put: async () => {},
         batch: async () => {},