nolo-cli 0.1.35 → 0.1.37

package/client/localRuntimeAdapter.test.ts

@@ -1324,6 +1324,70 @@ describe("CLI local runtime adapter", () => {
     expect(result.metadata).toMatchObject({ exitCode: 0 });
   });
 
+  test("applies runtime policy shell output limit to local executors without adding a timeout", async () => {
+    const requests: Array<{ body: any }> = [];
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
+        NOLO_LOCAL_SHELL_MODE: "worktree",
+      },
+      db: {
+        get: async () => ({
+          dbKey: "agent-local-shell-limits",
+          prompt: "Use shell when needed.",
+          model: "qwen-coder",
+          runtimeToolPolicy: {
+            version: 1,
+            runtimeTools: ["execShell"],
+            shell: { enabled: true, mode: "worktree", maxOutputBytes: 120 },
+          },
+        }),
+        put: async () => {},
+        batch: async () => {},
+        iterator: () => (async function* () {})(),
+      },
+      cwd: import.meta.dir,
+      fetchImpl: async (_url, init) => {
+        requests.push({ body: JSON.parse(String(init?.body)) });
+        if (requests.length === 1) {
+          return Response.json({
+            choices: [{
+              message: {
+                content: "",
+                tool_calls: [{
+                  id: "call-1",
+                  type: "function",
+                  function: {
+                    name: "execShell",
+                    arguments: JSON.stringify({
+                      cmd: process.platform === "win32"
+                        ? "'abcdefghijklmnopqrstuvwxyz0123456789'.PadRight(500, 'x')"
+                        : "bun -e 'console.log(\"x\".repeat(500))'",
+                    }),
+                  },
+                }],
+              },
+            }],
+          });
+        }
+        return Response.json({
+          choices: [{ message: { content: "limits applied" } }],
+        });
+      },
+    });
+
+    const result = await runLocalAgentTurn({
+      adapter,
+      agentRef: "shell-limits",
+      input: "run output limit check",
+    });
+
+    expect(result.content).toBe("limits applied");
+    const toolResult = requests[1]?.body.messages.at(-1)?.content ?? "";
+    expect(toolResult).toContain("[truncated ");
+    expect(toolResult).not.toContain("command timed out");
+  });
+
   test("accepts execShell aliases from the local model", async () => {
     const requests: Array<{ body: any }> = [];
     const adapter = createCliLocalRuntimeAdapter({

package/client/localRuntimeAdapter.ts

@@ -16,6 +16,8 @@ import {
   parsePlatformChatCompletionData,
   parsePlatformChatCompletionResponse,
   resolvePlatformChatProviderConfig,
+  resolveCurrentRunRuntimeToolPolicy,
+  resolveLocalWorkspaceExecutorOptionsFromPolicy,
   resolveRequestedRuntimeToolNames,
   shouldUsePlatformChatProvider,
 } from "../agentRuntimeLocal";
@@ -221,6 +223,29 @@ function buildRequestTimeoutSignal(timeoutMs?: number) {
   return controller.signal;
 }
 
+function summarizeEndpoint(value: unknown) {
+  if (typeof value !== "string" || !value.trim()) return undefined;
+  try {
+    const url = new URL(value);
+    return `${url.protocol}//${url.host}${url.pathname}`;
+  } catch {
+    return "invalid-url";
+  }
+}
+
+function parseJsonObject(raw: string) {
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function logLocalRuntimeDiagnostic(event: string, fields: Record<string, unknown>) {
+  console.error(`[nolo-local-runtime] ${event} ${JSON.stringify(fields)}`);
+}
+
 function buildOpenAiTools(args: { toolNames?: string[]; env: EnvLike }) {
   const toolset = buildLocalWorkspaceToolsetForEnv(args);
   return [
@@ -314,9 +339,15 @@ function buildLocalToolExecutors(args: {
   env: EnvLike;
   fetchImpl: typeof fetch;
   localToolExecutors?: CliLocalRuntimeAdapterDeps["localToolExecutors"];
+  commandTimeoutMs?: number;
+  commandOutputLimit?: number;
 }) {
   return {
-    ...createLocalWorkspaceToolExecutors({ workspaceRoot: args.workspaceRoot }),
+    ...createLocalWorkspaceToolExecutors({
+      workspaceRoot: args.workspaceRoot,
+      commandTimeoutMs: args.commandTimeoutMs,
+      commandOutputLimit: args.commandOutputLimit,
+    }),
     ...buildServerPlatformToolExecutors({
       env: args.env,
       fetchImpl: args.fetchImpl,
@@ -411,11 +442,13 @@ export function createCliLocalRuntimeAdapter(
       ? { defaultCwd: deps.cwd }
       : { cwd: deps.cwd }
   );
+  let runtimeToolExecutionLimits: ReturnType<typeof resolveLocalWorkspaceExecutorOptionsFromPolicy> = {};
   let localToolExecutors = buildLocalToolExecutors({
     workspaceRoot: workspaceSession.workspaceRoot,
     env: deps.env,
     fetchImpl,
     localToolExecutors: deps.localToolExecutors,
+    ...runtimeToolExecutionLimits,
   });
 
   async function activateAgentWorkspaceSession(args: {
@@ -435,6 +468,7 @@ export function createCliLocalRuntimeAdapter(
       env: deps.env,
       fetchImpl,
       localToolExecutors: deps.localToolExecutors,
+      ...runtimeToolExecutionLimits,
     });
     deps.output?.write(formatWorkspaceSessionActivation(workspaceSession));
   }
@@ -455,7 +489,17 @@ export function createCliLocalRuntimeAdapter(
         toolNames: requestedToolNames,
         env: deps.env,
       });
+      runtimeToolExecutionLimits = resolveLocalWorkspaceExecutorOptionsFromPolicy(
+        resolveCurrentRunRuntimeToolPolicy(agentConfig),
+      );
       await activateAgentWorkspaceSession({ agentRef, agentConfig });
+      localToolExecutors = buildLocalToolExecutors({
+        workspaceRoot: workspaceSession.workspaceRoot,
+        env: deps.env,
+        fetchImpl,
+        localToolExecutors: deps.localToolExecutors,
+        ...runtimeToolExecutionLimits,
+      });
       return agentConfig;
     },
     loadDialogHistory: async (dialogId) => readDialogMessages({
@@ -476,6 +520,20 @@ export function createCliLocalRuntimeAdapter(
           agentConfig,
           env: deps.env,
         });
+        logLocalRuntimeDiagnostic("provider.selected", {
+          agentKey: agentConfig.key,
+          transport: "platform-proxy",
+          apiSource: agentConfig.apiSource ?? null,
+          provider: providerConfig.provider,
+          model: providerConfig.model,
+          endpoint: summarizeEndpoint(providerConfig.endpoint) ?? null,
+          proxyServer: summarizeEndpoint(providerConfig.serverUrl) ?? null,
+          hasAuthToken: Boolean(providerConfig.authToken),
+          hasApiKey: Boolean(providerConfig.apiKey),
+          apiKeyHeader: providerConfig.apiKeyHeader ?? null,
+          useServerProxy: agentConfig.useServerProxy ?? null,
+          customProviderEndpoint: summarizeEndpoint(agentConfig.customProviderUrl) ?? null,
+        });
         return {
           model: providerConfig.model,
           complete: async (messages, options) => {
@@ -492,6 +550,16 @@ export function createCliLocalRuntimeAdapter(
               tools,
             });
             const signal = buildRequestTimeoutSignal(options?.timeoutMs);
+            logLocalRuntimeDiagnostic("provider.request.start", {
+              agentKey: agentConfig.key,
+              transport: "platform-proxy",
+              requestUrl: summarizeEndpoint(request.url) ?? null,
+              endpoint: summarizeEndpoint(providerConfig.endpoint) ?? null,
+              model: providerConfig.model,
+              messageCount: messages.length,
+              toolCount: tools.length,
+              timeoutMs: options?.timeoutMs ?? null,
+            });
             const res = await fetchWithTransientRetry(fetchImpl, request.url, {
               ...request.init,
               ...(signal ? { signal } : {}),
@@ -499,7 +567,15 @@ export function createCliLocalRuntimeAdapter(
               sleep: deps.sleep,
               loopbackRequest,
             });
-            const data = parsePlatformChatCompletionData(await res.text().catch(() => ""));
+            const raw = await res.text().catch(() => "");
+            logLocalRuntimeDiagnostic("provider.request.result", {
+              agentKey: agentConfig.key,
+              transport: "platform-proxy",
+              status: res.status,
+              ok: res.ok,
+              responseBytes: raw.length,
+            });
+            const data = parsePlatformChatCompletionData(raw);
             if (!res.ok) {
               throw new Error(`platform provider failed: HTTP ${res.status} ${JSON.stringify(data)}`);
             }
@@ -516,6 +592,18 @@ export function createCliLocalRuntimeAdapter(
         agentConfig,
         env: deps.env,
       });
+      logLocalRuntimeDiagnostic("provider.selected", {
+        agentKey: agentConfig.key,
+        transport: "direct-openai-compatible",
+        apiSource: agentConfig.apiSource ?? null,
+        provider: providerConfig.provider,
+        model: providerConfig.model,
+        endpoint: summarizeEndpoint(providerConfig.endpoint) ?? null,
+        hasApiKey: Boolean(providerConfig.apiKey),
+        apiKeyHeader: providerConfig.apiKeyHeader ?? null,
+        useServerProxy: agentConfig.useServerProxy ?? null,
+        customProviderEndpoint: summarizeEndpoint(agentConfig.customProviderUrl) ?? null,
+      });
       return {
         model: providerConfig.model,
         complete: async (messages, options) => {
@@ -532,6 +620,15 @@ export function createCliLocalRuntimeAdapter(
             tools,
           });
           const signal = buildRequestTimeoutSignal(options?.timeoutMs);
+          logLocalRuntimeDiagnostic("provider.request.start", {
+            agentKey: agentConfig.key,
+            transport: "direct-openai-compatible",
+            requestUrl: summarizeEndpoint(request.url) ?? null,
+            model: providerConfig.model,
+            messageCount: messages.length,
+            toolCount: tools.length,
+            timeoutMs: options?.timeoutMs ?? null,
+          });
           const res = await fetchWithTransientRetry(fetchImpl, request.url, {
             ...request.init,
             ...(signal ? { signal } : {}),
@@ -539,7 +636,15 @@ export function createCliLocalRuntimeAdapter(
             sleep: deps.sleep,
             loopbackRequest,
           });
-          const data = await res.json().catch(() => ({}));
+          const raw = await res.text().catch(() => "");
+          logLocalRuntimeDiagnostic("provider.request.result", {
+            agentKey: agentConfig.key,
+            transport: "direct-openai-compatible",
+            status: res.status,
+            ok: res.ok,
+            responseBytes: raw.length,
+          });
+          const data = parseJsonObject(raw);
           if (!res.ok) {
             throw new Error(`local provider failed: HTTP ${res.status} ${JSON.stringify(data)}`);
           }

package/machineWsRunDispatch.ts

@@ -1,4 +1,5 @@
 import { runLocalAgentTurn, type LocalAgentToolEvent } from "./agent-runtime/localLoop";
+import { resolveLocalRuntimeEnvFromPolicy } from "./agent-runtime/runtimeToolPolicy";
 import {
   assertMachineRunAllowed as defaultAssertMachineRunAllowed,
   resolveMachineRunPermissionPolicy as defaultResolveMachineRunPermissionPolicy,
@@ -96,6 +97,37 @@ function logConnectorRun(message: string, fields: Record<string, unknown> = {})
   console.error(`[nolo-connector] ${message} ${JSON.stringify(fields)}`);
 }
 
+function summarizeEndpoint(value: unknown) {
+  if (typeof value !== "string" || !value.trim()) return undefined;
+  try {
+    const url = new URL(value);
+    return `${url.protocol}//${url.host}${url.pathname}`;
+  } catch {
+    return "invalid-url";
+  }
+}
+
+function summarizeAgentConfigForLogs(agentConfig: any) {
+  const runtimeBinding = isRecord(agentConfig?.runtimeBinding) ? agentConfig.runtimeBinding : {};
+  return {
+    apiSource: agentConfig?.apiSource ?? null,
+    provider: agentConfig?.provider ?? null,
+    cliProvider: agentConfig?.cliProvider ?? null,
+    model: agentConfig?.model ?? null,
+    customProviderEndpoint: summarizeEndpoint(agentConfig?.customProviderUrl) ?? null,
+    useServerProxy: agentConfig?.useServerProxy ?? null,
+    skipLocalRuntimeEnsure: agentConfig?.skipLocalRuntimeEnsure ?? null,
+    hasApiKey: typeof agentConfig?.apiKey === "string" && agentConfig.apiKey.length > 0,
+    apiKeyHeader: agentConfig?.apiKeyHeader ?? null,
+    hasApiKeyFromAgentKey:
+      typeof agentConfig?.apiKeyFromAgentKey === "string" &&
+      agentConfig.apiKeyFromAgentKey.length > 0,
+    runtimeBindingKind: runtimeBinding.kind ?? null,
+    runtimeMachineId: runtimeBinding.machineId ?? null,
+    connectorSurface: runtimeBinding.connectorSurface ?? runtimeBinding.surface ?? null,
+  };
+}
+
 function isRecord(value: unknown): value is Record<string, any> {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -194,11 +226,8 @@ function mergeToolNames(...values: unknown[]) {
   return names;
 }
 
-function localRuntimeEnvFromPolicy(runtimeEnv: EnvLike, policy?: ConnectorRuntimePolicy): EnvLike {
-  return {
-    ...runtimeEnv,
-    ...(policy?.workspace?.cwd ? { NOLO_LOCAL_WORKTREE: policy.workspace.cwd } : {}),
-  };
+export function localRuntimeEnvFromPolicy(runtimeEnv: EnvLike, policy?: ConnectorRuntimePolicy): EnvLike {
+  return resolveLocalRuntimeEnvFromPolicy(runtimeEnv, policy);
 }
 
 function forwardedUserAuthToken(parsed: any): string {
@@ -569,6 +598,15 @@ export async function handleConnectorRunMessage(
     if (!requestsLocalWorkspaceRuntime(runtimePolicy) && !isMachineBoundLocalCustomProvider(agentConfig)) {
       throw new Error("Connector can only execute non-CLI agents when runtimeToolPolicySnapshot requests a local workspace runtime.");
     }
+    logConnectorRun("agent.run.local-runtime.start", {
+      requestId: parsed.requestId,
+      agentKey: parsed.payload?.agentKey,
+      cwd,
+      timeout,
+      machineBoundLocalCustomProvider: isMachineBoundLocalCustomProvider(agentConfig),
+      runtimePolicy: Boolean(runtimePolicy),
+      ...summarizeAgentConfigForLogs(agentConfig),
+    });
     baseSha = await readConnectorGitHead(cwd);
     const result = await runConnectorLocalRuntimeAgent({
       parsed,
@@ -607,6 +645,8 @@ export async function handleConnectorRunMessage(
     logConnectorRun("agent.run.error", {
       requestId: parsed.requestId,
       agentKey: parsed.payload?.agentKey,
+      ...summarizeAgentConfigForLogs(agentConfig),
+      errorName: error instanceof Error ? error.name : null,
       error: error instanceof Error ? error.message : String(error),
     });
     send(JSON.stringify({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nolo-cli",
-  "version": "0.1.35",
+  "version": "0.1.37",
   "type": "module",
   "description": "Agent-first terminal workspace for Nolo",
   "bin": {
@@ -158,8 +158,9 @@
     "agent-runtime/runtimeDecision.ts",
     "agent-runtime/workspaceSession.ts",
     "agent-runtime/taskWorkspace.ts",
-    "agent-runtime/types.ts",
+    "agent-runtime/runtimeToolPolicy.ts",
     "agent-runtime/hostAdapter.ts",
+    "agent-runtime/types.ts",
     "agent-runtime/agentConfigOptions.ts",
     "agent-runtime/openAiCompatibleProvider.ts",
     "agent-runtime/openAiCompatibleProviderConfig.ts",
@@ -173,7 +174,6 @@
     "agent-runtime/hybridRecordStore.ts",
     "agent-runtime/localToolPolicy.ts",
     "agent-runtime/shellCommandPolicy.ts",
-    "agent-runtime/runtimeToolPolicy.ts",
     "connector-experimental/heartbeatLoop.ts",
     "connector-experimental/capabilities.ts",
     "connector-experimental/codexBinary.ts",