agent-relay 2.0.12 → 2.0.14

package/packages/mcp/dist/install.js

@@ -14,6 +14,8 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { homedir, platform } from 'node:os';
+import { execSync } from 'node:child_process';
+import * as TOML from 'smol-toml';
 /**
  * Get platform-specific config paths
  */
@@ -39,7 +41,7 @@ function getConfigPaths() {
         },
         'claude-code': {
             name: 'Claude Code',
-            configPath: join(home, '.claude.json'),
+            configPath: join(home, '.claude', 'settings.json'),
             configKey: 'mcpServers',
             format: 'json',
             supportsLocal: true,
@@ -92,6 +94,13 @@ function getConfigPaths() {
             format: 'json',
             supportsLocal: true,
         },
+        codex: {
+            name: 'Codex',
+            configPath: join(home, '.codex', 'config.toml'),
+            configKey: 'mcp_servers', // TOML uses [mcp_servers.agent-relay] tables
+            format: 'toml',
+            supportsLocal: true,
+        },
     };
 }
 /**
@@ -103,6 +112,86 @@ export function getDefaultServerConfig() {
         args: ['@agent-relay/mcp', 'serve'],
     };
 }
+/**
+ * Check if node is installed via nvm (Node Version Manager).
+ * GUI apps (Claude, Cursor, VS Code) can't use nvm's shell function,
+ * so we need to use absolute paths for nvm installations.
+ */
+function isUsingNvm() {
+    try {
+        const nodePath = execSync('which node', { encoding: 'utf-8' }).trim();
+        return nodePath.includes('.nvm');
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get absolute path to node binary
+ */
+function getNodePath() {
+    try {
+        return execSync('which node', { encoding: 'utf-8' }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get path to globally installed @agent-relay/mcp bin.js
+ * Returns null if not installed globally.
+ */
+function getGlobalMcpBinPath() {
+    try {
+        // Get npm global prefix
+        const npmPrefix = execSync('npm prefix -g', { encoding: 'utf-8' }).trim();
+        const binPath = join(npmPrefix, 'lib', 'node_modules', '@agent-relay', 'mcp', 'dist', 'bin.js');
+        if (existsSync(binPath)) {
+            return binPath;
+        }
+    }
+    catch {
+        // npm not available or failed
+    }
+    return null;
+}
+/**
+ * Build MCP server configuration with proper paths.
+ *
+ * For nvm users: Uses absolute paths (recommended by MCP community)
+ * For others: Uses npx (works when node is in standard PATH)
+ *
+ * See: https://github.com/modelcontextprotocol/servers/issues/64
+ */
+function buildServerConfig() {
+    // If using nvm, we need absolute paths because GUI apps can't access nvm's shell function
+    if (isUsingNvm()) {
+        const nodePath = getNodePath();
+        const mcpBinPath = getGlobalMcpBinPath();
+        if (nodePath && mcpBinPath) {
+            // Best option: globally installed package with absolute paths
+            return {
+                command: nodePath,
+                args: [mcpBinPath, 'serve'],
+            };
+        }
+        // Package not installed globally - still try with absolute node path + npx
+        if (nodePath) {
+            const npxPath = join(dirname(nodePath), 'npx');
+            if (existsSync(npxPath)) {
+                return {
+                    command: npxPath,
+                    args: ['@agent-relay/mcp', 'serve'],
+                };
+            }
+        }
+    }
+    // Standard case: npx should work
+    return {
+        command: 'npx',
+        args: ['@agent-relay/mcp', 'serve'],
+    };
+}
 /**
  * Detect which editors are installed by checking for their config directories
  */
@@ -145,37 +234,45 @@ function stripJsonComments(content) {
     return result;
 }
 /**
- * Read and parse config file, handling both JSON and JSONC
+ * Read and parse config file, handling JSON, JSONC, and TOML
  */
 function readConfigFile(configPath, format) {
     if (!existsSync(configPath)) {
         return {};
     }
     const content = readFileSync(configPath, 'utf-8');
-    const jsonContent = format === 'jsonc' ? stripJsonComments(content) : content;
     try {
         // Handle empty or whitespace-only files
-        const trimmed = jsonContent.trim();
+        const trimmed = content.trim();
         if (!trimmed) {
             return {};
         }
-        return JSON.parse(trimmed);
+        if (format === 'toml') {
+            return TOML.parse(trimmed);
+        }
+        const jsonContent = format === 'jsonc' ? stripJsonComments(content) : content;
+        return JSON.parse(jsonContent.trim());
     }
     catch {
-        // Invalid JSON, start fresh
+        // Invalid config, start fresh
         return {};
     }
 }
 /**
  * Write config file with proper formatting
  */
-function writeConfigFile(configPath, config) {
+function writeConfigFile(configPath, config, format = 'json') {
     const configDir = dirname(configPath);
     // Ensure directory exists
     if (!existsSync(configDir)) {
         mkdirSync(configDir, { recursive: true });
     }
-    writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+    if (format === 'toml') {
+        writeFileSync(configPath, TOML.stringify(config) + '\n');
+    }
+    else {
+        writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+    }
 }
 /**
  * Get the config path for local (project-specific) installation
@@ -200,6 +297,8 @@ function getLocalConfigPath(editor, projectDir) {
             return join(projectDir, 'opencode.json');
         case 'Droid':
             return join(projectDir, '.factory', 'mcp.json');
+        case 'Codex':
+            return join(projectDir, 'codex.toml');
         default:
             return null;
     }
@@ -209,7 +308,8 @@ function getLocalConfigPath(editor, projectDir) {
  */
 export function installForEditor(editorKey, options = {}) {
     const editor = getEditorConfig(editorKey);
-    if (!editor) {
+    // Allow custom configPath even without known editor
+    if (!editor && !options.configPath) {
         return {
             editor: editorKey,
             configPath: '',
@@ -218,25 +318,63 @@ export function installForEditor(editorKey, options = {}) {
             created: false,
         };
     }
-    // Determine config path (global vs local)
-    let configPath = editor.configPath;
-    if (!options.global && options.projectDir && editor.supportsLocal) {
-        const localPath = getLocalConfigPath(editor, options.projectDir);
-        if (localPath) {
-            configPath = localPath;
+    // Determine config path, format, and key
+    // Custom configPath overrides everything (for programmatic installation)
+    let configPath;
+    let configFormat;
+    let configKey;
+    if (options.configPath) {
+        // Use custom path - for programmatic/auto installation
+        configPath = options.configPath;
+        configFormat = options.configFormat || 'json';
+        configKey = options.configKey || 'mcpServers';
+    }
+    else if (editor) {
+        // Use editor's config
+        configPath = editor.configPath;
+        configFormat = editor.format;
+        configKey = editor.configKey;
+        // Check for local path override
+        if (!options.global && options.projectDir && editor.supportsLocal) {
+            const localPath = getLocalConfigPath(editor, options.projectDir);
+            if (localPath) {
+                configPath = localPath;
+            }
         }
     }
-    // Build server config
+    else {
+        // Should not reach here due to early return above
+        return {
+            editor: editorKey,
+            configPath: '',
+            success: false,
+            error: `Unknown editor: ${editorKey}`,
+            created: false,
+        };
+    }
+    // Build server config - handles nvm users with absolute paths
+    const defaultConfig = buildServerConfig();
     const serverConfig = {
-        command: options.command || 'npx',
-        args: options.args || ['@agent-relay/mcp', 'serve'],
+        command: options.command || defaultConfig.command,
+        args: options.args || defaultConfig.args,
     };
-    // Note: We don't set RELAY_PROJECT for local installs because the MCP server
-    // will auto-discover the socket from the current working directory.
-    // This makes the config portable across machines.
+    // Set environment variables if provided (e.g., RELAY_SOCKET for project-local installs)
+    if (options.env) {
+        serverConfig.env = { ...options.env };
+    }
+    // For project-local installs with projectDir, also set RELAY_SOCKET if not already set
+    const isProjectLocal = !options.global && options.projectDir;
+    if (isProjectLocal && !serverConfig.env?.RELAY_SOCKET) {
+        const socketPath = join(options.projectDir, '.agent-relay', 'relay.sock');
+        serverConfig.env = {
+            ...serverConfig.env,
+            RELAY_SOCKET: socketPath,
+        };
+    }
     if (options.dryRun) {
+        const editorName = editor?.name || editorKey || 'custom';
         return {
-            editor: editor.name,
+            editor: editorName,
             configPath,
             success: true,
             created: !existsSync(configPath),
@@ -244,28 +382,71 @@ export function installForEditor(editorKey, options = {}) {
     }
     try {
         // Read existing config
-        const config = readConfigFile(configPath, editor.format);
+        const config = readConfigFile(configPath, configFormat);
         const created = !existsSync(configPath);
         // Initialize mcpServers if not present
-        const configKeyValue = config[editor.configKey];
+        const configKeyValue = config[configKey];
         if (!configKeyValue || typeof configKeyValue !== 'object') {
-            config[editor.configKey] = {};
+            config[configKey] = {};
         }
         // Add agent-relay server config
-        const mcpServers = config[editor.configKey];
-        mcpServers['agent-relay'] = serverConfig;
+        const mcpServers = config[configKey];
+        // OpenCode uses a different format: { type: "local", command: [...], environment: {...} }
+        if (editor?.name === 'OpenCode') {
+            const openCodeConfig = {
+                type: 'local',
+                command: [serverConfig.command, ...serverConfig.args],
+            };
+            if (serverConfig.env) {
+                openCodeConfig.environment = serverConfig.env;
+            }
+            mcpServers['agent-relay'] = openCodeConfig;
+        }
+        else {
+            mcpServers['agent-relay'] = serverConfig;
+        }
+        // For Claude Code, also add permissions to auto-approve agent-relay tools
+        // Permissions go in settings.json, not .mcp.json
+        if (editor?.name === 'Claude Code') {
+            // Determine settings path based on where MCP config is being written
+            const projectDir = configPath.endsWith('.mcp.json')
+                ? dirname(configPath) // project-local: same dir as .mcp.json
+                : dirname(configPath); // global: ~/.claude/
+            const settingsPath = configPath.endsWith('.mcp.json')
+                ? join(projectDir, '.claude', 'settings.json') // project-local
+                : configPath; // global uses same file (settings.json)
+            // Read existing settings
+            const settings = configPath.endsWith('.mcp.json')
+                ? readConfigFile(settingsPath, 'json') // separate file for project-local
+                : config; // same config object for global
+            const permissions = settings.permissions || {};
+            const allowList = permissions.allow || [];
+            // Add agent-relay permission if not already present
+            if (!allowList.includes('mcp__agent-relay__*')) {
+                allowList.push('mcp__agent-relay__*');
+            }
+            permissions.allow = allowList;
+            settings.permissions = permissions;
+            // Write settings (separate file for project-local)
+            if (configPath.endsWith('.mcp.json')) {
+                writeConfigFile(settingsPath, settings, 'json');
+            }
+            // For global, permissions are added to same config object
+        }
         // Write updated config
-        writeConfigFile(configPath, config);
+        writeConfigFile(configPath, config, configFormat);
+        const editorName = editor?.name || editorKey || 'custom';
         return {
-            editor: editor.name,
+            editor: editorName,
             configPath,
             success: true,
             created,
         };
     }
     catch (err) {
+        const editorName = editor?.name || editorKey || 'custom';
         return {
-            editor: editor.name,
+            editor: editorName,
             configPath,
             success: false,
             error: err instanceof Error ? err.message : String(err),
@@ -308,7 +489,7 @@ export function uninstallFromEditor(editorKey, options = {}) {
         const mcpServers = config[editor.configKey];
         if (mcpServers && 'agent-relay' in mcpServers) {
             delete mcpServers['agent-relay'];
-            writeConfigFile(configPath, config);
+            writeConfigFile(configPath, config, editor.format);
         }
         return {
             editor: editor.name,
@@ -379,6 +560,23 @@ export function install(options = {}) {
     }
     return results;
 }
+/**
+ * Install MCP server configuration to a specific config file path.
+ * This is a simpler API for programmatic/automated installation.
+ *
+ * @param configPath - Absolute path to config file
+ * @param options - Optional settings for format, key, etc.
+ */
+export function installMcpConfig(configPath, options = {}) {
+    return installForEditor('custom', {
+        configPath,
+        configFormat: options.format || 'json',
+        configKey: options.configKey || 'mcpServers',
+        command: options.command,
+        args: options.args,
+        env: options.env,
+    });
+}
 /**
  * Uninstall MCP server from all detected editors (or specified editors)
  */

package/packages/mcp/dist/server.js

@@ -1,7 +1,7 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListToolsRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
-import { relaySendTool, relaySendSchema, handleRelaySend, relayInboxTool, relayInboxSchema, handleRelayInbox, relayWhoTool, relayWhoSchema, handleRelayWho, relaySpawnTool, relaySpawnSchema, handleRelaySpawn, relayReleaseTool, relayReleaseSchema, handleRelayRelease, relayStatusTool, relayStatusSchema, handleRelayStatus, relayLogsTool, relayLogsSchema, handleRelayLogs, relayMetricsTool, relayMetricsSchema, handleRelayMetrics, relayHealthTool, relayHealthSchema, handleRelayHealth, } from './tools/index.js';
+import { relaySendTool, relaySendSchema, handleRelaySend, relayInboxTool, relayInboxSchema, handleRelayInbox, relayWhoTool, relayWhoSchema, handleRelayWho, relaySpawnTool, relaySpawnSchema, handleRelaySpawn, relayReleaseTool, relayReleaseSchema, handleRelayRelease, relayStatusTool, relayStatusSchema, handleRelayStatus, relayLogsTool, relayLogsSchema, handleRelayLogs, relayMetricsTool, relayMetricsSchema, handleRelayMetrics, relayHealthTool, relayHealthSchema, handleRelayHealth, relayContinuityTool, relayContinuitySchema, handleRelayContinuity, } from './tools/index.js';
 import { protocolPrompt, getProtocolPrompt } from './prompts/index.js';
 import { agentsResource, getAgentsResource, inboxResource, getInboxResource, projectResource, getProjectResource, } from './resources/index.js';
 /**
@@ -17,6 +17,7 @@ const TOOLS = [
     relayLogsTool,
     relayMetricsTool,
     relayHealthTool,
+    relayContinuityTool,
 ];
 /**
  * All available prompts
@@ -97,6 +98,11 @@ export function createMCPServer(client, config) {
                     result = await handleRelayHealth(client, input);
                     break;
                 }
+                case 'relay_continuity': {
+                    const input = relayContinuitySchema.parse(args);
+                    result = await handleRelayContinuity(client, input);
+                    break;
+                }
                 default:
                     return {
                         content: [

package/packages/mcp/dist/simple.d.ts

@@ -24,7 +24,7 @@ export interface Message {
 }
 export interface Agent {
     name: string;
-    cli: string;
+    cli?: string;
     idle?: boolean;
     parent?: string;
 }

package/packages/mcp/dist/tools/index.d.ts

@@ -7,4 +7,5 @@ export { relayStatusTool, relayStatusSchema, handleRelayStatus, type RelayStatus
 export { relayLogsTool, relayLogsSchema, handleRelayLogs, type RelayLogsInput, } from './relay-logs.js';
 export { relayMetricsTool, relayMetricsSchema, handleRelayMetrics, type RelayMetricsInput, } from './relay-metrics.js';
 export { relayHealthTool, relayHealthSchema, handleRelayHealth, type RelayHealthInput, } from './relay-health.js';
+export { relayContinuityTool, relayContinuitySchema, handleRelayContinuity, type RelayContinuityInput, } from './relay-continuity.js';
 //# sourceMappingURL=index.d.ts.map

package/packages/mcp/dist/tools/index.js

@@ -7,4 +7,5 @@ export { relayStatusTool, relayStatusSchema, handleRelayStatus, } from './relay-
 export { relayLogsTool, relayLogsSchema, handleRelayLogs, } from './relay-logs.js';
 export { relayMetricsTool, relayMetricsSchema, handleRelayMetrics, } from './relay-metrics.js';
 export { relayHealthTool, relayHealthSchema, handleRelayHealth, } from './relay-health.js';
+export { relayContinuityTool, relayContinuitySchema, handleRelayContinuity, } from './relay-continuity.js';
 //# sourceMappingURL=index.js.map

package/packages/mcp/dist/tools/relay-continuity.d.ts

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
+import type { RelayClient } from '../client.js';
+export declare const relayContinuitySchema: z.ZodObject<{
+    action: z.ZodEnum<["save", "load", "uncertain"]>;
+    current_task: z.ZodOptional<z.ZodString>;
+    completed: z.ZodOptional<z.ZodString>;
+    in_progress: z.ZodOptional<z.ZodString>;
+    key_decisions: z.ZodOptional<z.ZodString>;
+    files: z.ZodOptional<z.ZodString>;
+    item: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    action: "save" | "load" | "uncertain";
+    current_task?: string | undefined;
+    completed?: string | undefined;
+    in_progress?: string | undefined;
+    key_decisions?: string | undefined;
+    files?: string | undefined;
+    item?: string | undefined;
+}, {
+    action: "save" | "load" | "uncertain";
+    current_task?: string | undefined;
+    completed?: string | undefined;
+    in_progress?: string | undefined;
+    key_decisions?: string | undefined;
+    files?: string | undefined;
+    item?: string | undefined;
+}>;
+export type RelayContinuityInput = z.infer<typeof relayContinuitySchema>;
+export declare const relayContinuityTool: Tool;
+/**
+ * Handle continuity actions for session recovery.
+ */
+export declare function handleRelayContinuity(client: RelayClient, input: RelayContinuityInput): Promise<string>;
+//# sourceMappingURL=relay-continuity.d.ts.map

package/packages/mcp/dist/tools/relay-continuity.js

@@ -0,0 +1,101 @@
+import { z } from 'zod';
+export const relayContinuitySchema = z.object({
+    action: z.enum(['save', 'load', 'uncertain']).describe('Action: save state, load previous state, or mark uncertainty'),
+    current_task: z.string().optional().describe('Current task being worked on (for save)'),
+    completed: z.string().optional().describe('Completed work summary (for save)'),
+    in_progress: z.string().optional().describe('In-progress work summary (for save)'),
+    key_decisions: z.string().optional().describe('Key decisions made (for save)'),
+    files: z.string().optional().describe('Files being worked on (for save)'),
+    item: z.string().optional().describe('Item to mark as uncertain (for uncertain action)'),
+});
+export const relayContinuityTool = {
+    name: 'relay_continuity',
+    description: `Manage session continuity for agent recovery.
+
+Use this to:
+- Save your current state before long operations or session end
+- Load previous context when starting a new session
+- Mark items that need future verification
+
+Examples:
+- Save state: action="save", current_task="Implementing auth", completed="User model done"
+- Load state: action="load"
+- Mark uncertain: action="uncertain", item="API rate limit handling unclear"`,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            action: {
+                type: 'string',
+                enum: ['save', 'load', 'uncertain'],
+                description: 'Action: save state, load previous state, or mark uncertainty',
+            },
+            current_task: {
+                type: 'string',
+                description: 'Current task being worked on (for save)',
+            },
+            completed: {
+                type: 'string',
+                description: 'Completed work summary (for save)',
+            },
+            in_progress: {
+                type: 'string',
+                description: 'In-progress work summary (for save)',
+            },
+            key_decisions: {
+                type: 'string',
+                description: 'Key decisions made (for save)',
+            },
+            files: {
+                type: 'string',
+                description: 'Files being worked on (for save)',
+            },
+            item: {
+                type: 'string',
+                description: 'Item to mark as uncertain (for uncertain action)',
+            },
+        },
+        required: ['action'],
+    },
+};
+/**
+ * Handle continuity actions for session recovery.
+ */
+export async function handleRelayContinuity(client, input) {
+    const extClient = client;
+    const { action, current_task, completed, in_progress, key_decisions, files, item } = input;
+    switch (action) {
+        case 'save': {
+            if (!extClient.saveContinuity) {
+                return 'Continuity save not supported by this client';
+            }
+            await extClient.saveContinuity({
+                currentTask: current_task,
+                completed,
+                inProgress: in_progress,
+                keyDecisions: key_decisions,
+                files,
+            });
+            return 'Session state saved for recovery';
+        }
+        case 'load': {
+            if (!extClient.loadContinuity) {
+                return 'Continuity load not supported by this client';
+            }
+            await extClient.loadContinuity();
+            return 'Previous session context loaded';
+        }
+        case 'uncertain': {
+            if (!extClient.markUncertain) {
+                return 'Mark uncertain not supported by this client';
+            }
+            if (!item) {
+                return 'Item required for uncertain action';
+            }
+            await extClient.markUncertain(item);
+            return `Marked as uncertain: ${item}`;
+        }
+        default:
+            return `Unknown action: ${action}`;
+    }
+}
+//# sourceMappingURL=relay-continuity.js.map

package/packages/mcp/dist/tools/relay-health.d.ts

@@ -2,15 +2,12 @@ import { z } from 'zod';
 import type { Tool } from '@modelcontextprotocol/sdk/types.js';
 import type { RelayClient } from '../client.js';
 export declare const relayHealthSchema: z.ZodObject<{
-    port: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     include_crashes: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     include_alerts: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
 }, "strip", z.ZodTypeAny, {
-    port: number;
     include_crashes: boolean;
     include_alerts: boolean;
 }, {
-    port?: number | undefined;
     include_crashes?: boolean | undefined;
     include_alerts?: boolean | undefined;
 }>;
@@ -19,5 +16,5 @@ export declare const relayHealthTool: Tool;
 /**
  * Get system health, crash insights, and recommendations.
  */
-export declare function handleRelayHealth(_client: RelayClient, input: RelayHealthInput): Promise<string>;
+export declare function handleRelayHealth(client: RelayClient, input: RelayHealthInput): Promise<string>;
 //# sourceMappingURL=relay-health.d.ts.map

package/packages/mcp/dist/tools/relay-health.js

@@ -1,6 +1,5 @@
 import { z } from 'zod';
 export const relayHealthSchema = z.object({
-    port: z.number().optional().default(3888).describe('Dashboard port (default: 3888)'),
     include_crashes: z.boolean().optional().default(true).describe('Include recent crash history'),
     include_alerts: z.boolean().optional().default(true).describe('Include unacknowledged alerts'),
 });
@@ -24,11 +23,6 @@ Example: Health check without crash history
     inputSchema: {
         type: 'object',
         properties: {
-            port: {
-                type: 'number',
-                description: 'Dashboard port (default: 3888)',
-                default: 3888,
-            },
             include_crashes: {
                 type: 'boolean',
                 description: 'Include recent crash history',
@@ -46,14 +40,12 @@ Example: Health check without crash history
 /**
  * Get system health, crash insights, and recommendations.
  */
-export async function handleRelayHealth(_client, input) {
-    const port = input.port || 3888;
+export async function handleRelayHealth(client, input) {
     try {
-        const response = await fetch(`http://localhost:${port}/api/metrics/health`);
-        if (!response.ok) {
-            throw new Error(`HTTP ${response.status}`);
-        }
-        const data = await response.json();
+        const data = await client.getHealth({
+            include_crashes: input.include_crashes,
+            include_alerts: input.include_alerts,
+        });
         const lines = [];
         // Health score header
         const scoreEmoji = data.healthScore >= 80 ? '✅' :
@@ -129,8 +121,8 @@ export async function handleRelayHealth(_client, input) {
     }
     catch (err) {
         const error = err;
-        if (error.code === 'ECONNREFUSED') {
-            return `Cannot connect to dashboard at port ${port}. Is the daemon running?\n\nRun 'agent-relay up' to start the daemon.`;
+        if (error.code === 'ECONNREFUSED' || error.code === 'ENOENT') {
+            return `Cannot connect to daemon. Is the daemon running?\n\nRun 'agent-relay up' to start the daemon.`;
         }
         return `Failed to fetch health data: ${error.message || String(err)}`;
     }

package/packages/mcp/dist/tools/relay-logs.js

@@ -3,6 +3,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { promisify } from 'node:util';
 import { exec } from 'node:child_process';
+import { getProjectPaths } from '@agent-relay/config';
 const execAsync = promisify(exec);
 export const relayLogsSchema = z.object({
     agent: z.string().describe('Name of the agent to get logs for'),
@@ -39,10 +40,11 @@ Example: Get last 100 lines from Worker1
 };
 /**
  * Get the worker logs directory path.
- * Mirrors the logic from @agent-relay/bridge.
+ * Uses getProjectPaths from @agent-relay/config to match the bridge package.
  */
 function getWorkerLogsDir(projectRoot) {
-    return path.join(projectRoot, '.relay', 'logs');
+    const paths = getProjectPaths(projectRoot);
+    return path.join(paths.teamDir, 'worker-logs');
 }
 /**
  * Read recent logs from an agent's output file.