@runeya/runeya 2.0.69 → 2.0.71

package/agent-manager-UUSQK6S2.js

@@ -0,0 +1,7 @@
+import {
+  agentManager
+} from "./chunk-Z3KAXI7V.js";
+export {
+  agentManager
+};
+//# sourceMappingURL=agent-manager-UUSQK6S2.js.map

package/{chunk-YSJ6OJGN.js → chunk-Z3KAXI7V.js}

@@ -1,7 +1,7 @@
 // ../server/src/services/agent-manager.ts
 import { EventEmitter as EventEmitter2 } from "events";
 import WebSocket2 from "ws";
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 
 // ../server/src/services/agent-store.ts
 import { randomUUID, randomBytes, createCipheriv, createDecipheriv } from "crypto";
@@ -3095,8 +3095,187 @@ var serviceStore = new ServiceStore();
 import { spawn } from "child_process";
 import { createInterface } from "readline";
 import { watch } from "fs";
-import { dirname as dirname2, join as join5 } from "path";
+import { dirname as dirname2, join as join6 } from "path";
 import { fileURLToPath } from "url";
+
+// ../server/src/services/instance-registry.ts
+import { mkdir as mkdir5, readdir as readdir2, readFile as readFile5, writeFile as writeFile5, rm as rm3 } from "fs/promises";
+import { join as join5 } from "path";
+import { z as z21 } from "zod";
+var InstanceFileSchema = z21.object({
+  pid: z21.number().int().positive(),
+  /**
+   * The agent this server spawned, when it has one.
+   *
+   * Optional because an instance started before this field existed never wrote
+   * it, and because the agent may not be up yet — or at all, when the
+   * encryption key is missing. Absent means « unknown », never « none ».
+   */
+  agentPid: z21.number().int().positive().optional(),
+  port: z21.number().int().min(1).max(65535),
+  agentPort: z21.number().int().min(1).max(65535),
+  cwd: z21.string().max(4096),
+  dataDir: z21.string().max(4096),
+  version: z21.string().max(64),
+  fromDesktop: z21.boolean(),
+  startedAt: z21.number().int().nonnegative()
+});
+function registryDir() {
+  return join5(machineRoot(), "instances");
+}
+function fileFor(pid) {
+  return join5(registryDir(), `${pid}.json`);
+}
+var published = null;
+function selfRecord() {
+  return {
+    pid: process.pid,
+    port: env.PORT,
+    agentPort: env.RUNEYA_AGENT_PORT,
+    cwd: process.cwd(),
+    dataDir: env.DATA_DIR,
+    version: process.env["RUNEYA_VERSION"] ?? "unknown",
+    fromDesktop: env.FROM_DESKTOP,
+    startedAt: Date.now()
+  };
+}
+async function registerInstance() {
+  try {
+    await mkdir5(registryDir(), { recursive: true });
+    published = selfRecord();
+    await writeFile5(fileFor(process.pid), JSON.stringify(published, null, 2));
+  } catch (err) {
+    console.log("[instances] Could not register this instance:", err.message);
+  }
+}
+async function unregisterInstance() {
+  await rm3(fileFor(process.pid), { force: true }).catch(() => {
+  });
+}
+async function setInstanceAgentPid(agentPid) {
+  if (!published) return;
+  published = { ...published, agentPid: agentPid ?? void 0 };
+  try {
+    await writeFile5(fileFor(process.pid), JSON.stringify(published, null, 2));
+  } catch {
+  }
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+async function probe(port) {
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/api/trpc/health.check`, {
+      signal: AbortSignal.timeout(1500)
+    });
+    if (!res.ok) return { ok: false, uptimeMs: null, version: null };
+    const body = await res.json();
+    const data = body.result?.data;
+    return { ok: true, uptimeMs: data?.uptime ?? null, version: data?.version ?? null };
+  } catch {
+    return { ok: false, uptimeMs: null, version: null };
+  }
+}
+async function listInstances() {
+  let files;
+  try {
+    files = await readdir2(registryDir());
+  } catch {
+    return [];
+  }
+  const found = await Promise.all(
+    files.filter((f) => f.endsWith(".json")).map(async (name) => {
+      const path = join5(registryDir(), name);
+      let record;
+      try {
+        const parsed = InstanceFileSchema.safeParse(JSON.parse(await readFile5(path, "utf8")));
+        if (!parsed.success) {
+          await rm3(path, { force: true }).catch(() => {
+          });
+          return null;
+        }
+        record = parsed.data;
+      } catch {
+        return null;
+      }
+      if (!isProcessAlive(record.pid)) {
+        await rm3(path, { force: true }).catch(() => {
+        });
+        return null;
+      }
+      const { ok, uptimeMs, version } = await probe(record.port);
+      if (!ok) {
+        await rm3(path, { force: true }).catch(() => {
+        });
+        return null;
+      }
+      return {
+        ...record,
+        // Trust the live answer over the file: the file was written at boot
+        // and an upgraded instance would keep claiming its old version.
+        version: version ?? record.version,
+        reachable: true,
+        current: record.pid === process.pid,
+        uptimeMs
+      };
+    })
+  );
+  return dedupeByPort(found.filter((i) => i !== null)).sort((a, b) => Number(b.current) - Number(a.current) || a.port - b.port);
+}
+function dedupeByPort(instances) {
+  const byPort = /* @__PURE__ */ new Map();
+  for (const instance of instances) {
+    const kept = byPort.get(instance.port);
+    if (!kept || instance.current || !kept.current && instance.startedAt > kept.startedAt) {
+      byPort.set(instance.port, instance);
+    }
+  }
+  return [...byPort.values()];
+}
+var GRACE_MS = 5e3;
+var POLL_MS = 100;
+async function terminate(pid) {
+  if (!isProcessAlive(pid)) return "absent";
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch (err) {
+    const code = err.code;
+    if (code === "ESRCH") return "absent";
+    if (code === "EPERM") return "denied";
+    return "failed";
+  }
+  const deadline = Date.now() + GRACE_MS;
+  while (Date.now() < deadline) {
+    await new Promise((resolve) => setTimeout(resolve, POLL_MS));
+    if (!isProcessAlive(pid)) return "terminated";
+  }
+  try {
+    process.kill(pid, "SIGKILL");
+  } catch (err) {
+    return err.code === "ESRCH" ? "terminated" : "failed";
+  }
+  await new Promise((resolve) => setTimeout(resolve, POLL_MS));
+  return isProcessAlive(pid) ? "failed" : "killed";
+}
+async function killInstance(pid) {
+  const target = (await listInstances()).find((i) => i.pid === pid);
+  if (!target) throw new Error("instance-not-found");
+  if (target.current) throw new Error("instance-is-current");
+  const agent = target.agentPid ? await terminate(target.agentPid) : "absent";
+  const server = await terminate(pid);
+  if (server === "terminated" || server === "killed") {
+    await rm3(fileFor(pid), { force: true }).catch(() => {
+    });
+  }
+  return { agent, server };
+}
+
+// ../server/src/services/agent-spawner.ts
 var POSIX_SAFE_KEYS = [
   "PATH",
   "HOME",
@@ -3212,11 +3391,12 @@ var AgentSpawner = class {
     }
     console.log(`[agent-spawner] Spawning local agent on ${agentUrl}...`);
     const isDev = process.env.NODE_ENV === "development";
-    this.agentDistPath = env.AGENT_BINARY_PATH || join5(dirname2(fileURLToPath(import.meta.url)), "..", "..", "agent", "dist", "index.js");
+    this.agentDistPath = env.AGENT_BINARY_PATH || join6(dirname2(fileURLToPath(import.meta.url)), "..", "..", "agent", "dist", "index.js");
     this.agentProcess = spawn("node", [this.agentDistPath], {
       env: agentEnv,
       stdio: ["ignore", "pipe", "pipe"]
     });
+    void setInstanceAgentPid(this.agentProcess.pid ?? null);
     if (isDev) {
       this.setupFileWatcher();
     }
@@ -3299,6 +3479,7 @@ var AgentSpawner = class {
         setTimeout(resolve, 2e3);
       });
       this.agentProcess = null;
+      void setInstanceAgentPid(null);
     }
   }
   getLocalAgentId() {
@@ -3315,7 +3496,7 @@ var AgentSpawner = class {
       this.fileWatcher.close();
     }
     console.log("[agent-spawner] \u{1F50D} Watching agent dist for changes (hot reload enabled)");
-    const distDir = join5(this.agentDistPath, "..");
+    const distDir = join6(this.agentDistPath, "..");
     this.fileWatcher = watch(distDir, { persistent: false }, (eventType, filename) => {
       if ((eventType === "change" || eventType === "rename") && filename === "index.js" && !this.isRestarting) {
         this.isRestarting = true;
@@ -3624,13 +3805,13 @@ var AgentWSBridge = class extends EventEmitter {
 };
 
 // ../server/src/services/agent-manager.ts
-var HealthMessageSchema = z21.object({
-  status: z21.string(),
-  uptime: z21.number(),
-  runnersAvailable: z21.array(z21.enum(["native", "docker"])),
-  processCount: z21.number(),
-  runningCount: z21.number(),
-  lanIp: z21.string().optional()
+var HealthMessageSchema = z22.object({
+  status: z22.string(),
+  uptime: z22.number(),
+  runnersAvailable: z22.array(z22.enum(["native", "docker"])),
+  processCount: z22.number(),
+  runningCount: z22.number(),
+  lanIp: z22.string().optional()
 });
 var MIN_RECONNECT_DELAY = WS_RECONNECT_MIN;
 var MAX_RECONNECT_DELAY = WS_RECONNECT_MAX;
@@ -4184,8 +4365,12 @@ export {
   environmentStore,
   serviceStore,
   agentStore,
+  registerInstance,
+  unregisterInstance,
+  listInstances,
+  killInstance,
   agentSpawner,
   traefikManager,
   agentManager
 };
-//# sourceMappingURL=chunk-YSJ6OJGN.js.map
+//# sourceMappingURL=chunk-Z3KAXI7V.js.map