@sys9/chord-cli 0.1.159-linux-x64 → 0.1.159

package/bin/chord

@@ -0,0 +1,610 @@
+#!/usr/bin/env node
+
+"use strict";
+
+const { spawn } = require("node:child_process");
+const fs = require("node:fs");
+const path = require("node:path");
+
+const packageJSON = require("../package.json");
+const {
+  resolvePackagedBinaryPath,
+  resolvePlatformPackageName,
+} = require("../lib/platform");
+
+function detectPackageManager() {
+  const userAgent = process.env.npm_config_user_agent || "";
+  if (/\bbun\//.test(userAgent)) {
+    return "bun";
+  }
+
+  const execPath = process.env.npm_execpath || "";
+  if (execPath.includes("bun")) {
+    return "bun";
+  }
+
+  if (
+    __dirname.includes(".bun/install/global") ||
+    __dirname.includes(".bun\\install\\global")
+  ) {
+    return "bun";
+  }
+
+  return "npm";
+}
+
+function resolveBinaryPath() {
+  const platformPackage = resolvePlatformPackageName(packageJSON.name);
+  try {
+    const packageJSONPath = require.resolve(platformPackage + "/package.json");
+    return {
+      binaryPath: resolvePackagedBinaryPath(path.dirname(packageJSONPath)),
+      platformPackage,
+    };
+  } catch {
+    return {
+      binaryPath: resolvePackagedBinaryPath(path.join(__dirname, "..")),
+      platformPackage,
+    };
+  }
+}
+
+const updateRequestedExitCode = 75;
+const updateFDEnv = "CHORD_CLI_UPDATE_FD";
+const updateAttemptEnv = "CHORD_CLI_UPDATE_ATTEMPT_ID";
+const updateOutcomeEnv = "CHORD_CLI_UPDATE_OUTCOME";
+const updateErrorEnv = "CHORD_CLI_UPDATE_ERROR";
+const updateReadyFileEnv = "CHORD_CLI_UPDATE_READY_FILE";
+const updateReadyTimeoutEnv = "CHORD_CLI_UPDATE_READY_TIMEOUT_MS";
+const updateRetryInitialEnv = "CHORD_CLI_UPDATE_RETRY_INITIAL_MS";
+const updateRetryMaxEnv = "CHORD_CLI_UPDATE_RETRY_MAX_MS";
+const maxUpdateInstructionBytes = 4096;
+const defaultUpdateReadyTimeoutMs = 60_000;
+const defaultUpdateRetryInitialMs = 1_000;
+const defaultUpdateRetryMaxMs = 300_000;
+const activeChildren = new Set();
+let receivedSignal = null;
+
+const forwardSignal = (signal) => {
+  receivedSignal = signal;
+  for (const child of activeChildren) {
+    if (child.killed) {
+      continue;
+    }
+    try {
+      child.kill(signal);
+    } catch {
+      // Ignore failures while the child is already exiting.
+    }
+  }
+};
+
+["SIGINT", "SIGTERM", "SIGHUP"].forEach((signal) => {
+  process.on(signal, () => forwardSignal(signal));
+});
+
+function runChild(command, args, options) {
+  let spawned;
+  const completion = new Promise((resolve) => {
+    let updateInstruction = "";
+    let settled = false;
+    let childResult = null;
+    let updatePipeClosed = true;
+    let updateInstructionComplete = false;
+    const finish = (result) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      activeChildren.delete(spawned);
+      resolve(result);
+    };
+    const finishAfterUpdatePipe = () => {
+      if (childResult && (updatePipeClosed || updateInstructionComplete)) {
+        finish({ ...childResult, updateInstruction });
+      }
+    };
+    spawned = spawn(command, args, options);
+    activeChildren.add(spawned);
+    if (spawned.stdio[3]) {
+      updatePipeClosed = false;
+      spawned.stdio[3].setEncoding("utf8");
+      spawned.stdio[3].on("data", (chunk) => {
+        if (updateInstruction.length <= maxUpdateInstructionBytes) {
+          updateInstruction += chunk;
+        }
+        updateInstructionComplete = updateInstruction.includes("\n");
+        finishAfterUpdatePipe();
+      });
+      spawned.stdio[3].on("end", () => {
+        updatePipeClosed = true;
+        finishAfterUpdatePipe();
+      });
+    }
+    spawned.on("error", (error) => {
+      finish({ code: 1, signal: null, updateInstruction: "", error });
+    });
+    spawned.on("exit", (code, signal) => {
+      childResult = { code: code ?? 1, signal, error: null };
+      // A daemon descendant may temporarily retain the update pipe. Once the
+      // direct child supplies the complete newline-delimited update instruction,
+      // waiting for every inherited file descriptor would keep replacement stuck
+      // for that descendant's lifetime.
+      if (signal || receivedSignal) {
+        finish({ code: code ?? 1, signal, updateInstruction, error: null });
+        return;
+      }
+      finishAfterUpdatePipe();
+    });
+    spawned.on("close", (code, signal) => {
+      childResult = { code: code ?? 1, signal, error: null };
+      finishAfterUpdatePipe();
+    });
+  });
+  return { process: spawned, completion };
+}
+
+function parseUpdateInstruction(raw) {
+  if (!raw || raw.length > maxUpdateInstructionBytes) {
+    return null;
+  }
+  try {
+    const instruction = JSON.parse(raw);
+    const version = instruction && instruction.cli_version;
+    if (typeof version !== "string" || !/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.test(version)) {
+      return null;
+    }
+    const attemptID = instruction.attempt_id;
+    const dataDir = instruction.data_dir;
+    const fromVersion = instruction.from_version;
+    const hostID = instruction.host_id;
+    if (
+      typeof attemptID !== "string" ||
+      !/^[A-Za-z0-9_-]{1,128}$/.test(attemptID) ||
+      typeof dataDir !== "string" ||
+      !path.isAbsolute(dataDir) ||
+      typeof fromVersion !== "string" ||
+      !/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.test(fromVersion) ||
+      typeof hostID !== "string" ||
+      !hostID ||
+      hostID.length > 128
+    ) {
+      return null;
+    }
+    return { cliVersion: version, attemptID, dataDir, fromVersion, hostID };
+  } catch {
+    return null;
+  }
+}
+
+function updateCommand(packageManager, cliVersion, daemonArgs) {
+  const packageSpec = packageJSON.name + "@" + cliVersion;
+  if (packageManager === "bun") {
+    return { command: "bunx", args: [packageSpec, ...daemonArgs] };
+  }
+  return { command: "npx", args: ["--yes", packageSpec, ...daemonArgs] };
+}
+
+function updateReadyTimeoutMs() {
+  const configured = Number(process.env[updateReadyTimeoutEnv]);
+  if (Number.isInteger(configured) && configured >= 100 && configured <= 300_000) {
+    return configured;
+  }
+  return defaultUpdateReadyTimeoutMs;
+}
+
+function configuredMilliseconds(name, fallback) {
+  const configured = Number(process.env[name]);
+  if (Number.isInteger(configured) && configured >= 10 && configured <= 300_000) {
+    return configured;
+  }
+  return fallback;
+}
+
+function updateRetryInitialMs() {
+  return configuredMilliseconds(updateRetryInitialEnv, defaultUpdateRetryInitialMs);
+}
+
+function updateRetryMaxMs() {
+  return Math.max(
+    updateRetryInitialMs(),
+    configuredMilliseconds(updateRetryMaxEnv, defaultUpdateRetryMaxMs),
+  );
+}
+
+function monitorReadiness(readyFile, instruction, outcome) {
+  let timer = null;
+  let interval = null;
+  let settled = false;
+  let resolvePromise;
+  const finish = (result) => {
+    if (settled) {
+      return;
+    }
+    settled = true;
+    clearTimeout(timer);
+    clearInterval(interval);
+    resolvePromise(result);
+  };
+  const promise = new Promise((resolve) => {
+    resolvePromise = resolve;
+    const inspect = () => {
+      let record;
+      try {
+        record = JSON.parse(fs.readFileSync(readyFile, "utf8"));
+      } catch {
+        return;
+      }
+      if (
+        record.attempt_id === instruction.attemptID &&
+        record.version === (outcome === "target" ? instruction.cliVersion : instruction.fromVersion) &&
+        record.outcome === outcome &&
+        record.host_id === instruction.hostID
+      ) {
+        finish({ kind: "ready" });
+      }
+    };
+    interval = setInterval(inspect, 25);
+    timer = setTimeout(() => finish({ kind: "timeout" }), updateReadyTimeoutMs());
+    inspect();
+  });
+  return { promise, cancel: () => finish({ kind: "cancelled" }) };
+}
+
+function snapshotDaemonState(instruction) {
+  const updatesRoot = path.join(instruction.dataDir, ".updates");
+  const attemptDir = path.join(updatesRoot, instruction.attemptID);
+  fs.mkdirSync(updatesRoot, { recursive: true, mode: 0o700 });
+  fs.mkdirSync(attemptDir, { mode: 0o700 });
+  const database = path.join(instruction.dataDir, "queue.db");
+  const backup = path.join(attemptDir, "queue.db");
+  const databaseExisted = fs.existsSync(database);
+  if (databaseExisted) {
+    fs.copyFileSync(database, backup);
+    const backupFile = fs.openSync(backup, "r");
+    try {
+      fs.fsyncSync(backupFile);
+    } finally {
+      fs.closeSync(backupFile);
+    }
+  }
+  return {
+    attemptDir,
+    readyFile: path.join(attemptDir, "ready.json"),
+    database,
+    backup,
+    databaseExisted,
+  };
+}
+
+function restoreDaemonState(snapshot) {
+  for (const suffix of ["-wal", "-shm"]) {
+    fs.rmSync(snapshot.database + suffix, { force: true });
+  }
+  if (snapshot.databaseExisted) {
+    const restore = snapshot.database + ".restore";
+    fs.copyFileSync(snapshot.backup, restore);
+    fs.renameSync(restore, snapshot.database);
+  } else {
+    fs.rmSync(snapshot.database, { force: true });
+  }
+}
+
+function managedUpdateEnvironment(instruction, snapshot, outcome, error) {
+  return {
+    ...process.env,
+    [updateFDEnv]: "3",
+    [updateAttemptEnv]: instruction.attemptID,
+    [updateOutcomeEnv]: outcome,
+    [updateErrorEnv]: error || "",
+    [updateReadyFileEnv]: snapshot.readyFile,
+  };
+}
+
+function removeUpdateSnapshot(snapshot) {
+  try {
+    fs.rmSync(snapshot.attemptDir, { recursive: true, force: true });
+  } catch (error) {
+    console.error("Chord could not remove the completed daemon update snapshot: " + error.message);
+  }
+}
+
+async function stopChild(running) {
+  const child = running.process;
+  if (child && child.exitCode === null && child.signalCode === null) {
+    try {
+      child.kill("SIGTERM");
+    } catch {
+      // The child may have exited between the check and signal.
+    }
+  }
+  const stopped = await Promise.race([
+    running.completion.then(() => true),
+    new Promise((resolve) => setTimeout(() => resolve(false), 5_000)),
+  ]);
+  if (!stopped && child && child.exitCode === null && child.signalCode === null) {
+    try {
+      child.kill("SIGKILL");
+    } catch {
+      // The child may have exited between the check and signal.
+    }
+  }
+  return running.completion;
+}
+
+function candidateFailure(outcome) {
+  if (outcome.kind === "timeout") {
+    return "the updated daemon did not become ready within " + updateReadyTimeoutMs() + "ms";
+  }
+  const result = outcome.result;
+  if (result.error) {
+    return "the updated daemon could not start: " + result.error.message;
+  }
+  if (result.signal) {
+    return "the updated daemon exited before readiness with signal " + result.signal;
+  }
+  return "the updated daemon exited before readiness with code " + result.code;
+}
+
+function checkUpdatePackage(packageManager, instruction) {
+  const check = updateCommand(packageManager, instruction.cliVersion, ["version"]);
+  const running = runChild(check.command, check.args, {
+    stdio: ["ignore", "pipe", "inherit"],
+    env: process.env,
+  });
+  let stdout = "";
+  running.process.stdout.setEncoding("utf8");
+  running.process.stdout.on("data", (chunk) => {
+    if (stdout.length <= 1024) {
+      stdout += chunk;
+    }
+  });
+  const completion = running.completion.then((result) => {
+    if (result.error) {
+      return { kind: "fatal", error: result.error.message };
+    }
+    if (result.signal || receivedSignal) {
+      return { kind: "stopped", result };
+    }
+    if (result.code !== 0) {
+      return { kind: "retry", error: "package command exited with code " + result.code };
+    }
+    if (stdout.trim() !== "chord version " + instruction.cliVersion) {
+      return { kind: "fatal", error: "package version check returned an unexpected version" };
+    }
+    return { kind: "ready" };
+  });
+  return { running, completion };
+}
+
+function startPreviousDaemon(binaryPath, daemonArgs, instruction, snapshot, outcome, error) {
+  fs.rmSync(snapshot.readyFile, { force: true });
+  const running = runChild(binaryPath, daemonArgs, {
+    stdio: ["inherit", "inherit", "inherit", "pipe"],
+    env: managedUpdateEnvironment(instruction, snapshot, outcome, error),
+  });
+  const readiness = monitorReadiness(snapshot.readyFile, instruction, outcome);
+  void Promise.race([
+    running.completion.then((childResult) => ({ kind: "exit", result: childResult })),
+    readiness.promise,
+  ]).then((result) => {
+    readiness.cancel();
+    if (result.kind === "ready" && outcome === "rolled_back") {
+      removeUpdateSnapshot(snapshot);
+    }
+  });
+  return running;
+}
+
+async function waitForUpdatePackage(binaryPath, packageManager, instruction, daemonArgs, snapshot) {
+  let packageCheck = checkUpdatePackage(packageManager, instruction);
+  let check = await packageCheck.completion;
+  if (check.kind !== "retry") {
+    return check;
+  }
+
+  console.error(
+    "Chord could not fetch @sys9/chord-cli@" + instruction.cliVersion +
+      "; the previous daemon will stay online while Chord retries. " + check.error,
+  );
+  const previous = startPreviousDaemon(
+    binaryPath,
+    daemonArgs,
+    instruction,
+    snapshot,
+    "retrying",
+    check.error,
+  );
+
+  let delay = updateRetryInitialMs();
+  for (;;) {
+    console.error(
+      "Retrying Chord daemon package in " + delay + "ms (maximum interval " +
+        updateRetryMaxMs() + "ms).",
+    );
+    const wait = await Promise.race([
+      previous.completion.then((result) => ({ kind: "previous_exit", result })),
+      new Promise((resolve) => setTimeout(() => resolve({ kind: "retry" }), delay)),
+    ]);
+    if (wait.kind === "previous_exit") {
+      return wait;
+    }
+
+    packageCheck = checkUpdatePackage(packageManager, instruction);
+    const checked = await Promise.race([
+      previous.completion.then((result) => ({ kind: "previous_exit", result })),
+      packageCheck.completion,
+    ]);
+    if (checked.kind === "previous_exit") {
+      await stopChild(packageCheck.running);
+      return checked;
+    }
+    if (checked.kind === "ready") {
+      const previousResult = await stopChild(previous);
+      if (previousResult.code === updateRequestedExitCode && previousResult.updateInstruction) {
+        return { kind: "previous_exit", result: previousResult };
+      }
+      return checked;
+    }
+    if (checked.kind === "fatal" || checked.kind === "stopped") {
+      await stopChild(previous);
+      return checked;
+    }
+    delay = Math.min(delay * 2, updateRetryMaxMs());
+  }
+}
+
+async function runManagedUpdate(binaryPath, packageManager, instruction, daemonArgs) {
+  let snapshot;
+  try {
+    snapshot = snapshotDaemonState(instruction);
+  } catch (error) {
+    console.error("Chord could not prepare the daemon update: " + error.message);
+    return runChild(binaryPath, daemonArgs, {
+      stdio: ["inherit", "inherit", "inherit", "pipe"],
+      env: { ...process.env, [updateFDEnv]: "3" },
+    }).completion;
+  }
+
+  const packageResult = await waitForUpdatePackage(
+    binaryPath,
+    packageManager,
+    instruction,
+    daemonArgs,
+    snapshot,
+  );
+  if (packageResult.kind === "previous_exit") {
+    return packageResult.result;
+  }
+  if (packageResult.kind === "stopped") {
+    return packageResult.result;
+  }
+  if (packageResult.kind === "fatal") {
+    const failure = packageResult.error.slice(0, 1024);
+    console.error("Chord daemon update failed; restoring " + instruction.fromVersion + ". " + failure);
+    const restored = startPreviousDaemon(
+      binaryPath,
+      daemonArgs,
+      instruction,
+      snapshot,
+      "rolled_back",
+      failure,
+    );
+    return restored.completion;
+  }
+
+  // The retrying daemon may have changed local durable state while npm was
+  // unavailable. Snapshot only after it has stopped and immediately before the
+  // candidate can mutate that state.
+  removeUpdateSnapshot(snapshot);
+  try {
+    snapshot = snapshotDaemonState(instruction);
+  } catch (error) {
+    console.error("Chord could not prepare the daemon update: " + error.message);
+    return runChild(binaryPath, daemonArgs, {
+      stdio: ["inherit", "inherit", "inherit", "pipe"],
+      env: { ...process.env, [updateFDEnv]: "3" },
+    }).completion;
+  }
+
+  const update = updateCommand(packageManager, instruction.cliVersion, daemonArgs);
+  console.error("Updating Chord daemon to @sys9/chord-cli@" + instruction.cliVersion + ".");
+  const candidate = runChild(update.command, update.args, {
+    stdio: "inherit",
+    env: managedUpdateEnvironment(instruction, snapshot, "target", ""),
+  });
+  const readiness = monitorReadiness(snapshot.readyFile, instruction, "target");
+  const outcome = await Promise.race([
+    candidate.completion.then((result) => ({ kind: "exit", result })),
+    readiness.promise,
+  ]);
+  readiness.cancel();
+
+  if (receivedSignal) {
+    if (outcome.kind !== "ready") {
+      try {
+        restoreDaemonState(snapshot);
+      } catch (error) {
+        console.error("Chord could not restore daemon state during shutdown: " + error.message);
+      }
+    }
+    return candidate.completion;
+  }
+  if (outcome.kind === "ready") {
+    removeUpdateSnapshot(snapshot);
+    return candidate.completion;
+  }
+  if (outcome.kind === "timeout") {
+    await stopChild(candidate);
+  }
+  const failure = candidateFailure(outcome).slice(0, 1024);
+  console.error("Chord daemon update failed; restoring " + instruction.fromVersion + ". " + failure);
+  try {
+    restoreDaemonState(snapshot);
+  } catch (error) {
+    console.error("Chord could not restore the previous daemon state: " + error.message);
+    return { code: 1, signal: null, updateInstruction: "", error: null };
+  }
+
+  const restored = startPreviousDaemon(
+    binaryPath,
+    daemonArgs,
+    instruction,
+    snapshot,
+    "rolled_back",
+    failure,
+  );
+  return restored.completion;
+}
+
+async function main() {
+  const { binaryPath, platformPackage } = resolveBinaryPath();
+  if (!fs.existsSync(binaryPath)) {
+    const packageManager = detectPackageManager();
+    const update =
+      packageManager === "bun"
+        ? "bun add -g @sys9/chord-cli@latest"
+        : "npm install -g @sys9/chord-cli@latest";
+    throw new Error(
+      "Missing optional dependency " + platformPackage + ". Reinstall chord: " + update,
+    );
+  }
+
+  const daemonArgs = process.argv.slice(2);
+  let result = await runChild(binaryPath, daemonArgs, {
+    stdio: ["inherit", "inherit", "inherit", "pipe"],
+    env: { ...process.env, [updateFDEnv]: "3" },
+  }).completion;
+  const packageManager = detectPackageManager();
+  for (;;) {
+    if (result.error) {
+      console.error(result.error);
+      return result;
+    }
+    if (result.signal || receivedSignal) {
+      return { ...result, signal: result.signal || receivedSignal };
+    }
+    if (result.code !== updateRequestedExitCode) {
+      return result;
+    }
+
+    const instruction = parseUpdateInstruction(result.updateInstruction);
+    if (!instruction) {
+      console.error("Chord daemon exited for an update, but did not provide a valid managed update instruction.");
+      return result;
+    }
+    result = await runManagedUpdate(binaryPath, packageManager, instruction, daemonArgs);
+  }
+}
+
+main().then((result) => {
+  if (result.signal) {
+    process.removeAllListeners(result.signal);
+    process.kill(process.pid, result.signal);
+    return;
+  }
+  process.exit(result.code);
+}).catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/lib/platform.js

