ework-aio 0.5.1 → 0.5.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ework-aio",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "description": "All-in-one installer for ework (issue tracker) + ework-daemon (AI bridge) + opencode-ework (plugin). One command: npm i -g ework-aio && ework-aio install.",
   "type": "module",
   "license": "MIT",
@@ -47,7 +47,7 @@
   },
   "dependencies": {
     "ework-daemon": "^0.4.1",
-    "ework-web": "^0.7.0",
+    "ework-web": "^0.8.0",
     "opencode-ework": "^0.1.0",
     "zod": "^3.23.0"
   },

package/scripts/e2e-install.sh

@@ -709,6 +709,127 @@ case "$DELIVERIES_CODE" in
     ;;
 esac
 
+# Phase 7: multi-daemon coordination (requires MySQL shared DB)
+# -----------------------------------------------------------------------------
+if grep -q 'WORK_DB_DRIVER=mysql' "$DATA_DIR/ework-daemon/.env" 2>/dev/null; then
+echo
+echo "====================================================="
+echo "Phase 7: multi-daemon coordination"
+echo "====================================================="
+
+info "restarting daemon A on MySQL (ework-aio restart may not reload .env)"
+info "daemon .env WORK_DB_* lines:"
+grep WORK_DB "$DATA_DIR/ework-daemon/.env" 2>/dev/null || echo "  (none found)"
+ework-aio stop daemon --data-dir "$DATA_DIR" 2>&1 | tail -1
+sleep 1
+ework-aio start daemon --data-dir "$DATA_DIR" 2>&1 | tail -2
+sleep 3
+timeout 3 curl -sf "http://127.0.0.1:$DAEMON_PORT/healthz" >/dev/null 2>&1 \
+  || fail "daemon A did not respond after restart"
+DAEMON_A_DB=$(grep '"msg":"  db:' "$DATA_DIR/run/daemon.log" 2>/dev/null | tail -1 | sed 's/.*"msg":"//' | sed 's/".*//' || echo "?")
+info "daemon A startup log: $DAEMON_A_DB"
+[[ "$DAEMON_A_DB" == *"3312"* || "$DAEMON_A_DB" == *"mysql"* ]] \
+  || fail "daemon A is NOT on MySQL (log: $DAEMON_A_DB) — coordination requires shared DB"
+pass "daemon A on MySQL"
+
+DAEMON2_PORT=$((DAEMON_PORT + 1))
+DAEMON2_DIR="$DATA_DIR/ework-daemon-2"
+DAEMON2_BIN="$(npm root -g)/ework-aio/node_modules/ework-daemon/bin/ework-daemon-server.js"
+
+mkdir -p "$DAEMON2_DIR"
+cp "$DATA_DIR/ework-daemon/.env" "$DAEMON2_DIR/.env"
+sed -i "s/^DAEMON_PORT=.*/DAEMON_PORT=$DAEMON2_PORT/" "$DAEMON2_DIR/.env"
+echo "WORK_DAEMON_LEASE_TTL_MS=15000" >> "$DAEMON2_DIR/.env"
+
+info "starting daemon B on port $DAEMON2_PORT (short TTL=15s for failover test)"
+( set -a; . "$DAEMON2_DIR/.env" 2>/dev/null; set +a
+  cd "$DAEMON2_DIR"
+  DAEMON_PORT=$DAEMON2_PORT WORK_DAEMON_LEASE_TTL_MS=15000 \
+  exec bun "$DAEMON2_BIN" >> "$DATA_DIR/run/daemon-2.log" 2>&1 ) &
+DAEMON2_PID=$!
+
+for i in $(seq 1 15); do
+  curl -sf "http://127.0.0.1:$DAEMON2_PORT/healthz" >/dev/null 2>&1 && break
+  sleep 1
+done
+curl -sf "http://127.0.0.1:$DAEMON2_PORT/healthz" >/dev/null 2>&1 \
+  || { echo "=== daemon-2.log ==="; cat "$DATA_DIR/run/daemon-2.log" 2>/dev/null | tail -20; echo "=== bin check ==="; ls -la "$DAEMON2_BIN" 2>&1; fail "daemon B did not start on port $DAEMON2_PORT"; }
+pass "daemon B started (pid $DAEMON2_PID, port $DAEMON2_PORT)"
+
+info "daemon B startup config:"
+head -8 "$DATA_DIR/run/daemon-2.log" 2>/dev/null | while read -r line; do echo "  $line"; done
+
+WEBHOOK_SECRET=$(grep GITEA_WEBHOOK_SECRET "$DATA_DIR/ework-daemon/.env" 2>/dev/null | cut -d= -f2)
+
+make_hook() {
+  local payload="$1"
+  if [[ -n "$WEBHOOK_SECRET" ]]; then
+    local sig=$(printf '%s' "$payload" | openssl dgst -sha256 -hmac "$WEBHOOK_SECRET" -hex | awk '{print $NF}')
+    echo "-H x-gitea-signature:$sig"
+  fi
+}
+
+info "test 1: no-double-spawn — send identical webhook to both daemons"
+ISSUE_HOOK='{"action":"opened","issue":{"number":888,"title":"multi-daemon test","body":"coordination","state":"open","user":{"login":"e2e"}},"repository":{"owner":{"login":"e2e"},"name":"test"}}'
+HOOK_HDR=$(make_hook "$ISSUE_HOOK")
+
+timeout 5 curl -sS -o /dev/null -X POST "http://127.0.0.1:$DAEMON_PORT/webhook/gitea" \
+  -H "Content-Type: application/json" $HOOK_HDR -d "$ISSUE_HOOK" 2>/dev/null || true
+timeout 5 curl -sS -o /dev/null -X POST "http://127.0.0.1:$DAEMON2_PORT/webhook/gitea" \
+  -H "Content-Type: application/json" $HOOK_HDR -d "$ISSUE_HOOK" 2>/dev/null || true
+sleep 3
+
+A_SPAWNED=$(grep -c 'session.*created.*888\|observer started.*888' "$DATA_DIR/run/daemon.log" 2>/dev/null); A_SPAWNED=${A_SPAWNED:-0}
+B_SPAWNED=$(grep -c 'session.*created.*888\|observer started.*888' "$DATA_DIR/run/daemon-2.log" 2>/dev/null); B_SPAWNED=${B_SPAWNED:-0}
+TOTAL=$((A_SPAWNED + B_SPAWNED))
+info "daemon A spawned=$A_SPAWNED  daemon B spawned=$B_SPAWNED  total=$TOTAL"
+[[ "$TOTAL" -eq 2 ]] \
+  || { echo "--- daemon A 888 lines ---"; grep '888' "$DATA_DIR/run/daemon.log" 2>/dev/null | tail -5; echo "--- daemon B 888 lines ---"; grep '888' "$DATA_DIR/run/daemon-2.log" 2>/dev/null | tail -5; fail "no-double-spawn failed: expected 2 log lines (1 spawn), got $TOTAL"; }
+pass "no-double-spawn: exactly 1 daemon spawned for issue 888"
+
+info "test 2: failover — kill owner, verify survivor takes over"
+if [[ "$A_SPAWNED" -eq 1 ]]; then
+  OWNER_PID=$(cat "$DATA_DIR/run/daemon.pid" 2>/dev/null)
+  SURVIVOR_PORT=$DAEMON2_PORT
+  SURVIVOR_LOG="$DATA_DIR/run/daemon-2.log"
+else
+  OWNER_PID=$DAEMON2_PID
+  SURVIVOR_PORT=$DAEMON_PORT
+  SURVIVOR_LOG="$DATA_DIR/run/daemon.log"
+fi
+
+info "killing owner (pid $OWNER_PID)"
+kill "$OWNER_PID" 2>/dev/null
+sleep 1
+pass "owner killed"
+
+info "waiting 18s for lease expiry (TTL=15s)..."
+sleep 18
+
+COMMENT_HOOK='{"action":"created","issue":{"number":888,"title":"multi-daemon test","body":"coordination","state":"open","user":{"login":"e2e"}},"comment":{"id":99999,"body":"failover test","user":{"login":"e2e"}},"repository":{"owner":{"login":"e2e"},"name":"test"}}'
+COMMENT_HDR=$(make_hook "$COMMENT_HOOK")
+
+info "sending comment webhook to survivor (port $SURVIVOR_PORT)"
+timeout 5 curl -sS -o /dev/null -X POST "http://127.0.0.1:$SURVIVOR_PORT/webhook/gitea" \
+  -H "Content-Type: application/json" $COMMENT_HDR -d "$COMMENT_HOOK" 2>/dev/null || true
+sleep 3
+
+SURVIVOR_CLAIMED=$(grep -c "observer started.*888\|session.*created.*888\|claimed.*888\|absorb" "$SURVIVOR_LOG" 2>/dev/null | tail -1 || echo 0)
+SURVIVOR_CLAIMED_AFTER=$(grep "observer started.*888\|session.*created.*888" "$SURVIVOR_LOG" 2>/dev/null | wc -l || echo 0)
+info "survivor log shows $SURVIVOR_CLAIMED_AFTER session creation(s) for 888"
+[[ "$SURVIVOR_CLAIMED_AFTER" -ge 1 ]] \
+  || fail "failover failed: survivor did not claim issue 888"
+pass "failover: survivor claimed issue 888"
+
+info "cleanup: stop daemon B + restart main daemon"
+kill "$DAEMON2_PID" 2>/dev/null
+ework-aio start daemon --data-dir "$DATA_DIR" 2>&1 | tail -3
+sleep 2
+
+else
+  info "skipping Phase 7 (multi-daemon requires MySQL)"
+fi
+
 # Phase 6: uninstall
 # -----------------------------------------------------------------------------
 echo

