blitzwing 0.2.2 → 0.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blitzwing",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "Interactive setup wizard to join a Blitzwing Petals mother swarm as a compute contributor",
   "bin": {
     "blitzwing": "bin/blitzwing.js"
@@ -23,7 +23,7 @@
   ],
   "license": "MIT",
   "config": {
-    "discoveryUrl": "http://35.226.124.189:9000"
+    "discoveryUrl": "http://34.60.5.221:9000"
   },
   "dependencies": {
     "@clack/prompts": "^0.9.1",

package/runtime/app.py

@@ -301,6 +301,7 @@ def _prewarm_local_runner() -> None:
 
 @app.on_event("startup")
 def on_startup() -> None:
+    manager.last_exit_code = None
     if manager._auto_start:
         try:
             manager.start(bootstrap=manager.new_swarm)

package/src/config.js

@@ -2,7 +2,7 @@
 export const DEFAULT_DISCOVERY_URL =
   process.env.BLITZWING_DISCOVERY_URL ||
   process.env.npm_package_config_discoveryUrl ||
-  "http://35.226.124.189:9000";
+  "http://34.60.5.221:9000";
 
 export const HOME_DIR = process.env.BLITZWING_HOME || `${process.env.HOME || process.env.USERPROFILE}/.blitzwing`;
 export const STATE_PATH = `${HOME_DIR}/contributor.json`;

package/src/install.js

@@ -10,6 +10,72 @@ const PACKAGE_ROOT = path.join(__dirname, "..");
 const RUNTIME_SRC = path.join(PACKAGE_ROOT, "runtime");
 const RUNTIME_DEST = path.join(HOME_DIR, "runtime");
 
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+/**
+ * Kill leftover contributor shard/Petals processes so a new join does not talk to a
+ * stale uvicorn that still reports last_exit_code=-15 (SIGTERM from a prior leave).
+ */
+export function stopLocalContributorStack(extraPids = []) {
+  for (const pid of extraPids) {
+    if (!pid || !Number.isFinite(Number(pid))) continue;
+    try {
+      process.kill(Number(pid), "SIGTERM");
+    } catch {
+      /* already gone */
+    }
+  }
+
+  if (process.platform === "win32") {
+    for (const port of [SHARD_PORT, PETALS_PORT]) {
+      try {
+        const out = execFileSync("netstat", ["-ano"], { encoding: "utf8" });
+        const re = new RegExp(`:${port}\\s+.*LISTENING\\s+(\\d+)`, "i");
+        const m = out.match(re);
+        if (m) {
+          execFileSync("taskkill", ["/PID", m[1], "/T", "/F"], { stdio: "ignore" });
+        }
+      } catch {
+        /* ignore */
+      }
+    }
+    return;
+  }
+
+  try {
+    execFileSync(
+      "bash",
+      [
+        "-lc",
+        [
+          `fuser -k ${SHARD_PORT}/tcp ${PETALS_PORT}/tcp 2>/dev/null || true`,
+          `pkill -f 'uvicorn app:app --host 0.0.0.0 --port ${SHARD_PORT}' 2>/dev/null || true`,
+          `pkill -f 'petals.cli.run_server' 2>/dev/null || true`,
+          "sleep 1",
+        ].join("; "),
+      ],
+      { stdio: "ignore" }
+    );
+  } catch {
+    /* ignore */
+  }
+}
+
+function petalsLogShowsSessionStart(logPath) {
+  try {
+    if (!fs.existsSync(logPath)) return false;
+    const text = fs.readFileSync(logPath, "utf8");
+    return (
+      /Starting Petals:/.test(text) ||
+      /\[INFO\] Started\b/.test(text) ||
+      /Running a server on/.test(text)
+    );
+  } catch {
+    return false;
+  }
+}
 function venvPython() {
   if (process.platform === "win32") {
     return path.join(VENV_PATH, "Scripts", "python.exe");
@@ -226,7 +292,16 @@ export function writeLocalShardManager() {
 }
 
 export function startShardManagerProcess({ python, env, logPath }) {
+  // Always clear stale listeners before binding — leave() used to stop Petals only.
+  stopLocalContributorStack();
   const appPath = syncRuntimeFiles();
+  fs.mkdirSync(HOME_DIR, { recursive: true });
+  // Fresh logs so wait/error tails are from this session.
+  try {
+    fs.writeFileSync(path.join(HOME_DIR, "petals.log"), "");
+  } catch {
+    /* ignore */
+  }
   const out = fs.openSync(logPath, "a");
   const petalsPy = petalsImportable(venvPython()) ? venvPython() : python;
   const child = spawn(
@@ -253,28 +328,38 @@ export async function waitForShardRunning({ timeoutMs = 300000, statusHost } = {
   const host = statusHost || process.env.BLITZWING_STATUS_HOST || "127.0.0.1";
   const petalsLog = path.join(HOME_DIR, "petals.log");
   const start = Date.now();
+  let sawRunning = false;
+
   while (Date.now() - start < timeoutMs) {
     try {
       const res = await fetch(`http://${host}:${SHARD_PORT}/status`);
       if (res.ok) {
         const body = await res.json();
-        if (body.running && body.pid) return body;
+        if (body.running && body.pid) {
+          sawRunning = true;
+          return body;
+        }
         if (body.last_exit_code != null) {
-          const tail = fs.existsSync(petalsLog)
-            ? fs.readFileSync(petalsLog, "utf8").trim().split("\n").slice(-5).join("\n")
-            : "";
-          throw new Error(
-            `Petals exited (code ${body.last_exit_code}). ${tail || "See " + petalsLog}`
-          );
+          // A prior leave/stop leaves uvicorn up with last_exit_code=-15. Ignore that
+          // until this session's Petals has actually started (or we already saw running).
+          const sessionStarted = petalsLogShowsSessionStart(petalsLog);
+          if (sawRunning || sessionStarted) {
+            const tail = fs.existsSync(petalsLog)
+              ? fs.readFileSync(petalsLog, "utf8").trim().split("\n").slice(-8).join("\n")
+              : "";
+            throw new Error(
+              `Petals exited (code ${body.last_exit_code}). ${tail || "See " + petalsLog}`
+            );
+          }
         }
       }
     } catch (err) {
       if (err instanceof Error && err.message.startsWith("Petals exited")) throw err;
     }
-    await new Promise((r) => setTimeout(r, 2000));
+    await sleep(2000);
   }
   const tail = fs.existsSync(petalsLog)
-    ? fs.readFileSync(petalsLog, "utf8").trim().split("\n").slice(-5).join("\n")
+    ? fs.readFileSync(petalsLog, "utf8").trim().split("\n").slice(-8).join("\n")
     : "";
   throw new Error(
     `Timed out waiting for Petals on http://${host}:${SHARD_PORT}/status. ${tail || "See " + petalsLog}`

package/src/wizard.js

@@ -8,6 +8,7 @@ import {
   ensureVenvAndPetals,
   startShardManagerProcess,
   waitForShardRunning,
+  stopLocalContributorStack,
   syncRuntimeFiles,
   venvPython,
 } from "./install.js";
@@ -283,8 +284,9 @@ async function wizard(args) {
   spin.stop("Petals is serving your layers");
 
   spin.start("Finalizing handoff with mother…");
+  let readyResult;
   try {
-    await readyHost(selected.mother_url, {
+    readyResult = await readyHost(selected.mother_url, {
       host_id: assignment.host_id,
     });
   } catch (err) {
@@ -309,6 +311,7 @@ async function wizard(args) {
     shard_pid: pid,
     discovery_url: args.discoveryUrl,
     hedera_account_id: hederaAccountId,
+    ens_name: readyResult?.ens_name || null,
     joined_at: new Date().toISOString(),
   };
   saveState(state);
@@ -317,8 +320,10 @@ async function wizard(args) {
     hostId: state.host_id,
   });
 
+  const ensLine = state.ens_name ? `ENS name: ${color.cyan(state.ens_name)}\n` : "";
   p.outro(
     `${color.green("You are online.")} Hosting ${color.cyan(String(state.layers_hosted))} layers of ${color.cyan(state.model)} at ${state.block_indices}\n` +
+      ensLine +
       `Tunnel: ${color.cyan(tunnel.url)}\n` +
       `Run ${color.bold("blitzwing status")} anytime, or ${color.bold("blitzwing leave")} to exit.`
   );
@@ -338,6 +343,7 @@ async function showStatus() {
   console.log(`  mother:         ${state.mother_url}`);
   console.log(`  tunnel:         ${state.tunnel_url || state.shard_manager_url || "—"}`);
   console.log(`  hedera:         ${state.hedera_account_id || "—"}`);
+  console.log(`  ens_name:       ${state.ens_name || "—"}`);
   try {
     const res = await fetch(`http://127.0.0.1:${SHARD_PORT}/status`);
     if (res.ok) {
@@ -370,6 +376,7 @@ async function doLeave() {
   } catch {
     /* ignore */
   }
+  stopLocalContributorStack([state.shard_pid, state.tunnel_pid].filter(Boolean));
   if (state.tunnel_pid) {
     stopTunnelProcess(state.tunnel_pid);
   }