@relaymessenger/cli 0.3.0

package/dist/flags.d.ts

@@ -0,0 +1,9 @@
+import { type EngineName } from "./engine/catalog.js";
+export interface CliFlags {
+    engine: EngineName;
+    dir?: string;
+    name?: string;
+    rest: string[];
+}
+export declare function parseFlags(argv: string[]): CliFlags;
+//# sourceMappingURL=flags.d.ts.map

package/dist/flags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flags.d.ts","sourceRoot":"","sources":["../src/flags.ts"],"names":[],"mappings":"AACA,OAAO,EAA6B,KAAK,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEjF,MAAM,WAAW,QAAQ;IACvB,MAAM,EAAE,UAAU,CAAC;IACnB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,QAAQ,CAuBnD"}

package/dist/flags.js

@@ -0,0 +1,34 @@
+import { resolve } from "node:path";
+import { ENGINE_HELP, isEngineName } from "./engine/catalog.js";
+export function parseFlags(argv) {
+    const flags = { engine: "claude", rest: [] };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--staging") {
+            throw new Error("--staging is unavailable because Relay has no live staging API origin.");
+        }
+        else if (arg === "--engine") {
+            const value = argv[++i];
+            if (!isEngineName(value)) {
+                throw new Error(`--engine must be one of ${ENGINE_HELP}, got ${value ?? "(nothing)"}`);
+            }
+            flags.engine = value;
+        }
+        else if (arg === "--dir") {
+            const value = argv[++i];
+            if (!value)
+                throw new Error("--dir needs a path");
+            flags.dir = resolve(value);
+        }
+        else if (arg === "--name") {
+            const value = argv[++i];
+            if (!value)
+                throw new Error("--name needs a value");
+            flags.name = value;
+        }
+        else
+            flags.rest.push(arg);
+    }
+    return flags;
+}
+//# sourceMappingURL=flags.js.map

package/dist/flags.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flags.js","sourceRoot":"","sources":["../src/flags.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,WAAW,EAAE,YAAY,EAAmB,MAAM,qBAAqB,CAAC;AASjF,MAAM,UAAU,UAAU,CAAC,IAAc;IACvC,MAAM,KAAK,GAAa,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC;IACvD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;QACxC,MAAM,GAAG,GAAG,IAAI,CAAC,CAAC,CAAE,CAAC;QACrB,IAAI,GAAG,KAAK,WAAW,EAAE,CAAC;YACxB,MAAM,IAAI,KAAK,CAAC,wEAAwE,CAAC,CAAC;QAC5F,CAAC;aAAM,IAAI,GAAG,KAAK,UAAU,EAAE,CAAC;YAC9B,MAAM,KAAK,GAAG,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC;YACxB,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE,CAAC;gBACzB,MAAM,IAAI,KAAK,CAAC,2BAA2B,WAAW,SAAS,KAAK,IAAI,WAAW,EAAE,CAAC,CAAC;YACzF,CAAC;YACD,KAAK,CAAC,MAAM,GAAG,KAAK,CAAC;QACvB,CAAC;aAAM,IAAI,GAAG,KAAK,OAAO,EAAE,CAAC;YAC3B,MAAM,KAAK,GAAG,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC;YACxB,IAAI,CAAC,KAAK;gBAAE,MAAM,IAAI,KAAK,CAAC,oBAAoB,CAAC,CAAC;YAClD,KAAK,CAAC,GAAG,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;QAC7B,CAAC;aAAM,IAAI,GAAG,KAAK,QAAQ,EAAE,CAAC;YAC5B,MAAM,KAAK,GAAG,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC;YACxB,IAAI,CAAC,KAAK;gBAAE,MAAM,IAAI,KAAK,CAAC,sBAAsB,CAAC,CAAC;YACpD,KAAK,CAAC,IAAI,GAAG,KAAK,CAAC;QACrB,CAAC;;YAAM,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC9B,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/install.d.ts

