zyndo 0.1.5 → 0.1.6

package/dist/mcp/mcpCore.d.ts

@@ -13,8 +13,7 @@ export type McpSessionState = {
 };
 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 const WAIT_LONG_POLL_MS = 270000;
 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;

package/dist/mcp/mcpCore.js

@@ -24,7 +24,7 @@ export const TOOLS = [
     },
     {
         name: 'zyndo_browse_sellers',
-        description: 'Browse available seller agents on the Zyndo marketplace. Returns a list of sellers with their skills and descriptions.',
+        description: 'Browse available seller agents on the Zyndo marketplace. Returns a list of sellers, each with skills that include `buyerPriceCents` — the total amount in USD cents your buyer will be charged for that skill (already includes the Zyndo marketplace fee). This is the ONLY price field: quote `buyerPriceCents` verbatim to your human and confirm before calling zyndo_hire.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -86,7 +86,7 @@ export const TOOLS = [
     },
     {
         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.',
+        description: 'Blocks until the seller delivers, asks a question, or the task reaches a terminal state (completed, failed, rejected, canceled). Wakes on the broker event bus, NOT a polling loop. Call this EXACTLY ONCE after zyndo_hire and wait for it to return — do NOT call it in a loop. If it returns state "still-working" after ~4-5 minutes, you may call it again.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -125,8 +125,10 @@ export const TOOLS = [
 // 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;
+// Long-poll window the CLI asks the broker to hold the connection open for.
+// Capped under Railway's 300s idle timeout so the proxy never tears it down
+// mid-wait. See broker /agent/tasks/:id/wait for the server-side cap.
+export const WAIT_LONG_POLL_MS = 270_000;
 // ---------------------------------------------------------------------------
 // Auto-reconnect helpers
 // ---------------------------------------------------------------------------
@@ -356,37 +358,48 @@ async function handleRequestRevision(state, args) {
         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));
+    // ONE long-poll request. The broker holds the connection open and wakes on
+    // the task event bus — no client-side polling loop. The client-side fetch
+    // gets a slightly longer AbortController timeout than the broker's wait
+    // ceiling so we never abort a response that's about to arrive.
+    const controller = new AbortController();
+    const abortTimer = setTimeout(() => controller.abort(), WAIT_LONG_POLL_MS + 10_000);
+    let res;
+    try {
+        res = await fetchWithReconnect(state, (s) => `${state.bridgeUrl}/agent/tasks/${taskId}/wait?timeoutMs=${WAIT_LONG_POLL_MS}`, (s) => ({ headers: { authorization: `Bearer ${s.token}` }, signal: controller.signal }));
+    }
+    catch (err) {
+        clearTimeout(abortTimer);
+        const message = err instanceof Error ? err.message : String(err);
+        return JSON.stringify({ taskId, state: 'still-working', message: `Long-poll interrupted (${message}). Call zyndo_wait_for_completion again to resume waiting.` });
+    }
+    clearTimeout(abortTimer);
+    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) {
+        return JSON.stringify({ error: `Broker returned ${res.status}`, taskId });
+    }
+    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 });
     }
-    return JSON.stringify({ taskId, state: 'still-working', message: 'Task is still in progress. Call zyndo_wait_for_completion again to keep waiting.' });
+    // Broker hit its timeout cap before any state change. Safe for the LLM to
+    // call again — a second call is still ~30x cheaper than the legacy 10s poll.
+    return JSON.stringify({ taskId, state: 'still-working', message: 'Seller is still working. Call zyndo_wait_for_completion again to keep waiting.' });
 }
 // ---------------------------------------------------------------------------
 // Tool dispatch

package/dist/providers/claudeCode.js

@@ -2,7 +2,14 @@
 // Claude Code provider — spawns a CLI harness (claude, codex, or generic)
 // instead of making raw LLM API calls.
 // ---------------------------------------------------------------------------
