nolo-cli 0.1.29 → 0.1.31

package/agent-runtime/agentRecordConfig.ts

@@ -77,7 +77,6 @@ export function resolveAgentRuntimeConfigFromRecord(
     objectField(record, "runtimeToolPolicy") ??
     objectField(runtimeBinding ?? {}, "runtimeToolPolicy");
   const localWorkspaceMode = localWorkspaceModeField(record);
-  const delegation = objectField(record, "delegation");
   return {
     key,
     ...(name ? { name } : {}),
@@ -97,7 +96,6 @@ export function resolveAgentRuntimeConfigFromRecord(
     ...(runtimeBinding ? { runtimeBinding } : {}),
     ...(runtimeToolPolicy ? { runtimeToolPolicy } : {}),
     ...(localWorkspaceMode ? { localWorkspaceMode } : {}),
-    ...(delegation ? { delegation } : {}),
     rawRecord: record,
   };
 }

package/agent-runtime/hostAdapter.ts

@@ -24,7 +24,6 @@ export type AgentRuntimeAgentConfig = {
   runtimeBinding?: Record<string, unknown>;
   runtimeToolPolicy?: AgentRuntimeToolPolicy;
   localWorkspaceMode?: "current" | "task-worktree";
-  delegation?: Record<string, unknown>;
   rawRecord?: Record<string, unknown>;
 };
 

package/agent-runtime/hostRuntimeCapabilities.ts

@@ -0,0 +1,7 @@
+export type {
+  HostRuntimeCapabilities,
+} from "./hostRuntimeConfig";
+export {
+  createHostRuntimeCapabilities,
+  resolveHostRuntimeCapabilitiesFromEnv,
+} from "./hostRuntimeConfig";

package/agent-runtime/hostRuntimeConfig.ts

@@ -0,0 +1,86 @@
+type EnvLike = Record<string, string | undefined>;
+
+export type HostRuntimeSurface =
+  | "cli-local"
+  | "desktop"
+  | "connector-local"
+  | "connector-cli";
+
+export type HostRuntimeWorkspaceBinding =
+  | "explicit-cwd"
+  | "default-cwd";
+
+export type HostRuntimeCapabilities = {
+  allowShell: boolean;
+};
+
+export type HostRuntimeConfig = {
+  surface: HostRuntimeSurface;
+  workspaceBinding: HostRuntimeWorkspaceBinding;
+  capabilities: HostRuntimeCapabilities;
+};
+
+const SHELL_ENABLED_BY_DEFAULT_SURFACES = new Set<HostRuntimeSurface>([
+  "cli-local",
+  "desktop",
+]);
+
+function defaultAllowShellForSurface(surface: HostRuntimeSurface) {
+  return SHELL_ENABLED_BY_DEFAULT_SURFACES.has(surface);
+}
+
+function readAllowShellOverrideFromEnv(env: EnvLike) {
+  const rawMode = (env.NOLO_LOCAL_SHELL_MODE || "").trim().toLowerCase();
+  if (!rawMode) return undefined;
+  if (["worktree", "dangerous", "1", "true"].includes(rawMode)) return true;
+  if (["0", "false", "off", "none", "disabled"].includes(rawMode)) return false;
+  return undefined;
+}
+
+export function createHostRuntimeCapabilities(args: {
+  allowShell?: boolean;
+} = {}): HostRuntimeCapabilities {
+  return {
+    allowShell: args.allowShell === true,
+  };
+}
+
+export function createHostRuntimeConfig(args: {
+  surface: HostRuntimeSurface;
+  workspaceBinding: HostRuntimeWorkspaceBinding;
+  allowShell?: boolean;
+}): HostRuntimeConfig {
+  return {
+    surface: args.surface,
+    workspaceBinding: args.workspaceBinding,
+    capabilities: createHostRuntimeCapabilities({
+      allowShell: args.allowShell,
+    }),
+  };
+}
+
+export function resolveHostRuntimeCapabilitiesFromEnv(
+  env: EnvLike,
+  args: { surface?: HostRuntimeSurface } = {},
+): HostRuntimeCapabilities {
+  const allowShellOverride = readAllowShellOverrideFromEnv(env);
+  return createHostRuntimeCapabilities({
+    allowShell:
+      allowShellOverride ??
+      (args.surface ? defaultAllowShellForSurface(args.surface) : false),
+  });
+}
+
+export function resolveHostRuntimeConfigFromEnv(args: {
+  env: EnvLike;
+  surface: HostRuntimeSurface;
+  workspaceBinding: HostRuntimeWorkspaceBinding;
+}): HostRuntimeConfig {
+  return {
+    surface: args.surface,
+    workspaceBinding: args.workspaceBinding,
+    capabilities: resolveHostRuntimeCapabilitiesFromEnv(args.env, {
+      surface: args.surface,
+    }),
+  };
+}

package/agent-runtime/index.ts

@@ -46,6 +46,12 @@ export {
   formatPreparedGitTaskWorkspace,
   prepareGitTaskWorkspace,
 } from "./taskWorkspace";
+export {
+  createHostRuntimeConfig,
+  createHostRuntimeCapabilities,
+  resolveHostRuntimeConfigFromEnv,
+  resolveHostRuntimeCapabilitiesFromEnv,
+} from "./hostRuntimeConfig";
 export {
   executeLocalToolWithPolicy,
   resolveLocalToolPolicy,
@@ -53,6 +59,7 @@ export {
 export {
   mergeAgentRuntimeToolPolicies,
   normalizeAgentRuntimeToolPolicy,
+  resolveRequestedRuntimeToolNames,
   resolveEffectiveRuntimeToolPolicy,
 } from "./runtimeToolPolicy";
 export {
@@ -86,6 +93,12 @@ export type {
 export type {
   PreparedGitTaskWorkspace,
 } from "./taskWorkspace";
+export type {
+  HostRuntimeConfig,
+  HostRuntimeCapabilities,
+  HostRuntimeSurface,
+  HostRuntimeWorkspaceBinding,
+} from "./hostRuntimeConfig";
 export type {
   LocalToolPolicyDecision,
 } from "./localToolPolicy";

package/agent-runtime/localToolPolicy.ts

@@ -2,6 +2,7 @@ import type {
   AgentRuntimeToolCallInput,
   AgentRuntimeToolResult,
 } from "./types";
+import type { HostRuntimeConfig } from "./hostRuntimeConfig";
 
 type EnvLike = Record<string, string | undefined>;
 
@@ -48,10 +49,6 @@ function parseToolAllowlist(value: string | undefined) {
     .filter(Boolean);
 }
 
-function isLocalShellModeEnabled(env: EnvLike) {
-  return ["worktree", "dangerous", "1", "true"].includes(env.NOLO_LOCAL_SHELL_MODE || "");
-}
-
 function isRestrictedLocalToolMode(env: EnvLike) {
   return env.NOLO_LOCAL_TOOL_MODE === "restricted";
 }
@@ -69,18 +66,26 @@ function isToolDeclaredOrExplicitlyFree(args: {
 
 export function resolveLocalToolPolicy(args: {
   env: EnvLike;
+  hostRuntimeConfig?: HostRuntimeConfig;
   agentToolNames?: string[];
   toolName: string;
 }): LocalToolPolicyDecision {
   const restrictedMode = isRestrictedLocalToolMode(args.env);
   if (args.toolName === "execShell") {
-    if (isLocalShellModeEnabled(args.env)) {
+    if (!(args.agentToolNames ?? []).includes("execShell")) {
+      return {
+        allowed: false,
+        toolName: args.toolName,
+        reason: "execShell is not requested by this agent runtime.",
+      };
+    }
+    if (args.hostRuntimeConfig?.capabilities.allowShell === true) {
       return { allowed: true, toolName: args.toolName };
     }
     return {
       allowed: false,
       toolName: args.toolName,
-      reason: "execShell requires NOLO_LOCAL_SHELL_MODE=worktree.",
+      reason: "execShell requires host shell capability.",
     };
   }
 
@@ -123,12 +128,14 @@ export function resolveLocalToolPolicy(args: {
 
 export async function executeLocalToolWithPolicy(args: {
   env: EnvLike;
+  hostRuntimeConfig?: HostRuntimeConfig;
   agentToolNames?: string[];
   call: AgentRuntimeToolCallInput;
   executors?: Record<string, (call: AgentRuntimeToolCallInput) => Promise<AgentRuntimeToolResult>>;
 }): Promise<AgentRuntimeToolResult> {
   const decision = resolveLocalToolPolicy({
     env: args.env,
+    hostRuntimeConfig: args.hostRuntimeConfig,
     agentToolNames: args.agentToolNames,
     toolName: args.call.name,
   });