@rynx-ai/daemon 0.1.0 → 0.1.10-beta.2

package/dist/pm2.d.ts

@@ -8,9 +8,11 @@ export declare function formatControlUrl(host: string, port: number): string;
  * entry from scratch (delete + start) so config flags are always fresh; the
  * `force === false` path short-circuits when it's already online.
  */
-export declare function startDaemon({ force }: {
+export declare function startDaemon({ force, quiet }: {
     force: boolean;
+    quiet?: boolean;
 }): number;
+export declare function isPm2DaemonOnline(): boolean;
 /** Stop and remove the daemon from pm2's process list. */
 export declare function stopDaemon(): number;
 /** Print a one-line status; exit 0 only when online. */

package/dist/pm2.js

@@ -8,15 +8,18 @@
  * shipped `ecosystem.cjs` to keep in sync.
  */
 import { spawn, spawnSync } from "node:child_process";
-import { mkdirSync } from "node:fs";
+import { mkdirSync, realpathSync } from "node:fs";
 import { createRequire } from "node:module";
 import { homedir } from "node:os";
-import { dirname, join } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { loadConfig } from "@rynx-ai/core";
+import { daemonEntryRestartRequired } from "./daemon-build-status.js";
 const require = createRequire(import.meta.url);
 /** pm2 app name — single resident daemon per machine. */
 const APP_NAME = "rynx";
+const PM2_COMMAND_TIMEOUT_MS = 5_000;
+const DAEMON_PACKAGE_VERSION = require("../package.json").version;
 /**
  * Build a dialable control-console URL from the daemon's bind host/port. Bind-all
  * addresses (`0.0.0.0`, `::`) aren't dialable, so show a loopback host instead.
@@ -57,17 +60,37 @@ function logsDir() {
     mkdirSync(dir, { recursive: true });
     return dir;
 }
+function nodeRuntimeEnv() {
+    if (!process.versions.electron) {
+        return process.env;
+    }
+    return { ...process.env, ELECTRON_RUN_AS_NODE: "1" };
+}
 /** Run a pm2 command inheriting stdio; returns its exit code. */
-function runPm2(args) {
+function runPm2(args, quiet = false) {
     const res = spawnSync(process.execPath, [pm2Bin(), ...args], {
-        stdio: "inherit",
-        env: process.env,
+        stdio: quiet ? "ignore" : "inherit",
+        env: nodeRuntimeEnv(),
+        timeout: PM2_COMMAND_TIMEOUT_MS,
+        killSignal: "SIGTERM",
     });
+    if (res.error) {
+        if (!quiet)
+            console.error(`pm2 command failed: ${pm2ErrorMessage(res.error)}`);
+        return 1;
+    }
     return res.status ?? 1;
 }
 /** Read the daemon's current pm2 record, or null if not registered. */
 function describe() {
-    const res = spawnSync(process.execPath, [pm2Bin(), "jlist"], { encoding: "utf8" });
+    const res = spawnSync(process.execPath, [pm2Bin(), "jlist"], {
+        encoding: "utf8",
+        env: nodeRuntimeEnv(),
+        timeout: PM2_COMMAND_TIMEOUT_MS,
+        killSignal: "SIGTERM",
+    });
+    if (res.error)
+        throw new Error(`pm2 query failed: ${pm2ErrorMessage(res.error)}`);
     if (res.status !== 0 || !res.stdout)
         return null;
     let list;
@@ -79,21 +102,44 @@ function describe() {
     }
     return list.find((proc) => proc.name === APP_NAME) ?? null;
 }
+function pm2ErrorMessage(error) {
+    return error.code === "ETIMEDOUT"
+        ? `timed out after ${PM2_COMMAND_TIMEOUT_MS}ms`
+        : error.message;
+}
 /**
  * Start (or, with `force`, reload) the resident daemon. We recreate the pm2
  * entry from scratch (delete + start) so config flags are always fresh; the
  * `force === false` path short-circuits when it's already online.
  */
-export function startDaemon({ force }) {
-    const existing = describe();
-    if (!force && existing?.pm2_env?.status === "online") {
-        console.log(`rynx is already running (pid ${existing.pid ?? "?"}). Use \`rynx restart\` to reload.`);
-        console.log(`Control console: ${styleUrl(controlConsoleUrl())}`);
+export function startDaemon({ force, quiet = false }) {
+    let existing;
+    try {
+        existing = describe();
+    }
+    catch (error) {
+        if (!quiet)
+            console.error(error instanceof Error ? error.message : String(error));
+        return 1;
+    }
+    const staleBuild = existing?.pm2_env?.status === "online" &&
+        residentBuildRestartRequired(existing);
+    if (!force && existing?.pm2_env?.status === "online" && !staleBuild) {
+        if (!quiet) {
+            console.log(`rynx is already running (pid ${existing.pid ?? "?"}). Use \`rynx restart\` to reload.`);
+            console.log(`Control console: ${styleUrl(controlConsoleUrl())}`);
+        }
         return 0;
     }
+    if (staleBuild && !quiet) {
+        console.log("A newer daemon build is present on disk; restarting Rynx.");
+    }
     const dir = logsDir();
-    if (existing)
-        runPm2(["delete", APP_NAME]);
+    if (existing) {
+        const removed = runPm2(["delete", APP_NAME], quiet);
+        if (removed !== 0)
+            return removed;
+    }
     const status = runPm2([
         "start",
         daemonEntryPath(),
@@ -112,13 +158,16 @@ export function startDaemon({ force }) {
         join(dir, "err.log"),
         "--merge-logs",
         "--time",
-    ]);
-    if (status === 0) {
+    ], quiet);
+    if (status === 0 && !quiet) {
         console.log(`rynx ${force ? "restarted" : "started"} (pm2 app "${APP_NAME}", logs: ${dir}).`);
         console.log(`Control console: ${styleUrl(controlConsoleUrl())}`);
     }
     return status;
 }
+export function isPm2DaemonOnline() {
+    return describe()?.pm2_env?.status === "online";
+}
 /** Stop and remove the daemon from pm2's process list. */
 export function stopDaemon() {
     if (!describe()) {
@@ -140,14 +189,39 @@ export function statusDaemon() {
     const state = app.pm2_env?.status ?? "unknown";
     const pid = app.pid ? ` pid=${app.pid}` : "";
     const restarts = app.pm2_env?.restart_time != null ? ` restarts=${app.pm2_env.restart_time}` : "";
-    console.log(`rynx: ${state}${pid}${restarts}`);
-    return state === "online" ? 0 : 1;
+    const staleBuild = state === "online" && residentBuildRestartRequired(app);
+    console.log(`rynx: ${state}${pid}${restarts}` +
+        (staleBuild ? " restart-required (run `rynx restart`)" : ""));
+    return state === "online" && !staleBuild ? 0 : 1;
 }
 /** Stream the daemon's pm2 logs until the user detaches (Ctrl-C). */
 export function streamLogs() {
     const child = spawn(process.execPath, [pm2Bin(), "logs", APP_NAME, "--lines", "50"], {
         stdio: "inherit",
-        env: process.env,
+        env: nodeRuntimeEnv(),
     });
     child.on("exit", (code) => process.exit(code ?? 0));
 }
+function residentBuildRestartRequired(app) {
+    const runningEntry = app.pm2_env?.pm_exec_path;
+    if (runningEntry && !sameEntryPath(runningEntry, daemonEntryPath()))
+        return true;
+    const runningVersion = app.pm2_env?.version;
+    if (runningVersion &&
+        typeof DAEMON_PACKAGE_VERSION === "string" &&
+        runningVersion !== DAEMON_PACKAGE_VERSION) {
+        return true;
+    }
+    const startedAt = app.pm2_env?.pm_uptime;
+    return typeof startedAt === "number" &&
+        Number.isFinite(startedAt) &&
+        daemonEntryRestartRequired(daemonEntryPath(), startedAt);
+}
+function sameEntryPath(left, right) {
+    try {
+        return realpathSync(left) === realpathSync(right);
+    }
+    catch {
+        return resolve(left) === resolve(right);
+    }
+}

package/dist/provider-cli-service.d.ts

@@ -0,0 +1,46 @@
+import type { ProviderCliId, ProviderCliJob, ProviderCliOperation, ProviderCliStatusList } from "@rynx-ai/protocol/control";
+interface CommandResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+interface ProviderCliServiceDeps {
+    env?: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform;
+    now?: () => Date;
+    run?: (executable: string, args: string[], options: {
+        timeoutMs: number;
+        env: NodeJS.ProcessEnv;
+    }) => Promise<CommandResult>;
+    resolveExecutable?: (binary: string, env: NodeJS.ProcessEnv, platform: NodeJS.Platform) => Promise<string | null>;
+    download?: (url: string, maximumBytes: number) => Promise<Uint8Array>;
+}
+export declare class ProviderCliService {
+    private readonly env;
+    private readonly platform;
+    private readonly now;
+    private readonly runCommand;
+    private readonly resolveCommand;
+    private readonly download;
+    private readonly latestCache;
+    private readonly jobs;
+    private readonly activeJobs;
+    constructor(deps?: ProviderCliServiceDeps);
+    listStatuses(): Promise<ProviderCliStatusList>;
+    startOperation(provider: ProviderCliId, operation: ProviderCliOperation): Promise<ProviderCliJob>;
+    getJob(id: string): ProviderCliJob | undefined;
+    private inspect;
+    private resolveProviderExecutable;
+    private authStatus;
+    private latestVersion;
+    private execute;
+    private install;
+    private update;
+    private installTraex;
+    private pruneJobs;
+}
+export declare class ProviderCliOperationError extends Error {
+    readonly code: "failed_precondition";
+    constructor(code: "failed_precondition", message: string);
+}
+export {};