@sys9/chord-cli 0.1.126-linux-arm64 → 0.1.126

package/bin/chord

@@ -0,0 +1,454 @@
+#!/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 updateRequiredExitCode = 75;
+const updateFDEnv = "CHORD_CLI_UPDATE_FD";
+const updateVersionEnv = "CHORD_CLI_AUTO_UPDATE_VERSION";
+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 maxUpdateInstructionBytes = 4096;
+const defaultUpdateReadyTimeoutMs = 60_000;
+let child = null;
+let receivedSignal = null;
+
+const forwardSignal = (signal) => {
+  receivedSignal = signal;
+  if (!child || child.killed) {
+    return;
+  }
+  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) {
+  return new Promise((resolve) => {
+    let updateInstruction = "";
+    let settled = false;
+    let childResult = null;
+    let updatePipeClosed = true;
+    const finish = (result) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      child = null;
+      resolve(result);
+    };
+    const finishAfterUpdatePipe = () => {
+      if (childResult && updatePipeClosed) {
+        finish({ ...childResult, updateInstruction });
+      }
+    };
+    child = spawn(command, args, options);
+    if (child.stdio[3]) {
+      updatePipeClosed = false;
+      child.stdio[3].setEncoding("utf8");
+      child.stdio[3].on("data", (chunk) => {
+        if (updateInstruction.length <= maxUpdateInstructionBytes) {
+          updateInstruction += chunk;
+        }
+      });
+      child.stdio[3].on("end", () => {
+        updatePipeClosed = true;
+        finishAfterUpdatePipe();
+      });
+    }
+    child.on("error", (error) => {
+      finish({ code: 1, signal: null, updateInstruction: "", error });
+    });
+    child.on("exit", (code, signal) => {
+      // A daemon descendant may temporarily retain the update pipe. Once the
+      // direct child exits after a signal, waiting for every inherited file
+      // descriptor would keep service shutdown stuck for that descendant's
+      // lifetime.
+      if (signal || receivedSignal) {
+        finish({ code: code ?? 1, signal, updateInstruction, error: null });
+      }
+    });
+    child.on("close", (code, signal) => {
+      childResult = { code: code ?? 1, signal, error: null };
+      finishAfterUpdatePipe();
+    });
+  });
+}
+
+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 reason = instruction.reason || "protocol";
+    if (reason === "protocol") {
+      return { cliVersion: version, reason };
+    }
+    const attemptID = instruction.attempt_id;
+    const dataDir = instruction.data_dir;
+    const fromVersion = instruction.from_version;
+    const hostID = instruction.host_id;
+    if (
+      reason !== "user" ||
+      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, reason, 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 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 stopCandidate(completion, candidateChild) {
+  if (candidateChild && candidateChild.exitCode === null && candidateChild.signalCode === null) {
+    try {
+      candidateChild.kill("SIGTERM");
+    } catch {
+      // The child may have exited between the check and signal.
+    }
+  }
+  const stopped = await Promise.race([
+    completion.then(() => true),
+    new Promise((resolve) => setTimeout(() => resolve(false), 5_000)),
+  ]);
+  if (!stopped && candidateChild && candidateChild.exitCode === null && candidateChild.signalCode === null) {
+    try {
+      candidateChild.kill("SIGKILL");
+    } catch {
+      // The child may have exited between the check and signal.
+    }
+  }
+  return 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;
+}
+
+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" },
+    });
+  }
+
+  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", ""),
+      [updateVersionEnv]: instruction.cliVersion,
+    },
+  });
+  const candidateChild = child;
+  const readiness = monitorReadiness(snapshot.readyFile, instruction, "target");
+  const outcome = await Promise.race([
+    candidate.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;
+  }
+  if (outcome.kind === "ready") {
+    removeUpdateSnapshot(snapshot);
+    return candidate;
+  }
+  if (outcome.kind === "timeout") {
+    await stopCandidate(candidate, candidateChild);
+  }
+  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 };
+  }
+
+  fs.rmSync(snapshot.readyFile, { force: true });
+  const restored = runChild(binaryPath, daemonArgs, {
+    stdio: ["inherit", "inherit", "inherit", "pipe"],
+    env: managedUpdateEnvironment(instruction, snapshot, "rolled_back", failure),
+  });
+  const rollbackReadiness = monitorReadiness(snapshot.readyFile, instruction, "rolled_back");
+  const rollbackOutcome = await Promise.race([
+    restored.then((result) => ({ kind: "exit", result })),
+    rollbackReadiness.promise,
+  ]);
+  rollbackReadiness.cancel();
+  if (rollbackOutcome.kind === "ready") {
+    removeUpdateSnapshot(snapshot);
+  }
+  return restored;
+}
+
+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);
+  const result = await runChild(binaryPath, daemonArgs, {
+    stdio: ["inherit", "inherit", "inherit", "pipe"],
+    env: { ...process.env, [updateFDEnv]: "3" },
+  });
+  if (result.error) {
+    console.error(result.error);
+    return result;
+  }
+  if (result.signal || receivedSignal) {
+    return { ...result, signal: result.signal || receivedSignal };
+  }
+  if (result.code !== updateRequiredExitCode) {
+    return result;
+  }
+
+  const instruction = parseUpdateInstruction(result.updateInstruction);
+  if (!instruction) {
+    console.error("Chord daemon requires an update, but the server did not provide a valid CLI version.");
+    return result;
+  }
+  if (process.env[updateVersionEnv] === instruction.cliVersion) {
+    console.error("Chord daemon automatic update to " + instruction.cliVersion + " was already attempted; update @sys9/chord-cli manually.");
+    return result;
+  }
+
+  const packageManager = detectPackageManager();
+  if (instruction.reason === "user") {
+    return runManagedUpdate(binaryPath, packageManager, instruction, daemonArgs);
+  }
+  const update = updateCommand(packageManager, instruction.cliVersion, daemonArgs);
+  console.error("Chord daemon protocol changed; restarting with @sys9/chord-cli@" + instruction.cliVersion + ".");
+  const updated = await runChild(update.command, update.args, {
+    stdio: "inherit",
+    env: { ...process.env, [updateVersionEnv]: instruction.cliVersion },
+  });
+  return { ...updated, signal: updated.signal || receivedSignal };
+}
+
+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.126-linux-arm64",
+  "version": "0.1.126",
   "description": "Chord CLI package used by @sys9/cli",
   "license": "UNLICENSED",
-  "os": [
-    "linux"
-  ],
-  "cpu": [
-    "arm64"
-  ],
-  "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.126-linux-x64",
+    "@sys9/chord-cli-linux-arm64": "npm:@sys9/chord-cli@0.1.126-linux-arm64",
+    "@sys9/chord-cli-darwin-x64": "npm:@sys9/chord-cli@0.1.126-darwin-x64",
+    "@sys9/chord-cli-darwin-arm64": "npm:@sys9/chord-cli@0.1.126-darwin-arm64"
   }
 }