@causyne/agent 1.10.13 → 1.10.17

package/src/commands.js

@@ -20,7 +20,10 @@ import {
 } from './userSkills.js';
 import { buildContextText, buildUsageText, buildCheckpointsText, buildUndoText, buildStatusText } from './reporting.js';
 import { loadConfig, saveConfig } from './config.js';
-import { serverStatus, grantServer, revokeServer, addServer, removeServer } from './mcp/mcpRegistry.js';
+import {
+  serverStatus, grantServer, revokeServer, addServer, removeServer,
+  connectServer, disconnectServer, refreshServer
+} from './mcp/mcpRegistry.js';
 import { analyzeFiles, formatFindings } from './slopDetector.js';
 import { suggestMovements, formatMovementBrief, DESIGN_MOVEMENTS } from './designPalettes.js';
 import fs from 'fs';
@@ -657,10 +660,10 @@ export const COMMANDS = [
   {
     name: 'mcp',
     scope: 'local',
-    usage: '/mcp [add <name> <cmd…> | add <name> --url <url> | remove|grant|revoke <name>]',
-    description: 'Manage MCP servers: list, add, remove, grant, revoke',
+    usage: '/mcp [add <name> <cmd…> | add <name> --url <url> | remove|grant|revoke|connect|disconnect|test|refresh <name>]',
+    description: 'Manage and diagnose MCP server connections',
     dialogTitle: 'MCP servers',
-    run: (argv) => {
+    run: async (argv) => {
       const [action, serverName, ...rest] = argv;
 
       if (action === 'add') {
@@ -702,15 +705,40 @@ export const COMMANDS = [
         const known = serverStatus().some(s => s.name === serverName);
         if (!known) return fail(`No MCP server named "${serverName}" is configured.`);
         if (action === 'grant') {
-          grantServer(serverName);
+          const granted = grantServer(serverName);
+          if (!granted.ok) return fail(granted.error);
           return ok(`Granted "${serverName}". Its tools enter the catalogue on the next task.`);
         }
         revokeServer(serverName);
         return ok(`Revoked "${serverName}". Its tools are no longer callable.`);
       }
 
+      if (['connect', 'test', 'refresh', 'disconnect'].includes(action)) {
+        if (!serverName) return fail(`Usage: /mcp ${action} <server>`);
+        const known = serverStatus().some(server => server.name === serverName);
+        if (!known) return fail(`No MCP server named "${serverName}" is configured.`);
+
+        if (action === 'disconnect') {
+          await disconnectServer(serverName);
+          return ok(`Disconnected "${serverName}". Its grant remains in place.`);
+        }
+
+        if (action === 'refresh') {
+          const tools = await refreshServer(serverName);
+          return ok(`Refreshed "${serverName}": ${tools.length} tool(s) available${tools.length ? ` — ${tools.map(tool => tool.name).join(', ')}` : ''}.`);
+        }
+
+        const client = await connectServer(serverName);
+        return ok(
+          `${action === 'test' ? 'MCP test passed' : 'Connected'}: "${serverName}"\n`
+          + `Transport: ${client.status.transport || 'unknown'}\n`
+          + `Server: ${client.serverInfo ? `${client.serverInfo.name} ${client.serverInfo.version}` : 'identity not provided'}\n`
+          + `Tools: ${client.tools.length}${client.tools.length ? ` — ${client.tools.map(tool => tool.name).join(', ')}` : ''}`
+        );
+      }
+
       if (action) {
-        return fail(`Unknown mcp action "${action}". Try: add, remove, grant, revoke, or mcp on its own to list.`);
+        return fail(`Unknown mcp action "${action}". Try: add, remove, grant, revoke, connect, disconnect, test, refresh, or mcp on its own to list.`);
       }
 
       const servers = serverStatus();
@@ -719,12 +747,13 @@ export const COMMANDS = [
       }
       const lines = ['MCP servers', ''];
       for (const server of servers) {
-        lines.push(`  ${server.name}  [${server.transport}]  ${server.granted ? 'granted' : 'NOT granted'}${server.connected ? ', connected' : ''}`);
+        lines.push(`  ${server.name}  [${server.transport}]  ${server.granted ? 'granted' : 'NOT granted'}  ${server.status}`);
         lines.push(`    ${server.target}`);
         if (server.tools.length > 0) lines.push(`    tools: ${server.tools.join(', ')}`);
+        if (server.error) lines.push(`    error: ${server.error}`);
       }
       lines.push('');
-      lines.push('  mcp grant <name> to enable, mcp remove <name> to delete.');
+      lines.push('  mcp grant <name> to enable, mcp test <name> to diagnose, mcp remove <name> to delete.');
       return ok(lines.join('\n'), { effect: 'pick-mcp' });
     }
   },

package/src/config.d.ts

@@ -0,0 +1,2 @@
+export function loadConfig(): Record<string, unknown>;
+export function saveConfig(config: Record<string, unknown>): void;

package/src/hooks.js

@@ -1,95 +1,108 @@
 import { spawn } from 'node:child_process';
 import path from 'node:path';
-
 const MAX_HOOKS_PER_EVENT = 32;
 const MAX_OUTPUT_BYTES = 32 * 1024;
 const DEFAULT_TIMEOUT_MS = 5_000;
-
 function safeObject(value) {
-  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
 }
-
 function matchesTool(rule, toolName) {
-  const tools = Array.isArray(rule.tools)
-    ? rule.tools
-    : [rule.tool == null ? '*' : rule.tool];
-  return tools.some((candidate) => candidate === '*' || candidate === toolName);
+    const tools = Array.isArray(rule.tools)
+        ? rule.tools
+        : [rule.tool == null ? '*' : rule.tool];
+    return tools.some((candidate) => candidate === '*' || candidate === toolName);
 }
-
 function normalizeRule(rule, event, toolName) {
-  if (!rule || rule.enabled === false || rule.event !== event || !matchesTool(rule, toolName)) return null;
-  if (!Array.isArray(rule.command) || rule.command.length === 0) return null;
-  const command = rule.command.map((part) => String(part));
-  if (!command[0] || command.length > 64 || command.some((part) => part.length > 4096)) return null;
-  return {
-    name: String(rule.name || `${event}:${toolName}`).slice(0, 128),
-    command,
-    timeoutMs: Number.isInteger(rule.timeoutMs)
-      ? Math.max(100, Math.min(rule.timeoutMs, 10_000))
-      : DEFAULT_TIMEOUT_MS
-  };
+    if (rule === null || typeof rule !== 'object' || Array.isArray(rule))
+        return null;
+    const candidate = rule;
+    if (candidate.enabled === false || candidate.event !== event || !matchesTool(candidate, toolName))
+        return null;
+    if (!Array.isArray(candidate.command) || candidate.command.length === 0)
+        return null;
+    const command = candidate.command.map((part) => String(part));
+    const executable = command[0];
+    if (!executable || command.length > 64 || command.some((part) => part.length > 4096))
+        return null;
+    return {
+        name: String(candidate.name || `${event}:${toolName}`).slice(0, 128),
+        command: [executable, ...command.slice(1)],
+        timeoutMs: Number.isInteger(candidate.timeoutMs)
+            ? Math.max(100, Math.min(candidate.timeoutMs, 10_000))
+            : DEFAULT_TIMEOUT_MS
+    };
 }
-
 export function hasMatchingHook(hooks, event, toolName) {
-  return (Array.isArray(hooks) ? hooks : [])
-    .some((rule) => normalizeRule(rule, event, toolName) !== null);
+    return (Array.isArray(hooks) ? hooks : [])
+        .some((rule) => normalizeRule(rule, event, toolName) !== null);
 }
-
 function runOneHook(rule, payload, cwd) {
-  return new Promise((resolve) => {
-    const child = spawn(rule.command[0], rule.command.slice(1), {
-      cwd,
-      shell: false,
-      stdio: ['pipe', 'pipe', 'pipe'],
-      env: {
-        PATH: process.env.PATH || '',
-        LANG: process.env.LANG || 'C.UTF-8',
-        TMPDIR: process.env.TMPDIR || ''
-      }
+    return new Promise((resolve) => {
+        const child = spawn(rule.command[0], rule.command.slice(1), {
+            cwd,
+            shell: false,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: {
+                PATH: process.env.PATH || '',
+                LANG: process.env.LANG || 'C.UTF-8',
+                TMPDIR: process.env.TMPDIR || ''
+            }
+        });
+        let stdout = '';
+        let stderr = '';
+        let settled = false;
+        const finish = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(value);
+        };
+        const timer = setTimeout(() => {
+            child.kill('SIGTERM');
+            finish({ exitCode: null, timedOut: true, stdout, stderr });
+        }, rule.timeoutMs);
+        timer.unref();
+        const collect = (target, chunk) => {
+            const next = target + chunk.toString();
+            if (Buffer.byteLength(next, 'utf8') > MAX_OUTPUT_BYTES) {
+                child.kill('SIGTERM');
+                finish({ exitCode: null, overflow: true, stdout, stderr });
+                return target;
+            }
+            return next;
+        };
+        child.stdout.on('data', (chunk) => { stdout = collect(stdout, chunk); });
+        child.stderr.on('data', (chunk) => { stderr = collect(stderr, chunk); });
+        child.on('error', (error) => finish({ exitCode: null, spawnError: error.message, stdout, stderr }));
+        child.on('close', (code) => finish({ exitCode: code, stdout, stderr }));
+        child.stdin.end(JSON.stringify(payload));
     });
-    let stdout = '';
-    let stderr = '';
-    let settled = false;
-
-    const finish = (value) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      resolve(value);
-    };
-    const timer = setTimeout(() => {
-      child.kill('SIGTERM');
-      finish({ exitCode: null, timedOut: true, stdout, stderr });
-    }, rule.timeoutMs);
-    if (timer.unref) timer.unref();
-
-    const collect = (target, chunk) => {
-      const next = target + chunk;
-      if (Buffer.byteLength(next, 'utf8') > MAX_OUTPUT_BYTES) {
-        child.kill('SIGTERM');
-        finish({ exitCode: null, overflow: true, stdout, stderr });
-        return target;
-      }
-      return next;
-    };
-    child.stdout.on('data', (chunk) => { stdout = collect(stdout, chunk); });
-    child.stderr.on('data', (chunk) => { stderr = collect(stderr, chunk); });
-    child.on('error', (error) => finish({ exitCode: null, spawnError: error.message, stdout, stderr }));
-    child.on('close', (code) => finish({ exitCode: code, stdout, stderr }));
-    child.stdin.end(JSON.stringify(payload));
-  });
 }
-
 function feedbackFor(rule, result) {
-  const output = [result.stdout, result.stderr].filter(Boolean).join('\n').trim();
-  if (output) return `${rule.name}: ${output}`.slice(0, MAX_OUTPUT_BYTES);
-  if (result.timedOut) return `${rule.name}: timed out after ${rule.timeoutMs} ms`;
-  if (result.overflow) return `${rule.name}: output exceeded ${MAX_OUTPUT_BYTES} bytes`;
-  if (result.spawnError) return `${rule.name}: ${result.spawnError}`;
-  if (result.exitCode !== 0) return `${rule.name}: exited with code ${result.exitCode}`;
-  return '';
+    const output = [result.stdout, result.stderr].filter(Boolean).join('\n').trim();
+    if (output)
+        return `${rule.name}: ${output}`.slice(0, MAX_OUTPUT_BYTES);
+    if (result.timedOut)
+        return `${rule.name}: timed out after ${rule.timeoutMs} ms`;
+    if (result.overflow)
+        return `${rule.name}: output exceeded ${MAX_OUTPUT_BYTES} bytes`;
+    if (result.spawnError)
+        return `${rule.name}: ${result.spawnError}`;
+    if (result.exitCode !== 0)
+        return `${rule.name}: exited with code ${result.exitCode}`;
+    return '';
+}
+function resolveWorkspaceRoots(workspacePaths) {
+    if (!Array.isArray(workspacePaths))
+        return [process.cwd()];
+    const roots = workspacePaths
+        .filter((value) => typeof value === 'string' && value.length > 0)
+        .map((value) => path.resolve(value));
+    return roots.length > 0 ? roots : [process.cwd()];
 }
-
 /**
  * Run user-owned lifecycle hooks from ~/.causyne/config.json.
  *
@@ -98,39 +111,40 @@ function feedbackFor(rule, result) {
  * during startup before the user has trusted the workspace.
  */
 export async function runConfiguredHooks({ hooks, event, toolName, args, result, taskId, toolCallId, workspacePaths }) {
-  const source = Array.isArray(hooks) ? hooks : [];
-  const rules = source
-    .map((rule) => normalizeRule(rule, event, toolName))
-    .filter(Boolean)
-    .slice(0, MAX_HOOKS_PER_EVENT);
-  if (rules.length === 0) return { denied: false, messages: [] };
-
-  const roots = Array.isArray(workspacePaths) && workspacePaths.length > 0
-    ? workspacePaths.map((value) => path.resolve(value))
-    : [process.cwd()];
-  const payload = {
-    event,
-    tool: toolName,
-    args: safeObject(args),
-    result: result && typeof result === 'object' ? result : undefined,
-    taskId: String(taskId || ''),
-    toolCallId: String(toolCallId || ''),
-    workspacePaths: roots
-  };
-  const messages = [];
-
-  for (const rule of rules) {
-    const hookResult = await runOneHook(rule, payload, roots[0]);
-    const feedback = feedbackFor(rule, hookResult);
-    if (feedback) messages.push(feedback);
-
-    if (hookResult.exitCode === 2) return { denied: true, messages, reason: feedback };
-    if (event === 'PreToolUse' && hookResult.exitCode !== 0) {
-      return { denied: true, messages, reason: feedback || `${rule.name} failed closed` };
+    const source = Array.isArray(hooks) ? hooks : [];
+    const rules = source
+        .map((rule) => normalizeRule(rule, event, toolName))
+        .filter((rule) => rule !== null)
+        .slice(0, MAX_HOOKS_PER_EVENT);
+    if (rules.length === 0)
+        return { denied: false, messages: [] };
+    const roots = resolveWorkspaceRoots(workspacePaths);
+    const primaryRoot = roots[0] ?? process.cwd();
+    const payload = {
+        event,
+        tool: toolName,
+        args: safeObject(args),
+        taskId: String(taskId || ''),
+        toolCallId: String(toolCallId || ''),
+        workspacePaths: roots
+    };
+    if (result !== null && typeof result === 'object')
+        payload.result = result;
+    const messages = [];
+    for (const rule of rules) {
+        const hookResult = await runOneHook(rule, payload, primaryRoot);
+        const feedback = feedbackFor(rule, hookResult);
+        if (feedback)
+            messages.push(feedback);
+        if (hookResult.exitCode === 2) {
+            return feedback
+                ? { denied: true, messages, reason: feedback }
+                : { denied: true, messages };
+        }
+        if (event === 'PreToolUse' && hookResult.exitCode !== 0) {
+            return { denied: true, messages, reason: feedback || `${rule.name} failed closed` };
+        }
     }
-  }
-
-  return { denied: false, messages };
+    return { denied: false, messages };
 }
-
 export { MAX_HOOKS_PER_EVENT, MAX_OUTPUT_BYTES, DEFAULT_TIMEOUT_MS };

package/src/hooks.ts

@@ -0,0 +1,193 @@
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+
+import type { HookDecision, HookEvent } from './types/contracts.js';
+
+const MAX_HOOKS_PER_EVENT = 32;
+const MAX_OUTPUT_BYTES = 32 * 1024;
+const DEFAULT_TIMEOUT_MS = 5_000;
+
+type UnknownRecord = Record<string, unknown>;
+
+interface NormalizedHookRule {
+  name: string;
+  command: [string, ...string[]];
+  timeoutMs: number;
+}
+
+interface HookProcessResult {
+  exitCode: number | null;
+  stdout: string;
+  stderr: string;
+  timedOut?: boolean;
+  overflow?: boolean;
+  spawnError?: string;
+}
+
+interface RunConfiguredHooksOptions {
+  hooks?: unknown;
+  event: HookEvent;
+  toolName: string;
+  args?: unknown;
+  result?: unknown;
+  taskId?: unknown;
+  toolCallId?: unknown;
+  workspacePaths?: unknown;
+}
+
+function safeObject(value: unknown): UnknownRecord {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+    ? value as UnknownRecord
+    : {};
+}
+
+function matchesTool(rule: UnknownRecord, toolName: string): boolean {
+  const tools = Array.isArray(rule.tools)
+    ? rule.tools
+    : [rule.tool == null ? '*' : rule.tool];
+  return tools.some((candidate) => candidate === '*' || candidate === toolName);
+}
+
+function normalizeRule(rule: unknown, event: HookEvent, toolName: string): NormalizedHookRule | null {
+  if (rule === null || typeof rule !== 'object' || Array.isArray(rule)) return null;
+  const candidate = rule as UnknownRecord;
+  if (candidate.enabled === false || candidate.event !== event || !matchesTool(candidate, toolName)) return null;
+  if (!Array.isArray(candidate.command) || candidate.command.length === 0) return null;
+
+  const command = candidate.command.map((part) => String(part));
+  const executable = command[0];
+  if (!executable || command.length > 64 || command.some((part) => part.length > 4096)) return null;
+
+  return {
+    name: String(candidate.name || `${event}:${toolName}`).slice(0, 128),
+    command: [executable, ...command.slice(1)],
+    timeoutMs: Number.isInteger(candidate.timeoutMs)
+      ? Math.max(100, Math.min(candidate.timeoutMs as number, 10_000))
+      : DEFAULT_TIMEOUT_MS
+  };
+}
+
+export function hasMatchingHook(hooks: unknown, event: HookEvent, toolName: string): boolean {
+  return (Array.isArray(hooks) ? hooks : [])
+    .some((rule) => normalizeRule(rule, event, toolName) !== null);
+}
+
+function runOneHook(rule: NormalizedHookRule, payload: UnknownRecord, cwd: string): Promise<HookProcessResult> {
+  return new Promise((resolve) => {
+    const child = spawn(rule.command[0], rule.command.slice(1), {
+      cwd,
+      shell: false,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: {
+        PATH: process.env.PATH || '',
+        LANG: process.env.LANG || 'C.UTF-8',
+        TMPDIR: process.env.TMPDIR || ''
+      }
+    });
+    let stdout = '';
+    let stderr = '';
+    let settled = false;
+
+    const finish = (value: HookProcessResult): void => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(value);
+    };
+    const timer = setTimeout(() => {
+      child.kill('SIGTERM');
+      finish({ exitCode: null, timedOut: true, stdout, stderr });
+    }, rule.timeoutMs);
+    timer.unref();
+
+    const collect = (target: string, chunk: Buffer | string): string => {
+      const next = target + chunk.toString();
+      if (Buffer.byteLength(next, 'utf8') > MAX_OUTPUT_BYTES) {
+        child.kill('SIGTERM');
+        finish({ exitCode: null, overflow: true, stdout, stderr });
+        return target;
+      }
+      return next;
+    };
+    child.stdout.on('data', (chunk: Buffer | string) => { stdout = collect(stdout, chunk); });
+    child.stderr.on('data', (chunk: Buffer | string) => { stderr = collect(stderr, chunk); });
+    child.on('error', (error: Error) => finish({ exitCode: null, spawnError: error.message, stdout, stderr }));
+    child.on('close', (code: number | null) => finish({ exitCode: code, stdout, stderr }));
+    child.stdin.end(JSON.stringify(payload));
+  });
+}
+
+function feedbackFor(rule: NormalizedHookRule, result: HookProcessResult): string {
+  const output = [result.stdout, result.stderr].filter(Boolean).join('\n').trim();
+  if (output) return `${rule.name}: ${output}`.slice(0, MAX_OUTPUT_BYTES);
+  if (result.timedOut) return `${rule.name}: timed out after ${rule.timeoutMs} ms`;
+  if (result.overflow) return `${rule.name}: output exceeded ${MAX_OUTPUT_BYTES} bytes`;
+  if (result.spawnError) return `${rule.name}: ${result.spawnError}`;
+  if (result.exitCode !== 0) return `${rule.name}: exited with code ${result.exitCode}`;
+  return '';
+}
+
+function resolveWorkspaceRoots(workspacePaths: unknown): string[] {
+  if (!Array.isArray(workspacePaths)) return [process.cwd()];
+  const roots = workspacePaths
+    .filter((value): value is string => typeof value === 'string' && value.length > 0)
+    .map((value) => path.resolve(value));
+  return roots.length > 0 ? roots : [process.cwd()];
+}
+
+/**
+ * Run user-owned lifecycle hooks from ~/.causyne/config.json.
+ *
+ * Hooks are arrays of argv values and never pass through a shell. Project files
+ * are not searched for hooks, which prevents repository code from executing
+ * during startup before the user has trusted the workspace.
+ */
+export async function runConfiguredHooks({
+  hooks,
+  event,
+  toolName,
+  args,
+  result,
+  taskId,
+  toolCallId,
+  workspacePaths
+}: RunConfiguredHooksOptions): Promise<HookDecision> {
+  const source: unknown[] = Array.isArray(hooks) ? hooks : [];
+  const rules = source
+    .map((rule) => normalizeRule(rule, event, toolName))
+    .filter((rule): rule is NormalizedHookRule => rule !== null)
+    .slice(0, MAX_HOOKS_PER_EVENT);
+  if (rules.length === 0) return { denied: false, messages: [] };
+
+  const roots = resolveWorkspaceRoots(workspacePaths);
+  const primaryRoot = roots[0] ?? process.cwd();
+  const payload: UnknownRecord = {
+    event,
+    tool: toolName,
+    args: safeObject(args),
+    taskId: String(taskId || ''),
+    toolCallId: String(toolCallId || ''),
+    workspacePaths: roots
+  };
+  if (result !== null && typeof result === 'object') payload.result = result;
+  const messages: string[] = [];
+
+  for (const rule of rules) {
+    const hookResult = await runOneHook(rule, payload, primaryRoot);
+    const feedback = feedbackFor(rule, hookResult);
+    if (feedback) messages.push(feedback);
+
+    if (hookResult.exitCode === 2) {
+      return feedback
+        ? { denied: true, messages, reason: feedback }
+        : { denied: true, messages };
+    }
+    if (event === 'PreToolUse' && hookResult.exitCode !== 0) {
+      return { denied: true, messages, reason: feedback || `${rule.name} failed closed` };
+    }
+  }
+
+  return { denied: false, messages };
+}
+
+export { MAX_HOOKS_PER_EVENT, MAX_OUTPUT_BYTES, DEFAULT_TIMEOUT_MS };