zyndo 0.1.0

package/dist/mcp/mcpServer.js

@@ -0,0 +1,61 @@
+// ---------------------------------------------------------------------------
+// MCP Server — stdio transport adapter
+//
+// Thin wrapper over mcpCore.ts. Reads JSON-RPC from stdin, writes to stdout.
+// Manages a single McpSessionState and heartbeat timer for the stdio session.
+// ---------------------------------------------------------------------------
+import { createInterface } from 'node:readline';
+import { heartbeat } from '../connection.js';
+import { handleMcpMethod, mcpError } from './mcpCore.js';
+// ---------------------------------------------------------------------------
+// Heartbeat with auto-reconnect
+// ---------------------------------------------------------------------------
+function startHeartbeat(state) {
+    return setInterval(async () => {
+        if (state.agentSession === undefined)
+            return;
+        try {
+            await heartbeat(state.agentSession);
+        }
+        catch {
+            // Session expired — the next tool call will trigger auto-reconnect via mcpCore
+        }
+    }, 30_000);
+}
+// ---------------------------------------------------------------------------
+// Start MCP server (stdio transport)
+// ---------------------------------------------------------------------------
+export async function startMcpServer() {
+    const state = {
+        agentSession: undefined,
+        lastConnectName: 'Claude Code Buyer',
+        lastEventId: 0,
+        bridgeUrl: process.env.ZYNDO_BRIDGE_URL ?? 'https://bridge.zyndo.ai',
+        apiKey: process.env.ZYNDO_API_KEY ?? ''
+    };
+    let heartbeatTimer;
+    const rl = createInterface({ input: process.stdin, terminal: false });
+    rl.on('line', async (line) => {
+        if (line.trim().length === 0)
+            return;
+        try {
+            const request = JSON.parse(line);
+            const response = await handleMcpMethod(state, request.method, request.id, request.params);
+            // Start heartbeat after a successful connect
+            if (request.method === 'tools/call' && state.agentSession !== undefined && heartbeatTimer === undefined) {
+                heartbeatTimer = startHeartbeat(state);
+            }
+            if (response.length > 0) {
+                process.stdout.write(response + '\n');
+            }
+        }
+        catch {
+            process.stdout.write(mcpError(null, -32700, 'Parse error') + '\n');
+        }
+    });
+    rl.on('close', () => {
+        if (heartbeatTimer !== undefined)
+            clearInterval(heartbeatTimer);
+        process.exit(0);
+    });
+}

package/dist/providers/anthropic.d.ts

@@ -0,0 +1,2 @@
+import type { LLMProvider } from './types.js';
+export declare function createAnthropicProvider(apiKey: string, model: string): LLMProvider;

package/dist/providers/anthropic.js

@@ -0,0 +1,52 @@
+// ---------------------------------------------------------------------------
+// Anthropic Messages API adapter
+// ---------------------------------------------------------------------------
+export function createAnthropicProvider(apiKey, model) {
+    return {
+        async chat(messages, tools, systemPrompt) {
+            const anthropicMessages = messages.map((m) => ({
+                role: m.role,
+                content: m.content
+            }));
+            const anthropicTools = tools.map((t) => ({
+                name: t.name,
+                description: t.description,
+                input_schema: t.inputSchema
+            }));
+            const body = {
+                model,
+                max_tokens: 8192,
+                system: systemPrompt,
+                messages: anthropicMessages
+            };
+            if (anthropicTools.length > 0) {
+                body.tools = anthropicTools;
+            }
+            const res = await fetch('https://api.anthropic.com/v1/messages', {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    'x-api-key': apiKey,
+                    'anthropic-version': '2023-06-01'
+                },
+                body: JSON.stringify(body)
+            });
+            if (!res.ok) {
+                const text = await res.text();
+                throw new Error(`Anthropic API error (${res.status}): ${text}`);
+            }
+            const data = (await res.json());
+            return {
+                content: data.content,
+                stopReason: mapStopReason(data.stop_reason)
+            };
+        }
+    };
+}
+function mapStopReason(reason) {
+    if (reason === 'tool_use')
+        return 'tool_use';
+    if (reason === 'max_tokens')
+        return 'max_tokens';
+    return 'end_turn';
+}

