discoclaw 0.2.4 → 0.3.0

package/dist/discord/actions-crons.js

@@ -147,6 +147,11 @@ export async function executeCronAction(action, ctx, cronCtx) {
                 cadence,
                 purposeTags,
                 model,
+                schedule: action.schedule,
+                timezone,
+                channel: action.channel,
+                prompt: action.prompt,
+                authorId: cronCtx.client.user?.id,
             });
             // Create status message.
             try {
@@ -170,6 +175,11 @@ export async function executeCronAction(action, ctx, cronCtx) {
             }
             const updates = {};
             const changes = [];
+            // Silent mode.
+            if (action.silent !== undefined) {
+                updates.silent = action.silent;
+                changes.push(`silent → ${action.silent}`);
+            }
             // Model override.
             if (action.model) {
                 updates.modelOverride = action.model;
@@ -231,6 +241,11 @@ export async function executeCronAction(action, ctx, cronCtx) {
                     const msg = err instanceof Error ? err.message : String(err);
                     return { ok: false, error: `Invalid cron definition: ${msg}` };
                 }
+                // Persist updated definition fields.
+                updates.schedule = newSchedule;
+                updates.timezone = newTimezone;
+                updates.channel = newChannel;
+                updates.prompt = newPrompt;
             }
             await cronCtx.statsStore.upsertRecord(action.cronId, record.threadId, updates);
             // Update status message.
@@ -313,6 +328,8 @@ export async function executeCronAction(action, ctx, cronCtx) {
                 lines.push(`Runtime: \uD83D\uDD04 running`);
             }
             lines.push(`Model: ${record.modelOverride ?? record.model ?? 'N/A'}${record.modelOverride ? ' (override)' : ''}`);
+            if (record.silent)
+                lines.push(`Silent: yes`);
             lines.push(`Cadence: ${record.cadence ?? 'N/A'}`);
             lines.push(`Runs: ${record.runCount} | Last: ${record.lastRunStatus ?? 'never'}`);
             if (record.lastRunAt)
@@ -562,6 +579,7 @@ export function cronActionsPromptSection() {
 \`\`\`
 - \`cronId\` (required): The stable cron ID.
 - \`schedule\`, \`timezone\`, \`channel\`, \`prompt\`, \`model\`, \`tags\` (optional).
+- \`silent\` (optional): Boolean. When true, suppresses short "nothing to report" responses.
 
 **cronList** — List all cron jobs:
 \`\`\`

package/dist/discord/actions-crons.test.js

@@ -325,6 +325,18 @@ describe('executeCronAction', () => {
         expect(result.ok).toBe(true);
         expect(cronCtx.statsStore.upsertRecord).toHaveBeenCalledWith('cron-test0001', 'thread-1', expect.objectContaining({ modelOverride: 'opus' }));
     });
+    it('cronUpdate with silent sets silent flag', async () => {
+        const cronCtx = makeCronCtx();
+        const result = await executeCronAction({ type: 'cronUpdate', cronId: 'cron-test0001', silent: true }, makeActionCtx(), cronCtx);
+        expect(result.ok).toBe(true);
+        expect(cronCtx.statsStore.upsertRecord).toHaveBeenCalledWith('cron-test0001', 'thread-1', expect.objectContaining({ silent: true }));
+    });
+    it('cronUpdate with silent false clears silent flag', async () => {
+        const cronCtx = makeCronCtx();
+        const result = await executeCronAction({ type: 'cronUpdate', cronId: 'cron-test0001', silent: false }, makeActionCtx(), cronCtx);
+        expect(result.ok).toBe(true);
+        expect(cronCtx.statsStore.upsertRecord).toHaveBeenCalledWith('cron-test0001', 'thread-1', expect.objectContaining({ silent: false }));
+    });
     it('cronUpdate rejects invalid schedule before thread edits or scheduler mutation', async () => {
         const cronCtx = makeCronCtx();
         const thread = cronCtx.client.channels.cache.get('thread-1');

package/dist/discord/models-command.js

@@ -41,8 +41,13 @@ export function handleModelsCommand(cmd, opts) {
             '',
             '**Roles:** `chat`, `fast`, `forge-drafter`, `forge-auditor`, `summary`, `cron`, `cron-exec`',
             '',
+            '**Runtime switching (chat role only):**',
+            'Setting the `chat` role to a runtime name (`openrouter`, `openai`, `gemini`, `codex`, `claude`) switches the active runtime adapter so invocations route through that provider.',
+            '',
             '**Examples:**',
             '- `!models set chat sonnet`',
+            '- `!models set chat openrouter` — switch chat to the OpenRouter runtime',
+            '- `!models set chat gemini` — switch chat to the Gemini runtime',
             '- `!models set fast haiku`',
             '- `!models set forge-drafter opus`',
             '- `!models set cron-exec haiku` — run crons on a cheaper model',

package/dist/index.js

@@ -28,6 +28,7 @@ import { initTasksForumGuard } from './tasks/forum-guard.js';
 import { reloadTagMapInPlace } from './tasks/tag-map.js';
 import { ensureWorkspaceBootstrapFiles } from './workspace-bootstrap.js';
 import { probeWorkspacePermissions } from './workspace-permissions.js';
+import { detectMcpServers } from './mcp-detect.js';
 import { loadRunStats } from './cron/run-stats.js';
 import { seedTagMap } from './cron/discord-sync.js';
 import { loadCronTagMapStrict } from './cron/tag-map.js';
@@ -286,6 +287,27 @@ else if (permProbe.status === 'invalid') {
 else {
     log.info({ workspaceCwd, tier: permProbe.permissions.tier }, 'workspace permissions loaded');
 }
+// --- Detect MCP servers (startup health visibility) ---
+const mcpResult = await detectMcpServers(workspaceCwd);
+if (mcpResult.status === 'missing') {
+    log.debug({ workspaceCwd }, 'mcp: no .mcp.json found');
+}
+else if (mcpResult.status === 'invalid') {
+    log.warn({ workspaceCwd, reason: mcpResult.reason }, 'mcp: .mcp.json is invalid — MCP servers will not load');
+}
+else {
+    const serverNames = mcpResult.servers.map((s) => s.name);
+    const claudeInUse = primaryRuntimeName === 'claude'
+        || cfg.forgeDrafterRuntime === 'claude'
+        || cfg.forgeAuditorRuntime === 'claude';
+    let msg = serverNames.length === 0
+        ? 'mcp: .mcp.json found but no servers configured'
+        : `mcp: ${serverNames.length} server${serverNames.length === 1 ? '' : 's'} configured: ${serverNames.join(', ')}`;
+    if (serverNames.length > 0 && !claudeInUse) {
+        msg += ' (MCP servers only active with Claude runtime)';
+    }
+    log.info({ servers: serverNames, count: serverNames.length, strictMcpConfig: cfg.strictMcpConfig }, msg);
+}
 // --- Resolve bot display name ---
 const botDisplayName = await resolveDisplayName({
     configName: cfg.botDisplayName,
@@ -449,6 +471,7 @@ if (cfg.openaiApiKey) {
         baseUrl: cfg.openaiBaseUrl ?? 'https://api.openai.com/v1',
         apiKey: cfg.openaiApiKey,
         defaultModel: cfg.openaiModel,
+        enableTools: cfg.openaiCompatToolsEnabled,
         log,
     });
     const openaiRuntime = withConcurrencyLimit(openaiRuntimeRaw, {
@@ -464,6 +487,7 @@ if (cfg.openrouterApiKey) {
         baseUrl: cfg.openrouterBaseUrl ?? 'https://openrouter.ai/api/v1',
         apiKey: cfg.openrouterApiKey,
         defaultModel: cfg.openrouterModel,
+        enableTools: cfg.openaiCompatToolsEnabled,
         log,
     });
     const openrouterRuntime = withConcurrencyLimit(openrouterRuntimeRaw, {
@@ -619,6 +643,7 @@ const botParams = {
     memoryCtx: undefined,
     imagegenCtx: undefined,
     configCtx: undefined,
+    deferOpts: undefined,
     messageHistoryBudget,
     summaryEnabled,
     summaryModel,
@@ -733,6 +758,7 @@ if (discordActionsEnabled && cfg.discordActionsDefer) {
     };
     const deferScheduler = configureDeferredScheduler(deferOpts);
     botParams.deferScheduler = deferScheduler;
+    botParams.deferOpts = deferOpts;
 }
 let client, status, system;
 try {
@@ -920,6 +946,8 @@ if (taskCtx) {
         botParams.configCtx = {
             botParams,
             runtime: limitedRuntime,
+            runtimeRegistry,
+            runtimeName: primaryRuntimeName,
         };
         log.info('config:action context initialized');
     }

package/dist/mcp-detect.js

@@ -0,0 +1,74 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+/**
+ * Detect MCP servers configured in the workspace `.mcp.json` file.
+ * Returns structured info for startup health logging.
+ */
+export async function detectMcpServers(workspaceCwd) {
+    const mcpPath = path.join(workspaceCwd, '.mcp.json');
+    let raw;
+    try {
+        raw = await fs.readFile(mcpPath, 'utf-8');
+    }
+    catch {
+        return { status: 'missing' };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return { status: 'invalid', reason: 'invalid JSON' };
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        return { status: 'invalid', reason: 'root must be an object' };
+    }
+    const obj = parsed;
+    const mcpServers = obj.mcpServers;
+    if (mcpServers === undefined) {
+        return { status: 'invalid', reason: 'missing "mcpServers" key' };
+    }
+    if (typeof mcpServers !== 'object' || mcpServers === null || Array.isArray(mcpServers)) {
+        return { status: 'invalid', reason: '"mcpServers" must be an object' };
+    }
+    const entries = Object.entries(mcpServers);
+    const servers = [];
+    for (const [name, value] of entries) {
+        if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+            return { status: 'invalid', reason: `server "${name}" must be an object` };
+        }
+        const entry = value;
+        if (typeof entry.command !== 'string' || !entry.command) {
+            return { status: 'invalid', reason: `server "${name}" missing "command"` };
+        }
+        const server = { name, command: entry.command };
+        if (Array.isArray(entry.args)) {
+            server.args = entry.args.filter((a) => typeof a === 'string');
+        }
+        servers.push(server);
+    }
+    return { status: 'found', servers };
+}
+/**
+ * Log MCP detection results at startup.
+ */
+export function logMcpDetection(result, log) {
+    switch (result.status) {
+        case 'missing':
+            log.info({}, 'mcp: no .mcp.json found — MCP servers not configured');
+            break;
+        case 'invalid':
+            log.warn({ reason: result.reason }, 'mcp: .mcp.json is invalid — MCP servers will not load');
+            break;
+        case 'found': {
+            const names = result.servers.map((s) => s.name);
+            if (names.length === 0) {
+                log.info({}, 'mcp: .mcp.json found but no servers configured');
+            }
+            else {
+                log.info({ count: names.length, servers: names }, `mcp: ${names.length} server${names.length === 1 ? '' : 's'} configured: ${names.join(', ')}`);
+            }
+            break;
+        }
+    }
+}

package/dist/mcp-detect.test.js

@@ -0,0 +1,160 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { detectMcpServers, logMcpDetection } from './mcp-detect.js';
+function mockLog() {
+    return { info: vi.fn(), warn: vi.fn() };
+}
+describe('detectMcpServers', () => {
+    const dirs = [];
+    afterEach(async () => {
+        for (const d of dirs)
+            await fs.rm(d, { recursive: true, force: true });
+        dirs.length = 0;
+    });
+    it('returns missing when .mcp.json does not exist', async () => {
+        const workspace = await fs.mkdtemp(path.join(os.tmpdir(), 'mcp-detect-'));
+        dirs.push(workspace);
+        const result = await detectMcpServers(workspace);
+        expect(result).toEqual({ status: 'missing' });
+    });
+    it('returns invalid for malformed JSON', async () => {
+        const workspace = await fs.mkdtemp(path.join(os.tmpdir(), 'mcp-detect-'));
+        dirs.push(workspace);
+        await fs.writeFile(path.join(workspace, '.mcp.json'), '{ broken', 'utf-8');
+        const result = await detectMcpServers(workspace);
+        expect(result).toEqual({ status: 'invalid', reason: 'invalid JSON' });
+    });
+    it('returns invalid when root is not an object', async () => {
+        const workspace = await fs.mkdtemp(path.join(os.tmpdir(), 'mcp-detect-'));
+        dirs.push(workspace);
+        await fs.writeFile(path.join(workspace, '.mcp.json'), '"hello"', 'utf-8');
+        const result = await detectMcpServers(workspace);
+        expect(result).toEqual({ status: 'invalid', reason: 'root must be an object' });
+    });
+    it('returns invalid when root is an array', async () => {
+        const workspace = await fs.mkdtemp(path.join(os.tmpdir(), 'mcp-detect-'));
+        dirs.push(workspace);
+        await fs.writeFile(path.join(workspace, '.mcp.json'), '[]', 'utf-8');
+        const result = await detectMcpServers(workspace);
+        expect(result).toEqual({ status: 'invalid', reason: 'root must be an object' });
+    });
+    it('returns invalid when mcpServers key is missing', async () => {
+        const workspace = await fs.mkdtemp(path.join(os.tmpdir(), 'mcp-detect-'));
+        dirs.push(workspace);
+        await fs.writeFile(path.join(workspace, '.mcp.json'), '{}', 'utf-8');
+        const result = await detectMcpServers(workspace);
+        expect(result).toEqual({ status: 'invalid', reason: 'missing "mcpServers" key' });
+    });
+    it('returns invalid when mcpServers is not an object', async () => {
+        const workspace = await fs.mkdtemp(path.join(os.tmpdir(), 'mcp-detect-'));
+        dirs.push(workspace);
+        await fs.writeFile(path.join(workspace, '.mcp.json'), JSON.stringify({ mcpServers: 42 }), 'utf-8');
+        const result = await detectMcpServers(workspace);
+        expect(result).toEqual({ status: 'invalid', reason: '"mcpServers" must be an object' });
+    });
+    it('returns found with empty servers when mcpServers is empty', async () => {
+        const workspace = await fs.mkdtemp(path.join(os.tmpdir(), 'mcp-detect-'));
+        dirs.push(workspace);
+        await fs.writeFile(path.join(workspace, '.mcp.json'), JSON.stringify({ mcpServers: {} }), 'utf-8');
+        const result = await detectMcpServers(workspace);
+        expect(result).toEqual({ status: 'found', servers: [] });
+    });
+    it('returns found with server details for valid config', async () => {
+        const workspace = await fs.mkdtemp(path.join(os.tmpdir(), 'mcp-detect-'));
+        dirs.push(workspace);
+        const config = {
+            mcpServers: {
+                filesystem: {
+                    command: 'npx',
+                    args: ['-y', '@modelcontextprotocol/server-filesystem', '/home/user/docs'],
+                },
+                'brave-search': {
+                    command: 'npx',
+                    args: ['-y', '@anthropic/mcp-server-brave-search'],
+                    env: { BRAVE_API_KEY: 'key-here' },
+                },
+            },
+        };
+        await fs.writeFile(path.join(workspace, '.mcp.json'), JSON.stringify(config), 'utf-8');
+        const result = await detectMcpServers(workspace);
+        expect(result).toEqual({
+            status: 'found',
+            servers: [
+                { name: 'filesystem', command: 'npx', args: ['-y', '@modelcontextprotocol/server-filesystem', '/home/user/docs'] },
+                { name: 'brave-search', command: 'npx', args: ['-y', '@anthropic/mcp-server-brave-search'] },
+            ],
+        });
+    });
+    it('returns invalid when a server entry is missing command', async () => {
+        const workspace = await fs.mkdtemp(path.join(os.tmpdir(), 'mcp-detect-'));
+        dirs.push(workspace);
+        const config = {
+            mcpServers: {
+                broken: { args: ['--flag'] },
+            },
+        };
+        await fs.writeFile(path.join(workspace, '.mcp.json'), JSON.stringify(config), 'utf-8');
+        const result = await detectMcpServers(workspace);
+        expect(result).toEqual({ status: 'invalid', reason: 'server "broken" missing "command"' });
+    });
+    it('returns invalid when a server entry is not an object', async () => {
+        const workspace = await fs.mkdtemp(path.join(os.tmpdir(), 'mcp-detect-'));
+        dirs.push(workspace);
+        const config = { mcpServers: { bad: 'string' } };
+        await fs.writeFile(path.join(workspace, '.mcp.json'), JSON.stringify(config), 'utf-8');
+        const result = await detectMcpServers(workspace);
+        expect(result).toEqual({ status: 'invalid', reason: 'server "bad" must be an object' });
+    });
+    it('handles server with command only (no args)', async () => {
+        const workspace = await fs.mkdtemp(path.join(os.tmpdir(), 'mcp-detect-'));
+        dirs.push(workspace);
+        const config = {
+            mcpServers: {
+                simple: { command: '/usr/local/bin/mcp-server' },
+            },
+        };
+        await fs.writeFile(path.join(workspace, '.mcp.json'), JSON.stringify(config), 'utf-8');
+        const result = await detectMcpServers(workspace);
+        expect(result).toEqual({
+            status: 'found',
+            servers: [{ name: 'simple', command: '/usr/local/bin/mcp-server' }],
+        });
+    });
+});
+describe('logMcpDetection', () => {
+    it('logs info for missing .mcp.json', () => {
+        const log = mockLog();
+        logMcpDetection({ status: 'missing' }, log);
+        expect(log.info).toHaveBeenCalledWith({}, expect.stringContaining('no .mcp.json found'));
+        expect(log.warn).not.toHaveBeenCalled();
+    });
+    it('logs warn for invalid .mcp.json', () => {
+        const log = mockLog();
+        logMcpDetection({ status: 'invalid', reason: 'invalid JSON' }, log);
+        expect(log.warn).toHaveBeenCalledWith({ reason: 'invalid JSON' }, expect.stringContaining('invalid'));
+        expect(log.info).not.toHaveBeenCalled();
+    });
+    it('logs info for empty servers', () => {
+        const log = mockLog();
+        logMcpDetection({ status: 'found', servers: [] }, log);
+        expect(log.info).toHaveBeenCalledWith({}, expect.stringContaining('no servers configured'));
+    });
+    it('logs info with server names for configured servers', () => {
+        const log = mockLog();
+        logMcpDetection({
+            status: 'found',
+            servers: [
+                { name: 'filesystem', command: 'npx' },
+                { name: 'brave-search', command: 'npx' },
+            ],
+        }, log);
+        expect(log.info).toHaveBeenCalledWith({ count: 2, servers: ['filesystem', 'brave-search'] }, expect.stringContaining('2 servers configured: filesystem, brave-search'));
+    });
+    it('uses singular "server" for single server', () => {
+        const log = mockLog();
+        logMcpDetection({ status: 'found', servers: [{ name: 'filesystem', command: 'npx' }] }, log);
+        expect(log.info).toHaveBeenCalledWith({ count: 1, servers: ['filesystem'] }, expect.stringContaining('1 server configured'));
+    });
+});