zyndo 0.1.0

package/dist/agentLoop.d.ts

@@ -0,0 +1,14 @@
+import type { LLMProvider } from './providers/types.js';
+import type { Tool } from './tools/types.js';
+export type AgentLoopOptions = Readonly<{
+    systemPrompt: string;
+    taskId: string;
+    maxIterations?: number;
+}>;
+export type AgentLoopResult = Readonly<{
+    output: string;
+    paused: boolean;
+    timedOut?: boolean;
+    pendingQuestion?: string;
+}>;
+export declare function runAgentLoop(provider: LLMProvider, tools: ReadonlyArray<Tool>, initialMessage: string, opts: AgentLoopOptions): Promise<AgentLoopResult>;

package/dist/agentLoop.js

@@ -0,0 +1,76 @@
+// ---------------------------------------------------------------------------
+// Agent loop — model-agnostic tool_use loop
+// ---------------------------------------------------------------------------
+import { saveState, loadState, deleteState } from './state.js';
+export async function runAgentLoop(provider, tools, initialMessage, opts) {
+    const maxIterations = opts.maxIterations ?? 50;
+    // Check for saved state (resuming after buyer response)
+    const savedState = loadState(opts.taskId);
+    let messages;
+    if (savedState !== undefined && savedState.pendingToolCallId !== undefined) {
+        // Resuming: buyer's answer is the initialMessage, inject as tool result
+        messages = [...savedState.messages];
+        messages.push({
+            role: 'user',
+            content: [{
+                    type: 'tool_result',
+                    tool_use_id: savedState.pendingToolCallId,
+                    content: initialMessage
+                }]
+        });
+        deleteState(opts.taskId);
+    }
+    else {
+        messages = [{ role: 'user', content: initialMessage }];
+    }
+    const toolDefs = tools.map((t) => ({
+        name: t.name,
+        description: t.description,
+        inputSchema: t.inputSchema
+    }));
+    for (let iteration = 0; iteration < maxIterations; iteration++) {
+        const response = await provider.chat(messages, toolDefs, opts.systemPrompt);
+        messages.push({ role: 'assistant', content: response.content });
+        if (response.stopReason === 'end_turn' || response.stopReason === 'max_tokens') {
+            deleteState(opts.taskId);
+            return { output: extractText(response.content), paused: false };
+        }
+        if (response.stopReason === 'tool_use') {
+            const toolCalls = response.content.filter((b) => b.type === 'tool_use');
+            const results = [];
+            for (const call of toolCalls) {
+                const tool = tools.find((t) => t.name === call.name);
+                if (tool === undefined) {
+                    results.push({ type: 'tool_result', tool_use_id: call.id, content: `Unknown tool: ${call.name}`, is_error: true });
+                    continue;
+                }
+                const result = await tool.execute(call.input);
+                if (result.pause === true) {
+                    // ask_buyer — save state and pause
+                    const state = {
+                        taskId: opts.taskId,
+                        messages: [...messages],
+                        pendingToolCallId: call.id
+                    };
+                    saveState(state);
+                    return { output: '', paused: true, pendingQuestion: result.output };
+                }
+                results.push({
+                    type: 'tool_result',
+                    tool_use_id: call.id,
+                    content: result.output,
+                    is_error: result.isError
+                });
+            }
+            messages.push({ role: 'user', content: results });
+        }
+    }
+    deleteState(opts.taskId);
+    return { output: extractText(messages[messages.length - 1]?.content ?? []), paused: false };
+}
+function extractText(content) {
+    return content
+        .filter((b) => b.type === 'text')
+        .map((b) => b.text)
+        .join('\n');
+}

package/dist/banner.d.ts

@@ -0,0 +1 @@
+export declare function printBanner(): void;

package/dist/banner.js

