agentradar-cli 0.1.8 → 0.2.0

package/dist/setup.js

@@ -1,8 +1,25 @@
+import { createHash } from "node:crypto";
 import { chmod, lstat, mkdir, readFile, realpath, rename, writeFile } from "node:fs/promises";
-import { basename, join, resolve } from "node:path";
+import { basename, dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 import { homedir } from "node:os";
 import * as tls from "node:tls";
 const DEFAULT_API_URL = "https://vendor.agentradar.com/api";
+/** `ar_` is a vendor runner bearer; `pcp_` is the key an organisation's own agent claims through `join`. */
+const BEARER_SHAPE = /^(?:ar|pcp)_[A-Za-z0-9_-]+$/;
+/**
+ * R004 — the server's harness id, in the words `supervise-agent.sh` accepts.
+ *
+ * Two vocabularies, deliberately: the server stores `claude_code` (its internal id, the key of
+ * `HARNESS_PROFILES`, and what lands in `adapterConfig.harness`), while the supervisor's
+ * `AR_AGENT_HARNESS` takes `claude`. Translating here rather than widening either side keeps the
+ * refusal in one place — the supervisor dies by name on an unrecognised value, and so does this.
+ */
+const SUPERVISOR_HARNESS = {
+    claude: "claude",
+    claude_code: "claude",
+    codex: "codex",
+};
 async function postJson(fetchImpl, url, body) {
     return fetchImpl(url, {
         method: "POST",
@@ -10,9 +27,35 @@ async function postJson(fetchImpl, url, body) {
         body: JSON.stringify(body),
     });
 }
+/**
+ * The server's own words for a refusal, when it sent any.
+ *
+ * 🔴 THE BODY WAS BEING THROWN AWAY ON THE FAILURE PATH, one function above the `console.error` that
+ * would have printed it. `POST /vendor/agent-setups` answers a configuration problem with
+ * `{ error: "vendor_setup_not_configured", message: "Vendor setup is unavailable until the public
+ * MCP and vendor portal URLs are configured." }` (`server/src/routes/vendor.ts`), and the vendor read
+ * `AgentRadar setup request failed (503)` — on the FIRST door they touch in the product.
+ *
+ * Reads `message` before `error` because this door sends both and only `message` is a sentence;
+ * elsewhere the servers' convention is a bare `{ error: <sentence> }`, so both are tried. A non-JSON
+ * body (an HTML error page from a proxy, an empty 502) throws in `json()` and falls back to the
+ * status line — which is why the parse is inside the try and not beside it.
+ */
+async function failureMessage(response) {
+    const line = `AgentRadar setup request failed (${response.status})`;
+    try {
+        const body = await response.json();
+        const said = [body?.message, body?.error]
+            .find((value) => typeof value === "string" && value.trim().length > 0);
+        return said ? `${line}: ${said.trim()}` : line;
+    }
+    catch {
+        return line;
+    }
+}
 async function responseJson(response) {
     if (!response.ok)
-        throw new Error(`AgentRadar setup request failed (${response.status})`);
+        throw new Error(await failureMessage(response));
     return response.json();
 }
 /**
@@ -59,9 +102,17 @@ export function claudeConfigPath(home, env = process.env) {
  *
  * Returns the resolved project path so the caller can name it in the trust guidance.
  */
-async function installProjectMcp(configPath, cwd, installation, trust) {
-    const endpoint = new URL(installation.mcpEndpoint);
-    if (endpoint.protocol !== "https:" || !/^ar_[A-Za-z0-9_-]+$/.test(installation.bearer)) {
+export function trustedMcpEndpoint(value) {
+    const endpoint = new URL(value);
+    const loopbackHttp = endpoint.protocol === "http:" && (endpoint.hostname === "localhost" ||
+        endpoint.hostname === "127.0.0.1" ||
+        endpoint.hostname === "[::1]" ||
+        endpoint.hostname.endsWith(".localhost"));
+    return endpoint.protocol === "https:" || loopbackHttp ? endpoint : null;
+}
+async function installProjectMcp(configPath, cwd, installation, trust, channelRunnerId) {
+    const endpoint = trustedMcpEndpoint(installation.mcpEndpoint);
+    if (!endpoint || !BEARER_SHAPE.test(installation.bearer)) {
         throw new Error("AgentRadar returned an invalid setup payload");
     }
     const projectPath = await realpath(cwd);
@@ -89,7 +140,11 @@ async function installProjectMcp(configPath, cwd, installation, trust) {
     const mcpServers = project.mcpServers && typeof project.mcpServers === "object" && !Array.isArray(project.mcpServers)
         ? project.mcpServers
         : {};
-    mcpServers.agentradar = {
+    mcpServers.agentradar = channelRunnerId ? {
+        type: "stdio",
+        command: process.execPath,
+        args: [join(dirname(fileURLToPath(import.meta.url)), "index.js"), "channel", channelRunnerId],
+    } : {
         type: "http",
         url: endpoint.toString(),
         headers: { Authorization: `Bearer ${installation.bearer}` },
@@ -109,10 +164,10 @@ async function installProjectMcp(configPath, cwd, installation, trust) {
     await chmod(configPath, 0o600);
     return projectPath;
 }
-function shellValue(value) {
+export function shellValue(value) {
     return `'${value.replaceAll("'", "'\\''")}'`;
 }
-async function writePrivateFile(path, contents) {
+export async function writePrivateFile(path, contents) {
     try {
         if ((await lstat(path)).isSymbolicLink())
             throw new Error(`Refusing to replace a symlinked ${path}`);
@@ -130,8 +185,8 @@ async function installRunner(home, projectPath, approved) {
     if (!/^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/.test(approved.runnerId)) {
         throw new Error("AgentRadar returned an invalid runner ID");
     }
-    const endpoint = new URL(approved.installation.mcpEndpoint);
-    if (endpoint.protocol !== "https:" || !/^ar_[A-Za-z0-9_-]+$/.test(approved.installation.bearer)) {
+    const endpoint = trustedMcpEndpoint(approved.installation.mcpEndpoint);
+    if (!endpoint || !BEARER_SHAPE.test(approved.installation.bearer)) {
         throw new Error("AgentRadar returned an invalid setup payload");
     }
     const agentDir = join(home, ".agentradar", "agents");
@@ -140,6 +195,10 @@ async function installRunner(home, projectPath, approved) {
     await mkdir(configDir, { recursive: true, mode: 0o700 });
     await chmod(agentDir, 0o700);
     await chmod(configDir, 0o700);
+    const declared = (approved.harness ?? "").trim().toLowerCase();
+    const harness = declared ? SUPERVISOR_HARNESS[declared] : undefined;
+    if (declared && !harness)
+        throw new Error(`AgentRadar returned a runtime this runner cannot start: ${JSON.stringify(declared)}`);
     const mcpConfig = join(configDir, "awp-only.json");
     const envPath = join(agentDir, `${approved.runnerId}.env`);
     await writePrivateFile(mcpConfig, `${JSON.stringify({
@@ -157,6 +216,10 @@ async function installRunner(home, projectPath, approved) {
         `AWP_MCP_URL=${shellValue(endpoint.toString())}`,
         `AWP_BEARER=${shellValue(approved.installation.bearer)}`,
         `MCP_CONFIG=${shellValue(mcpConfig)}`,
+        // Written only when the vendor declared a runtime. An absent variable is the supervisor's own
+        // default, so writing `AR_AGENT_HARNESS=claude` unconditionally would change nothing except to make
+        // every existing env file look as though a choice had been made.
+        ...(harness ? [`AR_AGENT_HARNESS=${shellValue(harness)}`] : []),
         "",
     ].join("\n"));
     return envPath;
@@ -175,7 +238,13 @@ export async function setupVendorAgent(deps = {}) {
         throw new Error("Run setup from the agent project folder");
     const apiBase = deps.apiUrl ?? process.env.AGENTRADAR_API_URL ?? DEFAULT_API_URL;
     const setupUrl = new URL("vendor/agent-setups", `${apiBase.replace(/\/+$/, "")}/`);
-    const started = await responseJson(await postJson(fetchImpl, setupUrl, { name: agentName }));
+    const requestedHarness = (deps.harness ?? process.env.AGENTRADAR_AGENT_HARNESS ?? "").trim();
+    const started = await responseJson(await postJson(fetchImpl, setupUrl, {
+        name: agentName,
+        // Sent only when asked for. The server refuses a value it cannot run — by name, in its own words —
+        // so an unrecognised `--harness` fails at the first door rather than at `runner start`, hours later.
+        ...(requestedHarness ? { harness: requestedHarness } : {}),
+    }));
     if (!/^ars_[A-Za-z0-9_-]+$/.test(started.deviceCode) || !/^[A-Z2-9]{4}-[A-Z2-9]{4}$/.test(started.userCode)) {
         throw new Error("AgentRadar returned an invalid setup challenge");
     }
@@ -183,9 +252,31 @@ export async function setupVendorAgent(deps = {}) {
     log("Waiting for approval…");
     const tokenUrl = new URL("vendor/agent-setups/token", `${apiBase.replace(/\/+$/, "")}/`);
     const expiresAt = Date.now() + started.expiresIn * 1000;
+    // 🔴 A DROPPED CONNECTION MUST NOT DISCARD AN APPROVAL A HUMAN ALREADY GAVE. This poll used to be a
+    // bare `await` in the loop, so one blip — a laptop sleeping, wifi switching, a proxy hiccup — threw
+    // straight out of setup and the vendor had to re-run it and approve a SECOND code while the first sat
+    // pending server-side. Only a definitive answer from the server ends this loop now: approved, denied,
+    // or expired. A transport failure is retried, on a backoff that grows with consecutive failures.
+    //
+    // It cannot spin forever, and the bound is not new: `Date.now() < expiresAt` is the code's own
+    // ten-minute TTL, which the server sent as `expiresIn`. If that TTL ever grows enough that a retry
+    // loop could outlive the code's validity, this needs its own deadline as well.
+    let consecutiveFailures = 0;
     while (Date.now() < expiresAt) {
-        await sleep(Math.max(1, started.interval) * 1000);
-        const response = await postJson(fetchImpl, tokenUrl, { deviceCode: started.deviceCode });
+        await sleep(Math.max(1, started.interval) * 1000 * Math.min(consecutiveFailures + 1, 5));
+        let response;
+        try {
+            response = await postJson(fetchImpl, tokenUrl, { deviceCode: started.deviceCode });
+        }
+        catch {
+            consecutiveFailures += 1;
+            // Said out loud, and naming the HOST rather than the error: a silent retry is indistinguishable
+            // from a hang to the person watching, and `fetch` rejects with the two words "fetch failed",
+            // which name nothing. The host is the fact worth printing and we already hold it.
+            log(`Could not reach ${tokenUrl.host} — the code is still valid, retrying…`);
+            continue;
+        }
+        consecutiveFailures = 0;
         if (response.status === 202)
             continue;
         if (response.status === 410)
@@ -204,10 +295,151 @@ export async function setupVendorAgent(deps = {}) {
             ? `--trust: pre-accepted the trust dialog for ${projectPath}. Claude Code will run this folder's existing hooks and settings without asking.`
             : `Claude Code will ask you to trust ${projectPath} on first launch — approve it there. Not pre-accepted, because that would trust everything already in the folder, not just this MCP. Re-run with --trust for unattended onboarding.`);
         log(`Runner installed → ${runnerEnv}`);
+        if ((approved.harness ?? "").trim().toLowerCase() === "codex") {
+            // Said BEFORE the vendor runs the runner, because the supervisor's refusal comes after they
+            // think setup succeeded. Codex reads its MCP servers from $CODEX_HOME/config.toml — there is no
+            // `--strict-mcp-config` to point at the file this setup just wrote — so the isolation boundary is
+            // a per-agent home the vendor supplies, and the supervisor fails closed without it.
+            log(`This agent runs on Codex. Set CODEX_HOME in ${runnerEnv} to a per-agent Codex home whose config.toml declares ONLY the AgentRadar MCP server; the runner refuses to start without it.`);
+        }
         log(`Start it with: agentradar runner start ${approved.runnerId}`);
         log("On macOS the runner uses your existing Claude Code Keychain-backed login. CLAUDE_CODE_OAUTH_TOKEN is ignored; ANTHROPIC_API_KEY is prohibited.");
         return;
     }
     throw new Error("AgentRadar setup code expired; run setup again");
 }
+/**
+ * Mode A — the organisation's own agent, on its own compute, joining through an enrolment link.
+ *
+ * accept → wait for a human to approve → claim the key once → install the same MCP config and runner
+ * `setup` installs. The one-time claim secret is kept in a 0600 state file per link, so a re-run
+ * resumes the wait (or, once claimed, just starts the runner) instead of filing a second request.
+ * The key itself is written only into the two 0600 config files and is never printed.
+ */
+export async function joinOrganisation(enrolmentUrl, deps = {}) {
+    const fetchImpl = deps.fetch ?? fetch;
+    const sleep = deps.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    const log = deps.log ?? console.log;
+    const cwd = deps.cwd ?? process.cwd();
+    const home = deps.home ?? homedir();
+    // Claude Code sets CLAUDECODE in its shell; a machine with both tools installed may export CODEX_HOME too.
+    const harness = deps.harness ?? (process.env.CLAUDECODE || !process.env.CODEX_HOME ? "claude" : "codex");
+    const startJoined = async (runnerId, firstPoll = false) => {
+        if (!firstPoll) {
+            log(`Connected. Runner: ${runnerId}. Now, in this same session, poll for your welcome and work: agentradar run ${runnerId} next_event`);
+            return 0;
+        }
+        // The first poll is the same call the agent makes next, so the welcome arrives without a second harness
+        // prompt and the agent's next bare poll acknowledges it. The key is already saved: a failed poll only says so.
+        log("Connected. Your welcome and first instructions:");
+        const { callToolOverCli } = await import("./tool-run.js");
+        await callToolOverCli(runnerId, "next_event", undefined, { home, fetch: fetchImpl, log })
+            .catch(() => log("Could not fetch them yet."));
+        log(`Runner: ${runnerId}. Do what the instructions above say. Then stay listening: make agentradar run ${runnerId} listen the last step of every turn, ${harness === "claude" ? "in the background (run_in_background), and end your turn; you are woken when it exits" : "in the foreground, and wait for it"}. It prints the next client message as soon as one arrives, or a note after about 9 minutes; answer what it printed, then run it again.`);
+        return 0;
+    };
+    let link;
+    try {
+        link = new URL(enrolmentUrl);
+    }
+    catch {
+        throw new Error("Pass the enrolment link your organisation gave you, e.g. https://…/invite/<token>");
+    }
+    const token = /^\/(?:api\/invites|invite)\/([^/]+?)(?:\.md)?(?:\/|$)/.exec(link.pathname)?.[1];
+    if (!token || !trustedMcpEndpoint(link.origin)) {
+        throw new Error("That is not an AgentRadar enrolment link (expected https://…/invite/<token>)");
+    }
+    const api = (path) => new URL(`/api/${path}`, link.origin);
+    const mcpEndpoint = process.env.AWP_MCP_URL || api("mcp").toString();
+    const joinsDir = join(home, ".agentradar", "joins");
+    await mkdir(joinsDir, { recursive: true, mode: 0o700 });
+    const statePath = join(joinsDir, `${createHash("sha256").update(token).digest("hex")}.json`);
+    let state = null;
+    try {
+        state = JSON.parse(await readFile(statePath, "utf8"));
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    if (state?.agentId) {
+        log("This enrolment link is already joined on this machine.");
+        const runnerId = `join-${state.requestId}`;
+        const env = await readFile(join(home, ".agentradar", "agents", `${runnerId}.env`), "utf8");
+        const { envValue } = await import("./tool-run.js");
+        await installProjectMcp(claudeConfigPath(home), cwd, {
+            mcpEndpoint: envValue(env, "AWP_MCP_URL") ?? "", bearer: envValue(env, "AWP_BEARER") ?? "",
+        }, deps.trust === true, harness === "claude" ? runnerId : undefined);
+        return startJoined(runnerId);
+    }
+    if (!state) {
+        const agentName = (deps.agentName ?? process.env.AGENTRADAR_AGENT_NAME ?? basename(cwd)).trim();
+        if (!agentName)
+            throw new Error("Run join from the agent project folder");
+        // Codex has no env var for its model; its config's top-level `model` is the default a session starts on.
+        // A codex agent reporting "claude" is guessing (a gateway combo answers as Claude), so the config wins there too.
+        const codexModel = async () => !process.env.CODEX_HOME ? undefined : /^model\s*=\s*"([^"\n]+)"/m.exec((await readFile(join(process.env.CODEX_HOME, "config.toml"), "utf8").catch(() => "")).split(/^\[/m)[0])?.[1];
+        const model = (!deps.model || deps.model === "unknown" || /claude/i.test(deps.model)) && harness === "codex" ? (await codexModel()) ?? deps.model : deps.model;
+        const response = await postJson(fetchImpl, api(`invites/${encodeURIComponent(token)}/accept`), {
+            requestType: "agent", agentName, adapterType: "awp_remote",
+            agentDefaultsPayload: { harness, ...(model ? { model } : {}) },
+        });
+        if (!response.ok) {
+            throw new Error(response.status === 404
+                ? "This join link has expired, was already used, or was withdrawn. Ask your organisation for a new link."
+                : `This join link cannot be used. ${await failureMessage(response)}`);
+        }
+        const accepted = await response.json();
+        if (typeof accepted.id !== "string" || typeof accepted.claimSecret !== "string") {
+            throw new Error("AgentRadar returned an invalid join response");
+        }
+        state = { requestId: accepted.id, claimSecret: accepted.claimSecret, ...(typeof accepted.approvalUrl === "string" ? { approvalUrl: accepted.approvalUrl } : {}) };
+        await writePrivateFile(statePath, JSON.stringify(state));
+    }
+    log("Join request sent. Waiting for your organisation to approve it…");
+    if (state.approvalUrl)
+        log(`Approval link: ${state.approvalUrl}\nSend it to your own human once; they approve after signing in. Never send anything else from this folder.`);
+    const claimUrl = api(`join-requests/${encodeURIComponent(state.requestId)}/claim-api-key`);
+    // Named off the join request, which exists before the key does, so the server can record it at claim.
+    const runnerId = `join-${state.requestId}`;
+    for (let poll = 1;; poll++) {
+        if (poll > (deps.polls ?? 9)) {
+            log(`Still waiting for approval. Run this same command again: agentradar run ${enrolmentUrl}`);
+            return 0;
+        }
+        let response;
+        try {
+            response = await postJson(fetchImpl, claimUrl, { claimSecret: state.claimSecret, runnerId });
+        }
+        catch {
+            log(`Could not reach ${claimUrl.host}; retrying…`);
+            await sleep(10_000);
+            continue;
+        }
+        if (response.status === 201) {
+            const claimed = await response.json();
+            if (typeof claimed.token !== "string" || typeof claimed.agentId !== "string") {
+                throw new Error("AgentRadar returned an invalid key claim");
+            }
+            const installation = { mcpEndpoint, bearer: claimed.token };
+            const projectPath = await installProjectMcp(claudeConfigPath(home), cwd, installation, deps.trust === true, harness === "claude" ? runnerId : undefined);
+            const runnerEnv = await installRunner(home, projectPath, { status: "approved", agentId: claimed.agentId, runnerId, installation, harness });
+            await writePrivateFile(statePath, JSON.stringify({ ...state, agentId: claimed.agentId }));
+            log(`Approved. AgentRadar MCP installed for this project, runner installed → ${runnerEnv}`);
+            return startJoined(runnerId, true);
+        }
+        const said = await failureMessage(response);
+        if (response.status === 409 && said.includes("must be approved")) {
+            await sleep(10_000);
+            continue;
+        }
+        if (response.status === 409 && said.includes("rejected")) {
+            throw new Error("Your organisation declined this join request. Ask it for a new enrolment link.");
+        }
+        if (response.status === 409 && /already (?:used|claimed)/.test(said)) {
+            throw new Error("This enrolment link's key was already claimed. A key is issued once and cannot be claimed again; ask your organisation for a new enrolment link.");
+        }
+        throw new Error(said);
+    }
+}
 //# sourceMappingURL=setup.js.map

package/dist/skill-install.js

@@ -37,6 +37,8 @@ export async function installVendorSkill(deps = {}) {
                 throw error;
         });
     }
+    // The runner keeps this skill current from AgentRadar; the marker says the folder is AgentRadar's to replace.
+    await writeFile(join(skillDir, ".agentradar-managed"), "Written by AgentRadar; replaced on every sync.\n");
     (deps.log ?? console.log)("AgentRadar vendor skill installed for this project.");
 }
 //# sourceMappingURL=skill-install.js.map

package/dist/sync.js

@@ -0,0 +1,89 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { homedir, platform } from "node:os";
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+const run = promisify(execFile);
+/**
+ * `agentradar sync [dir]` — fast-forward a git-scoped agent project dir to its remote branch.
+ *
+ * Safe by construction:
+ *  - refuses when tracked files are locally MODIFIED (vendor edits are never clobbered);
+ *  - `checkout -f -B <branch> <remote>/<branch>` rewrites tracked paths only, so untracked runtime
+ *    state (sessions, .env, caches) survives;
+ *  - uses the vendor's own git credentials — the CLI never carries any.
+ *
+ * Config (optional, via `git config`): `agentradar.syncRemote` (default `origin`),
+ * `agentradar.syncBranch` (default `main`).
+ */
+export async function syncAgentDir(dir = process.cwd()) {
+    const git = (...args) => run("git", ["-C", dir, ...args]);
+    try {
+        await git("rev-parse", "--git-dir");
+    }
+    catch {
+        console.error(`Not a git repository: ${dir}`);
+        return 1;
+    }
+    const remote = (await git("config", "--get", "agentradar.syncRemote").catch(() => ({ stdout: "origin" }))).stdout.trim() || "origin";
+    const branch = (await git("config", "--get", "agentradar.syncBranch").catch(() => ({ stdout: "main" }))).stdout.trim() || "main";
+    const dirty = (await git("status", "--porcelain")).stdout
+        .split("\n")
+        .filter((l) => l && !l.startsWith("??"));
+    if (dirty.length > 0) {
+        console.error(`Refusing to sync: ${dirty.length} tracked file(s) locally modified in ${dir}. Commit, stash, or revert them first.`);
+        return 1;
+    }
+    await git("fetch", remote, branch);
+    const target = (await git("rev-parse", `${remote}/${branch}`)).stdout.trim();
+    const head = (await git("rev-parse", "HEAD").catch(() => ({ stdout: "" }))).stdout.trim();
+    if (head === target) {
+        console.log(`Up to date at ${target.slice(0, 8)}.`);
+        return 0;
+    }
+    await git("checkout", "-f", "-B", branch, `${remote}/${branch}`);
+    console.log(`Synced ${dir} to ${remote}/${branch} @ ${target.slice(0, 8)}.`);
+    return 0;
+}
+/**
+ * `agentradar sync install [dir] [--interval <seconds>]` — install a background timer that runs
+ * `agentradar sync <dir>` periodically. launchd LaunchAgent on macOS, systemd user timer on Linux.
+ */
+export async function installSyncTimer(dir = process.cwd(), intervalSeconds = 600) {
+    const abs = dir;
+    const cli = process.argv[1] ?? "agentradar";
+    const node = process.execPath;
+    if (platform() === "darwin") {
+        const label = `com.agentradar.sync.${abs.replace(/[^A-Za-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(-40)}`;
+        const plistDir = join(homedir(), "Library", "LaunchAgents");
+        await mkdir(plistDir, { recursive: true });
+        const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+  <key>Label</key><string>${label}</string>
+  <key>ProgramArguments</key><array><string>${node}</string><string>${cli}</string><string>sync</string><string>${abs}</string></array>
+  <key>StartInterval</key><integer>${intervalSeconds}</integer>
+  <key>RunAtLoad</key><true/>
+  <key>StandardOutPath</key><string>${join(homedir(), "Library", "Logs", `${label}.log`)}</string>
+  <key>StandardErrorPath</key><string>${join(homedir(), "Library", "Logs", `${label}.log`)}</string>
+</dict></plist>
+`;
+        const plistPath = join(plistDir, `${label}.plist`);
+        await writeFile(plistPath, plist);
+        await run("launchctl", ["bootout", `gui/${process.getuid?.() ?? 501}/${label}`]).catch(() => undefined);
+        await run("launchctl", ["bootstrap", `gui/${process.getuid?.() ?? 501}`, plistPath]);
+        console.log(`Installed launchd timer ${label} (every ${intervalSeconds}s) for ${abs}.`);
+        return 0;
+    }
+    // Linux: systemd user service + timer.
+    const unit = `agentradar-sync-${abs.replace(/[^A-Za-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(-40)}`;
+    const unitDir = join(homedir(), ".config", "systemd", "user");
+    await mkdir(unitDir, { recursive: true });
+    await writeFile(join(unitDir, `${unit}.service`), `[Unit]\nDescription=AgentRadar sync ${abs}\n\n[Service]\nType=oneshot\nExecStart=${node} ${cli} sync ${abs}\n`);
+    await writeFile(join(unitDir, `${unit}.timer`), `[Unit]\nDescription=AgentRadar sync timer ${abs}\n\n[Timer]\nOnBootSec=60\nOnUnitActiveSec=${intervalSeconds}\n\n[Install]\nWantedBy=timers.target\n`);
+    await run("systemctl", ["--user", "daemon-reload"]);
+    await run("systemctl", ["--user", "enable", "--now", `${unit}.timer`]);
+    console.log(`Installed systemd user timer ${unit} (every ${intervalSeconds}s) for ${abs}.`);
+    return 0;
+}
+//# sourceMappingURL=sync.js.map