package/src/cli.ts

@@ -31,6 +31,7 @@ import {
 } from "./commands/lifecycle.ts";
 import { runLogs } from "./commands/logs.ts";
 import { runEnv } from "./commands/env.ts";
+import { runAddDaemon } from "./commands/add-daemon.ts";
 import {
   runConfig,
   printConfigHelp,
@@ -67,6 +68,7 @@ Commands:
   start [web|daemon|both]         Start services in PID-file mode (default both)
   stop [web|daemon|both]          Stop services (SIGTERM, 5s grace, then SIGKILL)
   restart [web|daemon|both]       Stop + start
+  add-daemon [port]               Start an additional daemon instance
   ps                              Show PID-file mode status (alias for 'status')
 
   migrate [options]               Migrate issues from a Gitea instance
@@ -480,6 +482,16 @@ export async function main(
         await runRestart(opts, logger, target);
         return 0;
       }
+      case "add-daemon": {
+        const port = positionals[1] ? Number.parseInt(positionals[1], 10) : undefined;
+        if (port !== undefined && (!Number.isFinite(port) || port <= 0 || port > 65535)) {
+          throw new InstallError(
+            `add-daemon: invalid port '${positionals[1]}' (must be 1-65535)`,
+          );
+        }
+        await runAddDaemon(opts, logger, port);
+        return 0;
+      }
       case "migrate": {
         return runDelegateScript("migrate-from-gitea.ts", argv.slice(1));
       }

package/src/commands/add-daemon.ts

@@ -0,0 +1,86 @@
+import path from "node:path";
+import { mkdirSync } from "node:fs";
+import { Logger, InstallError } from "../log.ts";
+import { resolvePaths, daemonInstancePaths } from "../paths.ts";
+import { parseEnvFile, serializeEnvFile, writeEnvFileAtomic } from "../env.ts";
+import { startFromSp, type ServicePaths } from "./lifecycle.ts";
+import type { GlobalOptions } from "../types.ts";
+
+export async function runAddDaemon(
+  opts: GlobalOptions,
+  logger: Logger,
+  port?: number,
+): Promise<void> {
+  const paths = resolvePaths({
+    dataDir: opts.dataDir,
+    scope: opts.scope,
+    useSystemd: false,
+  });
+  const instances = daemonInstancePaths(paths.dataDir, paths.runDir);
+  const primary = instances.find((i) => i.num === 1);
+  if (!primary) {
+    throw new InstallError(
+      `No primary daemon found at ${paths.daemonDataDir}. Run 'ework-aio install' first.`,
+    );
+  }
+
+  let primaryContent: string;
+  try {
+    primaryContent = await Bun.file(primary.envFile).text();
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code === "ENOENT") {
+      throw new InstallError(
+        `Primary daemon .env not found at ${primary.envFile}. Run 'ework-aio install' first.`,
+      );
+    }
+    throw err;
+  }
+
+  const parsed = parseEnvFile(primaryContent);
+  const basePortStr = parsed.entries.get("DAEMON_PORT");
+  const basePort = basePortStr ? Number.parseInt(basePortStr, 10) : NaN;
+  if (!Number.isFinite(basePort)) {
+    throw new InstallError(
+      `Primary daemon .env has no valid DAEMON_PORT (got '${basePortStr ?? "<unset>"}')`,
+    );
+  }
+  const newPort = port ?? (basePort + instances.length);
+
+  const nextNum = instances.length + 1;
+  const newDataDir = nextNum === 1
+    ? paths.daemonDataDir
+    : path.join(paths.dataDir, `ework-daemon-${nextNum}`);
+  const newEnvFile = path.join(newDataDir, ".env");
+  const newPidFile = path.join(paths.runDir, `daemon-${nextNum}.pid`);
+  const newLogFile = path.join(paths.runDir, `daemon-${nextNum}.log`);
+
+  mkdirSync(newDataDir, { recursive: true });
+
+  const patchedRaw = parsed.rawLines.map((line) => {
+    const eqIdx = line.indexOf("=");
+    if (eqIdx === -1) return line;
+    if (line.slice(0, eqIdx).trim().startsWith("#")) return line;
+    if (line.slice(0, eqIdx).trim() === "DAEMON_PORT") {
+      return `DAEMON_PORT=${newPort}`;
+    }
+    return line;
+  });
+  const body = serializeEnvFile(
+    { entries: parsed.entries, rawLines: patchedRaw },
+    [],
+  );
+  await writeEnvFileAtomic(newEnvFile, body);
+
+  const sp: ServicePaths = {
+    bin: "ework-daemon-server",
+    pkg: "ework-daemon",
+    binRelPath: "bin/ework-daemon-server.js",
+    dataDir: newDataDir,
+    envFile: newEnvFile,
+    pidFile: newPidFile,
+    logFile: newLogFile,
+    portKey: "DAEMON_PORT",
+  };
+  const label = `daemon-${nextNum}`;
+  await startFromSp(sp, label, logger);
+}

