@nonbot/mcp 0.0.0-stage → 0.1.0

package/dist/core/toolsets/monitor.js

@@ -0,0 +1,160 @@
+import { z } from 'zod';
+import { api, expectJson } from '../http.js';
+const GATE = 'The Run feature is gated behind NONBOT_RUN_FEATURE_ENABLED on the server. Ask the non.bot operator to enable it.';
+const READ = { readOnlyHint: true, openWorldHint: true };
+async function monReq(ctx, method, path, body) {
+    const init = { method };
+    if (body !== undefined)
+        init.body = JSON.stringify(body);
+    const res = await api(ctx, path, init);
+    if (res.status === 503)
+        throw new Error(GATE);
+    return expectJson(res, `${method} ${path}`);
+}
+function textResult(data) {
+    return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+}
+function cancelled(message) {
+    return { content: [{ type: 'text', text: message }], isError: true };
+}
+async function confirmAction(server, confirmArg, message) {
+    if (confirmArg === true)
+        return { ok: true };
+    try {
+        const el = await server.server.elicitInput({
+            message,
+            requestedSchema: {
+                type: 'object',
+                properties: { confirm: { type: 'boolean', description: 'true to proceed' } },
+                required: ['confirm'],
+            },
+        });
+        if (el.action === 'accept' && el.content?.confirm === true)
+            return { ok: true };
+        return { ok: false, reply: cancelled('Cancelled — the action was not confirmed. Nothing happened.') };
+    }
+    catch {
+        return {
+            ok: false,
+            reply: cancelled(`Needs confirmation — re-call with confirm: true. About to: ${message}`),
+        };
+    }
+}
+export function registerMonitorTools(server, ctx) {
+    server.registerTool('run_feed', {
+        title: 'Read the run command-center feed',
+        description: 'The unified run feed — daemon heartbeat, fleet (active + last-24h runs with status/health/progress), needs-you items, and reconcile chips. The single answer to "what are my runs doing right now?". Pass slim:true for the lightweight cut, since:<ms> for deltas.',
+        inputSchema: {
+            slim: z.boolean().optional().describe('Lightweight cut (counts + glance fields).'),
+            include_digest: z.boolean().optional().describe('Include the digest sidebar block.'),
+            since: z.number().int().optional().describe('Delta cursor — only rows active since this ms timestamp.'),
+        },
+        annotations: READ,
+    }, async (a) => {
+        const q = new URLSearchParams();
+        if (a.slim)
+            q.set('slim', '1');
+        if (a.include_digest)
+            q.set('include', 'digest');
+        if (a.since !== undefined)
+            q.set('since', String(a.since));
+        const qs = q.toString();
+        return textResult(await monReq(ctx, 'GET', `/api/run/feed${qs ? `?${qs}` : ''}`));
+    });
+    server.registerTool('run_daemon_status', {
+        title: 'Check daemon health',
+        description: 'Is the operator\'s daemon connected? Returns connected/lastSeenAt, CLI version, terminal kind + launchability, tmux session, last launch-failure reason, and (daemon ≥0.9.10) load stats: running/done/failed counts, open prompt count, poll cadence.',
+        inputSchema: {},
+        annotations: READ,
+    }, async () => textResult(await monReq(ctx, 'GET', '/api/cli/daemon-status')));
+    server.registerTool('run_machines', {
+        title: 'List online machines',
+        description: 'The operator\'s machines with a live daemon (multi-machine runs): machine id, name, terminal kind, last-seen, and (≥0.9.10) per-machine load stats. A machine absent here is offline.',
+        inputSchema: {},
+        annotations: READ,
+    }, async () => textResult(await monReq(ctx, 'GET', '/api/cli/machines')));
+    server.registerTool('run_activations_recent', {
+        title: 'List recent launches',
+        description: 'The last 10 activations with launch traces (spawn steps, launcher stderr/stdout/exit code), derived status incl. staleness, terminal used, and tmux pane. Rate-limited pool — poll no more than every 30s.',
+        inputSchema: {},
+        annotations: READ,
+    }, async () => textResult(await monReq(ctx, 'GET', '/api/cli/activations/recent')));
+    server.registerTool('run_prompts_list', {
+        title: 'List waiting run prompts',
+        description: 'Mid-run prompts (a run paused on a menu/question). Default open = waiting on a human or supervisor right now. Answer via run_prompt_answer.',
+        inputSchema: {
+            status: z.enum(['open', 'answered', 'closed', 'cancelled']).optional().describe('Filter (default open).'),
+        },
+        annotations: READ,
+    }, async (a) => textResult(await monReq(ctx, 'GET', `/api/run/prompts${a.status ? `?status=${a.status}` : ''}`)));
+    server.registerTool('run_snapshot_get', {
+        title: 'Read a pane-output snapshot',
+        description: 'Fetch the result of a run_snapshot_request. status "ready" carries the scrubbed pane tail; "pending" = the daemon hasn\'t served it yet (re-poll in ~5s, up to ~45s total); "none" = expired or the daemon is offline/pre-0.9.10. Requires the runs:control scope on scoped tokens.',
+        inputSchema: {
+            activation_id: z.string(),
+            request_id: z.string().describe('The requestId returned by run_snapshot_request.'),
+        },
+        annotations: READ,
+    }, async (a) => textResult(await monReq(ctx, 'GET', `/api/run/activations/${encodeURIComponent(a.activation_id)}/snapshot?requestId=${encodeURIComponent(a.request_id)}`)));
+    if (ctx.readonly)
+        return;
+    server.registerTool('run_snapshot_request', {
+        title: 'Request a pane-output snapshot',
+        description: 'Ask the operator\'s daemon to capture the last lines of a RUNNING run\'s terminal pane (secrets scrubbed, 16KB tail cap, stored server-side for 5 minutes only). Answers "what is this run actually doing?". Then call run_snapshot_get with the returned requestId after ~5s. Requires runs:control scope; needs confirmation.',
+        inputSchema: {
+            activation_id: z.string(),
+            max_lines: z.number().int().min(1).max(200).optional().describe('Pane lines to capture (default 100).'),
+            confirm: z.boolean().optional().describe('Pass true to confirm when the client lacks elicitation.'),
+        },
+        annotations: { readOnlyHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (a) => {
+        const gate = await confirmAction(server, a.confirm, `capture the last ${a.max_lines ?? 100} lines of terminal output from run ${a.activation_id} and store them server-side for 5 minutes.`);
+        if (!gate.ok)
+            return gate.reply;
+        return textResult(await monReq(ctx, 'POST', `/api/run/activations/${encodeURIComponent(a.activation_id)}/snapshot-request`, {
+            ...(a.max_lines !== undefined ? { maxLines: a.max_lines } : {}),
+        }));
+    });
+    server.registerTool('run_prompt_answer', {
+        title: 'Answer a waiting run prompt',
+        description: 'Answer a mid-run prompt on the operator\'s behalf — the daemon types the answer into the live pane. POWERFUL: this unblocks (or misdirects) a real agent. Requires a supervisor token minted with the EXPLICIT runs:respond scope; the run\'s own daemon token is always refused (no-self-answer). Needs confirmation.',
+        inputSchema: {
+            prompt_id: z.string(),
+            answer_index: z.number().int().min(0).optional().describe('Numbered-option choice.'),
+            answer_text: z.string().max(500).optional().describe('Free-text answer (typed into the pane).'),
+            confirm: z.boolean().optional().describe('Pass true to confirm when the client lacks elicitation.'),
+        },
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true },
+    }, async (a) => {
+        if (a.answer_index === undefined && !a.answer_text) {
+            return cancelled('Provide answer_index or answer_text.');
+        }
+        const what = a.answer_index !== undefined ? `option ${a.answer_index}` : `"${a.answer_text}"`;
+        const gate = await confirmAction(server, a.confirm, `answer prompt ${a.prompt_id} with ${what} — the daemon will type this into the live run.`);
+        if (!gate.ok)
+            return gate.reply;
+        return textResult(await monReq(ctx, 'POST', `/api/run/prompts/${encodeURIComponent(a.prompt_id)}/answer`, {
+            ...(a.answer_index !== undefined ? { answerIndex: a.answer_index } : {}),
+            ...(a.answer_text ? { answerText: a.answer_text } : {}),
+        }));
+    });
+    server.registerTool('run_stop_daemon', {
+        title: 'Stop the operator\'s daemon',
+        description: 'The panic button — queue a remote shutdown for the operator\'s daemon (CLI ≥0.9.12). KILL-EVERYTHING semantics: the daemon kills every run pane on that machine, kills its own tmux session, and exits, picked up on its next poll (≤30s). Works even when the terminal window hosting the daemon is lost (headless tmux). Pass machine_id (see run_machines) to stop one machine, or all:true to stop every machine\'s daemon. The 200 means QUEUED, not stopped — verify with run_daemon_status until connected flips false. Requires runs:control scope; needs confirmation.',
+        inputSchema: {
+            machine_id: z.string().optional().describe('Stop this machine\'s daemon (from run_machines).'),
+            all: z.boolean().optional().describe('Stop EVERY machine\'s daemon.'),
+            confirm: z.boolean().optional().describe('Pass true to confirm when the client lacks elicitation.'),
+        },
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true },
+    }, async (a) => {
+        if (Boolean(a.all) === Boolean(a.machine_id)) {
+            return cancelled('Provide exactly one of machine_id or all:true.');
+        }
+        const target = a.all ? 'EVERY machine\'s daemon' : `the daemon on machine ${a.machine_id}`;
+        const gate = await confirmAction(server, a.confirm, `stop ${target} — every run pane it owns will be killed, then the daemon exits.`);
+        if (!gate.ok)
+            return gate.reply;
+        return textResult(await monReq(ctx, 'POST', '/api/run/daemon/stop', a.all ? { all: true } : { machineId: a.machine_id }));
+    });
+}

package/dist/core/toolsets/portfolio.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { ApiContext } from '../config.js';
+export declare function registerPortfolioTools(server: McpServer, ctx: ApiContext): void;