nolo-cli 0.1.37 → 0.1.39

package/cli/agentRunCommand.ts

@@ -4,13 +4,7 @@ import type { AgentRuntimeHostAdapter, AgentRuntimeRequestedMode } from "./agent
 import { existsSync, readFileSync } from "node:fs";
 import { extname, resolve } from "node:path";
 import { parseSkillDocProtocol, type WorkflowReferenceConfig } from "../ai/skills/skillDocProtocol";
-import { resolveCliAgentKeyInput } from "./agentAliases";
-import {
-  ensureWorkspacePackageLinks,
-  formatPreparedTaskWorktree,
-  prepareTaskWorktree,
-  type PreparedTaskWorktree,
-} from "./client/taskWorktree";
+import { MIMO_MONTH_AGENT_KEY, resolveCliAgentKeyInput } from "./agentAliases";
 import type { TaskRunPromptContext } from "./client/taskRunPrompt";
 
 type EnvLike = Record<string, string | undefined>;
@@ -25,8 +19,6 @@ type AgentRunCommandDeps = {
   output?: OutputLike;
   runner?: typeof runAgentTurn;
   localRuntimeAdapterFactory?: (env: EnvLike, options?: { cwd?: string }) => AgentRuntimeHostAdapter;
-  prepareTaskWorktree?: typeof prepareTaskWorktree;
-  ensureWorkspacePackageLinks?: typeof ensureWorkspacePackageLinks;
   inspectLocalRunWorkspace?: typeof inspectLocalRunWorkspace;
   resolveWorkflowReference?: typeof resolveWorkflowReference;
 };
@@ -63,7 +55,7 @@ type ParsedAgentRunArgs = {
   maxToolRounds?: number;
   timeoutMs?: number;
   traceTools: boolean;
-  useTaskWorktree: boolean;
+  injectFeatureWorktreeInstruction: boolean;
   taskRunContext?: TaskRunPromptContext;
   workflowRef?: string;
 };
@@ -102,6 +94,21 @@ function runtimeModeFromArgs(args: string[]): AgentRuntimeRequestedMode | undefi
   return undefined;
 }
 
