@myvillage/cli 1.23.2 → 1.26.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myvillage/cli",
-  "version": "1.23.2",
+  "version": "1.26.0",
   "description": "MyVillageOS CLI for community developers",
   "type": "module",
   "bin": {
@@ -26,7 +26,7 @@
   "author": "MyVillage Project",
   "license": "MIT",
   "dependencies": {
-    "@ai-sdk/anthropic": "^1.0.0",
+    "@ai-sdk/anthropic": "^3.0.78",
     "@ai-sdk/mcp": "^1.0.42",
     "@ai-sdk/openai": "^3.0.33",
     "ai": "^6.0.0",

package/src/agent-runtime/daemon-entry.js

@@ -4,6 +4,19 @@
 // It receives the agent name as a command-line argument,
 // writes a PID file, runs the agent loop, and cleans up.
 
+// Surface silent killers (uncaught exceptions, unhandled rejections, and
+// event-loop-emptied exits) to the captured stderr file so a failed start
+// always leaves a diagnostic trail.
+process.on('uncaughtException', (err) => {
+  process.stderr.write(`[daemon-entry] UNCAUGHT EXCEPTION: ${err?.stack || err}\n`);
+});
+process.on('unhandledRejection', (reason) => {
+  process.stderr.write(`[daemon-entry] UNHANDLED REJECTION: ${reason?.stack || reason}\n`);
+});
+process.on('beforeExit', (code) => {
+  process.stderr.write(`[daemon-entry] BEFORE EXIT code=${code} — event loop emptied (likely a hung await inside agent setup)\n`);
+});
+
 import { writeFileSync, unlinkSync, existsSync, mkdirSync, appendFileSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';

package/src/agent-runtime/daemon.js

@@ -5,16 +5,35 @@
 import { fork } from 'child_process';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
-import { existsSync, readFileSync, unlinkSync } from 'fs';
+import { existsSync, readFileSync, unlinkSync, openSync, mkdirSync } from 'fs';
 import { homedir } from 'os';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
+export function getDaemonStderrPath(agentName) {
+  return join(homedir(), '.myvillage', 'agents', agentName, 'logs', 'daemon-stderr.log');
+}
+
 export function startDaemon(agentName) {
   const entryScript = join(__dirname, 'daemon-entry.js');
+
+  // Capture daemon stderr to a file so crashes that happen BEFORE the loop
+  // starts logging (e.g. ESM module-resolution errors at top-level import)
+  // are visible. Without this, `stdio: 'ignore'` silently discarded the
+  // only signal of what went wrong, leaving the developer with a blank
+  // log file and no error.
+  const logsDir = join(homedir(), '.myvillage', 'agents', agentName, 'logs');
+  if (!existsSync(logsDir)) {
+    mkdirSync(logsDir, { recursive: true });
+  }
+  const stderrPath = getDaemonStderrPath(agentName);
+  // Open with 'w' to truncate so stale crashes from previous starts don't
+  // mislead the diagnostic.
+  const stderrFd = openSync(stderrPath, 'w');
+
   const child = fork(entryScript, [agentName], {
     detached: true,
-    stdio: 'ignore',
+    stdio: ['ignore', 'ignore', stderrFd, 'ipc'],
   });
   child.unref();
   return child.pid;

package/src/agent-runtime/loop.js

@@ -207,8 +207,9 @@ export async function agentLoop(agentName, { signal }) {
         type: 'llm_response',
         text: (result.text || '').slice(0, 500),
         tokensUsed: {
-          prompt: result.usage?.promptTokens || 0,
-          completion: result.usage?.completionTokens || 0,
+          prompt: result.usage?.inputTokens || 0,
+          completion: result.usage?.outputTokens || 0,
+          total: result.usage?.totalTokens || 0,
         },
       });
 
@@ -313,7 +314,7 @@ export async function agentLoop(agentName, { signal }) {
                 toolErrors: taskActionAudit.toolErrors,
                 note: 'Marked FAILED because the action tools did not succeed. The model\'s text may claim success but the underlying tool calls errored.',
               },
-              tokensUsed: (result.usage?.promptTokens || 0) + (result.usage?.completionTokens || 0),
+              tokensUsed: result.usage?.totalTokens || 0,
               durationMs: Date.now() - loopStart,
             });
             logActivity(agentDir, {
@@ -328,7 +329,7 @@ export async function agentLoop(agentName, { signal }) {
                 toolCalls: activity.toolCalls,
                 toolErrors: taskActionAudit.toolErrors.length > 0 ? taskActionAudit.toolErrors : undefined,
               },
-              tokensUsed: (result.usage?.promptTokens || 0) + (result.usage?.completionTokens || 0),
+              tokensUsed: result.usage?.totalTokens || 0,
               durationMs: Date.now() - loopStart,
             });
             logActivity(agentDir, { type: 'task_completed', taskId: activeTask.id });
@@ -347,7 +348,7 @@ export async function agentLoop(agentName, { signal }) {
             votesGiven: activity.votesGiven,
             toolCalls: activity.toolCalls,
             modelUsed: modelId,
-            tokensUsed: (result.usage?.promptTokens || 0) + (result.usage?.completionTokens || 0),
+            tokensUsed: result.usage?.totalTokens || 0,
             durationMs: Date.now() - loopStart,
             activitySummary: { feedItemsRead, mentionsFound },
           });