-import { spawn } from 'node:child_process';
+// Use cross-spawn instead of node:child_process spawn. cross-spawn resolves
+// Windows .cmd/.bat shims (codex.cmd, claude.cmd installed via `npm i -g`)
+// directly to their underlying node entry script, so we can spawn without
+// shell:true. Piping the prompt through node:child_process spawn + shell:true
+// on Windows deadlocks: cmd.exe does not reliably forward stdin EOF to the
+// grandchild node process behind the .cmd shim, and codex blocks forever
+// on `stdin.read()`, hitting our 600s abort.
+import spawn from 'cross-spawn';
 import { basename, join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { randomBytes } from 'node:crypto';
@@ -140,49 +147,6 @@ function parseOutput(raw, harness) {
     return { output: trimmed, paused: false };
 }
 // ---------------------------------------------------------------------------
-// Cross-platform spawn helpers
-// ---------------------------------------------------------------------------
-/**
- * Quote a single arg for cmd.exe. Wraps in double quotes if it contains
- * any whitespace, quote, or shell metacharacter. Internal double quotes are
- * doubled per cmd.exe convention. We only ever pass flag values and paths
- * here (the prompt goes via stdin), so this is sufficient.
- */
-function quoteWinArg(arg) {
-    if (arg === '')
-        return '""';
-    if (!/[\s"&|<>^()]/.test(arg))
-        return arg;
-    return `"${arg.replace(/"/g, '""')}"`;
-}
-/**
- * Spawn a child process. On Windows, builds a single shell-quoted command
- * string and passes shell:true so .cmd / .bat shims (codex.cmd, claude.cmd)
- * resolve correctly. On POSIX, spawns the binary directly with the args
- * array — no shell, no quoting concerns.
- *
- * Avoids Node DEP0190 (the warning fires when you pass shell:true together
- * with an args array, because Node concatenates without escaping).
- */
-function spawnHarness(binary, args, opts) {
-    if (process.platform === 'win32') {
-        const cmdLine = [binary, ...args].map(quoteWinArg).join(' ');
-        return spawn(cmdLine, {
-            cwd: opts.cwd,
-            signal: opts.signal,
-            stdio: ['pipe', 'pipe', 'pipe'],
-            env: opts.env,
-            shell: true
-        });
-    }
-    return spawn(binary, [...args], {
-        cwd: opts.cwd,
-        signal: opts.signal,
-        stdio: ['pipe', 'pipe', 'pipe'],
-        env: opts.env
-    });
-}
-// ---------------------------------------------------------------------------
 // Main entry point
 // ---------------------------------------------------------------------------
 const DEFAULT_TIMEOUT_MS = 600_000; // 10 minutes
@@ -197,19 +161,20 @@ export async function runClaudeCodeTask(taskContext, config, logger) {
     return new Promise((resolve) => {
         const controller = new AbortController();
         const timeoutHandle = setTimeout(() => controller.abort(), timeoutMs);
-        // Windows .cmd shims need shell:true to resolve. spawnHarness builds a
-        // pre-quoted command string for that case so we don't trigger DEP0190
-        // (passing shell:true + args array). On POSIX we spawn directly.
-        const proc = spawnHarness(binary, args, {
+        // cross-spawn handles Windows .cmd/.bat shim resolution without shell:true,
+        // so stdin pipes propagate EOF correctly on both Windows and POSIX. Without
+        // this, Windows + codex.cmd deadlocks because cmd.exe does not forward the
+        // stdin close to the real node child.
+        const proc = spawn(binary, [...args], {
             cwd: config.workingDirectory,
             signal: controller.signal,
+            stdio: ['pipe', 'pipe', 'pipe'],
             env: { ...process.env }
         });
         const stdoutChunks = [];
         const stderrChunks = [];
-        // stdio is always ['pipe','pipe','pipe'] in spawnHarness, so the
-        // streams are guaranteed non-null at runtime. The wrapped return type
-        // does not narrow that, so assert.
+        // stdio is always ['pipe','pipe','pipe'] so the streams are guaranteed
+        // non-null at runtime. The wrapped return type does not narrow that, so assert.
         proc.stdout.on('data', (chunk) => stdoutChunks.push(chunk));
         proc.stderr.on('data', (chunk) => stderrChunks.push(chunk));
         proc.on('error', (err) => {
@@ -252,7 +217,16 @@ export async function runClaudeCodeTask(taskContext, config, logger) {
             }
             resolve(parseOutput(agentOutput, harness));
         });
-        proc.stdin.write(prompt);
+        // Surface stdin write failures loudly. If the child closes its stdin
+        // early (e.g. a shim-resolution regression), silence would mean a 600s
+        // abort with no signal. Logging the error lets us fail fast.
+        proc.stdin.on('error', (err) => {
+            logger.error(`Harness stdin error: ${err.message}`);
+        });
+        proc.stdin.write(prompt, (err) => {
+            if (err)
+                logger.error(`Harness stdin write failed: ${err.message}`);
+        });
         proc.stdin.end();
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zyndo",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "The agent-to-agent CLI tool for sellers in the Zyndo Marketplace",
   "type": "module",
   "license": "MIT",
@@ -35,9 +35,11 @@
     "lint": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
+    "cross-spawn": "^7.0.6",
     "yaml": "^2.7.0"
   },
   "devDependencies": {
+    "@types/cross-spawn": "^6.0.6",
     "@types/node": "^22.12.0",
     "typescript": "^5.7.3",
     "vitest": "^2.1.9"