nolo-cli 0.1.37 → 0.1.39

package/cli/client/localRuntimeAdapter.ts

@@ -5,6 +5,8 @@ import type {
 } from "../agentRuntimeLocal";
 import { request as httpRequest } from "node:http";
 import { request as httpsRequest } from "node:https";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
 import {
   buildLocalWorkspacePolicyToolNames,
   buildLocalWorkspaceToolset,
@@ -40,19 +42,28 @@ import {
 } from "./hybridRecordStore";
 import { executeLocalToolWithPolicy } from "./localToolPolicy";
 import { taskRunFunctionSchema } from "../../ai/tools/agent/taskRunTool";
-import { prepareTaskWorktree } from "./taskWorktree";
 import {
-  activateWorkspaceSession,
-  createWorkspaceSession,
-  formatWorkspaceSessionActivation,
-  type WorkspaceSession,
-} from "./workspaceSession";
+  NOLO_DEFAULT_AGENT_ID,
+  NOLO_DEFAULT_AGENT_KEY,
+} from "../agentAliases";
+import {
+  buildNoloWorkspaceCliToolExecutors,
+  buildNoloWorkspaceOpenAiTools,
+  filterNoloWorkspaceToolNames,
+  NOLO_WORKSPACE_TOOL_NAMES,
+  NOLO_WORKSPACE_TOOL_PROMPT,
+  parseNoloWorkspaceToolArguments,
+} from "../../agent-runtime/noloWorkspaceTools";
 
 type EnvLike = Record<string, string | undefined>;
 type FetchInput = Parameters<typeof fetch>[0];
 type FetchInit = Parameters<typeof fetch>[1];
 const TRANSIENT_FETCH_MAX_ATTEMPTS = 8;
 const TRANSIENT_FETCH_RETRY_BASE_DELAY_MS = 250;
+export const BUILTIN_NOLO_AGENT_ID = NOLO_DEFAULT_AGENT_ID;
+export const BUILTIN_NOLO_AGENT_KEY = NOLO_DEFAULT_AGENT_KEY;
+const CLI_DIR = dirname(fileURLToPath(import.meta.url));
+const CLI_ENTRYPOINT = join(CLI_DIR, "..", "index.ts");
 
 export type CliLocalRuntimeDb = CliKvDb;
 
@@ -64,9 +75,7 @@ export type CliLocalRuntimeAdapterDeps = {
   createId?: () => string;
   fetchImpl?: typeof fetch;
   cwd?: string;
-  useCwdAsTaskWorkspaceBase?: boolean;
   output?: { write(chunk: string): unknown };
-  prepareTaskWorktree?: typeof prepareTaskWorktree;
   localToolExecutors?: Record<string, (call: any) => Promise<{ content: string; metadata?: Record<string, unknown> }>>;
   sleep?: (ms: number) => Promise<void>;
   loopbackRequest?: (input: FetchInput, init?: FetchInit) => Promise<Response>;
@@ -85,7 +94,7 @@ function resolveLocalUserId(env: EnvLike) {
 }
 
 function shellModeEnabled(env: EnvLike) {
-  return ["worktree", "dangerous", "1", "true"].includes(env.NOLO_LOCAL_SHELL_MODE || "");
+  return env.NOLO_LOCAL_SHELL_MODE === "worktree";
 }
 
 function parseLocalToolBudgets(env: EnvLike) {
@@ -246,6 +255,17 @@ function logLocalRuntimeDiagnostic(event: string, fields: Record<string, unknown
   console.error(`[nolo-local-runtime] ${event} ${JSON.stringify(fields)}`);
 }
 
+function summarizeOpenAiToolNames(tools: Array<Record<string, unknown>>) {
+  return tools
+    .map((tool) => {
+      const fn = tool.function;
+      return fn && typeof fn === "object" && "name" in fn && typeof fn.name === "string"
+        ? fn.name
+        : null;
+    })
+    .filter((name): name is string => Boolean(name));
+}
+
 function buildOpenAiTools(args: { toolNames?: string[]; env: EnvLike }) {
   const toolset = buildLocalWorkspaceToolsetForEnv(args);
   return [
@@ -254,6 +274,7 @@ function buildOpenAiTools(args: { toolNames?: string[]; env: EnvLike }) {
       exposeShellTools: toolset.exposeShellTools,
     }),
     ...buildServerPlatformOpenAiTools({ toolNames: args.toolNames }),
+    ...buildNoloWorkspaceOpenAiTools({ toolNames: args.toolNames }),
   ];
 }
 
@@ -272,6 +293,7 @@ function buildLocalPolicyToolNames(args: { toolNames?: string[]; env: EnvLike })
       exposeShellTools: shellModeEnabled(args.env),
     }),
     ...((args.toolNames ?? []).includes("taskRun") ? ["taskRun"] : []),