package/src/agent-runtime/mcp-client.js

@@ -33,41 +33,84 @@ export async function getMCPTools(agentDir, agentConfig) {
       continue;
     }
 
-    const transport = server.url ? 'sse' : 'stdio';
+    // URL-based servers default to Streamable HTTP (the current MCP
+    // standard), but allow `transport: 'sse'` in tools.yaml for legacy
+    // SSE-only servers.
+    const transport = server.url ? (server.transport || 'http') : 'stdio';
 
     try {
       // AI SDK v6 moved the MCP client into a separate package
-      // (`@ai-sdk/mcp`). Importing from `ai` returns undefined on v6 and
-      // throws "createMCPClient is not a function" when called.
-      const { experimental_createMCPClient: createMCPClient } = await import('@ai-sdk/mcp');
+      // (`@ai-sdk/mcp`). Walk through every plausible export shape so we
+      // survive ESM-vs-CJS interop quirks and future renames — and if
+      // none match, throw a *useful* error listing what the module
+      // actually exposes instead of the cryptic "X is not a function".
+      const mcpModule = await import('@ai-sdk/mcp');
+      const createMCPClient =
+        mcpModule.experimental_createMCPClient
+        ?? mcpModule.createMCPClient
+        ?? mcpModule.default?.experimental_createMCPClient
+        ?? mcpModule.default?.createMCPClient;
+      if (typeof createMCPClient !== 'function') {
+        throw new Error(
+          `@ai-sdk/mcp loaded but no createMCPClient export found. `
+          + `Module exports: [${Object.keys(mcpModule).sort().join(', ') || '(empty)'}]. `
+          + `If you upgraded the CLI via 'npm update', try a clean reinstall: `
+          + `npm uninstall -g @myvillage/cli && npm install -g @myvillage/cli`
+        );
+      }
+      // Wrap createMCPClient with a hard timeout. Without this, @ai-sdk/mcp's
+      // SSE transport can return a never-settling promise when the endpoint
+      // doesn't respond as expected — and because nothing else keeps the
+      // event loop alive during agent startup, Node will exit cleanly with
+      // code 0, bypassing every try/catch and .finally we've set up.
+      const MCP_CONNECT_TIMEOUT_MS = 30000;
+      const withTimeout = (promise, label) => Promise.race([
+        promise,
+        new Promise((_, reject) => setTimeout(
+          () => reject(new Error(`MCP connect timed out after ${MCP_CONNECT_TIMEOUT_MS}ms (${label})`)),
+          MCP_CONNECT_TIMEOUT_MS,
+        )),
+      ]);
       let client;
 
       if (server.url) {
         // Remote MCP server via Streamable HTTP transport
         const headers = {};
-        if (process.env.MYVILLAGE_ACCESS_TOKEN) {
-          headers['Authorization'] = `Bearer ${process.env.MYVILLAGE_ACCESS_TOKEN}`;
-        }
-        if (process.env.MYVILLAGE_AGENT_ID) {
-          headers['X-Agent-Id'] = process.env.MYVILLAGE_AGENT_ID;
+
+        // Auto-attach the MyVillage bearer ONLY for MyVillage hostnames.
+        // Sending an in-session OAuth token to an arbitrary third-party
+        // MCP would be a credential leak.
+        if (isMyVillageHost(server.url)) {
+          if (process.env.MYVILLAGE_ACCESS_TOKEN) {
+            headers['Authorization'] = `Bearer ${process.env.MYVILLAGE_ACCESS_TOKEN}`;
+          }
+          if (process.env.MYVILLAGE_AGENT_ID) {
+            headers['X-Agent-Id'] = process.env.MYVILLAGE_AGENT_ID;
+          }
         }
-        client = await createMCPClient({
+
+        // Per-server headers from tools.yaml (with `${VAR}` env expansion).
+        // These win over the auto-attached MyVillage headers so a developer
+        // can override on the same host if they need to.
+        Object.assign(headers, resolveEnvVars(server.headers || {}));
+
+        client = await withTimeout(createMCPClient({
           transport: {
-            type: 'sse',
+            type: transport,
             url: server.url,
             headers,
           },
-        });
+        }), `${name} (${transport} ${server.url})`);
       } else {
         // Local MCP servers via stdio transport
-        client = await createMCPClient({
+        client = await withTimeout(createMCPClient({
           transport: {
             type: 'stdio',
             command: server.command,
             args: server.args || [],
             env: { ...process.env, ...resolveEnvVars(server.env || {}) },
           },
-        });
+        }), `${name} (stdio ${server.command})`);
       }
 
       activeClients.push(client);
@@ -106,6 +149,15 @@ export async function cleanupMCPClients() {
 
 // ── Helpers ─────────────────────────────────────────────
 
+function isMyVillageHost(urlString) {
+  try {
+    const host = new URL(urlString).hostname;
+    return host === 'myvillageproject.ai' || host.endsWith('.myvillageproject.ai');
+  } catch {
+    return false;
+  }
+}
+
 function resolveEnvVars(envMap) {
   const resolved = {};
   for (const [key, val] of Object.entries(envMap)) {

package/src/commands/agent-local.js

@@ -416,7 +416,7 @@ export async function agentStartCommand(name) {
   const spinner = villageSpinner(`Starting agent "${name}"...`).start();
 
   try {
-    const { startDaemon } = await import('../agent-runtime/daemon.js');
+    const { startDaemon, getDaemonStderrPath } = await import('../agent-runtime/daemon.js');
     startDaemon(name);
 
     // Wait briefly for PID file to appear
@@ -437,6 +437,25 @@ export async function agentStartCommand(name) {
       const lastError = [...recent].reverse().find(e => e.type === 'error');
       if (lastError?.error) {
         console.log(chalk.red(`  ${lastError.error}`));
+      } else {
+        // Daemon died before it could write a single log entry. Fall back
+        // to the stderr capture file — catches top-level ESM resolution
+        // errors, missing modules, syntax errors, etc.
+        const stderrPath = getDaemonStderrPath(name);
+        if (existsSync(stderrPath)) {
+          try {
+            const stderrText = readFileSync(stderrPath, 'utf-8').trim();
+            if (stderrText) {
+              console.log(chalk.red('  Daemon stderr:'));
+              // Indent each line for readability and cap output length so a
+              // multi-MB stack trace doesn't drown the terminal.
+              const trimmed = stderrText.length > 2000
+                ? stderrText.slice(0, 2000) + '\n... (truncated; see ' + stderrPath + ')'
+                : stderrText;
+              console.log(trimmed.split('\n').map(l => '    ' + l).join('\n'));
+            }
+          } catch { /* ignore */ }
+        }
       }
       console.log(brand.teal(`  Full logs: myvillage agent logs ${name}\n`));
     }