local-commander-agent-linux-arm64 0.0.0-stage → 0.3.45

package/runtime/lifecycle.mjs

@@ -0,0 +1,788 @@
+// agent/src/posix-lifecycle.ts
+import { constants as constants2 } from "node:fs";
+import { copyFile, lstat as lstat2, mkdir as mkdir2, mkdtemp, open as open2, readlink, realpath as realpath2, rename, rm, stat, symlink, unlink as unlink2 } from "node:fs/promises";
+import path2 from "node:path";
+import os from "node:os";
+import { fileURLToPath } from "node:url";
+import { createHash, randomUUID } from "node:crypto";
+import { spawn as spawn2, spawnSync } from "node:child_process";
+import { setTimeout as delay } from "node:timers/promises";
+
+// agent/src/posix-store.ts
+import { constants } from "node:fs";
+import { lstat, mkdir, open, readdir, realpath, unlink } from "node:fs/promises";
+import path from "node:path";
+import { spawn } from "node:child_process";
+
+// src/child-environment.ts
+var COMMON_ALLOWED_KEYS = /* @__PURE__ */ new Set([
+  "PATH",
+  "TEMP",
+  "TMP",
+  "TMPDIR",
+  "HOME",
+  "USER",
+  "USERNAME",
+  "LOGNAME",
+  "LANG",
+  "LC_ALL",
+  "LC_CTYPE",
+  "TERM",
+  "COLORTERM",
+  "NO_COLOR",
+  "FORCE_COLOR",
+  "CI",
+  "DOTNET_ROOT",
+  "DOTNET_CLI_HOME"
+]);
+var WINDOWS_ALLOWED_KEYS = /* @__PURE__ */ new Set([
+  "PATHEXT",
+  "SYSTEMROOT",
+  "WINDIR",
+  "COMSPEC",
+  "USERPROFILE",
+  "HOMEDRIVE",
+  "HOMEPATH",
+  "APPDATA",
+  "LOCALAPPDATA",
+  "PROGRAMFILES",
+  "PROGRAMFILES(X86)",
+  "PROGRAMW6432",
+  "PROCESSOR_ARCHITECTURE",
+  "PROCESSOR_ARCHITEW6432",
+  "NUMBER_OF_PROCESSORS",
+  "OS",
+  "USERDOMAIN",
+  "PUBLIC"
+]);
+var POSIX_ALLOWED_KEYS = /* @__PURE__ */ new Set([
+  "SHELL",
+  "XDG_CACHE_HOME",
+  "XDG_CONFIG_HOME",
+  "XDG_DATA_HOME"
+]);
+var DENIED_KEYS = /* @__PURE__ */ new Set([
+  "NODE_OPTIONS",
+  "PYTHONPATH",
+  "PYTHONHOME",
+  "PYTHONSTARTUP",
+  "RUBYOPT",
+  "PERL5OPT",
+  "LD_PRELOAD",
+  "LD_LIBRARY_PATH",
+  "DYLD_INSERT_LIBRARIES",
+  "DYLD_LIBRARY_PATH",
+  "GIT_SSH_COMMAND",
+  "GIT_ASKPASS",
+  "SSH_ASKPASS",
+  "NPM_CONFIG_USERCONFIG"
+]);
+var DENIED_SUBSTRINGS = [
+  "LCMCP",
+  "LOCAL_COMMANDER",
+  "PAYPAL",
+  "SQL",
+  "CONNECTIONSTRING",
+  "CONNECTION_STRING",
+  "PASSWORD",
+  "PASSWD",
+  "SECRET",
+  "TOKEN",
+  "CREDENTIAL",
+  "OPENAI",
+  "ANTHROPIC",
+  "API_KEY",
+  "ACCESS_KEY",
+  "PRIVATE_KEY"
+];
+function canonicalAllowedKeys(platform) {
+  const keys = new Set(COMMON_ALLOWED_KEYS);
+  if (platform === "win32") {
+    for (const key of WINDOWS_ALLOWED_KEYS) keys.add(key);
+  } else {
+    for (const key of POSIX_ALLOWED_KEYS) keys.add(key);
+  }
+  const result = /* @__PURE__ */ new Map();
+  for (const key of keys) result.set(platform === "win32" ? key.toUpperCase() : key, key);
+  return result;
+}
+function isDeniedKey(key) {
+  const upper = key.toUpperCase();
+  if (DENIED_KEYS.has(upper)) return true;
+  return DENIED_SUBSTRINGS.some((item) => upper.includes(item));
+}
+function buildChildEnvironment(source, platform = process.platform) {
+  const allowed = canonicalAllowedKeys(platform);
+  const result = {};
+  const seen = /* @__PURE__ */ new Set();
+  for (const [rawKey, value] of Object.entries(source)) {
+    if (value === void 0) continue;
+    const lookupKey = platform === "win32" ? rawKey.toUpperCase() : rawKey;
+    const outputKey = allowed.get(lookupKey);
+    if (!outputKey) continue;
+    if (isDeniedKey(rawKey) || isDeniedKey(outputKey)) continue;
+    if (seen.has(lookupKey)) continue;
+    seen.add(lookupKey);
+    result[outputKey] = value;
+  }
+  return result;
+}
+
+// agent/src/posix-store.ts
+var fail = (code) => {
+  throw Object.assign(Error(code), { code });
+};
+async function privateDirectory(directory) {
+  const stat2 = await lstat(directory);
+  if (!stat2.isDirectory() || stat2.isSymbolicLink() || stat2.uid !== process.getuid() || (stat2.mode & 63) !== 0 || await realpath(directory) !== directory) fail("STORE_DIRECTORY_INVALID");
+}
+async function privateRead(filename, max) {
+  const handle = await open(filename, constants.O_RDONLY | constants.O_NOFOLLOW);
+  try {
+    const stat2 = await handle.stat();
+    if (!stat2.isFile() || stat2.uid !== process.getuid() || (stat2.mode & 63) !== 0 || stat2.nlink !== 1 || stat2.size > max)
+      return fail("STORE_FILE_INVALID");
+    const data = Buffer.alloc(max + 1);
+    let length = 0;
+    while (length < data.length) {
+      const read = await handle.read(data, length, data.length - length, null);
+      if (!read.bytesRead) break;
+      length += read.bytesRead;
+    }
+    if (length > max) return fail("STORE_FILE_INVALID");
+    return data.subarray(0, length);
+  } finally {
+    await handle.close();
+  }
+}
+async function syncDirectory(directory) {
+  const handle = await open(directory, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+  try {
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+}
+async function absent(filename) {
+  try {
+    await lstat(filename);
+    return false;
+  } catch (e) {
+    if (e.code === "ENOENT") return true;
+    throw e;
+  }
+}
+async function acquirePosixJournalGuard(directory, helper) {
+  await privateDirectory(directory);
+  const binary = await lstat(helper);
+  if (!binary.isFile() || binary.isSymbolicLink() || binary.mode & 18 || !(binary.mode & 73) || binary.uid !== 0 && binary.uid !== process.getuid() || await realpath(helper) !== helper) fail("JOURNAL_HELPER_INVALID");
+  const child = spawn(
+    helper,
+    ["--lock", path.join(directory, ".journal.guard")],
+    { stdio: ["pipe", "pipe", "ignore"], env: buildChildEnvironment(process.env), windowsHide: true, shell: false }
+  );
+  child.stdin.on("error", () => {
+  });
+  let ended = false;
+  const closed = new Promise((resolve) => child.once("close", () => {
+    ended = true;
+    resolve();
+  }));
+  const guard = { active: false, close: async () => {
+    if (!ended) child.stdin.end();
+    const timer = setTimeout(() => child.kill("SIGKILL"), 1e3);
+    try {
+      await closed;
+    } finally {
+      clearTimeout(timer);
+      guard.active = false;
+    }
+  } };
+  child.once("close", () => {
+    guard.active = false;
+  });
+  try {
+    await new Promise((resolve, reject) => {
+      let text = "";
+      const timer = setTimeout(() => {
+        child.kill("SIGKILL");
+        reject(Error("JOURNAL_LOCKED"));
+      }, 5e3);
+      const done = (error) => {
+        clearTimeout(timer);
+        error ? reject(error) : resolve();
+      };
+      child.once("error", () => done(Error("JOURNAL_HELPER_INVALID")));
+      child.once("close", (code) => done(Error(code === 75 ? "JOURNAL_LOCKED" : "JOURNAL_LOCK_INVALID")));
+      child.stdout.setEncoding("utf8");
+      child.stdout.on("data", (chunk) => {
+        text += chunk;
+        if (text.length < 64 && !text.includes("\n")) return;
+        if (text === '{"locked":true}\n') {
+          guard.active = true;
+          done();
+        } else {
+          child.kill("SIGKILL");
+          done(Error("JOURNAL_LOCK_INVALID"));
+        }
+      });
+    });
+    const lock = path.join(directory, "journal.lock");
+    if (!await absent(lock)) {
+      let previous;
+      try {
+        previous = JSON.parse((await privateRead(lock, 1024)).toString());
+      } catch {
+        return fail("JOURNAL_LOCK_INVALID");
+      }
+      if (!previous || Object.keys(previous).sort().join(",") !== "createdAt,nonce,pid" || !Number.isSafeInteger(previous.pid) || previous.pid <= 0 || previous.pid > 4294967295 || !/^[a-f0-9]{32}$/.test(previous.nonce) || typeof previous.createdAt !== "string" || !Number.isFinite(Date.parse(previous.createdAt)) || new Date(previous.createdAt).toISOString() !== previous.createdAt) return fail("JOURNAL_LOCK_INVALID");
+      let absentOwner = false;
+      try {
+        process.kill(previous.pid, 0);
+      } catch (e) {
+        absentOwner = e.code === "ESRCH";
+      }
+      if (!absentOwner || !guard.active) return fail("JOURNAL_LOCKED");
+      await unlink(lock);
+      await syncDirectory(directory);
+    }
+    if (!guard.active) return fail("JOURNAL_LOCK_LOST");
+    return guard;
+  } catch (e) {
+    await guard.close();
+    throw e;
+  }
+}
+
+// agent/src/posix-lifecycle.ts
+var label = "app.localcmd.agent";
+var PRODUCTION_ORIGIN = "https://localcmd.app";
+function fail2(code) {
+  throw Error(code);
+}
+var hash = (data) => createHash("sha256").update(data).digest("hex");
+var idPattern = /^[a-f0-9]{64}$/;
+function privateInstallPaths() {
+  const home = os.homedir();
+  const data = path2.join(home, process.platform === "darwin" ? "Library/Application Support" : ".local/share", "LocalCommander/Runtime");
+  const root = path2.join(data, "LocalCommander");
+  return {
+    home,
+    data,
+    root,
+    state: path2.join(root, "Agent"),
+    versions: path2.join(root, "versions"),
+    service: path2.join(home, process.platform === "darwin" ? "Library/LaunchAgents/" + label + ".plist" : ".config/systemd/user/" + label + ".service")
+  };
+}
+var paths = privateInstallPaths();
+var unit = label + ".service";
+var domain = "gui/" + process.getuid?.();
+var env = {
+  HOME: paths.home,
+  USER: os.userInfo().username,
+  LOGNAME: os.userInfo().username,
+  PATH: "/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin",
+  LC_NATIVE_253_INSTALLED: "1",
+  ...process.platform === "linux" ? {
+    XDG_CONFIG_HOME: path2.join(paths.home, ".config"),
+    XDG_RUNTIME_DIR: "/run/user/" + process.getuid(),
+    DBUS_SESSION_BUS_ADDRESS: "unix:path=/run/user/" + process.getuid() + "/bus"
+  } : {}
+};
+async function absent2(filename) {
+  try {
+    await lstat2(filename);
+    return false;
+  } catch (e) {
+    if (e.code === "ENOENT") return true;
+    throw e;
+  }
+}
+async function ownedParents(directory) {
+  if (!path2.isAbsolute(directory) || /[\0-\x1f\x7f]/.test(directory)) fail2("LIFECYCLE_PATH_INVALID");
+  const missing = [];
+  let cursor = directory;
+  while (await absent2(cursor)) {
+    missing.push(cursor);
+    cursor = path2.dirname(cursor);
+  }
+  for (let ancestor = cursor; ; ancestor = path2.dirname(ancestor)) {
+    const stat2 = await lstat2(ancestor);
+    if (!stat2.isDirectory() || stat2.isSymbolicLink() || stat2.mode & 18 || stat2.uid !== 0 && stat2.uid !== process.getuid() || await realpath2(ancestor) !== ancestor) {
+      process.stderr.write(JSON.stringify({
+        unsafeParent: ancestor,
+        mode: (stat2.mode & 4095).toString(8),
+        owner: stat2.uid,
+        expectedOwner: process.getuid(),
+        symlink: stat2.isSymbolicLink(),
+        canonical: await realpath2(ancestor) === ancestor
+      }) + "\n");
+      fail2("LIFECYCLE_PATH_INVALID");
+    }
+    if (ancestor === path2.dirname(ancestor)) break;
+  }
+  for (const item of missing.reverse()) await mkdir2(item, { mode: 448 });
+}
+async function versionLink(name) {
+  const filename = path2.join(paths.root, name);
+  if (await absent2(filename)) return null;
+  const stat2 = await lstat2(filename);
+  if (!stat2.isSymbolicLink() || stat2.uid !== process.getuid()) fail2("LIFECYCLE_LINK_INVALID");
+  const target = await readlink(filename);
+  if (!/^versions\/[a-f0-9]{64}$/.test(target)) fail2("LIFECYCLE_LINK_INVALID");
+  return target.slice("versions/".length);
+}
+async function setVersion(name, id) {
+  if (!idPattern.test(id)) fail2("LIFECYCLE_LINK_INVALID");
+  await versionLink(name);
+  const target = path2.join(paths.root, name), temporary = target + "." + randomUUID();
+  await symlink("versions/" + id, temporary);
+  try {
+    await rename(temporary, target);
+    await syncDirectory(paths.root);
+  } finally {
+    await rm(temporary, { force: true });
+  }
+}
+var executableNames = /* @__PURE__ */ new Set(["node", "posix-host", "owner-store"]);
+async function digestFile(filename) {
+  const file = await open2(filename, constants2.O_RDONLY | constants2.O_NOFOLLOW);
+  try {
+    const stat2 = await file.stat();
+    if (!stat2.isFile() || stat2.uid !== process.getuid() || stat2.nlink !== 1 || stat2.mode & 63 || stat2.size < 1 || stat2.size > 160 * 1024 * 1024 || executableNames.has(path2.basename(filename)) && !(stat2.mode & 64)) fail2("LIFECYCLE_ARTIFACT_INVALID");
+    const digest = createHash("sha256");
+    for await (const chunk of file.createReadStream({ autoClose: false })) digest.update(chunk);
+    return digest.digest("hex");
+  } finally {
+    await file.close();
+  }
+}
+async function artifact(directory) {
+  await privateDirectory(directory);
+  const bytes = await privateRead(path2.join(directory, "manifest.json"), 16384);
+  const manifest = JSON.parse(bytes.toString());
+  const names = [
+    "agent.mjs",
+    "lifecycle.mjs",
+    "node",
+    "posix-host",
+    "NODE-LICENSE.txt",
+    "job-host.mjs",
+    ...process.platform === "darwin" ? ["owner-store"] : []
+  ].sort();
+  if (!manifest || manifest.experimental !== true || manifest.lifecycleVersion !== 1 || manifest.platform !== process.platform || manifest.arch !== process.arch || !manifest.files || Object.keys(manifest.files).sort().join() !== names.join()) fail2("LIFECYCLE_ARTIFACT_INVALID");
+  for (const name of names)
+    if (!idPattern.test(manifest.files[name]) || await digestFile(path2.join(directory, name)) !== manifest.files[name]) fail2("LIFECYCLE_ARTIFACT_INVALID");
+  return { id: hash(bytes), names: [...names, "manifest.json"] };
+}
+async function stage(source) {
+  const verified = await artifact(source), target = path2.join(paths.versions, verified.id);
+  if (!await absent2(target)) {
+    if ((await artifact(target)).id !== verified.id) fail2("LIFECYCLE_ARTIFACT_INVALID");
+    return verified.id;
+  }
+  const temporary = await mkdtemp(path2.join(paths.versions, ".stage-"));
+  try {
+    for (const name of verified.names) {
+      const filename = path2.join(temporary, name);
+      await copyFile(path2.join(source, name), filename, constants2.COPYFILE_EXCL);
+      const file = await open2(filename, constants2.O_RDONLY | constants2.O_NOFOLLOW);
+      try {
+        await file.sync();
+      } finally {
+        await file.close();
+      }
+    }
+    if ((await artifact(temporary)).id !== verified.id) fail2("LIFECYCLE_ARTIFACT_INVALID");
+    await syncDirectory(temporary);
+    await rename(temporary, target);
+    await syncDirectory(paths.versions);
+    return verified.id;
+  } finally {
+    await rm(temporary, { recursive: true, force: true });
+  }
+}
+var logPath = () => path2.join(paths.root, "agent.log");
+function serviceText(legacy = false) {
+  const args = [
+    "/usr/bin/env",
+    "-i",
+    ...Object.entries(env).map(([k, v]) => k + "=" + v),
+    path2.join(paths.root, "current/node"),
+    path2.join(paths.root, "current/agent.mjs"),
+    "run"
+  ];
+  if (process.platform === "linux") {
+    const quote = (s) => '"' + s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/%/g, "%%") + '"';
+    return "[Unit]\nDescription=Local Commander agent\nStartLimitIntervalSec=30s\nStartLimitBurst=3\n[Service]\nType=exec\nExecStart=:" + args.map(quote).join(" ") + "\nUMask=0077\nRestart=on-failure\nRestartSec=2s\nKillMode=mixed\nTimeoutStopSec=10s\nStandardOutput=null\nStandardError=" + (legacy ? "null" : "journal") + "\n[Install]\nWantedBy=default.target\n";
+  }
+  const xml = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+  return '<?xml version="1.0" encoding="UTF-8"?>\n<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">\n<plist version="1.0"><dict><key>Label</key><string>' + label + "</string><key>ProgramArguments</key><array>" + args.map((s) => "<string>" + xml(s) + "</string>").join("") + "</array><key>RunAtLoad</key><true/><key>KeepAlive</key><dict><key>SuccessfulExit</key><false/></dict><key>ThrottleInterval</key><integer>2</integer><key>ExitTimeOut</key><integer>10</integer><key>Umask</key><integer>63</integer><key>StandardOutPath</key><string>/dev/null</string><key>StandardErrorPath</key><string>" + (legacy ? "/dev/null" : xml(logPath())) + "</string></dict></plist>\n";
+}
+function manager(args, allowFailure = false) {
+  const result = spawnSync(
+    process.platform === "linux" ? "/usr/bin/systemctl" : "/bin/launchctl",
+    process.platform === "linux" ? ["--user", "--no-pager", ...args] : args,
+    { env, encoding: "utf8", timeout: 15e3, maxBuffer: 65536, shell: false, windowsHide: true }
+  );
+  if (result.error || result.signal || !allowFailure && result.status !== 0) fail2("LIFECYCLE_MANAGER_FAILED");
+  return result;
+}
+var upgradeService = false;
+async function registered() {
+  if (await absent2(paths.service)) return false;
+  const text = (await privateRead(paths.service, 16384)).toString();
+  if (text === serviceText()) return true;
+  if (text !== serviceText(true)) fail2("LIFECYCLE_SERVICE_CONFLICT");
+  if (upgradeService) {
+    const temporary = paths.service + "." + randomUUID();
+    const handle = await open2(temporary, "wx", 384);
+    try {
+      await handle.writeFile(serviceText());
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+    try {
+      await rename(temporary, paths.service);
+      await syncDirectory(path2.dirname(paths.service));
+    } finally {
+      await rm(temporary, { force: true });
+    }
+    if (process.platform === "linux") manager(["daemon-reload"]);
+  }
+  return true;
+}
+async function prepareLog() {
+  if (process.platform !== "darwin") return;
+  const file = logPath();
+  try {
+    if ((await stat(file)).size > 1024 * 1024) await rename(file, file + ".1");
+  } catch (e) {
+    if (e.code !== "ENOENT") throw e;
+  }
+  const handle = await open2(file, constants2.O_CREAT | constants2.O_WRONLY | constants2.O_APPEND | constants2.O_NOFOLLOW, 384);
+  try {
+    if ((await handle.stat()).uid !== process.getuid()) fail2("LIFECYCLE_PATH_INVALID");
+  } finally {
+    await handle.close();
+  }
+}
+function servicePid() {
+  if (process.platform === "linux") {
+    const result2 = manager(["show", unit, "--property=MainPID,FragmentPath,DropInPaths"]);
+    const fields = Object.fromEntries(result2.stdout.trim().split("\n").map((line) => {
+      const index = line.indexOf("=");
+      return [line.slice(0, index), line.slice(index + 1)];
+    }));
+    if (fields.FragmentPath !== paths.service || fields.DropInPaths !== "") fail2("LIFECYCLE_SERVICE_CONFLICT");
+    const pid = Number(fields.MainPID);
+    if (!Number.isSafeInteger(pid) || pid < 0) fail2("LIFECYCLE_STATUS_INVALID");
+    return pid || null;
+  }
+  const result = manager(["print", domain + "/" + label], true);
+  if (result.status !== 0) return null;
+  if (/^\s*path = (.+)$/m.exec(result.stdout)?.[1]?.trim() !== paths.service) fail2("LIFECYCLE_SERVICE_CONFLICT");
+  const match = /^\s*pid = ([0-9]+)\s*$/m.exec(result.stdout);
+  return match ? Number(match[1]) : null;
+}
+async function stop() {
+  if (!await registered()) return;
+  servicePid();
+  if (process.platform === "linux") manager(["stop", unit]);
+  else {
+    const exists = manager(["print", domain + "/" + label], true);
+    if (exists.status === 0) manager(["bootout", domain + "/" + label]);
+  }
+  for (let i = 0; i < 100; i++) {
+    if (!servicePid()) return;
+    await delay(100);
+  }
+  fail2("LIFECYCLE_STOP_TIMEOUT");
+}
+async function start() {
+  if (!await registered()) fail2("LIFECYCLE_NOT_INSTALLED");
+  await prepareLog();
+  const id = await versionLink("current");
+  if (!id || (await artifact(path2.join(paths.versions, id))).id !== id) fail2("LIFECYCLE_ARTIFACT_INVALID");
+  servicePid();
+  if (process.platform === "linux") {
+    manager(["reset-failed", unit]);
+    manager(["start", unit]);
+  } else if (manager(["print", domain + "/" + label], true).status !== 0) manager(["bootstrap", domain, paths.service]);
+  else manager(["kickstart", domain + "/" + label]);
+  for (let i = 0; i < 100; i++) {
+    const pid = servicePid();
+    try {
+      const record = JSON.parse((await privateRead(path2.join(paths.state, "agent-process.json"), 8192)).toString());
+      const lock = JSON.parse((await privateRead(path2.join(paths.state, "journal/journal.lock"), 1024)).toString());
+      if (pid && record.pid === pid && lock.pid === pid && record.runtimeDir === path2.join(paths.versions, id)) return;
+      if (i === 99) process.stderr.write(JSON.stringify({
+        servicePid: pid,
+        recordPid: record.pid,
+        journalPid: lock.pid,
+        canonicalRuntime: record.runtimeDir === path2.join(paths.versions, id),
+        linkedRuntime: record.runtimeDir === path2.join(paths.root, "current")
+      }) + "\n");
+    } catch (e) {
+      if (e.code !== "ENOENT") throw e;
+    }
+    await delay(100);
+  }
+  if (process.platform === "darwin") {
+    const detail = manager(["print", domain + "/" + label], true);
+    process.stderr.write(detail.stdout.split("\n").filter((line) => /^\s*(state|pid|last exit code|last terminating signal|runs) = [a-z0-9 -]+\s*$/.test(line)).join("\n") + "\n");
+  }
+  fail2("LIFECYCLE_START_TIMEOUT");
+}
+var pendingPath = path2.join(paths.root, "lifecycle-pending.json");
+async function pendingSwitch() {
+  if (await absent2(pendingPath)) return null;
+  let value;
+  try {
+    value = JSON.parse((await privateRead(pendingPath, 1024)).toString());
+  } catch {
+    return fail2("LIFECYCLE_RECOVERY_INVALID");
+  }
+  if (!value || value.version !== 1 || typeof value.wasRunning !== "boolean" || typeof value.current !== "string" || !idPattern.test(value.current) || typeof value.next !== "string" || !idPattern.test(value.next) || value.current === value.next || value.previous !== null && (typeof value.previous !== "string" || !idPattern.test(value.previous)) || Object.keys(value).sort().join() !== "current,next,previous,version,wasRunning") fail2("LIFECYCLE_RECOVERY_INVALID");
+  return value;
+}
+async function saveSwitch(value) {
+  if (!await absent2(pendingPath)) fail2("LIFECYCLE_RECOVERY_REQUIRED");
+  const temporary = pendingPath + "." + randomUUID();
+  const handle = await open2(temporary, "wx", 384);
+  try {
+    await handle.writeFile(JSON.stringify(value) + "\n");
+    await handle.sync();
+    await rename(temporary, pendingPath);
+    await syncDirectory(paths.root);
+  } finally {
+    await handle.close();
+    await rm(temporary, { force: true });
+  }
+}
+async function clearSwitch() {
+  await unlink2(pendingPath);
+  await syncDirectory(paths.root);
+}
+async function restoreSwitch(value, restart) {
+  if (!await registered()) fail2("LIFECYCLE_SERVICE_CONFLICT");
+  const current = await versionLink("current"), previous = await versionLink("previous");
+  if (current !== value.current && current !== value.next || previous !== value.previous && previous !== value.current) fail2("LIFECYCLE_RECOVERY_CONFLICT");
+  for (const id of new Set([value.current, value.previous].filter((id2) => id2 !== null)))
+    if ((await artifact(path2.join(paths.versions, id))).id !== id) fail2("LIFECYCLE_ARTIFACT_INVALID");
+  await stop();
+  await setVersion("current", value.current);
+  if (value.previous) await setVersion("previous", value.previous);
+  else if (await versionLink("previous")) {
+    await unlink2(path2.join(paths.root, "previous"));
+    await syncDirectory(paths.root);
+  }
+  if (restart && value.wasRunning) await start();
+  await clearSwitch();
+}
+function agentArgs(args) {
+  const runtime = path2.join(paths.root, "current");
+  return {
+    file: path2.join(runtime, "node"),
+    args: [path2.join(runtime, "agent.mjs"), ...args],
+    env: { ...env, LC_CONTROL_PLANE_ORIGIN: process.env.LC_CONTROL_PLANE_ORIGIN || PRODUCTION_ORIGIN }
+  };
+}
+function agentStatus() {
+  const call = agentArgs(["identity-status"]);
+  const result = spawnSync(call.file, call.args, { env: call.env, encoding: "utf8", timeout: 3e4, maxBuffer: 65536, shell: false });
+  if (result.error || result.signal || result.status !== 0) fail2("AGENT_STATUS_FAILED");
+  const value = JSON.parse(result.stdout.trim().split("\n").at(-1));
+  if (typeof value?.paired !== "boolean") fail2("AGENT_STATUS_FAILED");
+  return value;
+}
+function configureAccess() {
+  const call = agentArgs(["configure-access"]);
+  const result = spawnSync(call.file, call.args, { env: call.env, stdio: ["inherit", "pipe", "inherit"], encoding: "utf8", timeout: 10 * 6e4, shell: false });
+  if (result.error || result.signal || result.status !== 0) fail2("ACCESS_SETUP_FAILED");
+  if (!result.stdout.includes("ACCESS_CONFIGURED")) fail2("ACCESS_CANCELLED");
+}
+async function pair() {
+  const call = agentArgs(["pair"]);
+  const child = spawn2(call.file, call.args, { env: call.env, stdio: ["ignore", "pipe", "inherit"], shell: false });
+  let buffer = "", paired = false;
+  child.stdout.setEncoding("utf8");
+  child.stdout.on("data", (chunk) => {
+    buffer += chunk;
+    for (let i; (i = buffer.indexOf("\n")) >= 0; ) {
+      const line = buffer.slice(0, i).trim();
+      buffer = buffer.slice(i + 1);
+      if (line === "DEVICE_PAIRED") {
+        paired = true;
+        continue;
+      }
+      try {
+        const begun = JSON.parse(line);
+        if (typeof begun.approvalUrl === "string") process.stdout.write("\nApprove this computer in your browser:\n  " + begun.approvalUrl + "\nConfirmation code: " + begun.confirmationCode + "\nWaiting for approval...\n");
+      } catch {
+      }
+    }
+  });
+  const code = await new Promise((resolve, reject) => {
+    child.once("error", reject);
+    child.once("close", resolve);
+  });
+  if (code !== 0 || !paired) fail2("PAIRING_FAILED");
+}
+async function main() {
+  if (!["linux", "darwin"].includes(process.platform) || !process.getuid || !process.getuid() || process.geteuid?.() !== process.getuid()) fail2("POSIX_OWNER_REQUIRED");
+  const command = process.argv[2];
+  const purge = process.argv.length === 4 && command === "uninstall" && process.argv[3] === "--purge-state";
+  if (process.argv.length !== 3 && !purge || !["setup", "install", "pair", "access", "update", "rollback", "start", "stop", "status", "uninstall"].includes(command)) fail2("LIFECYCLE_ARGUMENT_INVALID");
+  const source = path2.dirname(fileURLToPath(import.meta.url));
+  if (command === "status" && await absent2(paths.root)) {
+    process.stdout.write(JSON.stringify({ installed: false, running: false, stateDirectory: paths.state }) + "\n");
+    return;
+  }
+  await ownedParents(paths.root);
+  await privateDirectory(paths.root);
+  const marker = path2.join(paths.root, "agent.marker");
+  if (await absent2(marker)) {
+    const { readdir: readdir2 } = await import("node:fs/promises");
+    if ((await readdir2(paths.root)).length || command !== "install" && command !== "setup") fail2("LIFECYCLE_DIRECTORY_UNKNOWN");
+    const handle = await open2(marker, "wx", 384);
+    try {
+      await handle.writeFile(label + "\n");
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+    await syncDirectory(paths.root);
+  } else if ((await privateRead(marker, 128)).toString() !== label + "\n") fail2("LIFECYCLE_DIRECTORY_UNKNOWN");
+  const guard = await acquirePosixJournalGuard(paths.root, path2.join(source, "posix-host"));
+  upgradeService = command !== "status";
+  try {
+    await ownedParents(path2.dirname(paths.service));
+    await ownedParents(paths.versions);
+    await privateDirectory(paths.versions);
+    const pending = await pendingSwitch();
+    if (pending && command !== "status") await restoreSwitch(pending, !["start", "stop", "uninstall"].includes(command));
+    const installed = await registered(), current = await versionLink("current");
+    if (command === "status") {
+      const pid = installed ? servicePid() : null;
+      process.stdout.write(JSON.stringify({
+        installed,
+        running: !!pid,
+        pid,
+        current,
+        previous: await versionLink("previous"),
+        recoveryPending: !!pending,
+        runtimeDirectory: current ? path2.join(paths.versions, current) : null,
+        stateDirectory: paths.state,
+        dataDirectory: paths.data
+      }) + "\n");
+      return;
+    }
+    const install = async () => {
+      const id = await stage(source);
+      if (current && current !== id) fail2("LIFECYCLE_ALREADY_INSTALLED");
+      await setVersion("current", id);
+      if (!installed) {
+        const handle = await open2(paths.service, "wx", 384);
+        try {
+          await handle.writeFile(serviceText());
+          await handle.sync();
+        } finally {
+          await handle.close();
+        }
+        await syncDirectory(path2.dirname(paths.service));
+      }
+      if (process.platform === "linux") {
+        manager(["daemon-reload"]);
+        servicePid();
+        manager(["enable", unit]);
+      }
+    };
+    if (command === "install") await install();
+    else if (command === "setup") {
+      if (!installed || !current) await install();
+      await stop();
+      const identity = agentStatus();
+      if (!identity.paired) await pair();
+      configureAccess();
+      await start();
+      const status = agentStatus();
+      if (process.platform === "darwin") process.stdout.write("\nmacOS asks once before Local Commander first reads Documents, Desktop or Downloads; click Allow.\nTo allow it in advance: System Settings > Privacy & Security > Full Disk Access, add " + path2.join(paths.root, "current/node") + "\nAgent log: " + logPath() + "\n\n");
+      process.stdout.write(JSON.stringify({ action: "setup", success: true, running: !!servicePid(), accountEmail: status.accountEmail, deviceId: status.deviceId }) + "\n");
+      return;
+    } else if (command === "pair" || command === "access") {
+      if (!installed || !current) fail2("LIFECYCLE_NOT_INSTALLED");
+      const wasRunning = !!servicePid();
+      await stop();
+      if (command === "pair") {
+        if (agentStatus().paired) fail2("DEVICE_ALREADY_PAIRED");
+        await pair();
+      } else configureAccess();
+      if (wasRunning) await start();
+    } else if (command === "update" || command === "rollback") {
+      if (!installed || !current) fail2("LIFECYCLE_NOT_INSTALLED");
+      const next = command === "update" ? await stage(source) : await versionLink("previous");
+      if (!next || (await artifact(path2.join(paths.versions, next))).id !== next) fail2("LIFECYCLE_NO_ROLLBACK");
+      if (next === current) fail2("LIFECYCLE_VERSION_UNCHANGED");
+      const pending2 = { version: 1, current, previous: await versionLink("previous"), next, wasRunning: !!servicePid() };
+      await saveSwitch(pending2);
+      try {
+        await stop();
+        await setVersion("previous", current);
+        await setVersion("current", next);
+        if (pending2.wasRunning) await start();
+      } catch (error) {
+        await restoreSwitch(pending2, true);
+        throw error;
+      }
+      await clearSwitch();
+    } else if (command === "start") {
+      try {
+        await start();
+      } catch (error) {
+        await stop();
+        throw error;
+      }
+    } else if (command === "stop") await stop();
+    else if (command === "uninstall") {
+      if (!installed) fail2("LIFECYCLE_NOT_INSTALLED");
+      await stop();
+      if (process.platform === "linux") manager(["disable", unit]);
+      if (!await registered()) fail2("LIFECYCLE_SERVICE_CONFLICT");
+      await unlink2(paths.service);
+      await syncDirectory(path2.dirname(paths.service));
+      if (process.platform === "linux") manager(["daemon-reload"]);
+      for (const name of ["current", "previous"]) if (await versionLink(name)) await unlink2(path2.join(paths.root, name));
+      await syncDirectory(paths.root);
+      if (purge && !await absent2(paths.state)) {
+        const stat2 = await lstat2(paths.state);
+        if (!stat2.isDirectory() || stat2.isSymbolicLink() || stat2.uid !== process.getuid()) fail2("LIFECYCLE_PATH_INVALID");
+        if (process.platform === "linux") {
+          try {
+            const reference = JSON.parse((await privateRead(path2.join(paths.state, "owner-key.json"), 512)).toString());
+            if (reference?.provider === "secret-service" && typeof reference.id === "string" && /^[0-9a-f-]{36}$/.test(reference.id))
+              spawnSync("/usr/bin/secret-tool", ["clear", "service", "app.localcmd.agent.state.v1", "id", reference.id], { env, timeout: 15e3, shell: false });
+          } catch (e) {
+            if (e.code !== "ENOENT") throw e;
+          }
+        }
+        await rm(paths.state, { recursive: true, force: true });
+        await syncDirectory(paths.root);
+      }
+    }
+    process.stdout.write(JSON.stringify({ action: command, success: true, ...purge ? { stateRemoved: true } : {}, stateDirectory: paths.state, dataDirectory: paths.data }) + "\n");
+  } finally {
+    await guard.close();
+  }
+}
+if (process.argv[1] && await realpath2(process.argv[1]).catch(() => null) === fileURLToPath(import.meta.url)) {
+  void main().catch((error) => {
+    process.stderr.write(error instanceof Error && /^[A-Z0-9_]{1,64}$/.test(error.message) ? error.message + "\n" : "LIFECYCLE_FAILED\n");
+    process.exitCode = 1;
+  });
+}
+export {
+  privateInstallPaths
+};