loom-agent 1.3.3 → 1.6.0

package/src/core/permissions.js

@@ -34,7 +34,7 @@ const DANGER_PATTERNS = [
 // user config).
 const PERMISSION_KEYS = [
   'read', 'edit', 'glob', 'grep', 'bash', 'task', 'skill', 'lsp', 'question',
-  'webfetch', 'websearch', 'browser',
+  'webfetch', 'websearch', 'browser', 'mcp',
   'external_directory', 'doom_loop',
 ];
 
@@ -45,6 +45,11 @@ const DEFAULT_PERMISSIONS = {
   task: 'ask',
   skill: 'ask',
   question: 'ask',
+  // MCP tools can do anything their server exposes (send emails, modify
+  // cloud infra, run queries) — prompt by default. Patterns match the full
+  // tool name (mcp__<server>__<tool>), so the user can allow one server or
+  // tool precisely: {"permission": {"mcp": {"mcp__github__*": "allow"}}}.
+  mcp: 'ask',
   doom_loop: 'ask',
   external_directory: 'ask',
   read: {
@@ -73,6 +78,7 @@ const TOOL_TO_PERMISSION = {
   glob: 'glob',
   grep: 'grep',
   bash: 'bash',
+  sandbox: 'bash',   // same command gate as bash (danger heuristics apply)
   task: 'task',
   skill: 'skill',
   lsp: 'lsp',
@@ -82,7 +88,9 @@ const TOOL_TO_PERMISSION = {
   websearch: 'websearch',
   browser: 'browser',
   todowrite: null,   // never prompts
-  mcp: null,         // wired by the session (only the "add" action prompts)
+  todoread: 'read',  // read-only todo inspection
+  tasks: null,       // list/output/kill of the session's own background tasks
+  mcp: null,         // wired by the session (mcp__* tools + the "add" action prompt)
 };
 
 function expandHome(p, home) {
@@ -213,7 +221,11 @@ class PermissionManager {
    * 'allow' | 'ask' | 'deny'.
    */
   resolve(toolName, arg) {
-    const key = TOOL_TO_PERMISSION[toolName] !== undefined ? TOOL_TO_PERMISSION[toolName] : toolName;
+    // mcp__<server>__<tool> names resolve through the 'mcp' permission key
+    // (patterns match the full tool name).
+    const key = (toolName && toolName.indexOf('mcp__') === 0)
+      ? 'mcp'
+      : (TOOL_TO_PERMISSION[toolName] !== undefined ? TOOL_TO_PERMISSION[toolName] : toolName);
     if (!key) return 'allow';
 
     // Safety heuristics always run for dangerous shell commands — even when
@@ -298,7 +310,8 @@ class PermissionManager {
     const cwd = cwdOverride || this.cwd || process.cwd();
     const inp = input || {};
     switch (toolName) {
-      case 'bash': return String(inp.command ?? inp.args ?? '');
+      case 'bash':
+      case 'sandbox': return String(inp.command ?? inp.args ?? '');
       case 'read': return normPathArg(inp.filePath || inp.path || '', cwd);
       case 'edit':
       case 'write': return normPathArg(inp.filePath || inp.path || '', cwd);

package/src/core/plugin-cmd.js

@@ -1,5 +1,6 @@
 const { listSkills, installSkill, removeSkill } = require('../skills/skills-manager');
 const { loadServers, addServer, parseMcpAddArgs, removeServer, listServers, toggleServer, seedDefaults } = require('../mcp/mcp-manager');
+const { CONNECTOR_PRESETS } = require('../mcp/connector-presets');
 const sessionStore = require('./session-store');
 
 // Quote-aware CLI tokenizer for slash commands, so paths with spaces survive:
@@ -124,8 +125,9 @@ function mcpHelp() {
     'Example (claude-compatible): /mcp add stm32 -- "C:\\stm32-mcp\\.venv\\Scripts\\python.exe" -m stm32_mcp.server',
     'Example with env: /mcp add -e BRAVE_API_KEY=x brave-search -- npx -y @modelcontextprotocol/server-brave-search',
     'From the shell (same syntax): loom add mcp [-e KEY=V] <name> [--] <command> [args...]',
+    'Connectors from the shell: loom add connector <preset> [-e KEY=V]...  (or the same one-liner form)',
     'The "--" separator is optional; quote any path with spaces. Env keys are usable as $KEY in args.',
-    'In the /mcp and /connectors browsers, press A to add with the same one-liner syntax.',
+    'In the /mcp and /connectors browsers, press A (or Enter on the "+ Add" row) to add with the same one-liner syntax.',
   ].join('\n');
 }
 
@@ -172,6 +174,89 @@ function mcpAddLineCmd(line) {
   return addServerFromArgv(argv);
 }
 
+function connectorUsage() {
+  return [
+    'Usage: /connectors add <preset> [-e KEY=V]...   (presets: ' + CONNECTOR_PRESETS.map(p => p.id).join(', ') + ')',
+    '   or: /connectors add [-e KEY=V] <name> [--] <command> [args...]',
+    'Example: /connectors add supabase -e SUPABASE_ACCESS_TOKEN=xxx',
+  ].join('\n');
+}
+
+// /connectors add + `loom add connector` — preset-aware one-line add. A bare
+// preset name expands to the full one-liner (env from -e flags anywhere, any
+// leftover tokens appended as trailing args, e.g. --project-ref X); anything
+// else falls through to the generic mcp one-liner. A connector IS an MCP
+// server — only the wording differs. A missing required key is an error, not
+// a silently broken server.
+function connectorAddFromArgv(argvIn) {
+  let argv = argvIn.slice();
+  if (argv[0] === 'add') argv = argv.slice(1);
+  else if ((argv[0] === 'connector' || argv[0] === 'connectors') && argv[1] === 'add') argv = argv.slice(2);
+  else if (argv[0] === 'connector' || argv[0] === 'connectors') argv = argv.slice(1);
+  if (!argv.length) return connectorUsage();
+
+  // Collect -e/--env KEY=V pairs from the front while looking for a name.
+  const env = /** @type {Record<string, string>} */ ({});
+  let i = 0;
+  while (i + 1 < argv.length && (argv[i] === '-e' || argv[i] === '--env')) {
+    const kv = String(argv[i + 1]);
+    const eq = kv.indexOf('=');
+    if (eq > 0) env[kv.slice(0, eq)] = kv.slice(eq + 1);
+    i += 2;
+  }
+  const name = i < argv.length ? String(argv[i]) : '';
+  // Explicit "--" means the user wrote a full custom one-liner — never expand.
+  const preset = argv.indexOf('--') === -1 ? CONNECTOR_PRESETS.find(p => p.id === name) : undefined;
+  if (!preset) {
+    const msg = addServerFromArgv(argv);
+    return typeof msg === 'string' ? msg.replace('Added MCP server', 'Added connector') : msg;
+  }
+
+  // Preset form: env flags anywhere, leftover tokens appended as extra args.
+  const extras = /** @type {string[]} */ ([]);
+  for (let j = i + 1; j < argv.length; j++) {
+    const a = argv[j];
+    if ((a === '-e' || a === '--env') && j + 1 < argv.length) {
+      const kv = String(argv[j + 1]);
+      const eq = kv.indexOf('=');
+      if (eq > 0) env[kv.slice(0, eq)] = kv.slice(eq + 1);
+      j++;
+      continue;
+    }
+    extras.push(String(a));
+  }
+  // Required keys = every prompt the guided TUI flow would ask for.
+  const missing = (preset.prompts || []).map(p => p.key).filter(k => !env[k]);
+  if (missing.length) {
+    const hints = (preset.prompts || [])
+      .filter(p => missing.indexOf(p.key) !== -1)
+      .map(p => '  -e ' + p.key + '=...    ' + p.label);
+    const firstKey = (preset.prompts.find(p => p.key === missing[0]) || { key: missing[0] }).key;
+    return 'Missing key for ' + preset.label + ':\n' + hints.join('\n') +
+      '\nExample: /connectors add ' + preset.id + ' -e ' + firstKey + '=...';
+  }
+  // Build the claude-style one-liner argv and reuse the shared engine
+  // ($KEY resolution, npx wrapping, persistence).
+  const out = /** @type {string[]} */ ([]);
+  for (const k of Object.keys(env)) out.push('-e', k + '=' + env[k]);
+  out.push(preset.id, '--');
+  if (preset.command) out.push(preset.command, ...(preset.args || []));
+  else out.push('npx', '-y', String(preset.package), ...(preset.args || []));
+  for (const x of extras) out.push(x);
+  const msg = addServerFromArgv(out);
+  return typeof msg === 'string' ? msg.replace('Added MCP server', 'Added connector') : msg;
+}
+
+// argv-array flavor for /connectors add (App.tsx slash args).
+function connectorAddCmd(args) {
+  return connectorAddFromArgv(args);
+}
+
+// Single-raw-line flavor for `loom add connector` and the one-line add input.
+function connectorAddLineCmd(line) {
+  return connectorAddFromArgv(tokenizeCli(String(line || '').trim()));
+}
+
 function mcpRemoveCmd(args) {
   const name = args[0];
   if (!name) return 'Usage: /mcp remove <name>';
@@ -365,6 +450,8 @@ module.exports = {
   listMcpText,
   mcpAddCmd,
   mcpAddLineCmd,
+  connectorAddCmd,
+  connectorAddLineCmd,
   mcpRemoveCmd,
   mcpToggleCmd,
   diffCmd,

package/src/core/sandbox.js

@@ -74,6 +74,28 @@ function detectDocker(runner) {
   return { state: 'ready', version };
 }
 
+/**
+ * NON-BLOCKING Docker detection (spawn-based twin of detectDocker). The TUI
+ * must never call the sync version — `docker version` can hang 10s when the
+ * daemon is starting, which froze the whole interface. Injectable async
+ * runner for tests: (cmd, args) => Promise<{code, out}>.
+ * @param {(cmd: string, args: string[]) => Promise<{ code: number, out: string }>} [runner]
+ * @returns {Promise<{ state: DockerState, version: string }>}
+ */
+async function detectDockerAsync(runner) {
+  const run = runner || ((/** @type {string} */ cmd, /** @type {string[]} */ args) =>
+    spawnAsync(cmd, args, { timeoutMs: 10000 }));
+  const server = await run('docker', ['version', '--format', '{{.Server.Version}}']);
+  if (server.code === 0) {
+    const version = String(server.out || '').trim();
+    if (version) return { state: 'ready', version };
+    return { state: 'no_daemon', version: '' };
+  }
+  const cli = await run('docker', ['--version']);
+  if (cli.code === 0) return { state: 'no_daemon', version: '' };
+  return { state: 'not_installed', version: '' };
+}
+
 /**
  * Platform-appropriate Docker install guide shown before the user leaves to
  * install. Mentions the restart when the installer requires one, and the
@@ -165,6 +187,41 @@ function sandboxStatus() {
   };
 }
 
+/**
+ * NON-BLOCKING twin of sandboxStatus (spawn-based docker checks). Use this
+ * from the TUI — the sync version freezes the interface while docker answers.
+ * @returns {Promise<ReturnType<typeof sandboxStatus>>}
+ */
+async function sandboxStatusAsync() {
+  const cfg = loadConfig();
+  const sandboxCfg = cfg.sandbox || {};
+  const { state, version } = await detectDockerAsync();
+  let container = /** @type {'running'|'stopped'|'absent'} */ ('absent');
+  if (state === 'ready') {
+    const insp = await spawnAsync('docker', ['inspect', '-f', '{{.State.Running}}', CONTAINER], { timeoutMs: 10000 });
+    if (insp.code === 0) container = insp.out.trim() === 'true' ? 'running' : 'stopped';
+  }
+  return {
+    docker: state,
+    dockerVersion: version,
+    enabled: !!sandboxCfg.enabled && container === 'running',
+    pending: !!sandboxCfg.pending,
+    container,
+    image: sandboxCfg.image || DEFAULT_IMAGE,
+    osId: sandboxCfg.osId || 'alpine',
+    projectRoot: sandboxCfg.projectRoot || '',
+  };
+}
+
+/**
+ * Config-only pending check (no docker involved — zero cost, never blocks).
+ * @returns {boolean}
+ */
+function sandboxPending() {
+  const cfg = loadConfig();
+  return !!(cfg.sandbox && cfg.sandbox.pending);
+}
+
 /**
  * Map a host working directory to its path inside the container. The project
  * root is mounted at /workspace; subdirectories map underneath it. Anything
@@ -348,7 +405,7 @@ async function setupSandbox(opts) {
   const root = path.resolve(o.projectRoot || process.cwd());
   const log = o.onLog || (() => {});
   const prog = o.onProgress || (() => {});
-  const { state, version } = detectDocker();
+  const { state, version } = await detectDockerAsync();
   if (state === 'not_installed') return { ok: false, error: 'Docker is not installed. Run /sandbox guide for setup steps.' };
   if (state === 'no_daemon') {
     return { ok: false, error: 'Docker is installed but the daemon is not running. Start Docker Desktop (or `sudo systemctl start docker`), then run /sandbox setup again.' };
@@ -558,10 +615,13 @@ module.exports = {
   DEFAULT_IMAGE,
   OS_CATALOG,
   detectDocker,
+  detectDockerAsync,
   installGuide,
   installLink,
   openInstallPage,
   sandboxStatus,
+  sandboxStatusAsync,
+  sandboxPending,
   toSandboxPath,
   runInSandbox,
   setupSandbox,