@@ -0,0 +1,60 @@
+"use strict";
+
+const path = require("node:path");
+
+const SUPPORTED_TARGETS = [
+  {
+    slug: "linux-x64",
+    os: "linux",
+    cpu: "x64",
+    vendorDir: "linux_amd64",
+    targetTriple: "x86_64-unknown-linux-musl",
+  },
+  {
+    slug: "linux-arm64",
+    os: "linux",
+    cpu: "arm64",
+    vendorDir: "linux_arm64",
+    targetTriple: "aarch64-unknown-linux-musl",
+  },
+  {
+    slug: "darwin-x64",
+    os: "darwin",
+    cpu: "x64",
+    vendorDir: "darwin_amd64",
+    targetTriple: "x86_64-apple-darwin",
+  },
+  {
+    slug: "darwin-arm64",
+    os: "darwin",
+    cpu: "arm64",
+    vendorDir: "darwin_arm64",
+    targetTriple: "aarch64-apple-darwin",
+  }
+];
+
+function resolveSupportedTarget(platform = process.platform, arch = process.arch) {
+  for (const target of SUPPORTED_TARGETS) {
+    if (target.os === platform && target.cpu === arch) {
+      return target;
+    }
+  }
+  throw new Error("unsupported platform: " + platform + " (" + arch + ")");
+}
+
+function resolvePackagedBinaryPath(rootDir, platform = process.platform, arch = process.arch) {
+  const target = resolveSupportedTarget(platform, arch);
+  return path.join(rootDir, "vendor", target.vendorDir, "chord");
+}
+
+function resolvePlatformPackageName(rootPackageName, platform = process.platform, arch = process.arch) {
+  const target = resolveSupportedTarget(platform, arch);
+  return rootPackageName + "-" + target.slug;
+}
+
+module.exports = {
+  SUPPORTED_TARGETS,
+  resolvePackagedBinaryPath,
+  resolvePlatformPackageName,
+  resolveSupportedTarget,
+};

package/package.json

@@ -1,22 +1,30 @@
 {
   "name": "@sys9/chord-cli",
-  "version": "0.1.159-linux-x64",
+  "version": "0.1.159",
   "description": "Chord CLI package used by @sys9/cli",
   "license": "UNLICENSED",
-  "os": [
-    "linux"
-  ],
-  "cpu": [
-    "x64"
-  ],
-  "files": [
-    "vendor"
-  ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/sys9-ai/chord.git"
   },
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "chord": "bin/chord"
+  },
+  "files": [
+    "README.md",
+    "bin",
+    "lib"
+  ],
   "engines": {
     "node": ">=16"
+  },
+  "optionalDependencies": {
+    "@sys9/chord-cli-linux-x64": "npm:@sys9/chord-cli@0.1.159-linux-x64",
+    "@sys9/chord-cli-linux-arm64": "npm:@sys9/chord-cli@0.1.159-linux-arm64",
+    "@sys9/chord-cli-darwin-x64": "npm:@sys9/chord-cli@0.1.159-darwin-x64",
+    "@sys9/chord-cli-darwin-arm64": "npm:@sys9/chord-cli@0.1.159-darwin-arm64"
   }
 }