+    ...filterNoloWorkspaceToolNames(args.toolNames),
   ];
 }
 
@@ -287,13 +309,44 @@ function buildServerPlatformOpenAiTools(args: { toolNames?: string[] }) {
   ];
 }
 
-function parseToolArguments(raw: string) {
-  try {
-    const parsed = JSON.parse(raw || "{}");
-    return parsed && typeof parsed === "object" ? parsed : {};
-  } catch {
-    return {};
-  }
+function buildCliWorkspaceToolExecutors(args: {
+  env: EnvLike;
+  cliEntrypoint?: string;
+}) {
+  return buildNoloWorkspaceCliToolExecutors({
+    cliEntrypoint: args.cliEntrypoint ?? CLI_ENTRYPOINT,
+    env: args.env,
+    metadataKind: "cliWorkspaceTool",
+  });
+}
+
+export function isBuiltinNoloAgentRef(ref: unknown) {
+  if (typeof ref !== "string") return false;
+  const normalized = ref.trim();
+  return (
+    normalized === BUILTIN_NOLO_AGENT_KEY ||
+    normalized === BUILTIN_NOLO_AGENT_ID ||
+    normalized.endsWith(`-${BUILTIN_NOLO_AGENT_ID}`)
+  );
+}
+
+function isBuiltinNoloAgentConfig(agentConfig: AgentRuntimeAgentConfig | null | undefined) {
+  const key = agentConfig?.key || agentConfig?.rawRecord?.dbKey || agentConfig?.rawRecord?.agentKey;
+  const id = agentConfig?.rawRecord?.id;
+  return isBuiltinNoloAgentRef(key) || isBuiltinNoloAgentRef(id);
+}
+
+function withBuiltinNoloCliTools(agentConfig: AgentRuntimeAgentConfig | null) {
+  if (!agentConfig || !isBuiltinNoloAgentConfig(agentConfig)) return agentConfig;
+  const toolNames = [...new Set([...(agentConfig.toolNames ?? []), ...NOLO_WORKSPACE_TOOL_NAMES])];
+  return {
+    ...agentConfig,
+    toolNames,
+    prompt: [
+      agentConfig.prompt?.trim() ?? "",
+      NOLO_WORKSPACE_TOOL_PROMPT,
+    ].filter(Boolean).join("\n\n"),
+  };
 }
 
 function resolveRuntimeServerUrl(env: EnvLike) {
@@ -320,7 +373,7 @@ function buildServerPlatformToolExecutors(args: {
           "Content-Type": "application/json",
           Authorization: `Bearer ${authToken}`,
         },
-        body: JSON.stringify(parseToolArguments(call.arguments)),
+        body: JSON.stringify(parseNoloWorkspaceToolArguments(call.arguments)),
       });
       const text = await response.text().catch(() => "");
       if (!response.ok) {
@@ -352,17 +405,13 @@ function buildLocalToolExecutors(args: {
       env: args.env,
       fetchImpl: args.fetchImpl,
     }),
+    ...buildCliWorkspaceToolExecutors({
+      env: args.env,
+    }),
     ...(args.localToolExecutors ?? {}),
   };
 }
 