@@ -0,0 +1,69 @@
+import { CodexNotifyPolicyStore, ConfigStore } from "./store.js";
+export interface MergeReport {
+    changed: boolean;
+    notes: string[];
+}
+export interface InstallCodexOptions {
+    projectRoot?: string;
+    policy?: CodexNotifyPolicyStore;
+}
+/** Secret-bearing Codex config writes are private and crash-atomic. */
+export declare function writePrivateText(path: string, value: string): void;
+/**
+ * Pure merge for tests: returns the new TOML text plus a report.
+ *
+ * The existing file is parsed only to DETECT what is present; the returned
+ * text is the user's original byte-for-byte with the missing pieces added
+ * textually (top-level `notify` prepended before the first table so it stays
+ * top-level; `[mcp_servers.relay]` appended at the end). Comments, ordering,
+ * and formatting the user wrote are never round-tripped away.
+ */
+export declare function mergeCodexConfigToml(existing: string): {
+    toml: string;
+    report: MergeReport;
+};
+/** Pure merge for tests: hooks.json PermissionRequest handler, append-only. */
+export declare function mergeHooksJson(existing: string): {
+    json: string;
+    report: MergeReport;
+};
+export declare function installCodex(codexHome?: string, out?: (line: string) => void, options?: InstallCodexOptions): void;
+export interface InstallClaudeOptions {
+    config?: ConfigStore;
+    channelDir?: string;
+    /** Generated marketplace root; injectable only for tests. */
+    bundleDir?: string;
+    /** Stable account-scoped install root; injectable only for tests. */
+    installRoot?: string;
+    claudeCommand?: string;
+    runClaude?: (command: string, args: string[]) => {
+        status: number | null;
+        stdout?: string;
+        stderr?: string;
+        error?: Error;
+    };
+}
+export interface InstallOpenClawOptions {
+    config?: ConfigStore;
+    openclawHome?: string;
+    bundleDir?: string;
+    installRoot?: string;
+    openclawCommand?: string;
+    runOpenClaw?: InstallClaudeOptions["runClaude"];
+}
+export declare function mergeClaudeChannelEnv(existing: string, desired: {
+    token: string;
+    origin: string;
+    ownerUserId: string;
+}): string;
+export declare function platformCliCommand(command: string, platform?: NodeJS.Platform): string;
+export declare function mergeOpenClawConfig(existing: string, desired: {
+    token: string;
+    tokenFile: string;
+    baseUrl: string;
+}): string;
+/** Install the bundled marketplace plus owner-only channel credentials. */
+export declare function installClaude(out?: (line: string) => void, options?: InstallClaudeOptions): void;
+/** Install and configure the OpenClaw plugin from relaymessenger's bundled archive. */
+export declare function installOpenClaw(out?: (line: string) => void, options?: InstallOpenClawOptions): void;
+//# sourceMappingURL=install.d.ts.map

package/dist/install.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"install.d.ts","sourceRoot":"","sources":["../src/install.ts"],"names":[],"mappings":"AAqCA,OAAO,EACL,sBAAsB,EACtB,WAAW,EAGZ,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,MAAM,WAAW,mBAAmB;IAClC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,sBAAsB,CAAC;CACjC;AAYD,uEAAuE;AACvE,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CA6BlE;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,WAAW,CAAA;CAAE,CAwC5F;AAED,+EAA+E;AAC/E,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,WAAW,CAAA;CAAE,CAuBtF;AAYD,wBAAgB,YAAY,CAC1B,SAAS,SAA4B,EACrC,GAAG,GAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAkB,EACzC,OAAO,GAAE,mBAAwB,GAChC,IAAI,CAuDN;AAED,MAAM,WAAW,oBAAoB;IACnC,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,6DAA6D;IAC7D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,qEAAqE;IACrE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK;QAC/C,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;QACtB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,KAAK,CAAC,EAAE,KAAK,CAAC;KACf,CAAC;CACH;AAED,MAAM,WAAW,sBAAsB;IACrC,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,WAAW,CAAC,EAAE,oBAAoB,CAAC,WAAW,CAAC,CAAC;CACjD;AAkBD,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,GAC9D,MAAM,CAoBR;AAgBD,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EACf,QAAQ,GAAE,MAAM,CAAC,QAA2B,GAC3C,MAAM,CAGR;AA0FD,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAC7D,MAAM,CAmCR;AAED,2EAA2E;AAC3E,wBAAgB,aAAa,CAC3B,GAAG,GAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAkB,EACzC,OAAO,GAAE,oBAAyB,GACjC,IAAI,CAiGN;AAED,uFAAuF;AACvF,wBAAgB,eAAe,CAC7B,GAAG,GAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAkB,EACzC,OAAO,GAAE,sBAA2B,GACnC,IAAI,CAsEN"}

