@superjackfruitlabs/salaam 0.0.3 → 0.0.5

package/src/cli.ts

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+import { loadDangerClassifierOptions } from './danger-classifier.js';
+import { loadWebSearchConfig } from './web-search.js';
+import { SANDBOX_LEVELS, type SandboxLevel } from './command-sandbox.js';
 import { acp } from './acp.js';
 import { homedir } from 'node:os';
 import { join, resolve, dirname } from 'node:path';
@@ -14,9 +17,13 @@ import {
   realpathSync,
   writeFileSync,
   fsyncSync,
+  existsSync,
 } from 'node:fs';
 import { ROOT, VERSION } from './config.js';
 import { cliHelp, hasHelpFlag } from './cli-help.js';
+import { mcpCli, MCP_HELP } from './operator-mcp-cli.js';
+import { operatorMcpPath, readOperatorMcpFile } from './operator-mcp.js';
+import { defaultAgentPodConfig } from './agentpod-default-config.js';
 import { SalaamService } from './service.js';
 import { call } from './transport.js';
 import { attach, acquireControl, Outbox } from './attach.js';
@@ -62,6 +69,19 @@ async function main(): Promise<void> {
     console.log('salaam ' + VERSION);
     return;
   }
+  if (args[0] === '-c' || args[0] === '--continue') {
+    const { continueArgs } = await import('./session-pick.js');
+    args.splice(0, args.length, ...continueArgs(args)!);
+  }
+  if (args[0] === 'mcp') {
+    // Parsed before global help: a declared command's own flags follow "--".
+    const rest = args.slice(1);
+    const dash = rest.indexOf('--');
+    const flags = dash < 0 ? rest : rest.slice(0, dash);
+    if (!rest.length || flags.includes('--help') || flags.includes('-h')) console.log(MCP_HELP);
+    else console.log(mcpCli(rest));
+    return;
+  }
   if (
     (!args.length && !(process.stdin.isTTY && process.stdout.isTTY)) ||
     args[0] === 'help' ||
@@ -494,7 +514,21 @@ async function main(): Promise<void> {
     return;
   }
   if (group === 'host') {
-    const { planHost, readHost, hostUnit, runHost } = await import('./host.js');
+    const {
+      planHost,
+      readHost,
+      hostUnit,
+      runHost,
+      hostReceipt,
+      hostToolsUser,
+      hostApprovalTtlMs,
+      hostAllowsUnsandboxed,
+      hostAllowsFullAccessSessions,
+      hostAllowsYoloSessions,
+      hostDangerClassifier,
+      hostCommandNetwork,
+      hostReadPaths,
+    } = await import('./host.js');
     if (verb?.startsWith('config-')) {
       const file = option('--manifest');
       if (!file) throw Error('Supply --manifest FILE');
@@ -526,6 +560,44 @@ async function main(): Promise<void> {
       );
       return;
     }
+    if (verb === 'bind') {
+      const { bindHost } = await import('./host-bind.js');
+      const required = (name: string) => {
+        const v = option(name);
+        if (!v) throw new Error('Supply ' + name);
+        return v;
+      };
+      console.log(
+        JSON.stringify(
+          await bindHost({
+            organization_id: required('--organization'),
+            node_id: required('--node'),
+            station_key: required('--station-key'),
+            workspace: required('--workspace'),
+            tools_user: required('--tools-user'),
+            files: required('--files'),
+            runtime_root: required('--runtime-root'),
+            runtime_image_digest: required('--runtime-image-digest'),
+            operator_group: option('--operator-group'),
+            dir: option('--dir'),
+            state: explicitState ? state : undefined,
+            provider: option('--provider'),
+            model: option('--model'),
+            mcp_config: option('--mcp-config'),
+            persona: option('--persona'),
+            managed_mcp_config: option('--managed-mcp-config'),
+          }),
+        ),
+      );
+      return;
+    }
+    if (verb === 'unit-start') {
+      const { startHostUnit } = await import('./host-start.js');
+      const unit = option('--unit');
+      if (!unit || !explicitState) throw new Error('Supply --unit UNIT and --state DIR');
+      console.log(JSON.stringify(await startHostUnit(unit, state)));
+      return;
+    }
     const file = option('--manifest');
     if (!file) throw new Error('Supply --manifest FILE');
     if (verb === 'inspect') {
@@ -585,9 +657,32 @@ async function main(): Promise<void> {
                   : {}),
                 ...(m.schema === 5 || m.schema === 6 ? { stationConfig: m.station_execution } : {}),
                 ...(m.schema === 6 ? { agentpodWorkProgression: true } : {}),
+                ...(m.schema === 6 && m.operator_access
+                  ? { operatorAccess: m.operator_access }
+                  : {}),
+                ...(m.schema === 6 && m.operator_mcp
+                  ? { operatorMcpConfig: m.operator_mcp.config }
+                  : {}),
+                ...(m.schema === 6 && m.persona ? { personaConfig: m.persona } : {}),
               }),
           hostManifestDigest: digest(m),
+          hostReceipt: hostReceipt(m),
+          toolsUser: hostToolsUser(m),
           providerRoute: m.provider,
+          approvalTtlMs: hostApprovalTtlMs(m),
+          ...(hostAllowsUnsandboxed(m) ? { unsandboxedCommands: 'allow' as const } : {}),
+          // A host session may choose full access only when the reviewed manifest says so.
+          allowFullAccessSessions: hostAllowsFullAccessSessions(m),
+          allowYoloSessions: hostAllowsYoloSessions(m),
+          // The command reviewer only as the reviewed manifest names it (forbidden when absent).
+          ...(hostDangerClassifier(m).config
+            ? { dangerClassifierConfig: hostDangerClassifier(m).config }
+            : {}),
+          ...(hostDangerClassifier(m).pin
+            ? { dangerClassifierPin: hostDangerClassifier(m).pin }
+            : {}),
+          ...(hostCommandNetwork(m) ? { commandNetwork: hostCommandNetwork(m)! } : {}),
+          ...(hostReadPaths(m).length ? { localSandboxReadPaths: hostReadPaths(m) } : {}),
         });
       if (process.connected) process.once('disconnect', () => void service.close());
       for (const signal of ['SIGTERM', 'SIGINT'] as const)