+function isMonthlyMimoAgentRef(raw: string | undefined, resolved: string) {
+  const normalized = raw?.trim().toLowerCase();
+  return (
+    resolved === MIMO_MONTH_AGENT_KEY ||
+    normalized === "fullstack" ||
+    normalized === "full-stack" ||
+    normalized === "nolo-fullstack" ||
+    normalized === "包月mimo" ||
+    normalized === "包月mimo2.5" ||
+    normalized === "mimo-month" ||
+    normalized === "全栈" ||
+    normalized === "nolo 全栈工程师"
+  );
+}
+
 function parseNonNegativeInteger(value: string | undefined) {
   if (!value) return undefined;
   const parsed = Number(value);
@@ -123,7 +130,6 @@ function positionalArgs(args: string[]) {
     "--server",
     "--auto",
     "--dangerously-allow-shell",
-    "--worktree-task",
     "--trace-tools",
     "--bg",
     "--no-stream",
@@ -146,7 +152,8 @@ export function parseAgentRunArgs(
   args: string[],
   options: ParseAgentRunArgsOptions = {}
 ): ParsedAgentRunArgs | null {
-  const agentKey = readFlagValue(args, "--agent") ?? positionalArgs(args)[0];
+  const rawAgentKey = readFlagValue(args, "--agent") ?? positionalArgs(args)[0];
+  const agentKey = rawAgentKey ? resolveCliAgentKeyInput(rawAgentKey) : undefined;
   const explicitMsg = readFlagValue(args, "--msg");
   const msgFile = readFlagValue(args, "--msg-file");
   const fileMessage = msgFile
@@ -178,7 +185,8 @@ export function parseAgentRunArgs(
     ...readRepeatedFlagValues(args, "--image"),
     ...readRepeatedFlagValues(args, "--image-url"),
   ];
-  const useTaskWorktree = args.includes("--worktree-task");
+  const mimoLocalWorkspaceDefault =
+    isMonthlyMimoAgentRef(rawAgentKey, agentKey) && runtimeMode !== "server";
   const workflowRef = readFlagValue(args, "--workflow");
   const taskRowDbKey = readFlagValue(args, "--task-row-dbkey");
   const artifactIds = readFlagValue(args, "--artifact-ids")
@@ -186,12 +194,12 @@ export function parseAgentRunArgs(
     .map((item) => item.trim())
     .filter(Boolean);
   return {
-    agentKey: resolveCliAgentKeyInput(agentKey),
+    agentKey,
     message,
     imageUrls,
-    allowShell: args.includes("--dangerously-allow-shell"),
+    allowShell: args.includes("--dangerously-allow-shell") || mimoLocalWorkspaceDefault,
     traceTools: args.includes("--trace-tools"),
-    useTaskWorktree,
+    injectFeatureWorktreeInstruction: mimoLocalWorkspaceDefault,
     ...(workflowRef ? { workflowRef } : {}),
     ...(taskRowDbKey
       ? {
@@ -203,7 +211,11 @@ export function parseAgentRunArgs(
           },
         }
       : {}),
-    ...(runtimeMode ? { runtimeMode } : useTaskWorktree ? { runtimeMode: "local" as const } : {}),
+    ...(runtimeMode
+      ? { runtimeMode }
+      : mimoLocalWorkspaceDefault || args.includes("--dangerously-allow-shell")
+        ? { runtimeMode: "local" as const }
+        : {}),
     background: args.includes("--bg"),
     noStream: args.includes("--no-stream"),
     noDefaultTestRoot,
@@ -269,6 +281,20 @@ export function prependWorkflowReferencePrompt(message: string, workflow?: Resol
   ].join("\n");
 }
 
+function prependFeatureWorktreeInstruction(message: string, enabled: boolean) {
+  if (!enabled) return message;
+  return [
+    "Local execution rule:",
+    "- You are running in the current git checkout with shell access.",
+    "- For read-only checks, smoke tests, or answering questions, stay in the current directory.",
+    "- Before developing a new feature or making non-trivial code changes, create a separate git worktree yourself with git worktree and do the edits there.",
+    "- Commit and push only when the user explicitly asks or the task requires it.",
+    "",
+    "User task:",
+    message,
+  ].join("\n");
+}
+
 function parseDialogReference(rawInput: string) {
   const normalized = rawInput.trim();
   if (normalized.startsWith("dialog-")) {
@@ -381,19 +407,13 @@ function resolveServerUrl(env: EnvLike) {
   return (env.NOLO_SERVER || env.BASE_URL || DEFAULT_NOLO_SERVER_URL).replace(/\/+$/, "");
 }
 
-function shouldPrepareTaskWorktree(parsed: ParsedAgentRunArgs) {
-  return !parsed.cwd && (parsed.useTaskWorktree || parsed.allowShell);
-}
-
-function buildTaskWorktreeEnv(args: {
+function buildLocalRunEnv(args: {
   env: EnvLike;
-  worktreePath?: string;
   allowShell: boolean;
 }) {
   return {
     ...args.env,
     ...(args.allowShell ? { NOLO_LOCAL_SHELL_MODE: "worktree" } : {}),
-    ...(args.worktreePath ? { NOLO_LOCAL_WORKTREE: args.worktreePath } : {}),
   };
 }
 
@@ -426,52 +446,24 @@ export async function runAgentRunCommand(args: string[], deps: AgentRunCommandDe
     }
   }
   let localRuntimeCwd = parsed.cwd;
-  if (shouldPrepareTaskWorktree(parsed)) {
-    try {
-      const preparedWorktree = await (deps.prepareTaskWorktree ?? prepareTaskWorktree)({
-        agentKey: parsed.agentKey,
-        env,
-      });
-      localRuntimeCwd = preparedWorktree.path;
-      output.write(formatPreparedTaskWorktree(preparedWorktree));
-    } catch (error) {
-      output.write(
-        "[nolo] Could not prepare a local task worktree.\n" +
-          "Run from inside a git repository, or set NOLO_LOCAL_WORKTREE to an existing isolated checkout.\n" +
-          `Reason: ${error instanceof Error ? error.message : String(error)}\n`
-      );
-      return 1;
-    }
+  if (!localRuntimeCwd && parsed.runtimeMode === "local") {
+    localRuntimeCwd = process.cwd();
   }
-  const shouldBindLocalWorkspace =
-    !!localRuntimeCwd &&
-    (parsed.runtimeMode === "local" || parsed.allowShell || parsed.useTaskWorktree);
-  if (shouldBindLocalWorkspace) {
-    try {
-      await (deps.ensureWorkspacePackageLinks ?? ensureWorkspacePackageLinks)(
-        localRuntimeCwd!
-      );
-    } catch (error) {
-      output.write(
-        "[nolo] Dependency preflight failed for local task worktree.\n" +
-          "The worktree may have node_modules entries that point outside the task checkout, or paths that cannot be repaired safely.\n" +
-          `Reason: ${error instanceof Error ? error.message : String(error)}\n`
-      );
-      return 1;
-    }
-  }
-  const runEnv = shouldBindLocalWorkspace
-    ? buildTaskWorktreeEnv({
-        env,
-        worktreePath: localRuntimeCwd,
-        allowShell: parsed.allowShell,
-      })
-    : env;
+  const runEnv = buildLocalRunEnv({
+    env,
+    allowShell: parsed.allowShell,
+  });
   const result: RunAgentTurnResult = await runner({
     agentName: parsed.agentKey,
     agentKey: parsed.agentKey,
     serverUrl: resolveServerUrl(env),
-    message: prependWorkflowReferencePrompt(parsed.message, workflowReference),
+    message: prependWorkflowReferencePrompt(
+      prependFeatureWorktreeInstruction(
+        parsed.message,
+        parsed.injectFeatureWorktreeInstruction
+      ),
+      workflowReference
+    ),
     imageUrls: parsed.imageUrls.map(normalizeCliImageInput),
     scriptDir: deps.scriptDir,
     env: runEnv,

package/cli/agentRuntimeLocal.ts

@@ -5,12 +5,9 @@ export {
   hasDirectOpenAiCompatibleProvider,
   createHybridRecordStore,
   executeLocalToolWithPolicy,
-  activateWorkspaceSession,
-  createWorkspaceSession,
   buildAgentRuntimeAgentLookupKeys,
   buildAgentRuntimeDialogWritePlan,
   dialogMessageRecordToAgentRuntimeMessage,
-  formatWorkspaceSessionActivation,
   pickAgentRuntimeInferenceOptions,
   parseOpenAiCompatibleChatCompletionResponse,
   parsePlatformChatCompletionData,
@@ -44,8 +41,4 @@ export type {
   HybridRecordKvDb,
   HybridRecordStore,
   LocalToolPolicyDecision,
-  PreparedTaskWorkspace,
-  PrepareTaskWorkspace,
-  WorkspaceSession,
-  WorkspaceSessionMode,
 } from "../agent-runtime";

package/cli/cliEnvHelpers.ts

@@ -96,14 +96,18 @@ export function resolveAuthToken(
 }
 
 export function parseUserIdFromAuthToken(token: string) {
-  const payload = token.trim().split(".")[0];
-  if (!payload) return "";
-  try {
-    const parsed = JSON.parse(Buffer.from(payload, "base64").toString("utf8"));
-    return typeof parsed?.userId === "string" ? parsed.userId : "";
-  } catch {
-    return "";
+  const parts = token.trim().split(".").filter(Boolean);
+  const payloadCandidates = parts.length >= 3 ? [parts[1], parts[0]] : [parts[0]];
+  for (const payload of payloadCandidates) {
+    if (!payload) continue;
+    try {
+      const parsed = JSON.parse(Buffer.from(payload, "base64").toString("utf8"));
+      if (typeof parsed?.userId === "string") return parsed.userId;
+    } catch {
+      // Try the next token shape.
+    }
   }
+  return "";
 }
 
 export function readOption(args: string[], flag: string) {

package/cli/client/agentRun.ts

@@ -9,7 +9,7 @@ import {
 } from "../agentAliases";
 import type { LocalAgentToolEvent } from "../../agent-runtime/localLoop";
 import type { AgentRuntimeHostAdapter, AgentRuntimeRequestedMode } from "../agentRuntimeLocal";
-import { createCliLocalRuntimeAdapter } from "./localRuntimeAdapter";
+import { createCliLocalRuntimeAdapter, isBuiltinNoloAgentRef } from "./localRuntimeAdapter";
 import { createStreamingTextWriter } from "./streamingOutput";
 import { prependTaskRunPrompt, type TaskRunPromptContext } from "./taskRunPrompt";
 
@@ -73,6 +73,47 @@ export type RunAgentTurnResult = {
   streamInterrupted?: boolean;
 };
 
+class Spinner {
+  private timer: any = null;
+  private frameIndex = 0;
+  private frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+  private isTTY: boolean;
+
+  constructor(
+    private output: OutputLike,
+    private text: string
+  ) {
+    this.isTTY = Boolean((output as any).isTTY ?? process.stdout.isTTY);
+  }
+
+  start() {
+    if (!this.isTTY) {
+      this.output.write(`\n${this.text}...\n`);
+      return;
+    }
+
+    this.frameIndex = 0;
+    this.output.write(`\x1b[36m${this.frames[0]}\x1b[39m ${this.text}...`);
+
+    this.timer = setInterval(() => {
+      this.frameIndex = (this.frameIndex + 1) % this.frames.length;
+      this.output.write(`\r\x1b[36m${this.frames[this.frameIndex]}\x1b[39m ${this.text}...`);
+    }, 80);
+  }
+
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+
+    if (this.isTTY) {
+      this.output.write("\r\x1b[K");
+    }
+  }
+}
+
+
 const SERVER_PLATFORM_TOOL_NAMES = new Set([
   "addTableRow",
   "addTableRows",
@@ -139,10 +180,27 @@ function isKnownServerPlatformAgent(options: RunAgentTurnOptions) {
   const normalizedKey = normalizeAgentRef(options.agentKey);
   return Boolean(normalizedKey && KNOWN_SERVER_PLATFORM_AGENT_ALIASES.has(normalizedKey));
 }
-
-function resolveAuthToken(env: EnvLike) {
-  return env.AUTH_TOKEN || env.AUTH || env.BENCHMARK_AUTH_TOKEN || "";
-}
+
+function isMachineBoundLocalhostCustomProvider(agentConfig: any) {
+  const machineId =
+    agentConfig?.runtimeBinding && typeof agentConfig.runtimeBinding === "object"
+      ? String(agentConfig.runtimeBinding.machineId ?? "").trim()
+      : "";
+  const providerUrl = typeof agentConfig?.customProviderUrl === "string"
+    ? agentConfig.customProviderUrl.trim()
+    : "";
+  if (!machineId || !providerUrl) return false;
+  try {
+    const hostname = new URL(providerUrl).hostname.toLowerCase();
+    return hostname === "127.0.0.1" || hostname === "localhost" || hostname === "::1";
+  } catch {
+    return false;
+  }
+}
+
+function resolveAuthToken(env: EnvLike) {
+  return env.AUTH_TOKEN || env.AUTH || env.BENCHMARK_AUTH_TOKEN || "";
+}
 
 function shouldShowUsage(env: EnvLike) {
   return env.NOLO_DEBUG === "1" || env.NOLO_SHOW_USAGE === "1";
@@ -173,6 +231,10 @@ function resolveLocalRuntimeAdapter(options: RunAgentTurnOptions) {
 }
 
 async function shouldSkipAutoLocalForServerPlatformTools(options: RunAgentTurnOptions) {
+  if (isBuiltinNoloAgentRef(options.agentKey)) return false;
+  if (options.localRuntimeCwd && options.env.NOLO_LOCAL_SHELL_MODE === "worktree") {
+    return false;
+  }
   if (isKnownServerPlatformAgent(options)) {
     options.output.write(
       `[nolo] auto runtime: skipping local runtime because ${options.agentKey} is a known platform agent. ` +
@@ -188,6 +250,13 @@ async function shouldSkipAutoLocalForServerPlatformTools(options: RunAgentTurnOp
   } catch {
     return false;
   }
+  if (isMachineBoundLocalhostCustomProvider(agentConfig)) {
+    options.output.write(
+      `[nolo] auto runtime: skipping local runtime because ${options.agentKey} is a machine-bound localhost custom provider. ` +
+        "Use --local explicitly to force the current machine.\n"
+    );
+    return true;
+  }
   const serverTools = resolveServerPlatformToolNames(agentConfig);
   if (serverTools.length === 0) return false;
   options.output.write(
@@ -288,6 +357,13 @@ function formatToolTraceEvent(event: LocalAgentToolEvent) {
 
 function shouldAttemptAutoLocal(options: RunAgentTurnOptions) {
   if (options.localRuntimeAdapter || options.localRuntimeAdapterFactory) return true;
+  if (
+    options.env.NOLO_DISABLE_CLI_WORKSPACE_TOOLS !== "1" &&
+    isBuiltinNoloAgentRef(options.agentKey) &&
+    resolveAuthToken(options.env)
+  ) {
+    return true;
+  }
   return Boolean(
     options.env.NOLO_LOCAL_OPENAI_API_KEY ||
       options.env.OPENAI_API_KEY ||
@@ -502,7 +578,8 @@ function buildTransportErrorHint(serverUrl: string, error: unknown) {
 }
 
 async function runHttpAgentTurn(options: RunAgentTurnOptions, authToken: string) {
-  options.output.write(`\n${options.agentName} -> working...\n`);
+  const spinner = new Spinner(options.output, `${options.agentName} -> working`);
+  spinner.start();
 
   const fetchImpl = options.fetchImpl ?? fetch;
   let res: Response;
@@ -556,14 +633,16 @@ async function runHttpAgentTurn(options: RunAgentTurnOptions, authToken: string)
         ...(typeof options.timeoutMs === "number" ? { timeoutMs: options.timeoutMs } : {}),
         stream: !options.noStream && !options.background,
       }),
-    });
-  } catch (error) {
-    options.output.write(buildTransportErrorHint(options.serverUrl, error));
-    return { exitCode: 1 };
-  }
-
+    });
+  } catch (error) {
+    spinner.stop();
+    options.output.write(buildTransportErrorHint(options.serverUrl, error));
+    return { exitCode: 1 };
+  }
+
   const contentType = res.headers.get("content-type") || "";
   if (contentType.includes("text/event-stream") && res.body) {
+    spinner.stop();
     const result = await readStreamingAgentRun(options, res);
     await recordTaskRunOutcome({
       options,
@@ -577,18 +656,32 @@ async function runHttpAgentTurn(options: RunAgentTurnOptions, authToken: string)
     });
     return result;
   }
-
-  let data: any = {};
-  try {
-    data = await res.json();
-  } catch {
-    data = {};
-  }
-
+
+  spinner.stop();
+  let data: any = {};
+  try {
+    data = await res.json();
+  } catch {
+    data = {};
+  }
+
   if (!res.ok) {
     options.output.write(`[nolo] Agent request failed: HTTP ${res.status}\n`);
-    if (data?.error || data?.message) {
-      options.output.write(`${data.error || data.message}\n`);
+    const errorText = typeof data?.error === "string" ? data.error.trim() : "";
+    const messageText = typeof data?.message === "string" ? data.message.trim() : "";
+    const reasonText = typeof data?.reason === "string" ? data.reason.trim() : "";
+    const codeText = typeof data?.code === "string" ? data.code.trim() : "";
+    if (errorText || messageText) {
+      options.output.write(`${errorText || messageText}\n`);
+      if (messageText && messageText !== errorText) {
+        options.output.write(`${messageText}\n`);
+      }
+      if (codeText && codeText !== errorText && codeText !== messageText) {
+        options.output.write(`code=${codeText}\n`);
+      }
+      if (reasonText && reasonText !== errorText && reasonText !== messageText) {
+        options.output.write(`reason=${reasonText}\n`);
+      }
     }
     await recordTaskRunOutcome({
       options,
@@ -691,7 +784,8 @@ async function runLocalAgentTurnForCli(
     return { exitCode: 1 };
   }
 
-  options.output.write(`\n${options.agentName} -> working locally...\n`);
+  const spinner = new Spinner(options.output, `${options.agentName} -> working locally`);
+  spinner.start();
   const toolEvents: LocalAgentToolEvent[] = [];
   try {
     const traceLocalTools = shouldTraceLocalTools(options);
@@ -716,11 +810,15 @@ async function runLocalAgentTurnForCli(
         ? {
             onToolEvent: (event) => {
               if (collectToolEvidence) toolEvents.push(event);
-              if (traceLocalTools) options.output.write(formatToolTraceEvent(event));
+              if (traceLocalTools) {
+                spinner.stop();
+                options.output.write(formatToolTraceEvent(event));
+              }
             },
           }
         : {}),
     });
+    spinner.stop();
     const content = result.content.trim();
     if (content) {
       options.output.write(`\n${options.agentName} > ${content}\n`);
@@ -736,6 +834,7 @@ async function runLocalAgentTurnForCli(
     });
     return { exitCode: 0, dialogId: result.dialogId };
   } catch (error) {
+    spinner.stop();
     if (settings.reportFailure) {
       options.output.write(
         `[nolo] Local agent run failed: ${