@integrity-labs/agt-cli 0.8.9 → 0.9.0

package/mcp/index.js

@@ -0,0 +1,587 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+// ── Configuration via env vars ──────────────────────────────────────────────
+const AGT_HOST = process.env.AGT_HOST;
+const AGT_API_KEY = process.env.AGT_API_KEY; // Host API key (tlk_...) for token refresh
+const AGT_AGENT_ID = process.env.AGT_AGENT_ID; // Agent UUID
+const AGT_AGENT_CODE_NAME = process.env.AGT_AGENT_CODE_NAME; // Agent code_name (kebab-case)
+// Initial token from provisioning — will be refreshed automatically
+let AGT_TOKEN = process.env.AGT_TOKEN ?? '';
+if (!AGT_HOST || !AGT_AGENT_ID || (!AGT_TOKEN && !AGT_API_KEY)) {
+    console.error('augmented-mcp: Missing required env vars. Need AGT_HOST, AGT_AGENT_ID, and AGT_TOKEN or AGT_API_KEY');
+    process.exit(1);
+}
+// ── Token refresh ───────────────────────────────────────────────────────────
+let tokenExpiresAt = Date.now() + 50 * 60_000; // assume ~50min remaining on initial token
+async function getToken() {
+    // If we have an API key and the token is expiring soon (within 5 min), refresh
+    if (AGT_API_KEY && Date.now() > tokenExpiresAt - 5 * 60_000) {
+        try {
+            const res = await fetch(`${AGT_HOST}/host/exchange`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ host_key: AGT_API_KEY }),
+            });
+            if (res.ok) {
+                const data = (await res.json());
+                AGT_TOKEN = data.token;
+                tokenExpiresAt = new Date(data.expires_at).getTime();
+            }
+        }
+        catch {
+            // Use existing token if refresh fails
+        }
+    }
+    return AGT_TOKEN;
+}
+// ── API client ──────────────────────────────────────────────────────────────
+async function apiPost(path, body) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 15_000);
+    const token = await getToken();
+    try {
+        const res = await fetch(`${AGT_HOST}${path}`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${token}`,
+            },
+            body: JSON.stringify(body),
+            signal: controller.signal,
+        });
+        if (!res.ok) {
+            const text = await res.text().catch(() => res.statusText);
+            throw new Error(`API ${path} returned ${res.status}: ${text}`);
+        }
+        return (await res.json());
+    }
+    catch (err) {
+        if (err instanceof DOMException && err.name === 'AbortError') {
+            throw new Error(`API ${path} timed out after 15s`);
+        }
+        throw err;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+// ── MCP Server ──────────────────────────────────────────────────────────────
+const server = new McpServer({
+    name: 'augmented',
+    version: '0.1.0',
+});
+// ═══════════════════════════════════════════════════════════════════════════
+// KANBAN TOOLS
+// ═══════════════════════════════════════════════════════════════════════════
+// ── kanban.list ─────────────────────────────────────────────────────────────
+server.tool('kanban.list', 'List kanban board items for this agent. Returns active items and recently completed items (last 7 days).', {}, async () => {
+    const data = await apiPost('/host/my-kanban', {
+        agent_id: AGT_AGENT_ID,
+    });
+    if (!data.items.length) {
+        return { content: [{ type: 'text', text: 'Board is empty.' }] };
+    }
+    const grouped = groupByStatus(data.items);
+    const lines = [];
+    for (const status of ['in_progress', 'today', 'backlog', 'done']) {
+        const items = grouped[status];
+        if (!items?.length)
+            continue;
+        lines.push(`\n## ${statusLabel(status)} (${items.length})`);
+        for (const item of items) {
+            const pri = priorityLabel(item.priority);
+            const est = item.estimated_minutes ? ` ~${item.estimated_minutes}min` : '';
+            const del = item.deliverable ? ` → ${item.deliverable}` : '';
+            const res = item.result ? ` ✓ ${item.result}` : '';
+            lines.push(`- [${pri}] ${item.title}${est}${del}${res} (id: ${item.id})`);
+        }
+    }
+    return { content: [{ type: 'text', text: lines.join('\n') }] };
+});
+// ── kanban.add ──────────────────────────────────────────────────────────────
+server.tool('kanban.add', 'Add a new item to the kanban board.', {
+    title: z.string().describe('Item title (max 200 chars)'),
+    description: z.string().optional().describe('Detailed description'),
+    priority: z
+        .number()
+        .int()
+        .min(1)
+        .max(3)
+        .optional()
+        .describe('Priority: 1=high, 2=medium (default), 3=low'),
+    status: z
+        .enum(['backlog', 'today', 'in_progress'])
+        .optional()
+        .describe('Initial status (default: today)'),
+    estimated_minutes: z.number().int().optional().describe('Estimated time in minutes'),
+    deliverable: z.string().optional().describe('Expected output/deliverable'),
+    source: z
+        .enum(['cron', 'chat', 'manual', 'integration'])
+        .optional()
+        .describe('Source of the item (default: manual)'),
+    source_integration: z.string().optional().describe('Integration name (e.g., "linear", "github") when source is "integration"'),
+    source_external_id: z.string().optional().describe('ID in the external system (e.g., "ENG-123")'),
+    source_url: z.string().optional().describe('Deep link URL to the external source'),
+}, async (params) => {
+    const data = await apiPost('/host/kanban', {
+        agent_id: AGT_AGENT_ID,
+        add: [
+            {
+                title: params.title,
+                description: params.description,
+                priority: params.priority ?? 2,
+                status: params.status ?? 'today',
+                estimated_minutes: params.estimated_minutes,
+                deliverable: params.deliverable,
+                source: params.source ?? 'manual',
+                source_integration: params.source_integration,
+                source_external_id: params.source_external_id,
+                source_url: params.source_url,
+            },
+        ],
+    });
+    return {
+        content: [
+            {
+                type: 'text',
+                text: data.ok
+                    ? `Added "${params.title}" to board (status: ${params.status ?? 'today'}).`
+                    : 'Failed to add item.',
+            },
+        ],
+    };
+});
+// ── kanban.move ─────────────────────────────────────────────────────────────
+server.tool('kanban.move', 'Move a kanban item to a different status column.', {
+    id: z.string().optional().describe('Item UUID (preferred)'),
+    title: z.string().optional().describe('Item title for fuzzy match (if no id)'),
+    status: z
+        .enum(['backlog', 'today', 'in_progress', 'done'])
+        .describe('Target status'),
+    notes: z.string().optional().describe('Progress notes'),
+}, async (params) => {
+    if (!params.id && !params.title) {
+        return {
+            content: [{ type: 'text', text: 'Error: provide either id or title.' }],
+            isError: true,
+        };
+    }
+    const data = await apiPost('/host/kanban', {
+        agent_id: AGT_AGENT_ID,
+        update: [
+            {
+                id: params.id,
+                title: params.title,
+                status: params.status,
+                notes: params.notes,
+            },
+        ],
+    });
+    const label = params.id ?? params.title;
+    return {
+        content: [
+            {
+                type: 'text',
+                text: data.updated > 0
+                    ? `Moved "${label}" → ${params.status}.`
+                    : `Item "${label}" not found.`,
+            },
+        ],
+    };
+});
+// ── kanban.update ───────────────────────────────────────────────────────────
+server.tool('kanban.update', 'Update notes or result on a kanban item without changing its status.', {
+    id: z.string().optional().describe('Item UUID (preferred)'),
+    title: z.string().optional().describe('Item title for fuzzy match (if no id)'),
+    notes: z.string().optional().describe('Progress notes to append'),
+    result: z.string().optional().describe('Result/output produced'),
+}, async (params) => {
+    if (!params.id && !params.title) {
+        return {
+            content: [{ type: 'text', text: 'Error: provide either id or title.' }],
+            isError: true,
+        };
+    }
+    // We need a status for the API — fetch current status first
+    const board = await apiPost('/host/my-kanban', {
+        agent_id: AGT_AGENT_ID,
+    });
+    const match = board.items.find((i) => i.id === params.id || i.title === params.title);
+    if (!match) {
+        return {
+            content: [
+                { type: 'text', text: `Item "${params.id ?? params.title}" not found.` },
+            ],
+            isError: true,
+        };
+    }
+    const data = await apiPost('/host/kanban', {
+        agent_id: AGT_AGENT_ID,
+        update: [
+            {
+                id: match.id,
+                status: match.status,
+                notes: params.notes,
+                result: params.result,
+            },
+        ],
+    });
+    return {
+        content: [
+            {
+                type: 'text',
+                text: data.updated > 0 ? `Updated "${match.title}".` : 'Update failed.',
+            },
+        ],
+    };
+});
+// ── kanban.done ─────────────────────────────────────────────────────────────
+server.tool('kanban.done', 'Mark a kanban item as done with an optional result.', {
+    id: z.string().optional().describe('Item UUID (preferred)'),
+    title: z.string().optional().describe('Item title for fuzzy match (if no id)'),
+    result: z.string().optional().describe('What was produced/delivered'),
+    notes: z.string().optional().describe('Completion notes'),
+}, async (params) => {
+    if (!params.id && !params.title) {
+        return {
+            content: [{ type: 'text', text: 'Error: provide either id or title.' }],
+            isError: true,
+        };
+    }
+    const data = await apiPost('/host/kanban', {
+        agent_id: AGT_AGENT_ID,
+        update: [
+            {
+                id: params.id,
+                title: params.title,
+                status: 'done',
+                result: params.result,
+                notes: params.notes,
+            },
+        ],
+    });
+    const label = params.id ?? params.title;
+    return {
+        content: [
+            {
+                type: 'text',
+                text: data.updated > 0
+                    ? `Marked "${label}" as done.${params.result ? ` Result: ${params.result}` : ''}`
+                    : `Item "${label}" not found.`,
+            },
+        ],
+    };
+});
+// ═══════════════════════════════════════════════════════════════════════════
+// STATUS TOOLS
+// ═══════════════════════════════════════════════════════════════════════════
+// ── status.standup ──────────────────────────────────────────────────────────
+server.tool('status.standup', 'Submit a daily standup update with yesterday, today, and blockers.', {
+    yesterday: z.string().describe('What was accomplished yesterday/last session'),
+    today: z.string().describe('What is planned for today/this session'),
+    blockers: z.string().optional().describe('Any blockers or issues (default: none)'),
+}, async (params) => {
+    if (!AGT_AGENT_CODE_NAME) {
+        return {
+            content: [{ type: 'text', text: 'Error: AGT_AGENT_CODE_NAME not configured.' }],
+            isError: true,
+        };
+    }
+    const data = await apiPost('/host/agent-status', {
+        agent_code_name: AGT_AGENT_CODE_NAME,
+        standup: {
+            yesterday: params.yesterday,
+            today: params.today,
+            blockers: params.blockers ?? 'None',
+        },
+    });
+    return {
+        content: [
+            {
+                type: 'text',
+                text: data.ok
+                    ? 'Standup submitted successfully.'
+                    : 'Failed to submit standup.',
+            },
+        ],
+    };
+});
+// ── status.update ───────────────────────────────────────────────────────────
+server.tool('status.update', 'Report current task progress or status update.', {
+    current_tasks: z.string().describe('Summary of what you are currently working on'),
+}, async (params) => {
+    if (!AGT_AGENT_CODE_NAME) {
+        return {
+            content: [{ type: 'text', text: 'Error: AGT_AGENT_CODE_NAME not configured.' }],
+            isError: true,
+        };
+    }
+    const data = await apiPost('/host/agent-status', {
+        agent_code_name: AGT_AGENT_CODE_NAME,
+        current_tasks: params.current_tasks,
+    });
+    return {
+        content: [
+            {
+                type: 'text',
+                text: data.ok
+                    ? 'Status updated.'
+                    : 'Failed to update status.',
+            },
+        ],
+    };
+});
+// ═══════════════════════════════════════════════════════════════════════════
+// DRIFT & TOKEN TOOLS
+// ═══════════════════════════════════════════════════════════════════════════
+// ── drift.report ────────────────────────────────────────────────────────────
+server.tool('drift.report', 'Report configuration drift detected in local agent files (CHARTER.md, TOOLS.md, etc.). Compares local file hashes against API-side versions and reports any differences.', {
+    drifted_files: z
+        .array(z.string())
+        .describe('List of filenames that have drifted from provisioned state (e.g. ["CHARTER.md", "TOOLS.md"])'),
+    local_hashes: z
+        .record(z.string())
+        .optional()
+        .describe('Map of filename to SHA-256 hash of local content'),
+}, async (params) => {
+    const data = await apiPost('/host/drift', {
+        agent_id: AGT_AGENT_ID,
+        drifted_files: params.drifted_files,
+        local_hashes: params.local_hashes ?? {},
+    });
+    return {
+        content: [
+            {
+                type: 'text',
+                text: data.ok
+                    ? `Drift reported for ${params.drifted_files.length} file(s): ${params.drifted_files.join(', ')}`
+                    : 'Failed to report drift.',
+            },
+        ],
+    };
+});
+// ── token.refresh ───────────────────────────────────────────────────────────
+server.tool('token.refresh', 'Request fresh OAuth tokens for an integration. Returns the new access token directly — no file-based handoff needed.', {
+    integration_id: z
+        .string()
+        .optional()
+        .describe('Specific integration UUID to refresh. If omitted, refreshes all expiring tokens.'),
+}, async (params) => {
+    // Fetch all integrations for this agent
+    const integrations = await apiPost('/host/agent-integrations', {
+        agent_id: AGT_AGENT_ID,
+    });
+    // Filter to OAuth integrations; when no specific ID, only refresh expiring tokens
+    const TEN_MINUTES_MS = 10 * 60_000;
+    const oauthIntegrations = integrations.integrations.filter((i) => {
+        if (i.auth_type !== 'oauth2')
+            return false;
+        if (params.integration_id)
+            return i.id === params.integration_id;
+        // No specific ID — only refresh tokens expiring within 10 minutes
+        if (!i.credentials.token_expires_at)
+            return true;
+        return new Date(i.credentials.token_expires_at).getTime() - Date.now() < TEN_MINUTES_MS;
+    });
+    if (oauthIntegrations.length === 0) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: params.integration_id
+                        ? `No OAuth integration found with ID ${params.integration_id}.`
+                        : 'No expiring OAuth tokens found for this agent.',
+                },
+            ],
+        };
+    }
+    const results = [];
+    for (const integration of oauthIntegrations) {
+        try {
+            const refreshed = await apiPost(`/integrations/oauth/${integration.id}/refresh`, {});
+            if (refreshed.ok && refreshed.access_token) {
+                results.push({
+                    definition_id: integration.definition_id,
+                    access_token: refreshed.access_token,
+                    expires_at: refreshed.expires_at,
+                });
+            }
+            else {
+                results.push({ definition_id: integration.definition_id, error: true });
+            }
+        }
+        catch {
+            // Don't leak raw error messages into agent context
+            results.push({ definition_id: integration.definition_id, error: true });
+        }
+    }
+    // Return tokens directly for programmatic consumption
+    const summary = results.map((r) => r.access_token
+        ? `${r.definition_id}: refreshed (expires ${r.expires_at ?? 'unknown'})`
+        : `${r.definition_id}: refresh failed`);
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify({
+                    refreshed: results.filter((r) => r.access_token).map((r) => ({
+                        definition_id: r.definition_id,
+                        access_token: r.access_token,
+                        expires_at: r.expires_at,
+                    })),
+                    failed: results.filter((r) => r.error).map((r) => r.definition_id),
+                    summary: summary.join('; '),
+                }),
+            },
+        ],
+    };
+});
+// ═══════════════════════════════════════════════════════════════════════════
+// ACPX TOOLS — Agent-to-agent communication via ACP
+// ═══════════════════════════════════════════════════════════════════════════
+import { spawn } from 'node:child_process';
+async function runAcpxCommand(args, cwd) {
+    return new Promise((resolve) => {
+        const child = spawn('acpx', args, {
+            cwd: cwd ?? process.cwd(),
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout?.on('data', (d) => { stdout += d.toString(); });
+        child.stderr?.on('data', (d) => { stderr += d.toString(); });
+        child.on('close', (code) => resolve({ exitCode: code ?? 1, stdout, stderr }));
+        child.on('error', (err) => resolve({ exitCode: 1, stdout: '', stderr: err.message }));
+    });
+}
+// ── acpx.prompt ─────────────────────────────────────────────────────────────
+server.tool('acpx.prompt', 'Send a prompt to a coding agent (claude, codex, openclaw) via ACP. Uses persistent sessions scoped to the working directory.', {
+    agent: z.enum(['claude', 'codex', 'openclaw']).describe('Coding agent to use'),
+    prompt: z.string().describe('The prompt/instruction to send'),
+    session_name: z.string().optional().describe('Named session for parallel workstreams (default: uses directory-scoped session)'),
+    approve_all: z.boolean().optional().describe('Auto-approve all tool permissions (default: false)'),
+}, async (params) => {
+    const args = [];
+    if (params.approve_all)
+        args.push('--approve-all');
+    args.push('--format', 'json');
+    args.push(params.agent, 'prompt', params.prompt);
+    if (params.session_name)
+        args.push('-s', params.session_name);
+    const result = await runAcpxCommand(args);
+    if (result.exitCode !== 0) {
+        return {
+            content: [{ type: 'text', text: `acpx prompt failed (exit ${result.exitCode}): ${result.stderr || result.stdout}` }],
+            isError: true,
+        };
+    }
+    return { content: [{ type: 'text', text: result.stdout || 'Prompt completed (no output).' }] };
+});
+// ── acpx.exec ───────────────────────────────────────────────────────────────
+server.tool('acpx.exec', 'Run a one-shot task on a coding agent. Does not reuse sessions — fire and forget.', {
+    agent: z.enum(['claude', 'codex', 'openclaw']).describe('Coding agent to use'),
+    prompt: z.string().describe('The task to execute'),
+}, async (params) => {
+    const args = ['--format', 'json', params.agent, 'exec', params.prompt];
+    const result = await runAcpxCommand(args);
+    if (result.exitCode !== 0) {
+        return {
+            content: [{ type: 'text', text: `acpx exec failed (exit ${result.exitCode}): ${result.stderr || result.stdout}` }],
+            isError: true,
+        };
+    }
+    return { content: [{ type: 'text', text: result.stdout || 'Exec completed (no output).' }] };
+});
+// ── acpx.spawn ──────────────────────────────────────────────────────────────
+server.tool('acpx.spawn', 'Ensure an ACP session exists for a coding agent. Creates one if needed, reuses existing.', {
+    agent: z.enum(['claude', 'codex', 'openclaw']).describe('Coding agent to use'),
+    session_name: z.string().optional().describe('Named session for parallel workstreams'),
+}, async (params) => {
+    const args = ['--format', 'json', params.agent, 'sessions', 'ensure'];
+    if (params.session_name)
+        args.push('-s', params.session_name);
+    const result = await runAcpxCommand(args);
+    if (result.exitCode !== 0) {
+        return {
+            content: [{ type: 'text', text: `acpx spawn failed: ${result.stderr || result.stdout}` }],
+            isError: true,
+        };
+    }
+    return { content: [{ type: 'text', text: result.stdout || 'Session ready.' }] };
+});
+// ── acpx.cancel ─────────────────────────────────────────────────────────────
+server.tool('acpx.cancel', 'Send a cooperative cancel to the running ACP session. Does not destroy state.', {
+    agent: z.enum(['claude', 'codex', 'openclaw']).describe('Coding agent to cancel'),
+    session_name: z.string().optional().describe('Named session to cancel'),
+}, async (params) => {
+    const args = [params.agent, 'cancel'];
+    if (params.session_name)
+        args.push('-s', params.session_name);
+    const result = await runAcpxCommand(args);
+    return {
+        content: [{
+                type: 'text',
+                text: result.exitCode === 0 ? 'Cancel sent.' : `Cancel failed: ${result.stderr || result.stdout}`,
+            }],
+        ...(result.exitCode !== 0 ? { isError: true } : {}),
+    };
+});
+// ── acpx.status ─────────────────────────────────────────────────────────────
+server.tool('acpx.status', 'Check the status of the current ACP session (running, idle, dead).', {
+    agent: z.enum(['claude', 'codex', 'openclaw']).describe('Coding agent to check'),
+    session_name: z.string().optional().describe('Named session to check'),
+}, async (params) => {
+    const args = ['--format', 'json', params.agent, 'status'];
+    if (params.session_name)
+        args.push('-s', params.session_name);
+    const result = await runAcpxCommand(args);
+    return { content: [{ type: 'text', text: result.stdout || result.stderr || 'No session found.' }] };
+});
+// ── acpx.close ──────────────────────────────────────────────────────────────
+server.tool('acpx.close', 'Soft-close an ACP session. Terminates the process but preserves history.', {
+    agent: z.enum(['claude', 'codex', 'openclaw']).describe('Coding agent session to close'),
+    session_name: z.string().optional().describe('Named session to close'),
+}, async (params) => {
+    const args = [params.agent, 'sessions', 'close'];
+    if (params.session_name)
+        args.push(params.session_name);
+    const result = await runAcpxCommand(args);
+    return {
+        content: [{
+                type: 'text',
+                text: result.exitCode === 0 ? 'Session closed.' : `Close failed: ${result.stderr || result.stdout}`,
+            }],
+        ...(result.exitCode !== 0 ? { isError: true } : {}),
+    };
+});
+function groupByStatus(items) {
+    const groups = {};
+    for (const item of items) {
+        (groups[item.status] ??= []).push(item);
+    }
+    return groups;
+}
+function statusLabel(status) {
+    const labels = {
+        backlog: 'Backlog',
+        today: 'Today',
+        in_progress: 'In Progress',
+        done: 'Done',
+    };
+    return labels[status] ?? status;
+}
+function priorityLabel(priority) {
+    return priority === 1 ? 'HIGH' : priority === 3 ? 'LOW' : 'MED';
+}
+// ── Start server ────────────────────────────────────────────────────────────
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((err) => {
+    console.error('augmented-mcp: Fatal error:', err);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map