nolo-cli 0.1.16 → 0.1.18

package/agent-runtime/localLoop.ts

@@ -12,6 +12,7 @@ export type LocalAgentTurnInput = {
   agentRef: string;
   input: AgentRuntimeMessageContent;
   continueDialogId?: string;
+  maxToolRounds?: number;
 };
 
 export type LocalAgentTurnResult = AgentRuntimeResult & {
@@ -49,15 +50,48 @@ export async function runLocalAgentTurn(
     input: input.input,
   });
   const provider = await input.adapter.resolveProvider(agentConfig);
-  const result = await provider.complete(messages);
+  const maxToolRounds = input.maxToolRounds ?? 6;
+  let toolCallCount = 0;
+  let result: AgentRuntimeResult;
+  for (let round = 0; round <= maxToolRounds; round += 1) {
+    result = await provider.complete(messages);
+    const toolCalls = result.tool_calls ?? [];
+    if (toolCalls.length === 0) break;
+    if (round === maxToolRounds) {
+      throw new Error(`Local agent exceeded max tool rounds: ${maxToolRounds}`);
+    }
+    toolCallCount += toolCalls.length;
+    messages.push({
+      role: "assistant",
+      content: result.content || null,
+      tool_calls: toolCalls,
+    });
+    for (const toolCall of toolCalls) {
+      const toolResult = await input.adapter.executeTool({
+        id: toolCall.id,
+        name: toolCall.function.name,
+        arguments: toolCall.function.arguments,
+      });
+      messages.push({
+        role: "tool",
+        content: toolResult.content,
+        tool_call_id: toolCall.id,
+      });
+    }
+  }
+  result = result!;
   const saved = await input.adapter.saveTurn({
     agentKey: agentConfig.key,
     messages,
-    result,
+    result: {
+      ...result,
+      ...(toolCallCount > 0 ? { toolCallCount } : {}),
+    },
   });
 
   return {
     ...result,
+    ...(toolCallCount > 0 ? { toolCallCount } : {}),
     dialogId: saved.dialogId,
   };
 }

package/agent-runtime/types.ts

