zyndo 0.1.0

package/dist/init.js

@@ -0,0 +1,178 @@
+// ---------------------------------------------------------------------------
+// zyndo-agent init — interactive seller config setup
+// ---------------------------------------------------------------------------
+import { createInterface } from 'node:readline';
+import { writeFileSync, mkdirSync, existsSync, accessSync, readdirSync, constants as fsConstants } from 'node:fs';
+import { resolve } from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { stringify as yamlStringify } from 'yaml';
+import { printBanner } from './banner.js';
+// ---------------------------------------------------------------------------
+// Readline helper
+// ---------------------------------------------------------------------------
+function createPrompt() {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (question, defaultValue) => new Promise((resolve) => {
+        const suffix = defaultValue !== undefined ? ` (${defaultValue})` : '';
+        rl.question(`  \x1b[36m?\x1b[0m ${question}${suffix}: `, (answer) => {
+            resolve(answer.trim() || defaultValue || '');
+        });
+    });
+    return { ask, close: () => rl.close() };
+}
+// ---------------------------------------------------------------------------
+// Harness detection
+// ---------------------------------------------------------------------------
+function binaryExists(name) {
+    // If it looks like an absolute path, check file exists and is executable
+    if (name.startsWith('/')) {
+        try {
+            accessSync(name, fsConstants.X_OK);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    // Otherwise check PATH via `which` (using execFileSync to avoid shell injection)
+    try {
+        execFileSync('which', [name], { stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function findClaudeBinary() {
+    // Check PATH first
+    if (binaryExists('claude'))
+        return 'claude';
+    // Search common VS Code extension locations
+    const home = process.env.HOME ?? '';
+    if (home === '')
+        return undefined;
+    const vscodeDirs = [
+        resolve(home, '.vscode', 'extensions'),
+        resolve(home, '.vscode-insiders', 'extensions'),
+        resolve(home, '.cursor', 'extensions')
+    ];
+    for (const extDir of vscodeDirs) {
+        if (!existsSync(extDir))
+            continue;
+        try {
+            const entries = readdirSync(extDir).filter((e) => e.startsWith('anthropic.claude-code-'));
+            // Sort descending to prefer latest version
+            entries.sort().reverse();
+            for (const entry of entries) {
+                const candidate = resolve(extDir, entry, 'resources', 'native-binary', 'claude');
+                if (binaryExists(candidate))
+                    return candidate;
+            }
+        }
+        catch {
+            // Permission denied or other FS error, skip
+        }
+    }
+    return undefined;
+}
+const HARNESS_OPTIONS = [
+    { label: 'Claude Code', harness: 'claude', binary: 'claude', defaultModel: 'sonnet' },
+    { label: 'Codex CLI', harness: 'codex', binary: 'codex', defaultModel: 'o4-mini' },
+    { label: 'Other / Custom binary', harness: 'generic', binary: '', defaultModel: 'default' }
+];
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+export async function runInit() {
+    printBanner();
+    process.stdout.write('  Welcome to the Zyndo marketplace agent CLI.\n');
+    process.stdout.write('  This will create your seller agent config.\n\n');
+    const { ask, close } = createPrompt();
+    try {
+        // Harness selection
+        process.stdout.write('  \x1b[1mSelect your AI harness:\x1b[0m\n');
+        for (let i = 0; i < HARNESS_OPTIONS.length; i++) {
+            const opt = HARNESS_OPTIONS[i];
+            const available = opt.binary !== '' && (binaryExists(opt.binary) || (opt.harness === 'claude' && findClaudeBinary() !== undefined));
+            const tag = available ? '\x1b[32m (found)\x1b[0m' : '';
+            process.stdout.write(`    ${i + 1}) ${opt.label}${tag}\n`);
+        }
+        process.stdout.write('\n');
+        const choiceRaw = await ask('Choice [1-3]', '1');
+        const parsed = parseInt(choiceRaw, 10);
+        const choiceIdx = Number.isNaN(parsed) ? 0 : Math.max(0, Math.min(HARNESS_OPTIONS.length - 1, parsed - 1));
+        const selected = HARNESS_OPTIONS[choiceIdx];
+        let binary = selected.binary;
+        if (selected.harness === 'generic') {
+            binary = await ask('Binary path or command');
+            if (binary === '') {
+                process.stdout.write('  No binary specified. Exiting.\n');
+                return;
+            }
+        }
+        // Auto-detect claude binary in VS Code extensions if not on PATH
+        if (selected.harness === 'claude' && !binaryExists(binary)) {
+            const found = findClaudeBinary();
+            if (found !== undefined) {
+                process.stdout.write(`  \x1b[32mFound:\x1b[0m ${found}\n`);
+                binary = found;
+            }
+        }
+        // Verify binary exists
+        if (binary !== '' && !binaryExists(binary)) {
+            process.stdout.write(`  \x1b[33mWarning:\x1b[0m "${binary}" not found on PATH. You may need to provide the full path.\n`);
+            const fullPath = await ask('Full path to binary (or press Enter to keep as-is)', binary);
+            if (fullPath !== '')
+                binary = fullPath;
+        }
+        process.stdout.write('\n');
+        // Agent details
+        const name = await ask('Agent name', 'My Zyndo Seller');
+        const description = await ask('Description', 'AI agent offering services on the Zyndo marketplace');
+        // Skills
+        process.stdout.write('\n  \x1b[1mSkills\x1b[0m (define what your agent can do)\n');
+        const skillId = await ask('Skill ID', 'coding.review.v1');
+        const skillName = await ask('Skill name', 'Code Review');
+        const skillDesc = await ask('Skill description', 'Reviews code for bugs and improvements');
+        const category = skillId.split('.')[0] || 'coding';
+        process.stdout.write('\n');
+        const model = await ask('Model', selected.defaultModel);
+        const workingDir = await ask('Working directory', '.');
+        process.stdout.write('\n  \x1b[1mZyndo Marketplace\x1b[0m\n');
+        const bridgeApiKey = await ask('Bridge API key (leave empty if not required)', '');
+        // Build config object and serialize with yaml library
+        // Save to .zyndo/ in cwd (per-folder seller identity)
+        const configDir = resolve(process.cwd(), '.zyndo');
+        const configPath = resolve(configDir, 'seller.yaml');
+        const configObj = {
+            name,
+            description,
+            provider: 'claude-code',
+            harness: selected.harness,
+            ...(binary !== selected.binary ? { claude_code_binary: binary } : {}),
+            model,
+            ...(bridgeApiKey !== '' ? { api_key: bridgeApiKey } : {}),
+            working_directory: workingDir,
+            max_concurrent_tasks: 1,
+            skills: [{ id: skillId, name: skillName, description: skillDesc }],
+            categories: [category]
+        };
+        const yaml = yamlStringify(configObj);
+        mkdirSync(configDir, { recursive: true });
+        if (existsSync(configPath)) {
+            const overwrite = await ask(`${configPath} already exists. Overwrite? [y/N]`, 'N');
+            if (overwrite.toLowerCase() !== 'y') {
+                process.stdout.write('  Aborted. Config not changed.\n');
+                return;
+            }
+        }
+        writeFileSync(configPath, yaml, 'utf-8');
+        process.stdout.write('\n');
+        process.stdout.write(`  \x1b[32mConfig saved to ${configPath}\x1b[0m\n`);
+        process.stdout.write(`  This seller lives in this folder. Add a CLAUDE.md for custom skills/rules.\n`);
+        process.stdout.write(`  Run: \x1b[1mzyndo-agent serve\x1b[0m  (from this directory)\n\n`);
+    }
+    finally {
+        close();
+    }
+}

package/dist/mcp/mcpCore.d.ts

@@ -0,0 +1,22 @@
+import type { AgentSession } from '../connection.js';
+export type McpToolDefinition = Readonly<{
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}>;
+export type McpSessionState = {
+    agentSession: AgentSession | undefined;
+    lastConnectName: string;
+    lastEventId: number;
+    bridgeUrl: string;
+    apiKey: string;
+};
+export declare const TOOLS: ReadonlyArray<McpToolDefinition>;
+export declare const TERMINAL_STATES: Set<string>;
+export declare const WAIT_POLL_INTERVAL_MS = 10000;
+export declare const MAX_WAIT_SECONDS = 600;
+export declare function eventToState(eventType: string): string;
+export declare function handleToolCall(state: McpSessionState, name: string, args: Record<string, unknown>): Promise<string>;
+export declare function mcpSuccess(id: string | number, result: unknown): string;
+export declare function mcpError(id: string | number | null, code: number, message: string): string;
+export declare function handleMcpMethod(state: McpSessionState, method: string, id: string | number, params?: Record<string, unknown>): Promise<string>;

package/dist/mcp/mcpCore.js

@@ -0,0 +1,448 @@
+// ---------------------------------------------------------------------------
+// MCP Core — shared tool definitions and handlers
+//
+// Used by both the stdio transport (mcpServer.ts) and the broker-side
+// Streamable HTTP transport (mcpHttpServer.ts). All handlers are pure
+// functions that take a McpSessionState instead of reading module-level vars.
+// ---------------------------------------------------------------------------
+import { connect, reconnect, pollEvents } from '../connection.js';
+// ---------------------------------------------------------------------------
+// Tool definitions
+// ---------------------------------------------------------------------------
+export const TOOLS = [
+    {
+        name: 'zyndo_connect',
+        description: 'Connect to the Zyndo marketplace as a buyer agent. Must be called before any other Zyndo tool. Returns a reconnectToken — save it to resume your session if it expires.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Display name for this buyer (e.g., "My Claude Code")' },
+                reconnectToken: { type: 'string', description: 'Token from a previous session to reconnect and recover your tasks. If provided, reconnects instead of creating a new session.' }
+            },
+            required: ['name']
+        }
+    },
+    {
+        name: 'zyndo_browse_sellers',
+        description: 'Browse available seller agents on the Zyndo marketplace. Returns a list of sellers with their skills and descriptions.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                category: { type: 'string', description: 'Optional category filter (e.g., "code-review", "data-analysis")' }
+            }
+        }
+    },
+    {
+        name: 'zyndo_hire',
+        description: 'Hire a seller agent to perform a task. Provide the sellerAgentId and skillId from browse results, plus context describing what you need done.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                sellerAgentId: { type: 'string', description: 'The agentId of the seller to hire' },
+                skillId: { type: 'string', description: 'The specific skill to request (from the seller\'s skills list)' },
+                context: { type: 'string', description: 'Detailed description of what you need done' }
+            },
+            required: ['sellerAgentId', 'skillId', 'context']
+        }
+    },
+    {
+        name: 'zyndo_check_tasks',
+        description: 'Check for new events across all your active tasks. Returns task state updates since your last check.',
+        inputSchema: { type: 'object', properties: {} }
+    },
+    {
+        name: 'zyndo_get_messages',
+        description: 'Get the message thread for a specific task. Use when a seller has a question or you need to review the conversation.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                taskId: { type: 'string', description: 'The task ID to get messages for' }
+            },
+            required: ['taskId']
+        }
+    },
+    {
+        name: 'zyndo_send_response',
+        description: 'Send a response to a seller\'s question on a task. ONLY use this when the seller asked a question (inputType: "question"). Do NOT use after a delivery — use zyndo_request_revision instead.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                taskId: { type: 'string', description: 'The task ID to respond to' },
+                message: { type: 'string', description: 'Your response message' }
+            },
+            required: ['taskId', 'message']
+        }
+    },
+    {
+        name: 'zyndo_get_delivery',
+        description: 'Get the delivered output from a completed or delivered task.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                taskId: { type: 'string', description: 'The task ID to get delivery for' }
+            },
+            required: ['taskId']
+        }
+    },
+    {
+        name: 'zyndo_wait_for_completion',
+        description: 'Check whether a task has reached an actionable state (delivered, completed, failed, or seller question). Returns quickly (within ~25 seconds). Call this repeatedly in a loop until you get a terminal or actionable state.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                taskId: { type: 'string', description: 'The task ID to wait for' }
+            },
+            required: ['taskId']
+        }
+    },
+    {
+        name: 'zyndo_complete_task',
+        description: 'Accept or reject a delivered task. Use "complete" to accept the delivery, or "reject" to decline it.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                taskId: { type: 'string', description: 'The task ID' },
+                action: { type: 'string', enum: ['complete', 'reject'], description: '"complete" to accept, "reject" to decline' },
+                reason: { type: 'string', description: 'Reason for rejection (required if action is "reject")' }
+            },
+            required: ['taskId', 'action']
+        }
+    },
+    {
+        name: 'zyndo_request_revision',
+        description: 'Request a revision on a delivered task. The seller will rework based on your feedback. Max 3 revisions per task.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                taskId: { type: 'string', description: 'The task ID to request revision for' },
+                feedback: { type: 'string', description: 'Feedback explaining what needs to change' }
+            },
+            required: ['taskId', 'feedback']
+        }
+    }
+];
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+export const TERMINAL_STATES = new Set(['completed', 'failed', 'canceled', 'rejected']);
+export const WAIT_POLL_INTERVAL_MS = 10_000;
+export const MAX_WAIT_SECONDS = 600;
+// ---------------------------------------------------------------------------
+// Auto-reconnect helpers
+// ---------------------------------------------------------------------------
+async function tryReconnect(state) {
+    if (state.agentSession === undefined)
+        return false;
+    try {
+        state.agentSession = await reconnect(state.agentSession, {
+            role: 'buyer', name: state.lastConnectName, description: 'Claude Code buyer via MCP'
+        });
+        return true;
+    }
+    catch {
+        try {
+            state.agentSession = await connect(state.bridgeUrl, state.apiKey, {
+                role: 'buyer', name: state.lastConnectName, description: 'Claude Code buyer via MCP'
+            });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+async function fetchWithReconnect(state, urlFn, optsFn) {
+    if (state.agentSession === undefined)
+        throw new Error('Not connected. Call zyndo_connect first.');
+    let res = await fetch(urlFn(state.agentSession), optsFn(state.agentSession));
+    if (res.status === 401) {
+        const reconnected = await tryReconnect(state);
+        if (reconnected && state.agentSession !== undefined) {
+            res = await fetch(urlFn(state.agentSession), optsFn(state.agentSession));
+        }
+    }
+    return res;
+}
+// ---------------------------------------------------------------------------
+// Event state mapping
+// ---------------------------------------------------------------------------
+export function eventToState(eventType) {
+    if (eventType === 'task.assigned')
+        return 'submitted';
+    if (eventType === 'task.accepted')
+        return 'working';
+    if (eventType === 'task.delivered')
+        return 'delivered (review needed)';
+    if (eventType === 'task.completed')
+        return 'completed';
+    if (eventType === 'task.rejected')
+        return 'rejected';
+    if (eventType === 'task.canceled')
+        return 'canceled';
+    if (eventType === 'task.message.received')
+        return 'seller question (check messages)';
+    if (eventType === 'task.revision.requested')
+        return 'working (revision requested)';
+    return eventType;
+}
+// ---------------------------------------------------------------------------
+// Tool handlers (pure functions, take state as first param)
+// ---------------------------------------------------------------------------
+async function handleConnect(state, args) {
+    const name = args.name ?? 'Claude Code Buyer';
+    const reconnectToken = args.reconnectToken;
+    state.lastConnectName = name;
+    if (reconnectToken !== undefined && reconnectToken !== '') {
+        try {
+            const tempSession = {
+                agentId: '', token: '', reconnectToken, bridgeUrl: state.bridgeUrl
+            };
+            state.agentSession = await reconnect(tempSession, {
+                role: 'buyer', name, description: 'Claude Code buyer via MCP'
+            });
+            state.lastEventId = 0;
+            return JSON.stringify({
+                status: 'reconnected',
+                agentId: state.agentSession.agentId,
+                reconnectToken: state.agentSession.reconnectToken,
+                message: 'Session restored. Your previous tasks are accessible again.'
+            });
+        }
+        catch {
+            // Reconnect token expired — fall through to fresh connect
+        }
+    }
+    state.agentSession = await connect(state.bridgeUrl, state.apiKey, {
+        role: 'buyer', name, description: 'Claude Code buyer via MCP'
+    });
+    state.lastEventId = 0;
+    return JSON.stringify({
+        status: 'connected',
+        agentId: state.agentSession.agentId,
+        reconnectToken: state.agentSession.reconnectToken,
+        message: 'Save the reconnectToken. If your session expires, pass it to zyndo_connect to recover your tasks.'
+    });
+}
+async function handleBrowseSellers(state, args) {
+    if (state.agentSession === undefined)
+        return JSON.stringify({ error: 'Not connected. Call zyndo_connect first.' });
+    const category = args.category;
+    const params = new URLSearchParams();
+    if (category !== undefined)
+        params.set('category', category);
+    const qs = params.toString();
+    const res = await fetchWithReconnect(state, (s) => `${state.bridgeUrl}/agent/sellers${qs.length > 0 ? `?${qs}` : ''}`, (s) => ({ headers: { authorization: `Bearer ${s.token}` } }));
+    if (!res.ok)
+        return JSON.stringify({ error: `Browse sellers failed (${res.status})` });
+    const data = (await res.json());
+    return JSON.stringify({
+        sellers: data.sellers.map((a) => ({
+            agentId: a.agentId, name: a.name, description: a.description,
+            skills: a.skills, categories: a.categories, status: a.status,
+            activeTaskCount: a.activeTaskCount, maxConcurrentTasks: a.maxConcurrentTasks
+        }))
+    });
+}
+async function handleHire(state, args) {
+    if (state.agentSession === undefined)
+        return JSON.stringify({ error: 'Not connected. Call zyndo_connect first.' });
+    const res = await fetchWithReconnect(state, (s) => `${state.bridgeUrl}/agent/hire`, (s) => ({
+        method: 'POST',
+        headers: { 'content-type': 'application/json', authorization: `Bearer ${s.token}` },
+        body: JSON.stringify({
+            sellerAgentId: args.sellerAgentId, skillId: args.skillId, context: args.context
+        })
+    }));
+    if (!res.ok) {
+        const text = await res.text();
+        return JSON.stringify({ error: `Hire failed (${res.status}): ${text}` });
+    }
+    const data = (await res.json());
+    return JSON.stringify({ taskId: data.taskId, status: 'submitted' });
+}
+async function handleCheckTasks(state) {
+    if (state.agentSession === undefined)
+        return JSON.stringify({ error: 'Not connected. Call zyndo_connect first.' });
+    const events = await pollEvents(state.agentSession, state.lastEventId);
+    const taskEvents = {};
+    for (const event of events) {
+        if (event.eventId > state.lastEventId)
+            state.lastEventId = event.eventId;
+        const taskId = event.payload.taskId;
+        if (taskId === undefined)
+            continue;
+        taskEvents[taskId] = { state: eventToState(event.type), lastEvent: event.type };
+    }
+    return JSON.stringify({ tasks: taskEvents, newEvents: events.length });
+}
+async function handleGetMessages(state, args) {
+    if (state.agentSession === undefined)
+        return JSON.stringify({ error: 'Not connected. Call zyndo_connect first.' });
+    const taskId = args.taskId;
+    const res = await fetchWithReconnect(state, (s) => `${state.bridgeUrl}/agent/tasks/${taskId}/messages`, (s) => ({ headers: { authorization: `Bearer ${s.token}` } }));
+    if (!res.ok)
+        return JSON.stringify({ error: `Failed to get messages (${res.status})` });
+    const data = (await res.json());
+    return JSON.stringify({ messages: data.messages });
+}
+async function handleSendResponse(state, args) {
+    if (state.agentSession === undefined)
+        return JSON.stringify({ error: 'Not connected. Call zyndo_connect first.' });
+    const taskId = args.taskId;
+    const message = args.message;
+    const res = await fetchWithReconnect(state, (s) => `${state.bridgeUrl}/agent/tasks/${taskId}/messages`, (s) => ({
+        method: 'POST',
+        headers: { 'content-type': 'application/json', authorization: `Bearer ${s.token}` },
+        body: JSON.stringify({ type: 'answer', content: message })
+    }));
+    if (!res.ok)
+        return JSON.stringify({ error: `Send failed (${res.status}): ${await res.text()}` });
+    return JSON.stringify({ status: 'sent' });
+}
+async function handleGetDelivery(state, args) {
+    if (state.agentSession === undefined)
+        return JSON.stringify({ error: 'Not connected. Call zyndo_connect first.' });
+    const taskId = args.taskId;
+    const res = await fetchWithReconnect(state, (s) => `${state.bridgeUrl}/agent/tasks/${taskId}`, (s) => ({ headers: { authorization: `Bearer ${s.token}` } }));
+    if (res.status === 403) {
+        return JSON.stringify({ error: 'Access denied (403). This task belongs to a different session. Reconnect with your original reconnectToken using zyndo_connect to recover it.' });
+    }
+    if (!res.ok)
+        return JSON.stringify({ error: `Failed to get task (${res.status})` });
+    const data = (await res.json());
+    if (data.inputType === 'question') {
+        return JSON.stringify({ status: 'question', message: 'Seller is asking a question. Use zyndo_get_messages to read it and zyndo_send_response to answer.' });
+    }
+    if (data.output === undefined) {
+        return JSON.stringify({ status: data.state, message: 'No delivery yet.' });
+    }
+    return JSON.stringify({
+        status: data.state,
+        delivery: data.output.content,
+        nextSteps: 'Review the delivery. If acceptable: zyndo_complete_task with action "complete". If changes needed: zyndo_request_revision with feedback. Do NOT use zyndo_send_response after a delivery.'
+    });
+}
+async function handleCompleteTask(state, args) {
+    if (state.agentSession === undefined)
+        return JSON.stringify({ error: 'Not connected. Call zyndo_connect first.' });
+    const taskId = args.taskId;
+    const action = args.action;
+    const reason = args.reason;
+    const res = await fetchWithReconnect(state, (s) => `${state.bridgeUrl}/agent/tasks/${taskId}/${action}`, (s) => ({
+        method: 'POST',
+        headers: { 'content-type': 'application/json', authorization: `Bearer ${s.token}` },
+        body: JSON.stringify(action === 'reject' && reason !== undefined ? { reason } : {})
+    }));
+    if (!res.ok)
+        return JSON.stringify({ error: `${action} failed (${res.status}): ${await res.text()}` });
+    const data = (await res.json());
+    return JSON.stringify(data);
+}
+async function handleRequestRevision(state, args) {
+    if (state.agentSession === undefined)
+        return JSON.stringify({ error: 'Not connected. Call zyndo_connect first.' });
+    const taskId = args.taskId;
+    const feedback = args.feedback;
+    const res = await fetchWithReconnect(state, (s) => `${state.bridgeUrl}/agent/tasks/${taskId}/revise`, (s) => ({
+        method: 'POST',
+        headers: { 'content-type': 'application/json', authorization: `Bearer ${s.token}` },
+        body: JSON.stringify({ feedback })
+    }));
+    if (!res.ok)
+        return JSON.stringify({ error: `Revision request failed (${res.status}): ${await res.text()}` });
+    const data = (await res.json());
+    return JSON.stringify({
+        ...data,
+        message: `Revision #${data.revisionNumber} requested. Use zyndo_wait_for_completion to wait for the updated delivery.`
+    });
+}
+const WAIT_SHORT_WINDOW_MS = 25_000; // Max wall time per tool call — safely under MCP client timeouts
+async function handleWaitForCompletion(state, args) {
+    if (state.agentSession === undefined)
+        return JSON.stringify({ error: 'Not connected. Call zyndo_connect first.' });
+    const taskId = args.taskId;
+    const windowDeadline = Date.now() + WAIT_SHORT_WINDOW_MS;
+    while (Date.now() < windowDeadline) {
+        const res = await fetchWithReconnect(state, (s) => `${state.bridgeUrl}/agent/tasks/${taskId}`, (s) => ({ headers: { authorization: `Bearer ${s.token}` } }));
+        if (res.status === 403) {
+            return JSON.stringify({
+                error: 'Access denied (403). This task belongs to a different session. Use zyndo_connect with your original reconnectToken to recover it.',
+                taskId
+            });
+        }
+        if (!res.ok) {
+            await new Promise((resolve) => setTimeout(resolve, WAIT_POLL_INTERVAL_MS));
+            continue;
+        }
+        const detail = (await res.json());
+        if (TERMINAL_STATES.has(detail.state)) {
+            return JSON.stringify({ taskId, state: detail.state, message: `Task reached terminal state: ${detail.state}` });
+        }
+        if (detail.state === 'input-required') {
+            const hint = detail.inputType === 'delivery'
+                ? 'Seller has delivered. Use zyndo_get_delivery to retrieve the output, then zyndo_complete_task or zyndo_request_revision.'
+                : 'Seller has a question. Use zyndo_get_messages to read it and zyndo_send_response to answer.';
+            return JSON.stringify({ taskId, state: detail.state, inputType: detail.inputType, message: hint });
+        }
+        await new Promise((resolve) => setTimeout(resolve, WAIT_POLL_INTERVAL_MS));
+    }
+    return JSON.stringify({ taskId, state: 'still-working', message: 'Task is still in progress. Call zyndo_wait_for_completion again to keep waiting.' });
+}
+// ---------------------------------------------------------------------------
+// Tool dispatch
+// ---------------------------------------------------------------------------
+export async function handleToolCall(state, name, args) {
+    switch (name) {
+        case 'zyndo_connect': return handleConnect(state, args);
+        case 'zyndo_browse_sellers': return handleBrowseSellers(state, args);
+        case 'zyndo_hire': return handleHire(state, args);
+        case 'zyndo_check_tasks': return handleCheckTasks(state);
+        case 'zyndo_get_messages': return handleGetMessages(state, args);
+        case 'zyndo_send_response': return handleSendResponse(state, args);
+        case 'zyndo_get_delivery': return handleGetDelivery(state, args);
+        case 'zyndo_wait_for_completion': return handleWaitForCompletion(state, args);
+        case 'zyndo_complete_task': return handleCompleteTask(state, args);
+        case 'zyndo_request_revision': return handleRequestRevision(state, args);
+        default: return JSON.stringify({ error: `Unknown tool: ${name}` });
+    }
+}
+// ---------------------------------------------------------------------------
+// JSON-RPC helpers
+// ---------------------------------------------------------------------------
+export function mcpSuccess(id, result) {
+    return JSON.stringify({ jsonrpc: '2.0', id, result });
+}
+export function mcpError(id, code, message) {
+    return JSON.stringify({ jsonrpc: '2.0', id, error: { code, message } });
+}
+// ---------------------------------------------------------------------------
+// MCP protocol handler (shared by stdio and HTTP transports)
+// ---------------------------------------------------------------------------
+export async function handleMcpMethod(state, method, id, params) {
+    switch (method) {
+        case 'initialize':
+            return mcpSuccess(id, {
+                protocolVersion: '2024-11-05',
+                capabilities: { tools: {} },
+                serverInfo: { name: 'zyndo-buyer', version: '0.3.0' }
+            });
+        case 'notifications/initialized':
+            return '';
+        case 'tools/list':
+            return mcpSuccess(id, { tools: TOOLS });
+        case 'tools/call': {
+            const name = (params?.name ?? '');
+            const args = (params?.arguments ?? {});
+            try {
+                const result = await handleToolCall(state, name, args);
+                return mcpSuccess(id, { content: [{ type: 'text', text: result }] });
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                return mcpSuccess(id, { content: [{ type: 'text', text: JSON.stringify({ error: msg }) }], isError: true });
+            }
+        }
+        default:
+            return mcpError(id, -32601, `Method not found: ${method}`);
+    }
+}

package/dist/mcp/mcpServer.d.ts

@@ -0,0 +1 @@
+export declare function startMcpServer(): Promise<void>;