-function readLocalWorkspaceMode(agentConfig: AgentRuntimeAgentConfig | null) {
-  if (agentConfig?.localWorkspaceMode === "task-worktree") return "task-worktree";
-  const runtimeBinding = agentConfig?.runtimeBinding;
-  const value = runtimeBinding?.localWorkspaceMode ?? runtimeBinding?.workspaceMode;
-  return value === "task-worktree" ? "task-worktree" : "current";
-}
-
 async function resolveStore(deps: CliLocalRuntimeAdapterDeps) {
   if (deps.store) return deps.store;
   return createCliHybridRecordStore({
@@ -437,51 +486,25 @@ export function createCliLocalRuntimeAdapter(
   const localToolBudgets = parseLocalToolBudgets(deps.env);
   const localToolUsage = new Map<string, number>();
   let activeAgentToolNames: string[] = [];
-  let workspaceSession: WorkspaceSession = createWorkspaceSession(
-    deps.useCwdAsTaskWorkspaceBase
-      ? { defaultCwd: deps.cwd }
-      : { cwd: deps.cwd }
-  );
+  const workspaceRoot = deps.cwd ?? process.cwd();
   let runtimeToolExecutionLimits: ReturnType<typeof resolveLocalWorkspaceExecutorOptionsFromPolicy> = {};
   let localToolExecutors = buildLocalToolExecutors({
-    workspaceRoot: workspaceSession.workspaceRoot,
+    workspaceRoot,
     env: deps.env,
     fetchImpl,
     localToolExecutors: deps.localToolExecutors,
     ...runtimeToolExecutionLimits,
   });
 
-  async function activateAgentWorkspaceSession(args: {
-    agentRef: string;
-    agentConfig: AgentRuntimeAgentConfig | null;
-  }) {
-    const previousWorkspaceRoot = workspaceSession.workspaceRoot;
-    workspaceSession = await activateWorkspaceSession(workspaceSession, {
-      agentKey: args.agentConfig?.key ?? args.agentRef,
-      mode: readLocalWorkspaceMode(args.agentConfig),
-      env: deps.env,
-      prepareTaskWorkspace: deps.prepareTaskWorktree,
-    });
-    if (workspaceSession.workspaceRoot === previousWorkspaceRoot) return;
-    localToolExecutors = buildLocalToolExecutors({
-      workspaceRoot: workspaceSession.workspaceRoot,
-      env: deps.env,
-      fetchImpl,
-      localToolExecutors: deps.localToolExecutors,
-      ...runtimeToolExecutionLimits,
-    });
-    deps.output?.write(formatWorkspaceSessionActivation(workspaceSession));
-  }
-
   return {
     host: "cli",
     capabilities: ["leveldb-agent-config", "local-provider", "leveldb-persistence", "local-tools"],
     loadAgentConfig: async (agentRef) => {
-      const agentConfig = await readAgentFromStore({
+      const agentConfig = withBuiltinNoloCliTools(await readAgentFromStore({
         agentRef,
         store: await resolveStore(deps),
         userId,
-      });
+      }));
       const requestedToolNames = agentConfig
         ? resolveRequestedRuntimeToolNames({ agentConfig })
         : [];
@@ -492,9 +515,8 @@ export function createCliLocalRuntimeAdapter(
       runtimeToolExecutionLimits = resolveLocalWorkspaceExecutorOptionsFromPolicy(
         resolveCurrentRunRuntimeToolPolicy(agentConfig),
       );
-      await activateAgentWorkspaceSession({ agentRef, agentConfig });
       localToolExecutors = buildLocalToolExecutors({
-        workspaceRoot: workspaceSession.workspaceRoot,
+        workspaceRoot,
         env: deps.env,
         fetchImpl,
         localToolExecutors: deps.localToolExecutors,
@@ -512,7 +534,7 @@ export function createCliLocalRuntimeAdapter(
       userId,
       now,
       createId,
-      cwd: workspaceSession.workspaceRoot,
+      cwd: workspaceRoot,
     }),
     resolveProvider: async (agentConfig) => {
       if (shouldUsePlatformChatProvider(deps.env, agentConfig)) {
@@ -558,6 +580,9 @@ export function createCliLocalRuntimeAdapter(
               model: providerConfig.model,
               messageCount: messages.length,
               toolCount: tools.length,
+              requestedToolNames,
+              openAiToolNames: summarizeOpenAiToolNames(tools),
+              shellMode: deps.env.NOLO_LOCAL_SHELL_MODE ?? null,
               timeoutMs: options?.timeoutMs ?? null,
             });
             const res = await fetchWithTransientRetry(fetchImpl, request.url, {
@@ -627,6 +652,9 @@ export function createCliLocalRuntimeAdapter(
             model: providerConfig.model,
             messageCount: messages.length,
             toolCount: tools.length,
+            requestedToolNames,
+            openAiToolNames: summarizeOpenAiToolNames(tools),
+            shellMode: deps.env.NOLO_LOCAL_SHELL_MODE ?? null,
             timeoutMs: options?.timeoutMs ?? null,
           });
           const res = await fetchWithTransientRetry(fetchImpl, request.url, {
@@ -672,8 +700,8 @@ export function createCliLocalRuntimeAdapter(
         ...result,
         metadata: {
           ...(result.metadata ?? {}),
-          workspaceRoot: workspaceSession.workspaceRoot,
-          workspaceKind: workspaceSession.kind,
+          workspaceRoot,
+          workspaceKind: "current",
         },
       };
     },

package/cli/connectorRunArtifact.ts

@@ -32,7 +32,6 @@ export function resolveConnectorRunCwd(args: {
   const explicit =
     args.env?.NOLO_CONNECTOR_WORKDIR ||
     args.env?.NOLO_AGENT_WORKDIR ||
-    args.env?.NOLO_LOCAL_WORKTREE ||
     "";
   const candidate = explicit || args.policy.writableRoots[0] || args.fallbackCwd || process.cwd();
   const cwd = normalizePath(candidate);