@@ -51,6 +51,7 @@ export interface AgentRuntimeResult {
   outputPrice?: number;
   usage?: Record<string, any>;
   trace?: AgentRuntimeChatMessage[];
+  tool_calls?: AgentRuntimeToolCall[];
   runtimeToolNames?: string[];
   toolCallCount?: number;
   policyState?: unknown;

package/agentAliases.ts

@@ -0,0 +1,26 @@
+export const PLATFORM_DEMO_USER_ID = "b2e06f801f";
+export const FRONTEND_IMPLEMENTER_AGENT_ID = "01FRONTENDAG0000000115N4E1";
+export const FRONTEND_IMPLEMENTER_AGENT_KEY =
+  `agent-${PLATFORM_DEMO_USER_ID}-${FRONTEND_IMPLEMENTER_AGENT_ID}`;
+
+const AGENT_ALIAS_TO_KEY: Record<string, string> = {
+  "frontend-implementer": FRONTEND_IMPLEMENTER_AGENT_KEY,
+  "frontend-agent": FRONTEND_IMPLEMENTER_AGENT_KEY,
+  frontend: FRONTEND_IMPLEMENTER_AGENT_KEY,
+  "front-end": FRONTEND_IMPLEMENTER_AGENT_KEY,
+  "前端": FRONTEND_IMPLEMENTER_AGENT_KEY,
+  "前端实现员": FRONTEND_IMPLEMENTER_AGENT_KEY,
+};
+
+function parseAgentKeyFromInput(raw: string): string {
+  const trimmed = raw.trim();
+  if (trimmed.startsWith("http://") || trimmed.startsWith("https://")) {
+    const url = new URL(trimmed);
+    return url.pathname.replace(/^\/+/, "");
+  }
+  return trimmed;
+}
+
+export function resolveCliAgentKeyInput(raw: string): string {
+  return AGENT_ALIAS_TO_KEY[raw.trim().toLowerCase()] ?? parseAgentKeyFromInput(raw);
+}

package/agentPullCommand.ts

@@ -1,6 +1,7 @@
 import { DEFAULT_NOLO_SERVER_URL } from "./defaultServer";
 import { getDefaultCliLocalRuntimeDb } from "./localRuntimeDb";
 import type { CliLocalRuntimeDb } from "./client/localRuntimeAdapter";
+import { resolveCliAgentKeyInput } from "./agentAliases";
 
 type EnvLike = Record<string, string | undefined>;
 
@@ -40,7 +41,7 @@ function positionalArgs(args: string[]) {
 export function parseAgentPullArgs(args: string[]): ParsedAgentPullArgs | null {
   const agentKey = readFlagValue(args, "--agent") ?? positionalArgs(args)[0];
   if (!agentKey?.trim()) return null;
-  return { agentKey: agentKey.trim() };
+  return { agentKey: resolveCliAgentKeyInput(agentKey) };
 }
 
 function resolveServerUrl(env: EnvLike) {

package/agentRunCommand.ts

@@ -2,7 +2,8 @@ import { DEFAULT_NOLO_SERVER_URL } from "./defaultServer";
 import { runAgentTurn, type RunAgentTurnResult } from "./client/agentRun";
 import type { AgentRuntimeRequestedMode } from "./agentRuntimeLocal";
 import { existsSync, readFileSync } from "node:fs";
-import { extname, resolve } from "node:path";
+import { extname, join, resolve } from "node:path";
+import { resolveCliAgentKeyInput } from "./agentAliases";
 
 type EnvLike = Record<string, string | undefined>;
 
@@ -15,12 +16,14 @@ type AgentRunCommandDeps = {
   scriptDir: string;
   output?: OutputLike;
   runner?: typeof runAgentTurn;
+  prepareShellWorktree?: typeof prepareShellWorktree;
 };
 
 type ParsedAgentRunArgs = {
   agentKey: string;
   message: string;
   imageUrls: string[];
+  allowShell: boolean;
   runtimeMode?: AgentRuntimeRequestedMode;
   continueDialogId?: string;
 };
@@ -51,9 +54,15 @@ function runtimeModeFromArgs(args: string[]): AgentRuntimeRequestedMode | undefi
 
 function positionalArgs(args: string[]) {
   const values: string[] = [];
+  const valuelessFlags = new Set([
+    "--local",
+    "--server",
+    "--auto",
+    "--dangerously-allow-shell",
+  ]);
   for (let index = 0; index < args.length; index += 1) {
     const arg = args[index];
-    if (arg === "--local" || arg === "--server" || arg === "--auto") continue;
+    if (valuelessFlags.has(arg)) continue;
     if (arg.startsWith("--")) {
       index += 1;
       continue;
@@ -75,9 +84,10 @@ export function parseAgentRunArgs(args: string[]): ParsedAgentRunArgs | null {
     ...readRepeatedFlagValues(args, "--image-url"),
   ];
   return {
-    agentKey,
+    agentKey: resolveCliAgentKeyInput(agentKey),
     message: message.trim(),
     imageUrls,
+    allowShell: args.includes("--dangerously-allow-shell"),
     ...(runtimeMode ? { runtimeMode } : {}),
     ...(continueDialogId ? { continueDialogId } : {}),
   };
@@ -109,10 +119,53 @@ function resolveServerUrl(env: EnvLike) {
   return (env.NOLO_SERVER || env.BASE_URL || DEFAULT_NOLO_SERVER_URL).replace(/\/+$/, "");
 }
 
+function safePathSegment(input: string) {
+  return input.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80) || "agent";
+}
+
+function createTaskId() {
+  return Date.now().toString(36).toUpperCase();
+}
+
+async function runGit(args: string[], cwd: string) {
+  const proc = Bun.spawn(["git", ...args], {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+    stdin: "ignore",
+  });
+  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.trim() || stdout.trim() || `git ${args.join(" ")} failed`);
+  }
+  return stdout.trim();
+}
+
+export async function prepareShellWorktree(args: {
+  agentKey: string;
+  cwd?: string;
+  env?: EnvLike;
+}) {
+  if (args.env?.NOLO_LOCAL_WORKTREE) return args.env.NOLO_LOCAL_WORKTREE;
+  const cwd = args.cwd ?? process.cwd();
+  const root = await runGit(["rev-parse", "--show-toplevel"], cwd);
+  const parent = join(root, ".worktrees");
+  const safeAgent = safePathSegment(args.agentKey);
+  const taskId = createTaskId();
+  const worktreePath = join(parent, `nolo-agent-${safeAgent}-${taskId}`);
+  const branchName = `nolo-agent-${safeAgent}-${taskId}`;
+  await runGit(["worktree", "add", worktreePath, "-b", branchName, "HEAD"], root);
+  return worktreePath;
+}
+
 function writeUsage(output: OutputLike) {
   output.write(
     "Usage: nolo agent run <agent> <message> [--local|--server|--auto] [--continue <dialogId>]\n" +
-      "       nolo agent run --agent <agent> --msg <message> [--image <url-or-path>] [--local|--server|--auto]\n"
+      "       nolo agent run --agent <agent> --msg <message> [--image <url-or-path>] [--dangerously-allow-shell] [--local|--server|--auto]\n"
   );
 }
 
@@ -126,6 +179,20 @@ export async function runAgentRunCommand(args: string[], deps: AgentRunCommandDe
   }
 
   const runner = deps.runner ?? runAgentTurn;
+  let localRuntimeCwd: string | undefined;
+  if (parsed.allowShell) {
+    localRuntimeCwd = await (deps.prepareShellWorktree ?? prepareShellWorktree)({
+      agentKey: parsed.agentKey,
+      env,
+    });
+  }
+  const runEnv = parsed.allowShell
+    ? {
+        ...env,
+        NOLO_LOCAL_SHELL_MODE: "worktree",
+        ...(localRuntimeCwd ? { NOLO_LOCAL_WORKTREE: localRuntimeCwd } : {}),
+      }
+    : env;
   const result: RunAgentTurnResult = await runner({
     agentName: parsed.agentKey,
     agentKey: parsed.agentKey,
@@ -133,8 +200,9 @@ export async function runAgentRunCommand(args: string[], deps: AgentRunCommandDe
     message: parsed.message,
     imageUrls: parsed.imageUrls.map(normalizeCliImageInput),
     scriptDir: deps.scriptDir,
-    env,
+    env: runEnv,
     output,
+    ...(localRuntimeCwd ? { localRuntimeCwd } : {}),
     ...(parsed.runtimeMode ? { runtimeMode: parsed.runtimeMode } : {}),
     ...(parsed.continueDialogId ? { continueDialogId: parsed.continueDialogId } : {}),
   });

package/client/agentRun.ts

@@ -24,6 +24,7 @@ type RunAgentTurnOptions = {
   runtimeMode?: AgentRuntimeRequestedMode;
   localRuntimeAdapter?: AgentRuntimeHostAdapter;
   localRuntimeAdapterFactory?: (env: EnvLike) => AgentRuntimeHostAdapter;
+  localRuntimeCwd?: string;
   scriptPathExists?: (path: string) => boolean;
   fetchImpl?: typeof fetch;
 };
@@ -61,6 +62,7 @@ function buildDefaultLocalRuntimeAdapter(options: RunAgentTurnOptions) {
   return createCliLocalRuntimeAdapter({
     env: options.env,
     fetchImpl: options.fetchImpl,
+    cwd: options.localRuntimeCwd,
   });
 }
 

package/client/localRuntimeAdapter.test.ts

@@ -173,7 +173,7 @@ describe("CLI local runtime adapter", () => {
       id: "call-1",
       name: "execShell",
       arguments: "{}",
-    })).rejects.toThrow("blocked by the local CLI safety policy");
+    })).rejects.toThrow("execShell requires NOLO_LOCAL_SHELL_MODE");
   });
 
   test("executes explicitly allowed registered local tools declared by the agent", async () => {
@@ -214,4 +214,71 @@ describe("CLI local runtime adapter", () => {
 
     expect(result.content).toContain("README.md");
   });
+
+  test("advertises execShell to OpenAI-compatible providers when shell mode is enabled", 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",
+        }),
+        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: "shell",
+      input: "pwd",
+    });
+
+    expect(requests[0]?.body.tools).toEqual([{
+      type: "function",
+      function: expect.objectContaining({
+        name: "execShell",
+      }),
+    }]);
+  });
+
+  test("runs execShell locally in explicit worktree shell mode", async () => {
+    const adapter = createCliLocalRuntimeAdapter({
+      env: { NOLO_LOCAL_SHELL_MODE: "worktree" },
+      db: {
+        get: async () => ({
+          dbKey: "agent-local-shell",
+          toolNames: ["execShell"],
+        }),
+        put: async () => {},
+        batch: async () => {},
+        iterator: () => (async function* () {})(),
+      },
+      cwd: import.meta.dir,
+      fetchImpl: async () => Response.json({}),
+    });
+
+    await adapter.loadAgentConfig("shell");
+    const result = await adapter.executeTool({
+      id: "call-1",
+      name: "execShell",
+      arguments: "{\"cmd\":\"pwd\"}",
+    });
+
+    expect(result.content).toContain(import.meta.dir);
+    expect(result.metadata).toMatchObject({ exitCode: 0 });
+  });
 });