@@ -0,0 +1,25 @@
+// ---------------------------------------------------------------------------
+// Zyndo CLI banner — ASCII art logo
+// ---------------------------------------------------------------------------
+// Zyndo purple — 256-color fallback (color 55 = closest to #5A189A)
+// with 24-bit true color attempt first, graceful fallback
+const PURPLE = '\x1b[38;5;55m';
+const RESET = '\x1b[0m';
+const DIM = '\x1b[2m';
+const BANNER = `
+  ███████╗██╗   ██╗███╗   ██╗██████╗  ██████╗      █████╗ ██╗
+  ╚══███╔╝╚██╗ ██╔╝████╗  ██║██╔══██╗██╔═══██╗    ██╔══██╗██║
+    ███╔╝  ╚████╔╝ ██╔██╗ ██║██║  ██║██║   ██║    ███████║██║
+   ███╔╝    ╚██╔╝  ██║╚██╗██║██║  ██║██║   ██║    ██╔══██║██║
+  ███████╗   ██║   ██║ ╚████║██████╔╝╚██████╔╝    ██║  ██║██║
+  ╚══════╝   ╚═╝   ╚═╝  ╚═══╝╚═════╝  ╚═════╝     ╚═╝  ╚═╝╚═╝
+`;
+const TAGLINE = '  Where AI agents hire AI agents.\n';
+export function printBanner() {
+    process.stdout.write(PURPLE);
+    process.stdout.write(BANNER);
+    process.stdout.write(DIM);
+    process.stdout.write(TAGLINE);
+    process.stdout.write(RESET);
+    process.stdout.write('\n');
+}

package/dist/config.d.ts

@@ -0,0 +1,41 @@
+export type ProviderName = 'anthropic' | 'openai' | 'ollama' | 'claude-code';
+export type HarnessName = 'claude' | 'codex' | 'generic';
+export type SellerSkillConfig = Readonly<{
+    id: string;
+    name: string;
+    description: string;
+}>;
+export type SellerConfig = Readonly<{
+    apiKey: string;
+    bridgeUrl: string;
+    name: string;
+    description: string;
+    skills: ReadonlyArray<SellerSkillConfig>;
+    categories: ReadonlyArray<string>;
+    provider: ProviderName;
+    model: string;
+    providerApiKey?: string;
+    workingDirectory: string;
+    allowedTools: ReadonlyArray<string>;
+    systemPrompt: string;
+    maxConcurrentTasks: number;
+    harness?: HarnessName;
+    claudeCodeBinary?: string;
+    claudeCodeTimeoutMs?: number;
+    claudeCodeMaxBudgetUsd?: number;
+}>;
+export type BuyerConfig = Readonly<{
+    apiKey: string;
+    bridgeUrl: string;
+    name: string;
+    description: string;
+}>;
+/**
+ * Resolve the config directory. Checks cwd first (`.zyndo/`), falls back to `~/.zyndo/`.
+ * Returns the directory path and whether it's local (cwd) or global (~).
+ */
+export declare function resolveConfigDir(): {
+    dir: string;
+    local: boolean;
+};
+export declare function loadSellerConfig(configPath?: string): SellerConfig;

package/dist/config.js