package/src/commands/lifecycle.ts

@@ -9,7 +9,12 @@
 // responding" without having to curl themselves).
 
 import { Logger, InstallError } from "../log.ts";
-import { resolvePaths, type PathConfig } from "../paths.ts";
+import {
+  resolvePaths,
+  daemonInstancePaths,
+  type PathConfig,
+  type DaemonInstance,
+} from "../paths.ts";
 import {
   startProcess,
   stopProcess,
@@ -20,7 +25,7 @@ import { parseEnvFile } from "../env.ts";
 import { resolveCommand, resolveBundledBin } from "../preflight.ts";
 import type { GlobalOptions, ServiceTarget } from "../types.ts";
 
-interface ServicePaths {
+export interface ServicePaths {
   bin: string;
   pkg: string;
   binRelPath: string;
@@ -68,19 +73,48 @@ async function loadEnv(envFile: string): Promise<NodeJS.ProcessEnv> {
   return env;
 }
 
+async function readPort(sp: ServicePaths): Promise<number | null> {
+  try {
+    const content = await Bun.file(sp.envFile).text();
+    const portStr = parseEnvFile(content).entries.get(sp.portKey ?? "");
+    if (portStr) return Number.parseInt(portStr, 10) || null;
+  } catch {
+    // missing .env → no port
+  }
+  return null;
+}
+
+async function readLogTail(logFile: string, maxLines: number): Promise<string | null> {
+  try {
+    const text = await Bun.file(logFile).text();
+    const lines = text.trimEnd().split("\n");
+    return lines.slice(-maxLines).join("\n");
+  } catch {
+    return null;
+  }
+}
+
 async function startOne(
   svc: "web" | "daemon",
   paths: PathConfig,
   logger: Logger,
 ): Promise<boolean> {
   const sp = servicePaths(paths, svc);
+  return startFromSp(sp, svc, logger);
+}
+
+export async function startFromSp(
+  sp: ServicePaths,
+  label: string,
+  logger: Logger,
+): Promise<boolean> {
   const binPath = resolveBundledBin(sp.pkg, sp.binRelPath) ?? resolveCommand(sp.bin);
   if (!binPath) {
     throw new InstallError(`${sp.bin} not found — update with: npm install -g ework-aio@latest`);
   }
   const existingPid = await readPidFile(sp.pidFile);
   if (existingPid !== null && isProcessRunning(existingPid)) {
-    logger.log(`ework-${svc} already running (pid ${existingPid})`);
+    logger.log(`ework-${label} already running (pid ${existingPid})`);
     return false;
   }
   const env = await loadEnv(sp.envFile);
@@ -92,41 +126,106 @@ async function startOne(
     logFile: sp.logFile,
     pidFile: sp.pidFile,
   });
-  logger.ok(`ework-${svc} started (pid ${pid}, log ${sp.logFile})`);
+
+  await new Promise((r) => setTimeout(r, 1500));
+  if (!isProcessRunning(pid)) {
+    const tail = await readLogTail(sp.logFile, 10);
+    const detail = tail ? `\n${tail}` : "";
+    throw new InstallError(`ework-${label} failed to start (pid ${pid} exited within 1.5s)${detail}`);
+  }
+
+  const port = await readPort(sp);
+  const portStr = port !== null ? `, http://127.0.0.1:${port}` : "";
+  logger.ok(`ework-${label} started (pid ${pid}${portStr}, log ${sp.logFile})`);
   return true;
 }
 
 async function stopOne(svc: "web" | "daemon", paths: PathConfig, logger: Logger): Promise<boolean> {
   const sp = servicePaths(paths, svc);
+  return stopFromSp(sp, svc, logger);
+}
+
+export async function stopFromSp(
+  sp: ServicePaths,
+  label: string,
+  logger: Logger,
+): Promise<boolean> {
   try {
     const result = await stopProcess(sp.pidFile, { graceMs: 5000, sigkillAfter: true });
     if (result.killed) {
-      logger.ok(`ework-${svc} stopped (pid ${result.pid}${result.timedOut ? ", SIGKILL after timeout" : ""})`);
+      logger.ok(`ework-${label} stopped (pid ${result.pid}${result.timedOut ? ", SIGKILL after timeout" : ""})`);
     } else {
-      logger.log(`ework-${svc} was not running (stale pidfile cleaned)`);
+      logger.log(`ework-${label} was not running (stale pidfile cleaned)`);
     }
     return result.killed;
   } catch (err) {
     if (err instanceof Error && /not found or empty/.test(err.message)) {
-      logger.log(`ework-${svc} not running (no pidfile at ${sp.pidFile})`);
+      logger.log(`ework-${label} not running (no pidfile at ${sp.pidFile})`);
       return false;
     }
     throw err;
   }
 }
 
+function daemonSpFromInstance(inst: DaemonInstance): ServicePaths {
+  return {
+    bin: "ework-daemon-server",
+    pkg: "ework-daemon",
+    binRelPath: "bin/ework-daemon-server.js",
+    dataDir: inst.dataDir,
+    envFile: inst.envFile,
+    pidFile: inst.pidFile,
+    logFile: inst.logFile,
+    portKey: "DAEMON_PORT",
+  };
+}
+
+function instanceLabel(num: number): string {
+  return num === 1 ? "daemon" : `daemon-${num}`;
+}
+
+function iterDaemonInstances(
+  paths: PathConfig,
+): Array<{ sp: ServicePaths; label: string }> {
+  const instances = daemonInstancePaths(paths.dataDir, paths.runDir);
+  return instances.map((inst) => ({
+    sp: daemonSpFromInstance(inst),
+    label: instanceLabel(inst.num),
+  }));
+}
+
 function targets(target: ServiceTarget): Array<"web" | "daemon"> {
   return target === "both" ? ["web", "daemon"] : [target];
 }
 
+function iterTargets(
+  paths: PathConfig,
+  target: ServiceTarget,
+): Array<{ sp: ServicePaths; label: string }> {
+  const out: Array<{ sp: ServicePaths; label: string }> = [];
+  for (const svc of targets(target)) {
+    if (svc === "web") {
+      out.push({ sp: servicePaths(paths, "web"), label: "web" });
+    } else {
+      const insts = iterDaemonInstances(paths);
+      if (insts.length === 0) {
+        out.push({ sp: servicePaths(paths, "daemon"), label: "daemon" });
+      } else {
+        out.push(...insts);
+      }
+    }
+  }
+  return out;
+}
+
 export async function runStart(
   opts: GlobalOptions,
   logger: Logger,
   target: ServiceTarget,
 ): Promise<void> {
   const paths = resolvePaths({ dataDir: opts.dataDir, scope: opts.scope, useSystemd: false });
-  for (const svc of targets(target)) {
-    await startOne(svc, paths, logger);
+  for (const { sp, label } of iterTargets(paths, target)) {
+    await startFromSp(sp, label, logger);
   }
 }
 
@@ -136,8 +235,8 @@ export async function runStop(
   target: ServiceTarget,
 ): Promise<void> {
   const paths = resolvePaths({ dataDir: opts.dataDir, scope: opts.scope, useSystemd: false });
-  for (const svc of targets(target)) {
-    await stopOne(svc, paths, logger);
+  for (const { sp, label } of iterTargets(paths, target)) {
+    await stopFromSp(sp, label, logger);
   }
 }
 
@@ -147,14 +246,14 @@ export async function runRestart(
   target: ServiceTarget,
 ): Promise<void> {
   const paths = resolvePaths({ dataDir: opts.dataDir, scope: opts.scope, useSystemd: false });
-  for (const svc of targets(target)) {
-    await stopOne(svc, paths, logger);
-    await startOne(svc, paths, logger);
+  for (const { sp, label } of iterTargets(paths, target)) {
+    await stopFromSp(sp, label, logger);
+    await startFromSp(sp, label, logger);
   }
 }
 
 export interface StatusEntry {
-  svc: "web" | "daemon";
+  svc: string;
   pid: number | null;
   alive: boolean;
   port: number | null;
@@ -168,27 +267,25 @@ export async function runStatus(opts: GlobalOptions, logger: Logger): Promise<St
   logger.log("ework-aio status (PID-file mode)");
   logger.hr();
 
+  const probeTargets: Array<{ sp: ServicePaths; label: string }> = [
+    { sp: servicePaths(paths, "web"), label: "web" },
+  ];
+  const daemonInsts = iterDaemonInstances(paths);
+  if (daemonInsts.length === 0) {
+    probeTargets.push({ sp: servicePaths(paths, "daemon"), label: "daemon" });
+  } else {
+    probeTargets.push(...daemonInsts);
+  }
+
   const entries: StatusEntry[] = [];
-  for (const svc of ["web", "daemon"] as const) {
-    const sp = servicePaths(paths, svc);
+  for (const { sp, label } of probeTargets) {
     const pid = await readPidFile(sp.pidFile);
     const alive = pid !== null && isProcessRunning(pid);
 
-    let port: number | null = null;
-    try {
-      const content = await Bun.file(sp.envFile).text();
-      const portStr = parseEnvFile(content).entries.get(sp.portKey ?? "");
-      if (portStr) port = Number.parseInt(portStr, 10) || null;
-    } catch {
-      // missing .env → no port
-    }
-
+    const port = await readPort(sp);
     let listening: boolean | null = null;
     if (port !== null) {
-      // web exposes /login; daemon doesn't. Probe a per-service URL so the
-      // status line doesn't lie about the daemon being "not responding"
-      // when it's actually healthy.
-      const probeUrl = svc === "web"
+      const probeUrl = label === "web"
         ? `http://127.0.0.1:${port}/login`
         : `http://127.0.0.1:${port}/`;
       try {
@@ -199,13 +296,13 @@ export async function runStatus(opts: GlobalOptions, logger: Logger): Promise<St
       }
     }
 
-    entries.push({ svc, pid, alive, port, listening });
+    entries.push({ svc: label, pid, alive, port, listening });
 
     const pidStr = pid === null ? "—" : `pid ${pid}`;
     const aliveStr = alive ? "✓ running" : "✗ not running";
     const portStr = port === null ? "(no port in .env)" : `:${port}`;
     const listenStr = listening === null ? "" : listening ? " ✓ listening" : " ✗ not responding";
-    logger.log(`  ework-${svc.padEnd(8)} ${pidStr.padEnd(10)} ${aliveStr}  ${portStr}${listenStr}`);
+    logger.log(`  ework-${label.padEnd(10)} ${pidStr.padEnd(10)} ${aliveStr}  ${portStr}${listenStr}`);
   }
   logger.hr();
   return entries;

package/src/paths.ts

@@ -18,6 +18,7 @@
 
 import path from "node:path";
 import os from "node:os";
+import { existsSync } from "node:fs";
 
 export interface PathConfig {
   dataDir: string;
@@ -93,3 +94,37 @@ export function resolvePaths(opts: ResolvePathsOptions): PathConfig {
     daemonUnitFile: unitDir ? path.join(unitDir, "ework-daemon.service") : null,
   };
 }
+
+export interface DaemonInstance {
+  num: number;
+  dataDir: string;
+  envFile: string;
+  pidFile: string;
+  logFile: string;
+}
+
+export function daemonInstancePaths(dataDir: string, runDir: string): DaemonInstance[] {
+  const instances: DaemonInstance[] = [];
+  const primaryDir = path.join(dataDir, "ework-daemon");
+  if (existsSync(primaryDir)) {
+    instances.push({
+      num: 1,
+      dataDir: primaryDir,
+      envFile: path.join(primaryDir, ".env"),
+      pidFile: path.join(runDir, "daemon.pid"),
+      logFile: path.join(runDir, "daemon.log"),
+    });
+  }
+  for (let i = 2; i <= 100; i++) {
+    const dir = path.join(dataDir, `ework-daemon-${i}`);
+    if (!existsSync(dir)) break;
+    instances.push({
+      num: i,
+      dataDir: dir,
+      envFile: path.join(dir, ".env"),
+      pidFile: path.join(runDir, `daemon-${i}.pid`),
+      logFile: path.join(runDir, `daemon-${i}.log`),
+    });
+  }
+  return instances;
+}