package/client/localRuntimeAdapter.ts

@@ -22,6 +22,7 @@ export type CliLocalRuntimeAdapterDeps = {
   now?: () => number;
   createId?: () => string;
   fetchImpl?: typeof fetch;
+  cwd?: string;
   localToolExecutors?: Record<string, (call: any) => Promise<{ content: string; metadata?: Record<string, unknown> }>>;
 };
 
@@ -46,6 +47,83 @@ function resolveLocalUserId(env: EnvLike) {
   return env.NOLO_LOCAL_USER_ID || env.NOLO_USER_ID || "local";
 }
 
+function buildExecShellTool() {
+  return {
+    type: "function",
+    function: {
+      name: "execShell",
+      description: "Run a shell command in the current isolated local workspace.",
+      parameters: {
+        type: "object",
+        properties: {
+          cmd: {
+            type: "string",
+            description: "Shell command to run.",
+          },
+        },
+        required: ["cmd"],
+      },
+    },
+  };
+}
+
+function shellModeEnabled(env: EnvLike) {
+  return ["worktree", "dangerous", "1", "true"].includes(env.NOLO_LOCAL_SHELL_MODE || "");
+}
+
+function buildOpenAiTools(args: { toolNames?: string[]; env: EnvLike }) {
+  return args.toolNames?.includes("execShell") || shellModeEnabled(args.env)
+    ? [buildExecShellTool()]
+    : [];
+}
+
+function parseToolArguments(raw: string) {
+  try {
+    const parsed = JSON.parse(raw || "{}");
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+async function executeShellCommand(args: {
+  call: any;
+  cwd: string;
+}) {
+  const parsed = parseToolArguments(String(args.call.arguments ?? ""));
+  const cmd = String(parsed.cmd ?? parsed.command ?? "").trim();
+  if (!cmd) throw new Error("execShell requires a non-empty cmd argument.");
+  const proc = Bun.spawn(["/bin/sh", "-lc", cmd], {
+    cwd: args.cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+    stdin: "ignore",
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited,
+  ]);
+  return {
+    content: [
+      stdout.trim() ? `stdout:\n${stdout.trim()}` : "",
+      stderr.trim() ? `stderr:\n${stderr.trim()}` : "",
+      `exitCode: ${exitCode}`,
+    ].filter(Boolean).join("\n\n"),
+    metadata: { exitCode },
+  };
+}
+
+function buildLocalToolExecutors(deps: CliLocalRuntimeAdapterDeps) {
+  return {
+    execShell: (call: any) => executeShellCommand({
+      call,
+      cwd: deps.cwd ?? process.cwd(),
+    }),
+    ...(deps.localToolExecutors ?? {}),
+  };
+}
+
 async function resolveDb(deps: CliLocalRuntimeAdapterDeps) {
   return deps.db ?? defaultLocalRuntimeDb();
 }
@@ -191,6 +269,7 @@ export function createCliLocalRuntimeAdapter(
   const fetchImpl = deps.fetchImpl ?? fetch;
   const userId = resolveLocalUserId(deps.env);
   let activeAgentToolNames: string[] = [];
+  const localToolExecutors = buildLocalToolExecutors(deps);
 
   return {
     host: "cli",
@@ -218,6 +297,10 @@ export function createCliLocalRuntimeAdapter(
     resolveProvider: async (agentConfig) => ({
       model: agentConfig.model || "gpt-4.1-mini",
       complete: async (messages) => {
+        const tools = buildOpenAiTools({
+          toolNames: agentConfig.toolNames,
+          env: deps.env,
+        });
         const res = await fetchImpl(`${resolveOpenAiCompatibleBaseUrl(deps.env)}/chat/completions`, {
           method: "POST",
           headers: {
@@ -230,17 +313,20 @@ export function createCliLocalRuntimeAdapter(
             model: agentConfig.model || "gpt-4.1-mini",
             messages: toOpenAiMessages(messages),
             stream: false,
+            ...(tools.length > 0 ? { tools } : {}),
           }),
         });
         const data = await res.json().catch(() => ({}));
         if (!res.ok) {
           throw new Error(`local provider failed: HTTP ${res.status} ${JSON.stringify(data)}`);
         }
-        const content = String(data?.choices?.[0]?.message?.content ?? "");
+        const choiceMessage = data?.choices?.[0]?.message ?? {};
+        const content = String(choiceMessage?.content ?? "");
         return {
           content,
           model: agentConfig.model || "gpt-4.1-mini",
           provider: agentConfig.provider || "openai-compatible",
+          ...(Array.isArray(choiceMessage?.tool_calls) ? { tool_calls: choiceMessage.tool_calls } : {}),
           usage: data?.usage,
           trace: messages,
         };
@@ -250,7 +336,7 @@ export function createCliLocalRuntimeAdapter(
       env: deps.env,
       agentToolNames: activeAgentToolNames,
       call,
-      executors: deps.localToolExecutors,
+      executors: localToolExecutors,
     }),
   };
 }

package/client/localToolPolicy.test.ts

@@ -3,15 +3,20 @@ import { describe, expect, test } from "bun:test";
 import { executeLocalToolWithPolicy, resolveLocalToolPolicy } from "./localToolPolicy";
 
 describe("CLI local tool policy", () => {
-  test("blocks dangerous tools even when env tries to allow them", () => {
+  test("allows execShell in explicit worktree shell mode", () => {
+    expect(resolveLocalToolPolicy({
+      env: { NOLO_LOCAL_SHELL_MODE: "worktree" },
+      agentToolNames: [],
+      toolName: "execShell",
+    })).toEqual({ allowed: true, toolName: "execShell" });
+  });
+
+  test("blocks execShell unless explicit shell mode is enabled", () => {
     expect(resolveLocalToolPolicy({
       env: { NOLO_LOCAL_ALLOWED_TOOLS: "execShell" },
       agentToolNames: ["execShell"],
       toolName: "execShell",
-    })).toMatchObject({
-      allowed: false,
-      reason: expect.stringContaining("blocked"),
-    });
+    })).toMatchObject({ allowed: false });
   });
 
   test("requires both env allowlist and agent declaration", () => {

package/client/localToolPolicy.ts

@@ -7,7 +7,6 @@ export type LocalToolPolicyDecision =
   | { allowed: false; toolName: string; reason: string };
 
 const NEVER_LOCAL_TOOLS = new Set([
-  "execShell",
   "deleteSpaces",
   "updateAgent",
   "updateSelf",
@@ -26,6 +25,18 @@ export function resolveLocalToolPolicy(args: {
   agentToolNames?: string[];
   toolName: string;
 }): LocalToolPolicyDecision {
+  if (args.toolName === "execShell") {
+    const shellMode = args.env.NOLO_LOCAL_SHELL_MODE || "";
+    if (["worktree", "dangerous", "1", "true"].includes(shellMode)) {
+      return { allowed: true, toolName: args.toolName };
+    }
+    return {
+      allowed: false,
+      toolName: args.toolName,
+      reason: "execShell requires NOLO_LOCAL_SHELL_MODE=worktree.",
+    };
+  }
+
   if (NEVER_LOCAL_TOOLS.has(args.toolName)) {
     return {
       allowed: false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nolo-cli",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "type": "module",
   "description": "Agent-first terminal workspace for Nolo",
   "bin": {
@@ -10,6 +10,7 @@
   "files": [
     "index.ts",
     "agentRuntimeLocal.ts",
+    "agentAliases.ts",
     "localRuntimeDb.ts",
     "agentRuntimeCommands.ts",
     "agentPullCommand.ts",