@vibecodetown/mcp-server 1.3.1 → 1.5.0

package/build/companion/tools.js

@@ -0,0 +1,305 @@
+/**
+ * Companion Tools — Adapts existing Prime MCP handlers to Vercel AI SDK tool() format.
+ *
+ * Only includes tools that work without a database pool (DB-free).
+ */
+import { tool as aiTool } from 'ai';
+import { z } from 'zod';
+import { systemControlInputSchema, handleSystemControl, } from '../mcp/tools/vibe_pm/system_control.js';
+import { virtualShellInputSchema, hiveThinkInputSchema, simulateInputSchema, hybridStatusInputSchema, } from '../mcp/tools/vibe_pm/prime_tools.js';
+import { Holodeck } from '../domains/prime/holodeck.js';
+import { HiveMind } from '../domains/prime/hive_mind.js';
+import { TimeStone } from '../domains/prime/time_stone.js';
+import { HybridHealthChecker } from '../domains/prime/hybrid_check.js';
+import { createDelegation, createDelegationResult } from '../protocol/minp.js';
+import { createAskClaude, createManageGithub } from './external_tools.js';
+import { ScoutClient } from '../scout/client.js';
+import { getMusuBaseUrl, getMusuWorkerPort } from '../kernel/musu_endpoint.js';
+import { logger } from '../shared/logger.js';
+function tool(config) {
+    return aiTool(config);
+}
+// ---------------------------------------------------------------------------
+// Helper: extract text from MCP handler result
+// ---------------------------------------------------------------------------
+function extractResult(result) {
+    try {
+        return JSON.parse(result.content[0].text);
+    }
+    catch {
+        return result.content[0].text;
+    }
+}
+// ---------------------------------------------------------------------------
+// Companion Tools (AI SDK format)
+// ---------------------------------------------------------------------------
+/**
+ * Create companion tools with optional adapter injection for external tools.
+ * If a signalBridge is provided, all tools are wrapped to emit call/result signals.
+ */
+export function createCompanionTools(adapter, signalBridge) {
+    const tools = {
+        ...baseCompanionTools,
+        ask_claude: createAskClaude(adapter),
+        manage_github: createManageGithub(adapter),
+        scout_analyze: createScoutAnalyze(adapter),
+        delegate_task: createDelegateTask(adapter),
+        hybrid_status: createHybridStatus(adapter),
+    };
+    if (signalBridge) {
+        return wrapToolsWithSignals(tools, signalBridge);
+    }
+    return tools;
+}
+// ---------------------------------------------------------------------------
+// Signal Wrapper
+// ---------------------------------------------------------------------------
+/**
+ * Wrap all tools to emit mcp_tool_call / mcp_tool_result signals.
+ * Signal failures are non-blocking: tool execution continues even if signal write fails.
+ */
+export function wrapToolsWithSignals(tools, bridge) {
+    const wrapped = {};
+    for (const [name, t] of Object.entries(tools)) {
+        const execute = t?.execute;
+        if (!t || typeof execute !== 'function') {
+            wrapped[name] = t;
+            continue;
+        }
+        wrapped[name] = {
+            ...t,
+            execute: async (...args) => {
+                try {
+                    bridge.writeToolCall(name, args[0] ?? {});
+                }
+                catch (e) {
+                    logger.warn(`[SignalBridge] writeToolCall failed for ${name}: ${e}`);
+                }
+                try {
+                    const result = await execute(...args);
+                    try {
+                        bridge.writeToolResult(name, true, result);
+                    }
+                    catch (e) {
+                        logger.warn(`[SignalBridge] writeToolResult failed for ${name}: ${e}`);
+                    }
+                    return result;
+                }
+                catch (err) {
+                    try {
+                        bridge.writeToolResult(name, false, { error: String(err) });
+                    }
+                    catch (e) {
+                        logger.warn(`[SignalBridge] writeToolResult(error) failed for ${name}: ${e}`);
+                    }
+                    throw err;
+                }
+            },
+        };
+    }
+    return wrapped;
+}
+// ---------------------------------------------------------------------------
+// Scout Analyze Tool Factory
+// ---------------------------------------------------------------------------
+const scoutAnalyzeSchema = z.object({
+    scenario: z.enum(['T3', 'T6', 'T8']).describe('Scout scenario code'),
+    file_path: z.string().optional().describe('File path (T3 AuthTouch)'),
+    diff_summary: z.string().optional().describe('Change summary (T3 AuthTouch)'),
+    crate_name: z.string().optional().describe('Crate name (T6 DepShift)'),
+    from_version: z.string().optional().describe('Previous version (T6 DepShift)'),
+    to_version: z.string().optional().describe('New version (T6 DepShift)'),
+    issue_id: z.string().optional().describe('Gate issue ID (T8 GateFix)'),
+    code_diff: z.string().optional().describe('Code diff (T8 GateFix)'),
+});
+function buildScoutTrigger(params) {
+    switch (params.scenario) {
+        case 'T3':
+            return {
+                trigger_type: 'auth_touch',
+                payload: {
+                    file_path: params.file_path ?? 'unknown',
+                    diff_summary: params.diff_summary ?? '',
+                },
+            };
+        case 'T6':
+            return {
+                trigger_type: 'dep_shift',
+                payload: {
+                    crate_name: params.crate_name ?? 'unknown',
+                    from_version: params.from_version ?? '0.0.0',
+                    to_version: params.to_version ?? '0.0.0',
+                },
+            };
+        case 'T8':
+            return {
+                trigger_type: 'gate_fix',
+                payload: {
+                    issue_id: params.issue_id ?? 'unknown',
+                    code_diff: params.code_diff ?? '',
+                },
+            };
+    }
+}
+function createScoutAnalyze(adapter) {
+    return tool({
+        description: 'Analyze code changes for security, dependency, or gate risks via Scout',
+        parameters: scoutAnalyzeSchema,
+        execute: async (params) => {
+            const trigger = buildScoutTrigger(params);
+            // Use adapter's URL/token when Worker is running
+            if (adapter && adapter.getStatus() === 'running') {
+                const client = new ScoutClient(adapter.getBaseUrl(), adapter.getAccessToken() ?? 'scout-local');
+                try {
+                    return await client.dispatch(trigger);
+                }
+                catch (err) {
+                    return { error: String(err), scenario: params.scenario, fallback: true };
+                }
+            }
+            // Fallback: try Musu endpoint resolver (default: 127.0.0.1:8080)
+            const client = new ScoutClient(getMusuBaseUrl(), 'scout-local');
+            try {
+                return await client.dispatch(trigger);
+            }
+            catch (err) {
+                return { error: String(err), scenario: params.scenario };
+            }
+        },
+    });
+}
+// ---------------------------------------------------------------------------
+// Base Companion Tools (no adapter needed)
+// ---------------------------------------------------------------------------
+const baseCompanionTools = {
+    system_control: tool({
+        description: 'Check system vitals, list processes, disk usage, read/write files',
+        parameters: systemControlInputSchema,
+        execute: async (input) => {
+            const result = await handleSystemControl(input);
+            return extractResult(result);
+        },
+    }),
+    virtual_shell: tool({
+        description: 'Execute bash scripts in sandboxed virtual shell (in-memory)',
+        parameters: virtualShellInputSchema,
+        execute: async (input) => {
+            let holodeck = new Holodeck();
+            if (input.mount_files) {
+                holodeck = holodeck.withFiles(input.mount_files);
+            }
+            const scriptResult = await holodeck.executeScript(input.script);
+            const lastStep = scriptResult.steps.at(-1);
+            return {
+                stdout: scriptResult.output,
+                stderr: lastStep?.stderr ?? '',
+                exitCode: scriptResult.success ? 0 : (lastStep?.exitCode ?? 1),
+                durationMs: scriptResult.totalDurationMs,
+            };
+        },
+    }),
+    hive_think: tool({
+        description: 'Decompose a goal into sub-tasks and think in parallel',
+        parameters: hiveThinkInputSchema,
+        execute: async (input) => {
+            const hiveMind = new HiveMind(null, { maxParallel: input.max_parallel ?? 3 });
+            const result = await hiveMind.think(input.goal, input.strategy ?? 'MAP_REDUCE');
+            return result;
+        },
+    }),
+    simulate: tool({
+        description: 'Simulate multiple strategies and pick the best one',
+        parameters: simulateInputSchema,
+        execute: async (input) => {
+            const hiveMind = new HiveMind(null, { maxParallel: 3 });
+            const timeStone = new TimeStone(hiveMind, {
+                maxFutures: input.max_futures,
+                protectedPaths: input.protected_paths,
+            });
+            const result = await timeStone.simulateFutures(input.goal, input.mock_files);
+            return {
+                best_script: result.bestScript,
+                best_score: result.bestScore,
+                futures_explored: result.futuresExplored,
+                total_ms: result.totalMs,
+            };
+        },
+    }),
+};
+// ---------------------------------------------------------------------------
+// Delegate Task Factory (adapter-aware)
+// ---------------------------------------------------------------------------
+const JOB_TYPE_MAP = {
+    infer: 'semantic_grep',
+    gate_check: 'sanity_check',
+    risk_scan: 'dependency_scan',
+};
+function createDelegateTask(adapter) {
+    const delegateTaskSchema = z.object({
+        task_type: z.enum(['infer', 'gate_check', 'risk_scan']),
+        payload: z.record(z.unknown()).default({}),
+        priority: z.number().int().min(0).max(9).default(0),
+        timeout_ms: z.number().int().default(10000),
+    });
+    return tool({
+        description: 'Delegate a task to a remote Musu worker (infer, gate_check, risk_scan)',
+        parameters: delegateTaskSchema,
+        execute: async (input) => {
+            const taskId = `task_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+            // Real delegation when adapter is running
+            if (adapter && adapter.getStatus() === 'running') {
+                try {
+                    const res = await adapter.submitWork({
+                        job_id: taskId,
+                        job_type: (JOB_TYPE_MAP[input.task_type] ?? 'semantic_grep'),
+                        scope: { workspace: process.cwd() },
+                        params: input.payload,
+                        timeout_ms: input.timeout_ms,
+                    });
+                    return { task_id: taskId, status: res.status, result: res.result };
+                }
+                catch (err) {
+                    return { task_id: taskId, error: String(err), fallback: true };
+                }
+            }
+            // Stub: local execution (no Worker adapter connected)
+            logger.warn(`[companion] A2A delegation unavailable — running local stub for task: ${input.task_type}`);
+            const delegationPacket = createDelegation(taskId, input.task_type, input.payload);
+            const result = createDelegationResult(taskId, true, {
+                task_type: input.task_type,
+                message: 'Task delegated (local stub)',
+                payload_keys: Object.keys(input.payload),
+            });
+            return { delegation: delegationPacket, result, task_id: taskId };
+        },
+    });
+}
+// ---------------------------------------------------------------------------
+// Hybrid Status Factory (adapter-aware)
+// ---------------------------------------------------------------------------
+function createHybridStatus(adapter) {
+    return tool({
+        description: 'Check Musu worker and BitNet engine health status',
+        parameters: hybridStatusInputSchema,
+        execute: async (input) => {
+            const checker = new HybridHealthChecker(input.musu_port ?? getMusuWorkerPort(), input.bitnet_port ?? 8080);
+            const baseResult = await checker.check();
+            // Enrich with real Worker health when adapter is running
+            if (adapter && adapter.getStatus() === 'running') {
+                try {
+                    const health = await adapter.health();
+                    return { ...baseResult, worker: health, worker_url: adapter.getBaseUrl() };
+                }
+                catch (err) {
+                    return { ...baseResult, worker: { status: 'error', error: String(err) } };
+                }
+            }
+            return baseResult;
+        },
+    });
+}
+/**
+ * @deprecated Use `createCompanionTools(adapter, bridge)` directly for DI.
+ * Retained only for backward-compatible named import in existing tests.
+ */
+export const companionTools = createCompanionTools();

package/build/companion/types.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Companion types — configuration and handle interfaces.
+ */
+import type { MusuAdapter } from '../kernel/musu_adapter.js';
+import type { ISignalBridge } from '../kernel/contracts.js';
+export interface CompanionConfig {
+    host?: string;
+    port?: number;
+    bitnetUrl?: string;
+    bitnetModel?: string;
+    maxSteps?: number;
+    staticDir?: string;
+    /** Injected adapter for real Worker delegation. undefined = stub mode. */
+    adapter?: MusuAdapter;
+    /** Signal bridge for emitting tool call/result signals to Dashboard. */
+    signalBridge?: ISignalBridge;
+    /** Optional remote URL for forwarding mobile approval resolutions. */
+    mobileRelayUrl?: string;
+    /** Timeout for mobile relay request (ms). */
+    mobileRelayTimeoutMs?: number;
+    /** Audit log path for SEC-005 approval events. */
+    wardenAuditPath?: string;
+    /** Retry interval for mobile relay queue (ms). */
+    mobileRetryIntervalMs?: number;
+}
+export interface CompanionHandle {
+    url: string;
+    close: () => Promise<void>;
+}
+export interface ChatMessage {
+    role: 'user' | 'assistant';
+    content: string;
+}
+export interface ChatRequest {
+    messages: ChatMessage[];
+    stream?: boolean;
+}
+export declare const COMPANION_DEFAULTS: {
+    readonly host: "127.0.0.1";
+    readonly port: 3100;
+    readonly bitnetUrl: "http://127.0.0.1:9090";
+    readonly bitnetModel: "musu-prime-v1";
+    readonly maxSteps: 5;
+};

package/build/companion/types.js

@@ -0,0 +1,10 @@
+/**
+ * Companion types — configuration and handle interfaces.
+ */
+export const COMPANION_DEFAULTS = {
+    host: '127.0.0.1',
+    port: 3100,
+    bitnetUrl: 'http://127.0.0.1:9090',
+    bitnetModel: 'musu-prime-v1',
+    maxSteps: 5,
+};

package/build/companion/warden_runtime.d.ts

@@ -0,0 +1,106 @@
+import { z } from 'zod';
+import type { MusuPacket } from '../protocol/minp.js';
+import type { MusuAdapter } from '../kernel/musu_adapter.js';
+declare const consentRequestSchema: z.ZodObject<{
+    agent_id: z.ZodString;
+    session_id: z.ZodString;
+    tty_id: z.ZodString;
+    host_fingerprint: z.ZodString;
+    raw_command: z.ZodString;
+    requested_mode: z.ZodDefault<z.ZodEnum<["SingleCommand", "SessionWindow"]>>;
+    channel: z.ZodDefault<z.ZodEnum<["desktop", "mobile"]>>;
+}, "strip", z.ZodTypeAny, {
+    agent_id: string;
+    session_id: string;
+    tty_id: string;
+    host_fingerprint: string;
+    raw_command: string;
+    requested_mode: "SingleCommand" | "SessionWindow";
+    channel: "desktop" | "mobile";
+}, {
+    agent_id: string;
+    session_id: string;
+    tty_id: string;
+    host_fingerprint: string;
+    raw_command: string;
+    requested_mode?: "SingleCommand" | "SessionWindow" | undefined;
+    channel?: "desktop" | "mobile" | undefined;
+}>;
+declare const consentResolveSchema: z.ZodObject<{
+    request_id: z.ZodString;
+    decision: z.ZodEnum<["Grant", "Deny"]>;
+    ttl_seconds: z.ZodOptional<z.ZodNumber>;
+    mode: z.ZodOptional<z.ZodEnum<["SingleCommand", "SessionWindow"]>>;
+    channel: z.ZodDefault<z.ZodEnum<["desktop", "mobile"]>>;
+    password: z.ZodOptional<z.ZodString>;
+    token: z.ZodOptional<z.ZodString>;
+    secret: z.ZodOptional<z.ZodString>;
+    api_key: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    decision: "Grant" | "Deny";
+    channel: "desktop" | "mobile";
+    request_id: string;
+    mode?: "SingleCommand" | "SessionWindow" | undefined;
+    secret?: string | undefined;
+    token?: string | undefined;
+    ttl_seconds?: number | undefined;
+    password?: string | undefined;
+    api_key?: string | undefined;
+}, {
+    decision: "Grant" | "Deny";
+    request_id: string;
+    mode?: "SingleCommand" | "SessionWindow" | undefined;
+    secret?: string | undefined;
+    token?: string | undefined;
+    channel?: "desktop" | "mobile" | undefined;
+    ttl_seconds?: number | undefined;
+    password?: string | undefined;
+    api_key?: string | undefined;
+}>;
+export type ConsentRequestInput = z.infer<typeof consentRequestSchema>;
+export type ConsentResolveInput = z.infer<typeof consentResolveSchema>;
+export interface ConsentResponse {
+    ok: boolean;
+    event_name: 'warden.consent.requested' | 'warden.consent.resolved';
+    template_id: 'AUTHORIZATION_REQUIRED' | 'APPROVAL_AUTO_ALLOWED' | 'APPROVAL_BLOCKED_BY_POLICY' | 'APPROVAL_GRANTED' | 'APPROVAL_DENIED';
+    packet: MusuPacket;
+    request_id?: string;
+    decision?: 'ALLOW' | 'ASK' | 'BLOCK' | 'GRANTED' | 'DENIED';
+    message_key?: string;
+    rule_id?: string;
+}
+export interface CompanionWardenOptions {
+    adapter?: MusuAdapter;
+    mobileRelayUrl?: string;
+    mobileRelayTimeoutMs?: number;
+    mobileRetryIntervalMs?: number;
+    wardenAuditPath?: string;
+}
+export declare class CompanionWardenRuntime {
+    private readonly opts;
+    private readonly pending;
+    private readonly retries;
+    private readonly relayUrl?;
+    private readonly relayTimeoutMs;
+    private readonly retryIntervalMs;
+    private readonly auditPath;
+    private retryTimer?;
+    private seq;
+    constructor(opts: CompanionWardenOptions);
+    close(): void;
+    retryStats(): {
+        pending: number;
+    };
+    requestConsent(raw: unknown): Promise<ConsentResponse>;
+    resolveConsent(raw: unknown): Promise<ConsentResponse>;
+    private rejectCredentialFields;
+    private forwardToMobileRelay;
+    private enqueueRetry;
+    private flushRetryQueue;
+    private appendAudit;
+    private normalizeCommand;
+    private evaluatePolicy;
+    private messageKey;
+    private nextRequestId;
+}
+export {};