@@ -614,6 +709,20 @@ async function main(): Promise<void> {
     });
     return;
   }
+  if (group === 'code' || group === 'here') {
+    const { parseCodeStart } = await import('./session-pick.js');
+    const start = parseCodeStart(args.slice(1));
+    const { tui } = await import('./tui.js');
+    await tui({
+      state,
+      start,
+      cwd: option('--cwd'),
+      takeover: args.includes('--takeover'),
+      codingRoot: option('--coding-root'),
+      codingSocket: option('--coding-socket'),
+    });
+    return;
+  }
   if (
     !group ||
     group === 'tui' ||
@@ -767,7 +876,7 @@ async function main(): Promise<void> {
     return;
   }
   if (group === 'acp') {
-    await acp(state, { coding: args.includes('--coding') });
+    await acp(state, { coding: args.includes('--coding'), local: args.includes('--local') });
     return;
   }
   if (group === 'providers' && verb === 'list') {
@@ -1553,24 +1662,65 @@ async function main(): Promise<void> {
       codingSocket = option('--coding-socket'),
       harnessConfig = option('--harness-config'),
       a2aConfig = option('--a2a-config'),
-      agentpodConfig = option('--agentpod-config'),
-      a2aListenConfig = option('--a2a-listen-config');
+      agentpodConfig =
+        option('--agentpod-config') ?? defaultAgentPodConfig(process.env, existsSync),
+      a2aListenConfig = option('--a2a-listen-config'),
+      mcpConfig = resolve(option('--mcp-config') ?? operatorMcpPath(process.env)),
+      toolsUser = option('--tools-user') ?? (process.env.SALAAM_TOOLS_USER || undefined),
+      localSandbox = option('--local-sandbox') ?? (process.env.SALAAM_LOCAL_SANDBOX || undefined),
+      unsandboxedCommands =
+        option('--unsandboxed-commands') ?? (process.env.SALAAM_UNSANDBOXED_COMMANDS || undefined),
+      localSandboxRead = (
+        option('--local-sandbox-read') ??
+        (process.env.SALAAM_LOCAL_SANDBOX_READ || '')
+      )
+        .split(',')
+        .map((p) => p.trim())
+        .filter(Boolean),
+      webSearchConfig =
+        option('--web-search-config') ?? (process.env.SALAAM_WEB_SEARCH_CONFIG || undefined),
+      dangerClassifierConfig =
+        option('--danger-classifier-config') ??
+        (process.env.SALAAM_DANGER_CLASSIFIER_CONFIG || undefined);
+    // Fail early on a bad command-reviewer config; its key is read from the named variable, never printed.
+    if (dangerClassifierConfig)
+      loadDangerClassifierOptions(
+        JSON.parse(readFileSync(resolve(dangerClassifierConfig), 'utf8')),
+      );
+    // Fail early on a bad web search config; its keys are read, never printed.
+    if (webSearchConfig) loadWebSearchConfig(resolve(webSearchConfig));
+    if (localSandbox !== undefined && !(SANDBOX_LEVELS as readonly string[]).includes(localSandbox))
+      throw Error('--local-sandbox is read-only, workspace-write or full-access');
+    if (unsandboxedCommands !== undefined && unsandboxedCommands !== 'allow')
+      throw Error('--unsandboxed-commands is allow or absent');
     if (foreground) {
       const service = await SalaamService.open({
         stateDir: state,
         providerRoute: route,
         agentpodConfig: agentpodConfig ? resolve(agentpodConfig) : undefined,
+        operatorMcpConfig: mcpConfig,
         codingRoot: codingRoot ? resolve(codingRoot) : undefined,
         codingSocket: codingSocket ? resolve(codingSocket) : undefined,
         harnessConfig: harnessConfig ? resolve(harnessConfig) : undefined,
         a2aConfig: a2aConfig ? resolve(a2aConfig) : undefined,
         a2aListenConfig: a2aListenConfig ? resolve(a2aListenConfig) : undefined,
+        toolsUser,
+        ...(localSandbox ? { localSandbox: localSandbox as SandboxLevel } : {}),
+        ...(unsandboxedCommands ? { unsandboxedCommands: 'allow' as const } : {}),
+        ...(localSandboxRead.length ? { localSandboxReadPaths: localSandboxRead } : {}),
+        ...(webSearchConfig ? { webSearchConfig: resolve(webSearchConfig) } : {}),
+        ...(dangerClassifierConfig
+          ? { dangerClassifierConfig: resolve(dangerClassifierConfig) }
+          : {}),
         effectConnector: effectSocket
           ? new SocketEffectConnector(resolve(effectSocket), { opaque })
           : undefined,
       });
       const warning = service.supervisor.providerCapabilities().warning;
       if (warning) console.error(warning);
+      // Only a live provider has a credential to share; the offline proof route stays quiet.
+      if (service.toolIdentity.warning && route.provider !== 'salaam-proof')
+        console.error('warning: ' + service.toolIdentity.warning);
       process.stdout.write(JSON.stringify({ socket, service: 'started' }) + '\n');
       for (const signal of ['SIGINT', 'SIGTERM'] as const)
         process.once(signal, () => {
@@ -1589,6 +1739,7 @@ async function main(): Promise<void> {
           coding_socket?: string | null;
           agentpod_config?: string | null;
           agentpod_pins_digest?: string | null;
+          operator_mcp?: { config: string; digest: string } | null;
         }
       | undefined;
     try {
@@ -1613,6 +1764,15 @@ async function main(): Promise<void> {
         throw new Error(
           'Service is already running with another coding configuration; stop it first',
         );
+      if ((health.operator_mcp?.config ?? null) !== mcpConfig)
+        throw new Error('Service is already running with another MCP config; stop it first');
+      if (
+        health.operator_mcp &&
+        health.operator_mcp.digest !== digest(readOperatorMcpFile(mcpConfig))
+      )
+        console.error(
+          'Declared MCP servers changed since the service started; run salaam service stop, then start, to apply them',
+        );
       console.log('Salaam service already running');
       return;
     }
@@ -1640,6 +1800,16 @@ async function main(): Promise<void> {
         ...(a2aConfig ? ['--a2a-config', resolve(a2aConfig)] : []),
         ...(agentpodConfig ? ['--agentpod-config', resolve(agentpodConfig)] : []),
         ...(a2aListenConfig ? ['--a2a-listen-config', resolve(a2aListenConfig)] : []),
+        '--mcp-config',
+        mcpConfig,
+        ...(toolsUser ? ['--tools-user', toolsUser] : []),
+        ...(localSandbox ? ['--local-sandbox', localSandbox] : []),
+        ...(unsandboxedCommands ? ['--unsandboxed-commands', 'allow'] : []),
+        ...(localSandboxRead.length ? ['--local-sandbox-read', localSandboxRead.join(',')] : []),
+        ...(webSearchConfig ? ['--web-search-config', resolve(webSearchConfig)] : []),
+        ...(dangerClassifierConfig
+          ? ['--danger-classifier-config', resolve(dangerClassifierConfig)]
+          : []),
       ],
       { detached: true, stdio: ['ignore', fd, fd] },
     );