package/dist/install.js

@@ -0,0 +1,510 @@
+/**
+ * `relaymessenger install-codex` / `relaymessenger install-claude`.
+ *
+ * install-codex merges — never clobbers — three things into the user's Codex
+ * setup:
+ *   ~/.codex/config.toml  [mcp_servers.relay]  → `relaymessenger mcp` stdio server
+ *   ~/.codex/config.toml  notify               → `relaymessenger notify` turn-complete ping
+ *   ~/.codex/hooks.json   PermissionRequest    → `relaymessenger hook permission-request`
+ *                                                (phone-tap approvals; Codex hooks
+ *                                                answer with decision JSON on stdout)
+ *
+ * Existing user values are preserved: a different notify command or an
+ * existing hook list is left alone (we append/skip, and report what we did).
+ */
+import { chmodSync, closeSync, cpSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, rmSync, statSync, unlinkSync, writeSync, } from "node:fs";
+import { createHash } from "node:crypto";
+import { spawnSync } from "node:child_process";
+import crossSpawn from "cross-spawn";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parse as parseToml } from "smol-toml";
+import { CodexNotifyPolicyStore, ConfigStore, resolveOwnerUserId, runtimeHomeForConfig, } from "./store.js";
+const RELAY_NOTIFY = ["relaymessenger", "notify"];
+const RELAY_PERMISSION_HOOK_COMMAND = "relaymessenger hook permission-request";
+// Codex's hooks engine is Claude-style: matcher groups wrapping command handlers.
+const RELAY_PERMISSION_HOOK_ENTRY = {
+    matcher: "*",
+    hooks: [{ type: "command", command: RELAY_PERMISSION_HOOK_COMMAND }],
+};
+const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
+/** Secret-bearing Codex config writes are private and crash-atomic. */
+export function writePrivateText(path, value) {
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const tmp = `${path}.tmp-${process.pid}-${Date.now()}`;
+    let fd = openSync(tmp, "wx", 0o600);
+    let installed = false;
+    try {
+        writeSync(fd, value);
+        fsyncSync(fd);
+        closeSync(fd);
+        fd = -1;
+        renameSync(tmp, path);
+        chmodSync(path, 0o600);
+        installed = true;
+    }
+    finally {
+        if (fd !== -1) {
+            try {
+                closeSync(fd);
+            }
+            catch {
+                // Preserve the original write failure.
+            }
+        }
+        if (!installed) {
+            try {
+                unlinkSync(tmp);
+            }
+            catch {
+                // Best effort cleanup; preserve the original failure.
+            }
+        }
+    }
+}
+/**
+ * Pure merge for tests: returns the new TOML text plus a report.
+ *
+ * The existing file is parsed only to DETECT what is present; the returned
+ * text is the user's original byte-for-byte with the missing pieces added
+ * textually (top-level `notify` prepended before the first table so it stays
+ * top-level; `[mcp_servers.relay]` appended at the end). Comments, ordering,
+ * and formatting the user wrote are never round-tripped away.
+ */
+export function mergeCodexConfigToml(existing) {
+    const notes = [];
+    let changed = false;
+    let doc;
+    try {
+        doc = (existing.trim().length > 0 ? parseToml(existing) : {});
+    }
+    catch {
+        throw new Error("~/.codex/config.toml exists but is not valid TOML; not touching it");
+    }
+    let toml = existing;
+    const servers = doc.mcp_servers;
+    if (servers?.relay === undefined) {
+        const suffix = `[mcp_servers.relay]\ncommand = "relaymessenger"\nargs = ["mcp"]\n`;
+        toml = toml.length === 0 || toml.endsWith("\n\n") ? `${toml}${suffix}`
+            : toml.endsWith("\n") ? `${toml}\n${suffix}`
+                : `${toml}\n\n${suffix}`;
+        notes.push("added [mcp_servers.relay]");
+        changed = true;
+    }
+    else {
+        notes.push("kept existing [mcp_servers.relay]");
+    }
+    if (doc.notify === undefined) {
+        // Top-level keys must precede any [table]; prepending is always valid.
+        toml = `notify = ["relaymessenger", "notify"]\n${toml.length > 0 && !toml.startsWith("\n") ? "\n" : ""}${toml}`;
+        notes.push('set notify = ["relaymessenger", "notify"]');
+        changed = true;
+    }
+    else if (JSON.stringify(doc.notify) === JSON.stringify(RELAY_NOTIFY)) {
+        notes.push("notify already points at relaymessenger");
+    }
+    else {
+        notes.push(`left existing notify unchanged (${JSON.stringify(doc.notify)}); ` +
+            "chain relaymessenger notify from your own script if you want both");
+    }
+    // Sanity: never write a file Codex cannot parse.
+    parseToml(toml);
+    return { toml, report: { changed, notes } };
+}
+/** Pure merge for tests: hooks.json PermissionRequest handler, append-only. */
+export function mergeHooksJson(existing) {
+    const notes = [];
+    let changed = false;
+    let doc;
+    try {
+        doc = existing.trim().length > 0 ? JSON.parse(existing) : {};
+    }
+    catch {
+        throw new Error("~/.codex/hooks.json exists but is not valid JSON; not touching it");
+    }
+    const hooks = (doc.hooks ??= {});
+    const list = (hooks.PermissionRequest ??= []);
+    if (!Array.isArray(list)) {
+        throw new Error("hooks.PermissionRequest is not an array; not touching it");
+    }
+    const already = JSON.stringify(list).includes(RELAY_PERMISSION_HOOK_COMMAND);
+    if (already) {
+        notes.push("PermissionRequest hook already installed");
+    }
+    else {
+        list.push(RELAY_PERMISSION_HOOK_ENTRY);
+        notes.push("appended relaymessenger PermissionRequest hook");
+        changed = true;
+    }
+    return { json: `${JSON.stringify(doc, null, 2)}\n`, report: { changed, notes } };
+}
+function currentProjectRoot(cwd = process.cwd()) {
+    const git = spawnSync("git", ["rev-parse", "--show-toplevel"], {
+        cwd,
+        encoding: "utf8",
+        timeout: 5_000,
+        windowsHide: true,
+    });
+    return git.status === 0 && git.stdout.trim().length > 0 ? git.stdout.trim() : cwd;
+}
+export function installCodex(codexHome = join(homedir(), ".codex"), out = console.log, options = {}) {
+    mkdirSync(codexHome, { recursive: true });
+    const allowedRoot = (options.policy ?? new CodexNotifyPolicyStore()).allowProject(options.projectRoot ?? currentProjectRoot());
+    const configPath = join(codexHome, "config.toml");
+    const existingToml = existsSync(configPath) ? readFileSync(configPath, "utf8") : "";
+    const merged = mergeCodexConfigToml(existingToml);
+    if (merged.report.changed) {
+        // Keep a copy of the pristine original before our first modification.
+        if (existingToml.length > 0 && !existsSync(`${configPath}.bak`)) {
+            writePrivateText(`${configPath}.bak`, existingToml);
+            merged.report.notes.push(`original saved to ${configPath}.bak`);
+        }
+        writePrivateText(configPath, merged.toml);
+    }
+    out(`${configPath}:`);
+    for (const note of merged.report.notes)
+        out(`  - ${note}`);
+    const hooksPath = join(codexHome, "hooks.json");
+    const existingHooks = existsSync(hooksPath) ? readFileSync(hooksPath, "utf8") : "";
+    const hooks = mergeHooksJson(existingHooks);
+    if (hooks.report.changed) {
+        if (existingHooks.length > 0 && !existsSync(`${hooksPath}.bak`)) {
+            writePrivateText(`${hooksPath}.bak`, existingHooks);
+            hooks.report.notes.push(`original saved to ${hooksPath}.bak`);
+        }
+        writePrivateText(hooksPath, hooks.json);
+    }
+    out(`${hooksPath}:`);
+    for (const note of hooks.report.notes)
+        out(`  - ${note}`);
+    const finalConfig = parseToml(merged.toml);
+    const relayMcp = finalConfig.mcp_servers?.relay;
+    const mcpActive = relayMcp?.command === "relaymessenger" &&
+        JSON.stringify(relayMcp?.args) === JSON.stringify(["mcp"]);
+    const notifyActive = JSON.stringify(finalConfig.notify) === JSON.stringify(RELAY_NOTIFY);
+    const finalHooks = JSON.parse(hooks.json);
+    const permissionActive = JSON.stringify(finalHooks).includes(RELAY_PERMISSION_HOOK_COMMAND);
+    out("");
+    out(`Relay enabled only for this project root: ${allowedRoot}`);
+    if (mcpActive && notifyActive && permissionActive) {
+        out("Codex will send the final assistant message when a turn completes and route tool");
+        out("approvals to your phone only from that project.");
+    }
+    else {
+        out("Relay Codex setup is partial because existing non-Relay values were preserved:");
+        out(`  - MCP relay_send_message: ${mcpActive ? "active" : "inactive (existing mcp_servers.relay kept)"}`);
+        out(`  - final-message notify: ${notifyActive ? "active" : "inactive (existing notify kept)"}`);
+        out(`  - phone permission hook: ${permissionActive ? "active" : "inactive"}`);
+    }
+    out("Codex gates untrusted hook handlers: the first run may ask you to trust the relaymessenger handler.");
+    out("Approvals require `relaymessenger pair` to have run on this machine.");
+    out("Run install-codex separately inside each additional project you explicitly opt in.");
+}
+function parseEnvValues(contents) {
+    const values = {};
+    for (const raw of contents.split(/\r?\n/)) {
+        const line = raw.trim();
+        if (!line || line.startsWith("#"))
+            continue;
+        const match = /^(?:export\s+)?([A-Z0-9_]+)=(.*)$/u.exec(line);
+        if (!match)
+            continue;
+        let value = match[2].trim();
+        if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        values[match[1]] = value;
+    }
+    return values;
+}
+export function mergeClaudeChannelEnv(existing, desired) {
+    const values = parseEnvValues(existing);
+    const required = {
+        RELAY_AGENT_TOKEN: desired.token,
+        RELAY_BASE_URL: desired.origin,
+        RELAY_OWNER_USER_ID: desired.ownerUserId,
+    };
+    for (const [key, value] of Object.entries(required)) {
+        if (/[\r\n]/u.test(value))
+            throw new Error(`Refusing newline in ${key}`);
+        if (values[key] && values[key] !== value) {
+            throw new Error(`Claude Relay channel already has a different ${key}. ` +
+                "Its .env was not changed; move it aside deliberately before installing this paired agent.");
+        }
+    }
+    const missing = Object.entries(required).filter(([key]) => values[key] !== required[key]);
+    if (missing.length === 0)
+        return existing;
+    const prefix = existing.length === 0 || existing.endsWith("\n") ? existing : `${existing}\n`;
+    return `${prefix}${missing.map(([key, value]) => `${key}=${value}`).join("\n")}\n`;
+}
+function runExternalCommand(product, command, args, stage, runner) {
+    const result = runner(command, args);
+    if (result.status === 0)
+        return result;
+    const detail = `${result.stderr ?? ""}\n${result.stdout ?? ""}`.trim();
+    const suffix = detail.length > 0 ? `: ${detail}` : result.error ? `: ${result.error.message}` : "";
+    throw new Error(`${product} ${stage} failed${suffix}`);
+}
+export function platformCliCommand(command, platform = process.platform) {
+    if (platform !== "win32" || /\.(?:bat|cmd|com|exe)$/iu.test(command))
+        return command;
+    return `${command}.cmd`;
+}
+function resolveOpenClawConfigPath(command, runner) {
+    const result = runExternalCommand("OpenClaw", command, ["config", "file"], "config path lookup", runner);
+    const lines = (result.stdout ?? "").split(/\r?\n/u).map((line) => line.trim()).filter(Boolean);
+    const reported = lines.at(-1) ?? "";
+    if (!reported || /[\0\r\n]/u.test(reported)) {
+        throw new Error("OpenClaw config path lookup returned no usable path");
+    }
+    if (/^~[\\/]/u.test(reported))
+        return join(homedir(), reported.slice(2));
+    return isAbsolute(reported) ? reported : resolve(reported);
+}
+function makeTreePrivate(path) {
+    const stat = statSync(path);
+    if (!stat.isDirectory()) {
+        chmodSync(path, 0o600);
+        return;
+    }
+    chmodSync(path, 0o700);
+    for (const name of readdirSync(path))
+        makeTreePrivate(join(path, name));
+}
+function persistClaudeMarketplace(source, installRoot) {
+    const digest = createHash("sha256");
+    const visit = (path, relative = "") => {
+        for (const name of readdirSync(path).sort()) {
+            const absolute = join(path, name);
+            const child = relative ? `${relative}/${name}` : name;
+            if (statSync(absolute).isDirectory())
+                visit(absolute, child);
+            else {
+                digest.update(child).update("\0").update(readFileSync(absolute)).update("\0");
+            }
+        }
+    };
+    visit(source);
+    const destination = join(installRoot, digest.digest("hex").slice(0, 24), "marketplace");
+    if (existsSync(destination))
+        return destination;
+    mkdirSync(dirname(dirname(destination)), { recursive: true, mode: 0o700 });
+    const temporary = `${dirname(destination)}.tmp-${process.pid}-${Date.now()}`;
+    try {
+        cpSync(source, join(temporary, "marketplace"), { recursive: true, errorOnExist: true });
+        makeTreePrivate(temporary);
+        renameSync(temporary, dirname(destination));
+    }
+    catch (error) {
+        rmSync(temporary, { recursive: true, force: true });
+        if (error?.code !== "EEXIST" && error?.code !== "ENOTEMPTY")
+            throw error;
+    }
+    if (!existsSync(destination))
+        throw new Error("Could not persist the bundled Claude marketplace");
+    return destination;
+}
+function persistOpenClawArchive(source, installRoot) {
+    const digest = createHash("sha256").update(readFileSync(source)).digest("hex").slice(0, 24);
+    const destination = join(installRoot, digest, "relay-openclaw-plugin.tgz");
+    if (existsSync(destination))
+        return destination;
+    mkdirSync(dirname(destination), { recursive: true, mode: 0o700 });
+    const temporary = `${destination}.tmp-${process.pid}-${Date.now()}`;
+    try {
+        cpSync(source, temporary, { errorOnExist: true });
+        chmodSync(temporary, 0o600);
+        renameSync(temporary, destination);
+    }
+    finally {
+        rmSync(temporary, { force: true });
+    }
+    return destination;
+}
+function objectAt(parent, key) {
+    const value = parent[key];
+    if (value === undefined) {
+        const created = {};
+        parent[key] = created;
+        return created;
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`OpenClaw config ${key} must be an object; not touching it`);
+    }
+    return value;
+}
+export function mergeOpenClawConfig(existing, desired) {
+    let doc;
+    try {
+        doc = existing.trim() ? JSON.parse(existing) : {};
+    }
+    catch {
+        throw new Error("~/.openclaw/openclaw.json exists but is not valid JSON; not touching it");
+    }
+    if (!doc || typeof doc !== "object" || Array.isArray(doc)) {
+        throw new Error("~/.openclaw/openclaw.json root must be an object; not touching it");
+    }
+    const plugins = objectAt(doc, "plugins");
+    const allow = plugins.allow ?? [];
+    if (!Array.isArray(allow) || !allow.every((entry) => typeof entry === "string")) {
+        throw new Error("OpenClaw config plugins.allow must be a string array; not touching it");
+    }
+    if (!allow.includes("relay"))
+        allow.push("relay");
+    plugins.allow = allow;
+    const entries = objectAt(plugins, "entries");
+    objectAt(entries, "relay").enabled = true;
+    const channels = objectAt(doc, "channels");
+    const relay = objectAt(channels, "relay");
+    if (typeof relay.token === "string" && relay.token !== desired.token) {
+        throw new Error("OpenClaw Relay channel already has a different token; not touching it");
+    }
+    if (typeof relay.tokenFile === "string" && relay.tokenFile !== desired.tokenFile) {
+        throw new Error("OpenClaw Relay channel already has a different tokenFile; not touching it");
+    }
+    if (typeof relay.baseUrl === "string" && new URL(relay.baseUrl).origin !== new URL(desired.baseUrl).origin) {
+        throw new Error("OpenClaw Relay channel already has a different baseUrl; not touching it");
+    }
+    relay.enabled = true;
+    relay.tokenFile = desired.tokenFile;
+    relay.baseUrl = desired.baseUrl;
+    return `${JSON.stringify(doc, null, 2)}\n`;
+}
+/** Install the bundled marketplace plus owner-only channel credentials. */
+export function installClaude(out = console.log, options = {}) {
+    const config = options.config ?? new ConfigStore();
+    const paired = config.load();
+    if (!paired?.agent_token)
+        throw new Error("Not paired. Run `relaymessenger pair` first.");
+    const ownerUserId = resolveOwnerUserId(paired);
+    const channelDir = options.channelDir ?? join(homedir(), ".claude", "channels", "relay");
+    const envPath = join(channelDir, ".env");
+    const existingEnv = existsSync(envPath) ? readFileSync(envPath, "utf8") : "";
+    const mergedEnv = mergeClaudeChannelEnv(existingEnv, {
+        token: paired.agent_token,
+        origin: paired.api_origin,
+        ownerUserId,
+    });
+    const bundledMarketplace = options.bundleDir ?? join(MODULE_DIR, "..", "claude-plugin", "marketplace");
+    const pluginDir = join(bundledMarketplace, "plugins", "relay");
+    for (const relative of [
+        ".claude-plugin/plugin.json",
+        "commands/configure.md",
+        "runtime/server.mjs",
+        "LICENSE",
+        "README.md",
+    ]) {
+        if (!existsSync(join(pluginDir, relative))) {
+            throw new Error(`Installed relaymessenger package is missing bundled Claude plugin file: ${relative}`);
+        }
+    }
+    if (!existsSync(join(bundledMarketplace, ".claude-plugin", "marketplace.json"))) {
+        throw new Error("Installed relaymessenger package is missing its bundled Claude marketplace manifest");
+    }
+    const command = options.claudeCommand ?? process.env.RELAYMESSENGER_CLAUDE_BIN?.trim() ?? "claude";
+    const runner = options.runClaude ?? ((binary, args) => {
+        const result = crossSpawn.sync(platformCliCommand(binary), args, {
+            encoding: "utf8",
+            stdio: "pipe",
+            windowsHide: true,
+        });
+        return {
+            status: result.status,
+            stdout: result.stdout ?? "",
+            stderr: result.stderr ?? "",
+            error: result.error,
+        };
+    });
+    // Validate what will actually be installed, then add the local marketplace.
+    // `marketplace add` and `plugin install` are idempotent in Claude Code and
+    // update a moved npm package path without needing GitHub access.
+    runExternalCommand("Claude Code", command, ["plugin", "validate", pluginDir, "--strict"], "plugin validation", runner);
+    runExternalCommand("Claude Code", command, ["plugin", "validate", bundledMarketplace, "--strict"], "marketplace validation", runner);
+    const marketplaceDir = persistClaudeMarketplace(bundledMarketplace, options.installRoot ?? join(runtimeHomeForConfig(paired, dirname(config.path)), "installed-plugins", "claude"));
+    runExternalCommand("Claude Code", command, ["plugin", "validate", join(marketplaceDir, "plugins", "relay"), "--strict"], "persisted plugin validation", runner);
+    runExternalCommand("Claude Code", command, ["plugin", "marketplace", "add", marketplaceDir], "local marketplace installation", runner);
+    runExternalCommand("Claude Code", command, ["plugin", "install", "relay@relaymessenger-bundled", "--scope", "user"], "plugin installation", runner);
+    if (mergedEnv !== existingEnv) {
+        if (existingEnv.length > 0 && !existsSync(`${envPath}.bak`)) {
+            writePrivateText(`${envPath}.bak`, existingEnv);
+        }
+        writePrivateText(envPath, mergedEnv);
+    }
+    else if (existsSync(envPath)) {
+        chmodSync(envPath, 0o600);
+    }
+    out(`Configured Claude Relay channel at ${envPath} (mode 600).`);
+    out(`API origin: ${paired.api_origin}; owner pin: ${ownerUserId}. Agent Token was not printed.`);
+    out(`Installed bundled Claude plugin relay@relaymessenger-bundled from ${marketplaceDir}.`);
+    out("");
+    out("Run:");
+    out("  claude --dangerously-load-development-channels plugin:relay@relaymessenger-bundled");
+    out("Setup guide: https://docs.relayapp.im/guides/coding-agents");
+}
+/** Install and configure the OpenClaw plugin from relaymessenger's bundled archive. */
+export function installOpenClaw(out = console.log, options = {}) {
+    const config = options.config ?? new ConfigStore();
+    const paired = config.load();
+    if (!paired?.agent_token)
+        throw new Error("Not paired. Run `relaymessenger pair` first.");
+    if (/[\r\n]/u.test(paired.agent_token))
+        throw new Error("Refusing newline in Agent Token");
+    const openclawHome = options.openclawHome ?? join(homedir(), ".openclaw");
+    const command = options.openclawCommand ?? process.env.RELAYMESSENGER_OPENCLAW_BIN?.trim() ?? "openclaw";
+    const runner = options.runOpenClaw ?? ((binary, args) => {
+        const result = crossSpawn.sync(platformCliCommand(binary), args, {
+            encoding: "utf8",
+            stdio: "pipe",
+            windowsHide: true,
+        });
+        return { status: result.status, stdout: result.stdout ?? "", stderr: result.stderr ?? "", error: result.error };
+    });
+    // OpenClaw can relocate its config via environment/state settings. Ask its
+    // own CLI for the authoritative path instead of assuming ~/.openclaw.
+    const configPath = resolveOpenClawConfigPath(command, runner);
+    const tokenPath = join(openclawHome, "secrets", "relay-agent-token");
+    const existingToken = existsSync(tokenPath) ? readFileSync(tokenPath, "utf8").trim() : "";
+    if (existingToken && existingToken !== paired.agent_token) {
+        throw new Error("OpenClaw Relay token file contains a different paired identity; not touching it");
+    }
+    const existingConfig = existsSync(configPath) ? readFileSync(configPath, "utf8") : "";
+    const desired = {
+        token: paired.agent_token,
+        tokenFile: tokenPath,
+        baseUrl: paired.api_origin,
+    };
+    // Identity conflicts must fail before the official installer changes any
+    // external state. This first merge is validation-only.
+    mergeOpenClawConfig(existingConfig, desired);
+    const bundleDir = options.bundleDir ?? join(MODULE_DIR, "..", "openclaw-plugin");
+    const archives = readdirSync(bundleDir).filter((name) => name.endsWith(".tgz"));
+    if (archives.length !== 1) {
+        throw new Error(`Installed relaymessenger package must contain exactly one OpenClaw archive; found ${archives.length}`);
+    }
+    const archive = persistOpenClawArchive(join(bundleDir, archives[0]), options.installRoot ?? join(runtimeHomeForConfig(paired, dirname(config.path)), "installed-plugins", "openclaw"));
+    runExternalCommand("OpenClaw", command, ["plugins", "install", archive, "--force"], "plugin installation", runner);
+    // The official installer stamps root metadata and records install
+    // provenance/update/uninstall state. Re-read after it returns; a merge
+    // computed before that command would overwrite the newly authoritative
+    // state. Apply only Relay's fields through OpenClaw's config writer so the
+    // resulting write is validated and freshly stamped by OpenClaw itself.
+    const installedConfig = existsSync(configPath) ? readFileSync(configPath, "utf8") : "";
+    const mergedConfig = JSON.parse(mergeOpenClawConfig(installedConfig, desired));
+    const configUpdates = [
+        { path: "plugins.allow", value: mergedConfig.plugins.allow },
+        { path: "plugins.entries.relay.enabled", value: true },
+        { path: "channels.relay.enabled", value: true },
+        { path: "channels.relay.tokenFile", value: tokenPath },
+        { path: "channels.relay.baseUrl", value: paired.api_origin },
+    ];
+    writePrivateText(tokenPath, `${paired.agent_token}\n`);
+    runExternalCommand("OpenClaw", command, ["config", "set", "--batch-json", JSON.stringify(configUpdates)], "Relay config merge", runner);
+    if (existsSync(configPath))
+        chmodSync(configPath, 0o600);
+    out(`Installed bundled Relay plugin into OpenClaw from ${archive}.`);
+    out(`Configured ${configPath} and owner-private token file ${tokenPath}. Agent Token was not printed.`);
+    out("Restart the OpenClaw gateway to activate Relay.");
+}
+//# sourceMappingURL=install.js.map