package/dist/providers/claudeCode.d.ts

@@ -0,0 +1,5 @@
+import type { SellerConfig, HarnessName } from '../config.js';
+import type { AgentLoopResult } from '../agentLoop.js';
+import type { DaemonLogger } from '../sellerDaemon.js';
+export declare function detectHarness(binary: string): HarnessName;
+export declare function runClaudeCodeTask(taskContext: string, config: SellerConfig, logger: DaemonLogger): Promise<AgentLoopResult>;

package/dist/providers/claudeCode.js

@@ -0,0 +1,174 @@
+// ---------------------------------------------------------------------------
+// Claude Code provider — spawns a CLI harness (claude, codex, or generic)
+// instead of making raw LLM API calls.
+// ---------------------------------------------------------------------------
+import { spawn } from 'node:child_process';
+import { basename } from 'node:path';
+// ---------------------------------------------------------------------------
+// Harness detection and args
+// ---------------------------------------------------------------------------
+export function detectHarness(binary) {
+    const name = basename(binary).toLowerCase();
+    if (name === 'codex' || name.startsWith('codex-'))
+        return 'codex';
+    if (name === 'claude' || name.startsWith('claude-'))
+        return 'claude';
+    return 'generic';
+}
+function buildHarnessArgs(harness, config, systemPrompt) {
+    switch (harness) {
+        case 'claude': {
+            const args = [
+                '--print',
+                '--output-format', 'json',
+                '--system-prompt', systemPrompt,
+                '--model', config.model,
+                '--add-dir', config.workingDirectory,
+                '--permission-mode', 'bypassPermissions',
+                '--no-session-persistence'
+            ];
+            if (config.claudeCodeMaxBudgetUsd !== undefined) {
+                args.push('--max-budget-usd', String(config.claudeCodeMaxBudgetUsd));
+            }
+            return args;
+        }
+        case 'codex':
+            return [
+                '--quiet',
+                '--model', config.model,
+                '--approval-mode', 'full-auto'
+            ];
+        case 'generic':
+            return [];
+    }
+}
+// ---------------------------------------------------------------------------
+// Prompt construction
+// ---------------------------------------------------------------------------
+function buildPrompt(taskContext, config) {
+    const skillLines = config.skills
+        .map((s) => `- ${s.id}: ${s.name} — ${s.description}`)
+        .join('\n');
+    return [
+        'You are a seller agent on the Zyndo marketplace.',
+        '',
+        '**Your identity:**',
+        `- Name: ${config.name}`,
+        `- Description: ${config.description}`,
+        '',
+        '**Your skills:**',
+        skillLines,
+        '',
+        `**Working directory:** ${config.workingDirectory}`,
+        '',
+        '**Task from buyer:**',
+        taskContext,
+        '',
+        '**Instructions:**',
+        'Do the work described above. Use the tools available to you (read files, write files, run commands, search code).',
+        '',
+        '**Delivery format — CRITICAL:**',
+        'When finished, output the COMPLETE content of every file you created or modified.',
+        'Each file MUST appear in a fenced code block with the filename as the info string:',
+        '',
+        '```filename.html',
+        '<full file content here>',
+        '```',
+        '',
+        'Include ALL files. Do not summarize, abbreviate, or describe what you built.',
+        'The text you output IS the deliverable — the buyer CANNOT access your filesystem.',
+        'If multiple files, output each in its own code block.',
+        'After all file blocks, add a 2-3 line summary of what was built.',
+        '',
+        'If you need clarification from the buyer before you can proceed, output ONLY this JSON on a line by itself and stop:',
+        '{"__zyndo_ask_buyer__": "your question here"}',
+        'Do not output anything else after this sentinel. Do not attempt to answer the question yourself.'
+    ].join('\n');
+}
+// ---------------------------------------------------------------------------
+// Output parsing
+// ---------------------------------------------------------------------------
+const ASK_BUYER_RE = /\{"__zyndo_ask_buyer__":\s*"[^"]*"\}\s*$/;
+function parseClaudeJsonOutput(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed.result ?? raw;
+    }
+    catch {
+        return raw;
+    }
+}
+function extractAskBuyerQuestion(text) {
+    const match = text.match(ASK_BUYER_RE);
+    if (match === null)
+        return undefined;
+    try {
+        const parsed = JSON.parse(match[0]);
+        return parsed.__zyndo_ask_buyer__;
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseOutput(raw, harness) {
+    const text = harness === 'claude' ? parseClaudeJsonOutput(raw) : raw;
+    const trimmed = text.trim();
+    const question = extractAskBuyerQuestion(trimmed);
+    if (question !== undefined) {
+        return { output: '', paused: true, pendingQuestion: question };
+    }
+    return { output: trimmed, paused: false };
+}
+// ---------------------------------------------------------------------------
+// Main entry point
+// ---------------------------------------------------------------------------
+const DEFAULT_TIMEOUT_MS = 600_000; // 10 minutes
+export async function runClaudeCodeTask(taskContext, config, logger) {
+    const binary = config.claudeCodeBinary ?? 'claude';
+    const harness = config.harness ?? detectHarness(binary);
+    const timeoutMs = config.claudeCodeTimeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const prompt = buildPrompt(taskContext, config);
+    const systemPrompt = config.systemPrompt;
+    const args = buildHarnessArgs(harness, config, systemPrompt);
+    logger.info(`Spawning ${harness} harness: ${binary} ${args.join(' ')}`);
+    return new Promise((resolve) => {
+        const controller = new AbortController();
+        const timeoutHandle = setTimeout(() => controller.abort(), timeoutMs);
+        const proc = spawn(binary, [...args], {
+            cwd: config.workingDirectory,
+            signal: controller.signal,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: { ...process.env }
+        });
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        proc.stdout.on('data', (chunk) => stdoutChunks.push(chunk));
+        proc.stderr.on('data', (chunk) => stderrChunks.push(chunk));
+        proc.on('error', (err) => {
+            clearTimeout(timeoutHandle);
+            if (err.name === 'AbortError') {
+                logger.error(`Task timed out after ${timeoutMs / 1000}s`);
+                resolve({ output: `Task timed out after ${timeoutMs / 1000} seconds.`, paused: false, timedOut: true });
+                return;
+            }
+            logger.error(`Spawn error: ${err.message}`);
+            resolve({ output: `Harness error: ${err.message}`, paused: false, timedOut: true });
+        });
+        proc.on('close', (code) => {
+            clearTimeout(timeoutHandle);
+            const stdout = Buffer.concat(stdoutChunks).toString('utf-8');
+            const stderr = Buffer.concat(stderrChunks).toString('utf-8');
+            if (stderr.length > 0) {
+                logger.info(`Harness stderr: ${stderr.slice(0, 500)}`);
+            }
+            if (code !== 0 && stdout.length === 0) {
+                logger.error(`Harness exited with code ${code}`);
+                resolve({ output: `Harness failed (exit ${code}): ${stderr.slice(0, 1000)}`, paused: false });
+                return;
+            }
+            resolve(parseOutput(stdout, harness));
+        });
+        proc.stdin.write(prompt);
+        proc.stdin.end();
+    });
+}

package/dist/providers/ollama.d.ts

@@ -0,0 +1,2 @@
+import type { LLMProvider } from './types.js';
+export declare function createOllamaProvider(model: string, baseUrl?: string): LLMProvider;

package/dist/providers/ollama.js

@@ -0,0 +1,90 @@
+// ---------------------------------------------------------------------------
+// Ollama adapter (local models)
+// ---------------------------------------------------------------------------
+import { randomUUID } from 'node:crypto';
+export function createOllamaProvider(model, baseUrl = 'http://localhost:11434') {
+    return {
+        async chat(messages, tools, systemPrompt) {
+            const ollamaMessages = [
+                { role: 'system', content: systemPrompt }
+            ];
+            for (const msg of messages) {
+                if (typeof msg.content === 'string') {
+                    ollamaMessages.push({ role: msg.role, content: msg.content });
+                }
+                else {
+                    const textParts = msg.content.filter((b) => b.type === 'text');
+                    const toolUseParts = msg.content.filter((b) => b.type === 'tool_use');
+                    if (msg.role === 'assistant') {
+                        const text = textParts.map((t) => t.text).join('\n');
+                        const toolCalls = toolUseParts.map((t) => ({
+                            function: { name: t.name, arguments: t.input }
+                        }));
+                        ollamaMessages.push({
+                            role: 'assistant',
+                            content: text,
+                            tool_calls: toolCalls.length > 0 ? toolCalls : undefined
+                        });
+                    }
+                    else {
+                        const toolResults = msg.content.filter((b) => b.type === 'tool_result');
+                        for (const tr of toolResults) {
+                            ollamaMessages.push({
+                                role: 'tool',
+                                content: 'content' in tr ? tr.content : ''
+                            });
+                        }
+                        if (textParts.length > 0) {
+                            ollamaMessages.push({ role: 'user', content: textParts.map((t) => t.text).join('\n') });
+                        }
+                    }
+                }
+            }
+            const ollamaTools = tools.map((t) => ({
+                type: 'function',
+                function: {
+                    name: t.name,
+                    description: t.description,
+                    parameters: t.inputSchema
+                }
+            }));
+            const body = {
+                model,
+                messages: ollamaMessages,
+                stream: false
+            };
+            if (ollamaTools.length > 0) {
+                body.tools = ollamaTools;
+            }
+            const res = await fetch(`${baseUrl}/api/chat`, {
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify(body)
+            });
+            if (!res.ok) {
+                const text = await res.text();
+                throw new Error(`Ollama API error (${res.status}): ${text}`);
+            }
+            const data = (await res.json());
+            const content = [];
+            if (data.message.content.length > 0) {
+                content.push({ type: 'text', text: data.message.content });
+            }
+            if (data.message.tool_calls !== undefined) {
+                for (const tc of data.message.tool_calls) {
+                    content.push({
+                        type: 'tool_use',
+                        id: randomUUID(),
+                        name: tc.function.name,
+                        input: tc.function.arguments
+                    });
+                }
+            }
+            const hasToolUse = content.some((b) => b.type === 'tool_use');
+            return {
+                content,
+                stopReason: hasToolUse ? 'tool_use' : 'end_turn'
+            };
+        }
+    };
+}

package/dist/providers/openai.d.ts

@@ -0,0 +1,2 @@
+import type { LLMProvider } from './types.js';
+export declare function createOpenAIProvider(apiKey: string, model: string): LLMProvider;

package/dist/providers/openai.js

@@ -0,0 +1,103 @@
+// ---------------------------------------------------------------------------
+// OpenAI Chat Completions adapter
+// ---------------------------------------------------------------------------
+export function createOpenAIProvider(apiKey, model) {
+    return {
+        async chat(messages, tools, systemPrompt) {
+            const openaiMessages = [
+                { role: 'system', content: systemPrompt }
+            ];
+            for (const msg of messages) {
+                if (typeof msg.content === 'string') {
+                    openaiMessages.push({ role: msg.role, content: msg.content });
+                }
+                else {
+                    // Map content blocks
+                    const textParts = msg.content.filter((b) => b.type === 'text');
+                    const toolUseParts = msg.content.filter((b) => b.type === 'tool_use');
+                    const toolResultParts = msg.content.filter((b) => b.type === 'tool_result');
+                    if (msg.role === 'assistant') {
+                        const text = textParts.map((t) => t.text).join('\n') || null;
+                        const toolCalls = toolUseParts.map((t) => ({
+                            id: t.id,
+                            type: 'function',
+                            function: { name: t.name, arguments: JSON.stringify(t.input) }
+                        }));
+                        openaiMessages.push({
+                            role: 'assistant',
+                            content: text,
+                            tool_calls: toolCalls.length > 0 ? toolCalls : undefined
+                        });
+                    }
+                    else {
+                        // User message with tool results
+                        for (const tr of toolResultParts) {
+                            if (tr.type === 'tool_result') {
+                                openaiMessages.push({
+                                    role: 'tool',
+                                    content: 'content' in tr ? tr.content : '',
+                                    tool_call_id: 'tool_use_id' in tr ? tr.tool_use_id : ''
+                                });
+                            }
+                        }
+                        if (textParts.length > 0) {
+                            openaiMessages.push({ role: 'user', content: textParts.map((t) => t.text).join('\n') });
+                        }
+                    }
+                }
+            }
+            const openaiTools = tools.map((t) => ({
+                type: 'function',
+                function: {
+                    name: t.name,
+                    description: t.description,
+                    parameters: t.inputSchema
+                }
+            }));
+            const body = {
+                model,
+                messages: openaiMessages,
+                max_tokens: 8192
+            };
+            if (openaiTools.length > 0) {
+                body.tools = openaiTools;
+            }
+            const res = await fetch('https://api.openai.com/v1/chat/completions', {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    'authorization': `Bearer ${apiKey}`
+                },
+                body: JSON.stringify(body)
+            });
+            if (!res.ok) {
+                const text = await res.text();
+                throw new Error(`OpenAI API error (${res.status}): ${text}`);
+            }
+            const data = (await res.json());
+            const choice = data.choices[0];
+            const content = [];
+            if (choice.message.content !== null) {
+                content.push({ type: 'text', text: choice.message.content });
+            }
+            if (choice.message.tool_calls !== undefined) {
+                for (const tc of choice.message.tool_calls) {
+                    content.push({
+                        type: 'tool_use',
+                        id: tc.id,
+                        name: tc.function.name,
+                        input: JSON.parse(tc.function.arguments)
+                    });
+                }
+            }
+            return {
+                content,
+                stopReason: choice.finish_reason === 'tool_calls'
+                    ? 'tool_use'
+                    : choice.finish_reason === 'length'
+                        ? 'max_tokens'
+                        : 'end_turn'
+            };
+        }
+    };
+}

package/dist/providers/types.d.ts

@@ -0,0 +1,33 @@
+export type ToolDefinition = Readonly<{
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}>;
+export type TextBlock = Readonly<{
+    type: 'text';
+    text: string;
+}>;
+export type ToolUseBlock = Readonly<{
+    type: 'tool_use';
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+}>;
+export type ToolResultBlock = Readonly<{
+    type: 'tool_result';
+    tool_use_id: string;
+    content: string;
+    is_error?: boolean;
+}>;
+export type ContentBlock = TextBlock | ToolUseBlock;
+export type Message = Readonly<{
+    role: 'user' | 'assistant';
+    content: string | ReadonlyArray<ContentBlock | ToolResultBlock>;
+}>;
+export type ChatResponse = Readonly<{
+    content: ReadonlyArray<ContentBlock>;
+    stopReason: 'end_turn' | 'tool_use' | 'max_tokens';
+}>;
+export type LLMProvider = Readonly<{
+    chat: (messages: ReadonlyArray<Message>, tools: ReadonlyArray<ToolDefinition>, systemPrompt: string) => Promise<ChatResponse>;
+}>;

package/dist/providers/types.js

@@ -0,0 +1,4 @@
+// ---------------------------------------------------------------------------
+// LLM Provider interface — model-agnostic adapter
+// ---------------------------------------------------------------------------
+export {};

package/dist/sellerDaemon.d.ts

@@ -0,0 +1,9 @@
+import type { SellerConfig } from './config.js';
+export type DaemonLogger = Readonly<{
+    info: (msg: string) => void;
+    error: (msg: string) => void;
+}>;
+export declare function startSellerDaemon(config: SellerConfig, opts?: {
+    logger?: DaemonLogger;
+    signal?: AbortSignal;
+}): Promise<void>;