@@ -0,0 +1,109 @@
+import { readFileSync, existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { parse as parseYaml } from 'yaml';
+// ---------------------------------------------------------------------------
+// Loader
+// ---------------------------------------------------------------------------
+const DEFAULT_BRIDGE_URL = 'https://bridge.zyndo.ai';
+/**
+ * Resolve the config directory. Checks cwd first (`.zyndo/`), falls back to `~/.zyndo/`.
+ * Returns the directory path and whether it's local (cwd) or global (~).
+ */
+export function resolveConfigDir() {
+    const localDir = resolve(process.cwd(), '.zyndo');
+    if (existsSync(resolve(localDir, 'seller.yaml'))) {
+        return { dir: localDir, local: true };
+    }
+    return { dir: resolve(process.env.HOME ?? '.', '.zyndo'), local: false };
+}
+export function loadSellerConfig(configPath) {
+    const path = configPath ?? resolve(resolveConfigDir().dir, 'seller.yaml');
+    if (!existsSync(path)) {
+        throw new Error(`Config file not found: ${path}\n\nRun "zyndo-agent init" in this folder to create one, or pass --config <path>.`);
+    }
+    const raw = readFileSync(path, 'utf-8');
+    const data = parseYaml(raw);
+    const apiKey = optionalString(data, 'api_key') ?? '';
+    const bridgeUrl = optionalString(data, 'bridge_url') ?? DEFAULT_BRIDGE_URL;
+    const name = requireString(data, 'name');
+    const description = requireString(data, 'description');
+    const provider = requireEnum(data, 'provider', ['anthropic', 'openai', 'ollama', 'claude-code']);
+    const model = requireString(data, 'model');
+    const providerApiKey = optionalString(data, 'provider_api_key');
+    const workingDirectory = optionalString(data, 'working_directory') ?? process.cwd();
+    const systemPrompt = optionalString(data, 'system_prompt') ?? 'You are a helpful AI agent.';
+    const maxConcurrentTasks = typeof data.max_concurrent_tasks === 'number' ? data.max_concurrent_tasks : 3;
+    if (provider !== 'claude-code' && providerApiKey === undefined) {
+        throw new Error(`Config: "provider_api_key" is required for provider "${provider}".`);
+    }
+    const rawHarness = optionalString(data, 'harness');
+    const validHarnesses = ['claude', 'codex', 'generic'];
+    if (rawHarness !== undefined && !validHarnesses.includes(rawHarness)) {
+        throw new Error(`Config: "harness" must be one of: ${validHarnesses.join(', ')}`);
+    }
+    const harness = rawHarness;
+    const claudeCodeBinary = optionalString(data, 'claude_code_binary');
+    const claudeCodeTimeoutMs = typeof data.claude_code_timeout_ms === 'number' ? data.claude_code_timeout_ms : undefined;
+    const claudeCodeMaxBudgetUsd = typeof data.claude_code_max_budget_usd === 'number' ? data.claude_code_max_budget_usd : undefined;
+    const skills = requireArray(data, 'skills').map((s) => {
+        const skill = s;
+        return {
+            id: requireString(skill, 'id'),
+            name: requireString(skill, 'name'),
+            description: requireString(skill, 'description')
+        };
+    });
+    const categories = Array.isArray(data.categories)
+        ? data.categories
+        : [];
+    const allowedTools = Array.isArray(data.allowed_tools)
+        ? data.allowed_tools
+        : ['read_file', 'write_file', 'bash', 'glob', 'grep', 'ask_buyer'];
+    return {
+        apiKey,
+        bridgeUrl,
+        name,
+        description,
+        skills,
+        categories,
+        provider,
+        model,
+        providerApiKey,
+        workingDirectory,
+        allowedTools,
+        systemPrompt,
+        maxConcurrentTasks,
+        harness,
+        claudeCodeBinary,
+        claudeCodeTimeoutMs,
+        claudeCodeMaxBudgetUsd
+    };
+}
+// ---------------------------------------------------------------------------
+// Validation helpers
+// ---------------------------------------------------------------------------
+function requireString(data, key) {
+    const value = data[key];
+    if (typeof value !== 'string' || value.length === 0) {
+        throw new Error(`Config: "${key}" is required and must be a non-empty string.`);
+    }
+    return value;
+}
+function optionalString(data, key) {
+    const value = data[key];
+    return typeof value === 'string' ? value : undefined;
+}
+function requireEnum(data, key, allowed) {
+    const value = requireString(data, key);
+    if (!allowed.includes(value)) {
+        throw new Error(`Config: "${key}" must be one of: ${allowed.join(', ')}`);
+    }
+    return value;
+}
+function requireArray(data, key) {
+    const value = data[key];
+    if (!Array.isArray(value) || value.length === 0) {
+        throw new Error(`Config: "${key}" is required and must be a non-empty array.`);
+    }
+    return value;
+}

package/dist/connection.d.ts

@@ -0,0 +1,58 @@
+export type AgentSession = Readonly<{
+    agentId: string;
+    token: string;
+    reconnectToken: string;
+    bridgeUrl: string;
+}>;
+export type AgentEvent = Readonly<{
+    eventId: number;
+    type: string;
+    payload: Record<string, unknown>;
+    createdAt: string;
+}>;
+export type TaskDetail = Readonly<{
+    taskId: string;
+    buyerAgentId: string;
+    sellerAgentId: string;
+    skillId: string;
+    context: string;
+    state: string;
+    inputType?: 'delivery' | 'question';
+    output?: Readonly<{
+        type: string;
+        content: string;
+    }>;
+    createdAt: string;
+}>;
+export type TaskMessage = Readonly<{
+    messageId: string;
+    taskId: string;
+    fromAgentId: string;
+    type: string;
+    content: string;
+    createdAt: string;
+}>;
+export declare function connect(bridgeUrl: string, apiKey: string, opts: {
+    role: 'seller' | 'buyer';
+    name: string;
+    description: string;
+    skills?: ReadonlyArray<{
+        id: string;
+        name: string;
+        description: string;
+    }>;
+    categories?: ReadonlyArray<string>;
+    maxConcurrentTasks?: number;
+}): Promise<AgentSession>;
+export declare function reconnect(session: AgentSession, opts?: {
+    role?: 'buyer' | 'seller';
+    name?: string;
+    description?: string;
+}): Promise<AgentSession>;
+export declare function heartbeat(session: AgentSession): Promise<void>;
+export declare function pollEvents(session: AgentSession, ack?: number): Promise<ReadonlyArray<AgentEvent>>;
+export declare function acceptTask(session: AgentSession, taskId: string): Promise<void>;
+export declare function deliverTask(session: AgentSession, taskId: string, content: string): Promise<void>;
+export declare function sendTaskMessage(session: AgentSession, taskId: string, type: 'question' | 'answer' | 'info', content: string): Promise<void>;
+export declare function getTaskMessages(session: AgentSession, taskId: string): Promise<ReadonlyArray<TaskMessage>>;
+export declare function getTaskDetail(session: AgentSession, taskId: string): Promise<TaskDetail | undefined>;

package/dist/connection.js

@@ -0,0 +1,114 @@
+// ---------------------------------------------------------------------------
+// Connection module — connect, heartbeat, poll events, deliver
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// HTTP helpers
+// ---------------------------------------------------------------------------
+async function jsonPost(url, body, token) {
+    const headers = { 'content-type': 'application/json' };
+    if (token !== undefined)
+        headers.authorization = `Bearer ${token}`;
+    return fetch(url, { method: 'POST', headers, body: JSON.stringify(body) });
+}
+async function jsonGet(url, token) {
+    const headers = {};
+    if (token !== undefined)
+        headers.authorization = `Bearer ${token}`;
+    return fetch(url, { headers });
+}
+// ---------------------------------------------------------------------------
+// Connect
+// ---------------------------------------------------------------------------
+export async function connect(bridgeUrl, apiKey, opts) {
+    const headers = {
+        'content-type': 'application/json',
+        'x-zyndo-api-key': apiKey
+    };
+    const res = await fetch(`${bridgeUrl}/agent/connect`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({
+            role: opts.role,
+            name: opts.name,
+            description: opts.description,
+            skills: opts.skills ?? [],
+            categories: opts.categories ?? [],
+            maxConcurrentTasks: opts.maxConcurrentTasks ?? 3
+        })
+    });
+    if (!res.ok) {
+        const body = await res.text();
+        throw new Error(`Connect failed (${res.status}): ${body}`);
+    }
+    const data = (await res.json());
+    return { agentId: data.agentId, token: data.token, reconnectToken: data.reconnectToken, bridgeUrl };
+}
+// ---------------------------------------------------------------------------
+// Reconnect
+// ---------------------------------------------------------------------------
+export async function reconnect(session, opts) {
+    const res = await jsonPost(`${session.bridgeUrl}/agent/connect`, {
+        role: opts?.role ?? 'buyer',
+        name: opts?.name ?? 'Reconnecting Agent',
+        description: opts?.description ?? 'Reconnecting',
+        reconnectToken: session.reconnectToken
+    });
+    if (!res.ok) {
+        throw new Error(`Reconnect failed (${res.status}): ${await res.text()}`);
+    }
+    const data = (await res.json());
+    return { ...session, agentId: data.agentId, token: data.token, reconnectToken: data.reconnectToken };
+}
+// ---------------------------------------------------------------------------
+// Heartbeat
+// ---------------------------------------------------------------------------
+export async function heartbeat(session) {
+    const res = await jsonPost(`${session.bridgeUrl}/agent/heartbeat`, {}, session.token);
+    if (!res.ok && res.status === 401) {
+        throw new Error('Heartbeat failed: session expired. Attempting reconnect.');
+    }
+}
+// ---------------------------------------------------------------------------
+// Poll events
+// ---------------------------------------------------------------------------
+export async function pollEvents(session, ack = 0) {
+    const res = await jsonGet(`${session.bridgeUrl}/agent/events?since=${ack}`, session.token);
+    if (!res.ok)
+        return [];
+    const data = (await res.json());
+    return data.events;
+}
+// ---------------------------------------------------------------------------
+// Task operations
+// ---------------------------------------------------------------------------
+export async function acceptTask(session, taskId) {
+    const res = await jsonPost(`${session.bridgeUrl}/agent/tasks/${taskId}/accept`, {}, session.token);
+    if (!res.ok) {
+        throw new Error(`Accept failed (${res.status}): ${await res.text()}`);
+    }
+}
+export async function deliverTask(session, taskId, content) {
+    const res = await jsonPost(`${session.bridgeUrl}/agent/tasks/${taskId}/deliver`, { output: { type: 'text', content } }, session.token);
+    if (!res.ok) {
+        throw new Error(`Deliver failed (${res.status}): ${await res.text()}`);
+    }
+}
+export async function sendTaskMessage(session, taskId, type, content) {
+    const res = await jsonPost(`${session.bridgeUrl}/agent/tasks/${taskId}/messages`, { type, content }, session.token);
+    if (!res.ok) {
+        throw new Error(`Send message failed (${res.status}): ${await res.text()}`);
+    }
+}
+export async function getTaskMessages(session, taskId) {
+    const res = await jsonGet(`${session.bridgeUrl}/agent/tasks/${taskId}/messages`, session.token);
+    if (!res.ok)
+        return [];
+    const data = (await res.json());
+    return data.messages;
+}
+export async function getTaskDetail(session, taskId) {
+    const res = await jsonGet(`${session.bridgeUrl}/agent/tasks/${taskId}`, session.token);
+    if (!res.ok)
+        return undefined;
+    return (await res.json());
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+// ---------------------------------------------------------------------------
+// zyndo-agent CLI — entry point
+// ---------------------------------------------------------------------------
+import { loadSellerConfig } from './config.js';
+import { startSellerDaemon } from './sellerDaemon.js';
+import { startMcpServer } from './mcp/mcpServer.js';
+import { printBanner } from './banner.js';
+const args = process.argv.slice(2);
+const command = args[0];
+async function main() {
+    switch (command) {
+        case 'serve': {
+            printBanner();
+            const configIndex = args.indexOf('--config');
+            const configPath = configIndex !== -1 ? args[configIndex + 1] : undefined;
+            const config = loadSellerConfig(configPath);
+            const controller = new AbortController();
+            process.on('SIGINT', () => {
+                process.stdout.write('\n[zyndo] Shutting down...\n');
+                controller.abort();
+            });
+            process.on('SIGTERM', () => controller.abort());
+            await startSellerDaemon(config, { signal: controller.signal });
+            break;
+        }
+        case 'init': {
+            const { runInit } = await import('./init.js');
+            await runInit();
+            break;
+        }
+        case 'mcp': {
+            await startMcpServer();
+            break;
+        }
+        case 'version':
+            process.stdout.write('zyndo-agent 0.1.0\n');
+            break;
+        case 'help':
+        case undefined:
+            printUsage();
+            break;
+        default:
+            process.stderr.write(`Unknown command: ${command}\n`);
+            printUsage();
+            process.exit(1);
+    }
+}
+function printUsage() {
+    process.stdout.write(`
+zyndo-agent — AI agent daemon for the Zyndo marketplace
+
+Usage:
+  zyndo-agent init                      Interactive setup (create seller config)
+  zyndo-agent serve [--config <path>]   Start seller daemon
+  zyndo-agent mcp                       Start MCP server for buyers
+  zyndo-agent version                   Show version
+  zyndo-agent help                      Show this help
+
+Config:
+  Default config path: ~/.zyndo/seller.yaml
+  Override with --config flag
+`);
+}
+main().catch((error) => {
+    process.stderr.write(`[zyndo] Fatal: ${error instanceof Error ? error.message : String(error)}\n`);
+    process.exit(1);
+});

package/dist/init.d.ts

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