@shipers-dev/multi 0.9.4 → 0.9.6

package/dist/index.js

@@ -5703,7 +5703,7 @@ import { join as join3, dirname as dirname2 } from "path";
 // package.json
 var package_default = {
   name: "@shipers-dev/multi",
-  version: "0.9.4",
+  version: "0.9.6",
   type: "module",
   bin: {
     "multi-agent": "./dist/index.js"
@@ -6144,24 +6144,16 @@ async function cmdConnect(apiUrl, config) {
   try {
     writeFileSync3(PORT_PATH, String(port));
   } catch {}
-  const cf = Bun.spawn(["cloudflared", "tunnel", "--no-autoupdate", "--url", `http://127.0.0.1:${port}`], {
-    stdout: "pipe",
-    stderr: "pipe",
-    stdin: "ignore"
-  });
-  const tunnelUrl = await parseTunnelUrl(cf.stderr);
-  if (!tunnelUrl) {
+  let tunnel = await startTunnel(port);
+  if (!tunnel) {
     log("\u274C cloudflared did not emit a tunnel URL \u2014 is `cloudflared` installed? (`brew install cloudflared`)");
-    try {
-      cf.kill();
-    } catch {}
     try {
       server.stop();
     } catch {}
     process.exit(1);
   }
-  log(`\u2601\uFE0F  Tunnel up: ${tunnelUrl}`);
-  await apiClient.post(`${apiUrl}/api/devices/${config.deviceId}/heartbeat`, { status: "online", tunnel_url: tunnelUrl });
+  log(`\u2601\uFE0F  Tunnel up: ${tunnel.url}`);
+  await apiClient.post(`${apiUrl}/api/devices/${config.deviceId}/heartbeat`, { status: "online", tunnel_url: tunnel.url });
   let alive = true;
   const shutdown = async (reason) => {
     if (!alive)
@@ -6172,7 +6164,7 @@ async function cmdConnect(apiUrl, config) {
       server.stop();
     } catch {}
     try {
-      cf.kill();
+      tunnel?.child.kill();
     } catch {}
     try {
       await apiClient.post(`${apiUrl}/api/devices/${config.deviceId}/heartbeat`, { status: "offline", tunnel_url: null });
@@ -6190,19 +6182,102 @@ async function cmdConnect(apiUrl, config) {
   process.on("SIGINT", () => shutdown("SIGINT"));
   process.on("SIGTERM", () => shutdown("SIGTERM"));
   schedule();
+  const restartTunnel = async (reason) => {
+    if (!alive)
+      return;
+    log(`\uD83D\uDD01 Restarting tunnel (${reason})`);
+    try {
+      tunnel?.child.kill();
+    } catch {}
+    for (let attempt = 1;alive; attempt++) {
+      const next = await startTunnel(port);
+      if (next) {
+        tunnel = next;
+        log(`\u2601\uFE0F  Tunnel up: ${tunnel.url}`);
+        try {
+          await apiClient.post(`${apiUrl}/api/devices/${config.deviceId}/heartbeat`, { status: "online", tunnel_url: tunnel.url });
+        } catch (e) {
+          log(`heartbeat error after tunnel restart: ${String(e)}`);
+        }
+        return;
+      }
+      const wait = Math.min(30000, 2000 * attempt);
+      log(`tunnel restart failed, retry in ${wait}ms`);
+      await sleep(wait);
+    }
+  };
+  (async () => {
+    while (alive) {
+      const t = tunnel;
+      if (!t) {
+        await sleep(1000);
+        continue;
+      }
+      const code = await t.child.exited;
+      if (!alive)
+        return;
+      if (tunnel === t)
+        await restartTunnel(`cloudflared exited code=${code}`);
+    }
+  })();
+  let probeFailures = 0;
+  let tick = 0;
+  const PROBE_EVERY = 6;
   while (alive) {
     await sleep(20000);
     if (existsSync3(STOP_PATH)) {
       await shutdown("stop flag");
       break;
     }
+    tick++;
+    const currentUrl = tunnel?.url;
+    if (currentUrl && tick % PROBE_EVERY === 0) {
+      const ok = await probeTunnel(currentUrl);
+      if (!ok) {
+        probeFailures++;
+        log(`tunnel probe failed (${probeFailures}/2): ${currentUrl}`);
+        if (probeFailures >= 2) {
+          probeFailures = 0;
+          await restartTunnel("probe failed 2x");
+          continue;
+        }
+      } else {
+        probeFailures = 0;
+      }
+    }
     try {
-      await apiClient.post(`${apiUrl}/api/devices/${config.deviceId}/heartbeat`, { status: "online", tunnel_url: tunnelUrl });
+      await apiClient.post(`${apiUrl}/api/devices/${config.deviceId}/heartbeat`, { status: "online", tunnel_url: tunnel?.url });
     } catch (e) {
       log(`heartbeat error: ${String(e)}`);
     }
   }
 }
+async function startTunnel(port) {
+  const child = Bun.spawn(["cloudflared", "tunnel", "--no-autoupdate", "--url", `http://127.0.0.1:${port}`], {
+    stdout: "pipe",
+    stderr: "pipe",
+    stdin: "ignore"
+  });
+  const url = await parseTunnelUrl(child.stderr);
+  if (!url) {
+    try {
+      child.kill();
+    } catch {}
+    return null;
+  }
+  return { child, url };
+}
+async function probeTunnel(url) {
+  try {
+    const ctrl = new AbortController;
+    const t = setTimeout(() => ctrl.abort(), 8000);
+    const res = await fetch(url, { method: "GET", signal: ctrl.signal });
+    clearTimeout(t);
+    return res.status > 0;
+  } catch {
+    return false;
+  }
+}
 async function cmdConnectDetached(apiUrl) {
   if (existsSync3(PID_PATH)) {
     const pid = Number(readFileSync3(PID_PATH, "utf8").trim());
@@ -6772,7 +6847,7 @@ ${userPart}` : userPart;
 }
 async function buildPlanningPreamble(apiUrl, task) {
   const depth = typeof task.planning_depth === "number" ? task.planning_depth : 0;
-  if (depth >= 1) {
+  if (depth >= PLANNING_DEPTH_LIMIT) {
     return `# Planning (sub-task context)
 
 You are acting on a sub-issue spawned by another agent. You MAY emit a \`multi-plan\` block to update your own issue's status (e.g. mark done/failed) but CANNOT create child issues or delegate further.
@@ -6817,7 +6892,7 @@ Syntax:
 Rules:
 - Omit the block entirely if no actions are needed.
 - Max 10 actions per turn; additional actions are dropped.
-- Sub-issues spawned from your plan run one-shot: they cannot themselves spawn further children (only \`update\` allowed there).
+- Planning depth is capped at ${PLANNING_DEPTH_LIMIT}: descendants beyond that depth may only \`update\` their own issue.
 - \`create\` defaults \`project_id\` to the current project and \`parent_id\` to the current issue.
 - \`update\` may change title, description, status (todo/in_progress/done/failed), priority, assignee_type, assignee_id.
 - \`delegate\` is shorthand for reassigning and resetting status to todo.
@@ -6845,6 +6920,7 @@ function extractPlanActions(text) {
   return out;
 }
 var PLAN_ACTION_LIMIT = 10;
+var PLANNING_DEPTH_LIMIT = 10;
 async function executePlanActions(apiUrl, parentTask, actions, ctx) {
   const lines = [];
   let truncated = false;
@@ -6853,11 +6929,11 @@ async function executePlanActions(apiUrl, parentTask, actions, ctx) {
     actions = actions.slice(0, PLAN_ACTION_LIMIT);
   }
   const depth = typeof parentTask.planning_depth === "number" ? parentTask.planning_depth : 0;
-  if (depth >= 1) {
+  if (depth >= PLANNING_DEPTH_LIMIT) {
     const blocked = actions.filter((a) => a.type === "create" || a.type === "delegate").length;
     actions = actions.filter((a) => a.type === "update");
     if (blocked)
-      lines.push(`- \u26A0 ${blocked} create/delegate action(s) blocked (planning depth limit)`);
+      lines.push(`- \u26A0 ${blocked} create/delegate action(s) blocked (planning depth limit ${PLANNING_DEPTH_LIMIT})`);
   }
   const parentId = parentTask.issue_id;
   const parentProjectId = await (async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shipers-dev/multi",
-  "version": "0.9.4",
+  "version": "0.9.6",
   "type": "module",
   "bin": {
     "multi-agent": "./dist/index.js"

package/src/index.ts

@@ -432,20 +432,16 @@ async function cmdConnect(apiUrl: string, config: Config) {
   log(`🌐 Local server: http://127.0.0.1:${port}`);
   try { writeFileSync(PORT_PATH, String(port)); } catch {}
 
-  // Spawn cloudflared quick tunnel
-  const cf = Bun.spawn(['cloudflared', 'tunnel', '--no-autoupdate', '--url', `http://127.0.0.1:${port}`], {
-    stdout: 'pipe', stderr: 'pipe', stdin: 'ignore',
-  });
-  const tunnelUrl = await parseTunnelUrl(cf.stderr as ReadableStream<Uint8Array>);
-  if (!tunnelUrl) {
+  // Spawn cloudflared quick tunnel (with self-healing on death)
+  let tunnel = await startTunnel(port);
+  if (!tunnel) {
     log('❌ cloudflared did not emit a tunnel URL — is `cloudflared` installed? (`brew install cloudflared`)');
-    try { cf.kill(); } catch {}
     try { server.stop(); } catch {}
     process.exit(1);
   }
-  log(`☁️  Tunnel up: ${tunnelUrl}`);
+  log(`☁️  Tunnel up: ${tunnel.url}`);
 
-  await apiClient.post(`${apiUrl}/api/devices/${config.deviceId}/heartbeat`, { status: 'online', tunnel_url: tunnelUrl });
+  await apiClient.post(`${apiUrl}/api/devices/${config.deviceId}/heartbeat`, { status: 'online', tunnel_url: tunnel.url });
 
   let alive = true;
 
@@ -454,7 +450,7 @@ async function cmdConnect(apiUrl: string, config: Config) {
     alive = false;
     log(`🛑 Shutting down (${reason})`);
     try { server.stop(); } catch {}
-    try { cf.kill(); } catch {}
+    try { tunnel?.child.kill(); } catch {}
     try { await apiClient.post(`${apiUrl}/api/devices/${config.deviceId}/heartbeat`, { status: 'offline', tunnel_url: null }); } catch {}
     if (existsSync(PID_PATH)) unlinkSync(PID_PATH);
     if (existsSync(STOP_PATH)) unlinkSync(STOP_PATH);
@@ -469,18 +465,97 @@ async function cmdConnect(apiUrl: string, config: Config) {
   // Kick the scheduler on startup to drain any leftover queued rows.
   schedule();
 
-  // Heartbeat loop
+  // Tunnel self-heal: relaunch cloudflared if child exits or DNS stops resolving.
+  const restartTunnel = async (reason: string) => {
+    if (!alive) return;
+    log(`🔁 Restarting tunnel (${reason})`);
+    try { tunnel?.child.kill(); } catch {}
+    // Small backoff so we don't spam cloudflared edge under prolonged outage.
+    for (let attempt = 1; alive; attempt++) {
+      const next = await startTunnel(port);
+      if (next) {
+        tunnel = next;
+        log(`☁️  Tunnel up: ${tunnel.url}`);
+        try {
+          await apiClient.post(`${apiUrl}/api/devices/${config.deviceId}/heartbeat`, { status: 'online', tunnel_url: tunnel.url });
+        } catch (e) {
+          log(`heartbeat error after tunnel restart: ${String(e)}`);
+        }
+        return;
+      }
+      const wait = Math.min(30000, 2000 * attempt);
+      log(`tunnel restart failed, retry in ${wait}ms`);
+      await sleep(wait);
+    }
+  };
+
+  // Watch for cloudflared process exit.
+  (async () => {
+    while (alive) {
+      const t = tunnel;
+      if (!t) { await sleep(1000); continue; }
+      const code = await t.child.exited;
+      if (!alive) return;
+      if (tunnel === t) await restartTunnel(`cloudflared exited code=${code}`);
+    }
+  })();
+
+  // Heartbeat (20s) + tunnel liveness probe (every 6 ticks = ~2min).
+  let probeFailures = 0;
+  let tick = 0;
+  const PROBE_EVERY = 6;
   while (alive) {
     await sleep(20000);
     if (existsSync(STOP_PATH)) { await shutdown('stop flag'); break; }
+    tick++;
+    const currentUrl = tunnel?.url;
+    if (currentUrl && tick % PROBE_EVERY === 0) {
+      const ok = await probeTunnel(currentUrl);
+      if (!ok) {
+        probeFailures++;
+        log(`tunnel probe failed (${probeFailures}/2): ${currentUrl}`);
+        if (probeFailures >= 2) {
+          probeFailures = 0;
+          await restartTunnel('probe failed 2x');
+          continue;
+        }
+      } else {
+        probeFailures = 0;
+      }
+    }
     try {
-      await apiClient.post(`${apiUrl}/api/devices/${config.deviceId}/heartbeat`, { status: 'online', tunnel_url: tunnelUrl });
+      await apiClient.post(`${apiUrl}/api/devices/${config.deviceId}/heartbeat`, { status: 'online', tunnel_url: tunnel?.url });
     } catch (e) {
       log(`heartbeat error: ${String(e)}`);
     }
   }
 }
 
+async function startTunnel(port: number): Promise<{ child: ReturnType<typeof Bun.spawn>; url: string } | null> {
+  const child = Bun.spawn(['cloudflared', 'tunnel', '--no-autoupdate', '--url', `http://127.0.0.1:${port}`], {
+    stdout: 'pipe', stderr: 'pipe', stdin: 'ignore',
+  });
+  const url = await parseTunnelUrl(child.stderr as ReadableStream<Uint8Array>);
+  if (!url) {
+    try { child.kill(); } catch {}
+    return null;
+  }
+  return { child, url };
+}
+
+async function probeTunnel(url: string): Promise<boolean> {
+  try {
+    const ctrl = new AbortController();
+    const t = setTimeout(() => ctrl.abort(), 8000);
+    // Any HTTP response — even 404 — proves the tunnel edge is routing.
+    const res = await fetch(url, { method: 'GET', signal: ctrl.signal });
+    clearTimeout(t);
+    return res.status > 0;
+  } catch {
+    return false;
+  }
+}
+
 async function cmdConnectDetached(apiUrl: string) {
   if (existsSync(PID_PATH)) {
     const pid = Number(readFileSync(PID_PATH, 'utf8').trim());
@@ -972,7 +1047,7 @@ async function handleRunTask(apiUrl: string, deviceId: string, task: any, detect
 // the project, or delegate to other agents.
 async function buildPlanningPreamble(apiUrl: string, task: any): Promise<string> {
   const depth = typeof task.planning_depth === 'number' ? task.planning_depth : 0;
-  if (depth >= 1) {
+  if (depth >= PLANNING_DEPTH_LIMIT) {
     return `# Planning (sub-task context)
 
 You are acting on a sub-issue spawned by another agent. You MAY emit a \`multi-plan\` block to update your own issue's status (e.g. mark done/failed) but CANNOT create child issues or delegate further.
@@ -1017,7 +1092,7 @@ Syntax:
 Rules:
 - Omit the block entirely if no actions are needed.
 - Max 10 actions per turn; additional actions are dropped.
-- Sub-issues spawned from your plan run one-shot: they cannot themselves spawn further children (only \`update\` allowed there).
+- Planning depth is capped at ${PLANNING_DEPTH_LIMIT}: descendants beyond that depth may only \`update\` their own issue.
 - \`create\` defaults \`project_id\` to the current project and \`parent_id\` to the current issue.
 - \`update\` may change title, description, status (todo/in_progress/done/failed), priority, assignee_type, assignee_id.
 - \`delegate\` is shorthand for reassigning and resetting status to todo.
@@ -1048,6 +1123,7 @@ function extractPlanActions(text: string): PlanAction[] {
 }
 
 const PLAN_ACTION_LIMIT = 10;
+const PLANNING_DEPTH_LIMIT = 10;
 
 async function executePlanActions(apiUrl: string, parentTask: any, actions: PlanAction[], ctx: RuntimeCtx): Promise<string> {
   const lines: string[] = [];
@@ -1059,10 +1135,10 @@ async function executePlanActions(apiUrl: string, parentTask: any, actions: Plan
   // Prevent agent recursion: a child turn's plan cannot itself spawn more children.
   // `planning_depth` is carried on each dispatched task (set server-side from issue row).
   const depth = typeof parentTask.planning_depth === 'number' ? parentTask.planning_depth : 0;
-  if (depth >= 1) {
+  if (depth >= PLANNING_DEPTH_LIMIT) {
     const blocked = actions.filter(a => a.type === 'create' || a.type === 'delegate').length;
     actions = actions.filter(a => a.type === 'update');
-    if (blocked) lines.push(`- ⚠ ${blocked} create/delegate action(s) blocked (planning depth limit)`);
+    if (blocked) lines.push(`- ⚠ ${blocked} create/delegate action(s) blocked (planning depth limit ${PLANNING_DEPTH_LIMIT})`);
   }
   const parentId = parentTask.issue_id;
   const parentProjectId = await (async () => {