ework-aio 0.3.4 → 0.3.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ework-aio",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "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",

package/src/cli.ts

@@ -12,6 +12,7 @@
 //   - Unknown flags → error. We never silently swallow typos.
 
 import os from "node:os";
+import { readFileSync } from "node:fs";
 import { spawnSync } from "node:child_process";
 import { Logger, InstallError, log as defaultLogger } from "./log.ts";
 import {
@@ -21,6 +22,7 @@ import {
 } from "./types.ts";
 import { runInstall } from "./commands/install.ts";
 import { runUninstall } from "./commands/uninstall.ts";
+import { runUpgrade } from "./commands/upgrade.ts";
 import {
   runStart,
   runStop,
@@ -35,7 +37,10 @@ import {
   type ConfigArgs,
 } from "./commands/config.ts";
 
-const VERSION = "0.2.7-dev";
+// Read from package.json — never hardcode (every release reported "0.2.7-dev").
+const VERSION: string = JSON.parse(
+  readFileSync(new URL("../package.json", import.meta.url), "utf-8"),
+).version;
 
 const USAGE = `ework-aio <command> [options]
 
@@ -44,6 +49,9 @@ Commands:
                                   Add 'systemd' to also write+enable systemd
                                   units. Without 'systemd', runs in pure
                                   PID-file mode (no systemctl calls).
+  upgrade                         Pull latest ework-aio from npm and restart
+                                  services. Use this to update — don't re-run
+                                  'install' for version bumps.
   uninstall                       Stop services and remove units (data preserved)
   status                          Show service status (PID-file mode)
   logs [web|daemon]               Tail logs (Ctrl+C to stop)
@@ -426,6 +434,10 @@ export async function main(
         await runInstall(opts, logger);
         return 0;
       }
+      case "upgrade": {
+        await runUpgrade(opts, logger);
+        return 0;
+      }
       case "uninstall": {
         await runUninstall(opts, logger);
         return 0;

package/src/commands/install.ts

@@ -24,7 +24,7 @@ import { resolvePaths, type PathConfig } from "../paths.ts";
 import { type InstallContext } from "../config.ts";
 import { ensureEnvFile, parseEnvFile, patchEnvKey } from "../env.ts";
 import { startProcess, isProcessRunning, readPidFile } from "../pidfile.ts";
-import { checkPreflight, resolveCommand, resolveBundledBin, REQUIRED_COMMANDS } from "../preflight.ts";
+import { checkPreflight, resolveCommand, resolveBundledBin, ensureSelfBinSymlink, REQUIRED_COMMANDS } from "../preflight.ts";
 import {
   generateUnitFile,
   writeUnitFile,
@@ -83,6 +83,15 @@ export async function runInstall(
   logger.log(`  data dir   : ${opts.dataDir ?? "(default ~/.local/share/ework-aio)"}`);
   logger.hr();
 
+  const preflightPaths = resolvePaths({
+    dataDir: opts.dataDir,
+    scope: opts.scope,
+    useSystemd: opts.useSystemd,
+  });
+  if (fs.existsSync(preflightPaths.webEnvFile)) {
+    logger.warn("existing install detected — use 'ework-aio upgrade' to update versions");
+  }
+
   // 1. Preflight: bun/npm/opencode must exist on PATH.
   const preflight = checkPreflight([...REQUIRED_COMMANDS], {
     optionalCommands: ["systemctl"],
@@ -96,6 +105,8 @@ export async function runInstall(
   const opencodeBin = preflight.found.get("opencode")!;
   logger.ok(`preflight: bun, npm, opencode all on PATH`);
 
+  ensureSelfBinSymlink(logger);
+
   // 2. Resolve ework-web / ework-daemon binaries.
   //
   // ework-daemon ships TWO bins: `ework-daemon` (client CLI: status/issues/...)

package/src/commands/lifecycle.ts

@@ -17,12 +17,13 @@ import {
   isProcessRunning,
 } from "../pidfile.ts";
 import { parseEnvFile } from "../env.ts";
-import { resolveCommand } from "../preflight.ts";
+import { resolveCommand, resolveBundledBin } from "../preflight.ts";
 import type { GlobalOptions, ServiceTarget } from "../types.ts";
 
 interface ServicePaths {
   bin: string;
   pkg: string;
+  binRelPath: string;
   dataDir: string;
   envFile: string;
   pidFile: string;
@@ -35,6 +36,7 @@ function servicePaths(paths: PathConfig, svc: "web" | "daemon"): ServicePaths {
     return {
       bin: "ework-web",
       pkg: "ework-web",
+      binRelPath: "bin/ework-web.js",
       dataDir: paths.webDataDir,
       envFile: paths.webEnvFile,
       pidFile: paths.webPidFile,
@@ -43,14 +45,9 @@ function servicePaths(paths: PathConfig, svc: "web" | "daemon"): ServicePaths {
     };
   }
   return {
-    // ework-daemon ships two bins; only `ework-daemon-server` actually starts
-    // the HTTP server. The `ework-daemon` bin is a client CLI that prints help
-    // and exits — spawning it leaves the daemon "looking dead" with help text
-    // in the log. See install.ts preflight for the full rationale.
     bin: "ework-daemon-server",
-    // npm package name differs from the bin name — the error hint must use the
-    // package name, not the bin, or the user gets a 404 trying to install.
     pkg: "ework-daemon",
+    binRelPath: "bin/ework-daemon-server.js",
     dataDir: paths.daemonDataDir,
     envFile: paths.daemonEnvFile,
     pidFile: paths.daemonPidFile,
@@ -77,9 +74,9 @@ async function startOne(
   logger: Logger,
 ): Promise<boolean> {
   const sp = servicePaths(paths, svc);
-  const binPath = resolveCommand(sp.bin);
+  const binPath = resolveBundledBin(sp.pkg, sp.binRelPath) ?? resolveCommand(sp.bin);
   if (!binPath) {
-    throw new InstallError(`${sp.bin} not found on PATH — install with: npm install -g ${sp.pkg}`);
+    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)) {

package/src/commands/upgrade.ts

@@ -0,0 +1,40 @@
+import { spawnSync } from "node:child_process";
+import { Logger, InstallError } from "../log.ts";
+import type { GlobalOptions } from "../types.ts";
+
+export async function runUpgrade(opts: GlobalOptions, logger: Logger): Promise<void> {
+  logger.hr();
+  logger.log("ework-aio upgrade");
+  logger.hr();
+
+  logger.log("pulling latest ework-aio from npm...");
+  const result = spawnSync("npm", ["install", "-g", "ework-aio@latest"], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    env: process.env,
+  });
+  if (result.status !== 0) {
+    const stderr = result.stderr ?? "(no stderr)";
+    throw new InstallError(`npm install -g ework-aio@latest failed:\n${stderr}`);
+  }
+  logger.ok("ework-aio updated to latest");
+
+  // Re-exec as a fresh process so the NEW code resolves bundled deps.
+  // The current process still holds the old version in memory.
+  logger.log("restarting services with new version...");
+  const restartResult = spawnSync("ework-aio", ["restart", ...restartFlags(opts)], {
+    encoding: "utf8",
+    stdio: "inherit",
+    env: process.env,
+  });
+  if (restartResult.status !== 0) {
+    throw new InstallError("restart after upgrade failed — run 'ework-aio restart' manually");
+  }
+  logger.ok("upgrade complete");
+}
+
+function restartFlags(opts: GlobalOptions): string[] {
+  const flags: string[] = [];
+  if (opts.dataDir) flags.push("--data-dir", opts.dataDir);
+  return flags;
+}

package/src/preflight.ts

@@ -1,6 +1,7 @@
 import { spawnSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
+import type { Logger } from "./log.ts";
 
 // Root of the ework-aio package itself. Derived from this file's location
 // (<root>/src/preflight.ts). Used to resolve bins that ework-aio ships as
@@ -68,3 +69,47 @@ export function checkPreflight(
 
 export const REQUIRED_COMMANDS: readonly string[] = ["bun", "npm", "opencode"];
 export const OPTIONAL_COMMANDS: readonly string[] = ["systemctl", "sudo"];
+
+// Ensure `ework-aio` is reachable from PATH. npm puts the bin at its own
+// global prefix's bin dir, which may differ from every dir on PATH (e.g.
+// prefix changed after a node upgrade). Walk PATH in order and, at the
+// first writable dir, create/repair a symlink to our actual bin.
+export function ensureSelfBinSymlink(logger: Logger): void {
+  const ourBin = path.resolve(import.meta.dir, "..", "bin", "ework-aio");
+  if (!fs.existsSync(ourBin)) return;
+  const ourBinReal = fs.realpathSync(ourBin);
+
+  const pathDirs = (process.env.PATH ?? "").split(":").filter(Boolean);
+  for (const dir of pathDirs) {
+    try {
+      fs.accessSync(dir, fs.constants.W_OK);
+    } catch {
+      continue;
+    }
+
+    const target = path.join(dir, "ework-aio");
+    try {
+      const stat = fs.lstatSync(target);
+      if (stat.isSymbolicLink()) {
+        try {
+          if (fs.realpathSync(target) === ourBinReal) return;
+        } catch {
+          // broken symlink — fall through to replace
+        }
+        fs.unlinkSync(target);
+      } else {
+        continue; // regular file — don't clobber
+      }
+    } catch {
+      // doesn't exist — fall through to create
+    }
+
+    try {
+      fs.symlinkSync(ourBin, target);
+      logger.ok(`bin symlink: ${target} → ${ourBin}`);
+      return;
+    } catch {
+      continue;
+    }
+  }
+}