zyndo 0.1.8 → 0.2.0

package/dist/sellerDaemon.d.ts

@@ -1,4 +1,17 @@
 import type { SellerConfig } from './config.js';
+/** Parse "Reconnect failed (NNN): ..." and return the status code or undefined. */
+export declare function parseReconnectErrorStatus(err: unknown): number | undefined;
+/**
+ * Permanent failures that will never succeed on retry: 400 (schema/validation
+ * error — the CLI payload itself is wrong for this broker), 404 (endpoint
+ * gone), 410 (reconnectToken invalid/expired — the broker explicitly told us
+ * to stop trying and start fresh).
+ *
+ * Transient failures worth retrying: 401 (may be a race with key rotation),
+ * 408/429/5xx, and everything else (including network errors where the status
+ * could not be parsed).
+ */
+export declare function isPermanentReconnectFailure(err: unknown): boolean;
 export type DaemonLogger = Readonly<{
     info: (msg: string) => void;
     error: (msg: string) => void;

package/dist/sellerDaemon.js

@@ -16,6 +16,44 @@ import { createAskBuyerTool } from './tools/askBuyer.js';
 import { loadState, saveState, deleteState, loadSession, saveSession } from './state.js';
 const POLL_INTERVAL_MS = 25_000;
 const HEARTBEAT_INTERVAL_MS = 45_000;
+// ---------------------------------------------------------------------------
+// Reconnect error classification (incident 2026-04-09 follow-up)
+//
+// When a reconnect attempt fails, we need to distinguish transient failures
+// (network blip, 5xx, 401 on a rotated key) from permanent ones (4xx schema
+// validation, 410 reconnect-token invalid). Transient failures should be
+// retried with exponential backoff. Permanent failures should NOT be retried
+// — instead the daemon should fall through to a fresh connect with the full
+// registration payload (skills, categories, etc.) so the seller stays online.
+//
+// Before this classification, a permanent 400 ("Sellers must register at
+// least one skill") would retry 5x, fail, continue the outer loop, and hit
+// the same 400 on the next heartbeat cycle forever.
+// ---------------------------------------------------------------------------
+/** Parse "Reconnect failed (NNN): ..." and return the status code or undefined. */
+export function parseReconnectErrorStatus(err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    const match = /Reconnect failed \((\d{3})\)/.exec(msg);
+    if (match === null)
+        return undefined;
+    return Number.parseInt(match[1], 10);
+}
+/**
+ * Permanent failures that will never succeed on retry: 400 (schema/validation
+ * error — the CLI payload itself is wrong for this broker), 404 (endpoint
+ * gone), 410 (reconnectToken invalid/expired — the broker explicitly told us
+ * to stop trying and start fresh).
+ *
+ * Transient failures worth retrying: 401 (may be a race with key rotation),
+ * 408/429/5xx, and everything else (including network errors where the status
+ * could not be parsed).
+ */
+export function isPermanentReconnectFailure(err) {
+    const status = parseReconnectErrorStatus(err);
+    if (status === undefined)
+        return false;
+    return status === 400 || status === 404 || status === 410;
+}
 const defaultLogger = {
     info: (msg) => process.stdout.write(`[zyndo] ${msg}\n`),
     error: (msg) => process.stderr.write(`[zyndo] ERROR: ${msg}\n`)
@@ -104,14 +142,16 @@ export async function startSellerDaemon(config, opts) {
                 }
                 catch {
                     logger.info('Heartbeat failed, attempting reconnect...');
-                    // Bounded retry with exponential backoff. Previously a single
-                    // reconnect failure would `break` out of the main loop and kill
-                    // the daemon mid-task. A transient network blip or 401 is now
-                    // survivable — we retry up to 5 times (2s/4s/8s/16s/32s) before
-                    // giving up and restarting the outer loop iteration. If the
-                    // signal is aborted, exit cleanly. Incident 2026-04-09.
+                    // Retry strategy (incident 2026-04-09):
+                    //  - Transient failures (5xx, 401, network blip): retry up to 5x
+                    //    with 2/4/8/16/32s backoff.
+                    //  - Permanent failures (400/404/410): abort retry immediately
+                    //    and fall through to a FRESH connect that re-registers skills.
+                    //    This handles the "Sellers must register at least one skill"
+                    //    endless-loop bug and the 410 reconnectToken-invalid case.
                     const backoffs = [2_000, 4_000, 8_000, 16_000, 32_000];
                     let reconnected = false;
+                    let permanent = false;
                     for (let attempt = 0; attempt < backoffs.length; attempt += 1) {
                         if (signal !== undefined && signal.aborted)
                             break;
@@ -129,16 +169,45 @@ export async function startSellerDaemon(config, opts) {
                         }
                         catch (reconnectError) {
                             const msg = reconnectError instanceof Error ? reconnectError.message : String(reconnectError);
+                            if (isPermanentReconnectFailure(reconnectError)) {
+                                logger.error(`Reconnect permanently failed (${msg}). Falling through to fresh registration.`);
+                                permanent = true;
+                                break;
+                            }
                             logger.error(`Reconnect attempt ${attempt + 1}/${backoffs.length} failed: ${msg}`);
                             if (attempt < backoffs.length - 1) {
                                 await new Promise((resolve) => setTimeout(resolve, backoffs[attempt]));
                             }
                         }
                     }
-                    if (!reconnected) {
+                    if (!reconnected && permanent && (signal === undefined || !signal.aborted)) {
+                        // Permanent reconnect failure — re-register from scratch so the
+                        // daemon stays alive. The new agentId will be different; the
+                        // broker's account-scoped identity lookup (Fix C) should map
+                        // the user's API key back to the same stable seller agentId.
+                        try {
+                            logger.info(`Re-registering as seller "${config.name}"...`);
+                            session = await connect(config.bridgeUrl, config.apiKey, {
+                                role: 'seller',
+                                name: config.name,
+                                description: config.description,
+                                skills: [...config.skills],
+                                categories: [...config.categories],
+                                maxConcurrentTasks: config.maxConcurrentTasks
+                            });
+                            saveSession(session.agentId, session.reconnectToken);
+                            logger.info(`Re-registered: agentId=${session.agentId}`);
+                            lastHeartbeat = Date.now();
+                            reconnected = true;
+                        }
+                        catch (freshErr) {
+                            const msg = freshErr instanceof Error ? freshErr.message : String(freshErr);
+                            logger.error(`Fresh re-registration failed: ${msg}. Will retry on next heartbeat cycle.`);
+                            lastHeartbeat = Date.now();
+                        }
+                    }
+                    if (!reconnected && !permanent) {
                         logger.error('All reconnect attempts exhausted. Will retry on next heartbeat cycle.');
-                        // Reset the heartbeat clock so we don't spin on reconnect —
-                        // wait a full HEARTBEAT_INTERVAL_MS before trying again.
                         lastHeartbeat = Date.now();
                     }
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zyndo",
-  "version": "0.1.8",
+  "version": "0.2.0",
   "description": "The agent-to-agent CLI tool for sellers in the Zyndo Marketplace",
   "type": "module",
   "license": "MIT",