antechamber 0.0.0-stage → 0.1.0

package/dist/catalog.js

@@ -0,0 +1,118 @@
+/**
+ * Model/provider catalog: obtained from a throwaway `pi --mode rpc` process
+ * (`get_available_models` + `get_state`), translated into OpenCode v2
+ * Provider/Model shapes, cached for the adapter lifetime.
+ */
+import { PiRpcClient } from "./pi-rpc.js";
+import { thinkingVariants } from "./thinking-levels.js";
+/**
+ * OpenChamber preselects an agent's `model` + `variant` for new sessions; publish
+ * pi's active model and its resolved thinking level so "Default" is pi's level.
+ */
+export function agentDefaults(cat) {
+    if (cat.default === undefined)
+        return {};
+    return cat.defaultThinkingLevel !== undefined
+        ? { model: cat.default, variant: cat.defaultThinkingLevel }
+        : { model: cat.default };
+}
+function toOCModel(m) {
+    const inputs = new Set(m.input ?? ["text"]);
+    const modality = (name) => inputs.has(name);
+    const variants = thinkingVariants(m);
+    return {
+        id: m.id,
+        providerID: m.provider,
+        api: { id: m.id, url: m.baseUrl ?? "", npm: "@ai-sdk/openai-compatible" },
+        name: m.name ?? m.id,
+        capabilities: {
+            temperature: true,
+            reasoning: m.reasoning ?? false,
+            attachment: modality("image"),
+            toolcall: true,
+            input: { text: modality("text"), audio: false, image: modality("image"), video: false, pdf: false },
+            output: { text: true, audio: false, image: false, video: false, pdf: false },
+            interleaved: m.reasoning ? true : false,
+        },
+        cost: {
+            input: m.cost?.input ?? 0,
+            output: m.cost?.output ?? 0,
+            cache: { read: m.cost?.cacheRead ?? 0, write: m.cost?.cacheWrite ?? 0 },
+        },
+        limit: { context: m.contextWindow ?? 0, output: m.maxTokens ?? 0 },
+        options: {},
+        ...(variants !== undefined ? { variants } : {}),
+    };
+}
+export async function loadCatalog(directory) {
+    const pi = new PiRpcClient({ cwd: directory });
+    try {
+        const [modelsRes, firstState] = await Promise.all([
+            pi.command({ type: "get_available_models" }),
+            pi.command({ type: "get_state" }),
+        ]);
+        const providers = new Map();
+        if (modelsRes.success && modelsRes.data) {
+            for (const m of modelsRes.data.models) {
+                let p = providers.get(m.provider);
+                if (!p) {
+                    p = { id: m.provider, name: m.provider, source: "config", env: [], options: {}, models: {} };
+                    providers.set(m.provider, p);
+                }
+                p.models[m.id] = toOCModel(m);
+            }
+        }
+        // get_state occasionally races pi's own startup. One retry beats resolving
+        // no active model, which is precisely what leaves the UI picker guessing.
+        let active = firstState.success ? (firstState.data?.model ?? null) : null;
+        let thinkingLevel = firstState.success ? firstState.data?.thinkingLevel : undefined;
+        if (active === null) {
+            const retry = await pi.command({ type: "get_state" });
+            active = retry.success ? (retry.data?.model ?? null) : null;
+            thinkingLevel = retry.success ? retry.data?.thinkingLevel : undefined;
+        }
+        if (active === null) {
+            console.error("[catalog] warning: pi reported no active model — /api/model/default will be null and the UI picker falls back to its own default");
+        }
+        const defaults = {};
+        let resolvedDefault;
+        if (active !== null) {
+            defaults[active.provider] = active.id;
+            resolvedDefault = { providerID: active.provider, modelID: active.id };
+            // The client drops any selection it cannot find in this catalog and picks
+            // something else instead, so a model get_available_models omitted still
+            // has to be listed here — otherwise the active model is unselectable.
+            let p = providers.get(active.provider);
+            if (p === undefined) {
+                p = { id: active.provider, name: active.provider, source: "config", env: [], options: {}, models: {} };
+                providers.set(active.provider, p);
+            }
+            if (p.models[active.id] === undefined)
+                p.models[active.id] = toOCModel(active);
+        }
+        // OpenChamber's picker defaults to the first listed provider/model — put pi's active config there.
+        const sorted = [...providers.values()].sort((a, b) => {
+            const aDef = defaults[a.id] !== undefined ? 0 : 1;
+            const bDef = defaults[b.id] !== undefined ? 0 : 1;
+            return aDef - bDef;
+        });
+        for (const p of sorted) {
+            const def = defaults[p.id];
+            if (!def)
+                continue;
+            const entries = Object.entries(p.models).sort(([a], [b]) => (a === def ? -1 : b === def ? 1 : 0));
+            p.models = Object.fromEntries(entries);
+        }
+        // exactOptionalPropertyTypes: omit `default` rather than set it undefined.
+        if (resolvedDefault === undefined)
+            return { providers: sorted, defaults };
+        // Only a level the catalog offers as a variant is selectable in the picker.
+        const offered = sorted.find((p) => p.id === resolvedDefault.providerID)?.models[resolvedDefault.modelID]?.variants;
+        return thinkingLevel !== undefined && offered?.[thinkingLevel] !== undefined
+            ? { providers: sorted, defaults, default: resolvedDefault, defaultThinkingLevel: thinkingLevel }
+            : { providers: sorted, defaults, default: resolvedDefault };
+    }
+    finally {
+        await pi.dispose();
+    }
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+/** CLI parsing and dispatch. Server code is loaded only for serve/default mode. */
+import { parseArgs } from "node:util";
+import { ADAPTER_VERSION, OPENCODE_API_VERSION } from "./version.js";
+try {
+    const argv = process.argv.slice(2);
+    // Keep this probe byte-identical: OpenChamber expects an OpenCode 2.x version.
+    if (argv.includes("--version") || argv.includes("-v")) {
+        console.log(`opencode v${OPENCODE_API_VERSION}`);
+    }
+    else {
+        const { values, positionals } = parseArgs({
+            args: argv,
+            allowPositionals: true,
+            options: {
+                help: { type: "boolean", short: "h" },
+                port: { type: "string" },
+                host: { type: "string" },
+                hostname: { type: "string" },
+                directory: { type: "string" },
+                "insecure-no-auth": { type: "boolean" },
+                settings: { type: "string" },
+                profile: { type: "string" },
+                binary: { type: "string" },
+                "dry-run": { type: "boolean" },
+                systemd: { type: "boolean" },
+                "pi-binary": { type: "string" },
+                restart: { type: "boolean" },
+                json: { type: "boolean" },
+            },
+        });
+        const command = values.help ? "help" : (positionals[0] ?? "serve");
+        if (command === "help") {
+            const { help } = await import("./commands/help.js");
+            console.log(help);
+        }
+        else if (command === "version") {
+            console.log(`antechamber ${ADAPTER_VERSION} (OpenCode API v${OPENCODE_API_VERSION})`);
+        }
+        else if (command === "setup") {
+            if (positionals.length > (values.systemd ? 2 : 1))
+                throw new Error("Unexpected setup argument");
+            const { setup } = await import("./commands/setup.js");
+            setup({
+                ...(values.settings !== undefined ? { settings: values.settings } : {}),
+                ...(values.profile !== undefined ? { profile: values.profile } : {}),
+                ...(values.binary !== undefined ? { binary: values.binary } : {}),
+                ...(values["pi-binary"] !== undefined ? { piBinary: values["pi-binary"] } : {}),
+                ...(values.systemd ? { systemd: positionals[1] ?? "openchamber.service" } : {}),
+                dryRun: values["dry-run"] ?? false,
+                restart: values.restart ?? false,
+            });
+        }
+        else if (command === "doctor") {
+            const { doctor, formatDoctor } = await import("./commands/doctor.js");
+            const report = doctor({
+                ...(values.settings !== undefined ? { settings: values.settings } : {}),
+                ...(values.profile !== undefined ? { profile: values.profile } : {}),
+            });
+            console.log(formatDoctor(report, values.json ?? false));
+            process.exitCode = report.exitCode;
+        }
+        else if (command === "serve") {
+            if (positionals.length > 1)
+                throw new Error("Unexpected serve argument");
+            const { serve } = await import("./commands/serve.js");
+            const port = Number(values.port ?? "4096");
+            if (!Number.isInteger(port) || port < 0 || port > 65535)
+                throw new Error("Invalid --port: expected 0-65535");
+            await serve({
+                port,
+                host: values.host ?? values.hostname ?? "127.0.0.1",
+                directory: values.directory ?? process.cwd(),
+                insecureNoAuth: values["insecure-no-auth"] ?? false,
+                compatible: positionals[0] === "serve",
+            });
+        }
+        else {
+            throw new Error(`Unknown command: ${command}. Run antechamber help.`);
+        }
+    }
+}
+catch (error) {
+    console.error(`antechamber: ${error instanceof Error ? error.message : String(error)}`);
+    process.exitCode = 1;
+}

package/dist/commands/context.d.ts

@@ -0,0 +1,26 @@
+import * as fs from "node:fs";
+export interface CommandContext {
+    readonly fs: typeof fs;
+    readonly env: NodeJS.ProcessEnv;
+    readonly home: string;
+    readonly cwd: string;
+    readonly exec: (binary: string, args: readonly string[]) => string;
+    readonly now: () => Date;
+    readonly platform: NodeJS.Platform;
+    readonly nodeVersion: string;
+    readonly output: (line: string) => void;
+    readonly cliPath: string;
+    readonly launcherPath: string;
+}
+export declare function createContext(overrides?: Partial<CommandContext>): CommandContext;
+export declare const packageCliPath: string;
+/** Resolve executables without shell evaluation, respecting the supplied PATH. */
+export declare function resolveBinary(binary: string, ctx: CommandContext): string | undefined;
+export interface SettingsOptions {
+    readonly settings?: string;
+    readonly profile?: string;
+}
+export declare function settingsPath(options: SettingsOptions, ctx: CommandContext): string;
+export declare function readSettings(path: string, ctx: CommandContext): Record<string, unknown>;
+export declare function shellQuote(value: string): string;
+export declare function isPackageBinary(binary: string, ctx: CommandContext): boolean;

package/dist/commands/context.js

@@ -0,0 +1,89 @@
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import { homedir } from "node:os";
+import { delimiter, isAbsolute, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+export function createContext(overrides = {}) {
+    const env = overrides.env ?? process.env;
+    const cwd = overrides.cwd ?? process.cwd();
+    return {
+        fs,
+        env,
+        home: overrides.home ?? env.HOME ?? homedir(),
+        cwd,
+        exec: (binary, args) => {
+            const result = spawnSync(binary, args, {
+                env,
+                cwd,
+                encoding: "utf8",
+                timeout: 5000,
+                killSignal: "SIGKILL",
+                maxBuffer: 1024 * 1024,
+            });
+            if (result.error)
+                throw result.error;
+            if (result.status !== 0)
+                throw new Error(`${binary} exited ${result.status}: ${result.stderr.trim()}`);
+            return result.stdout.trim();
+        },
+        now: () => new Date(),
+        platform: process.platform,
+        nodeVersion: process.versions.node,
+        output: console.log,
+        cliPath: packageCliPath,
+        launcherPath: fileURLToPath(new URL("../../bin/opencode-antechamber", import.meta.url)),
+        ...overrides,
+    };
+}
+export const packageCliPath = fileURLToPath(new URL("../../dist/cli.js", import.meta.url));
+/** Resolve executables without shell evaluation, respecting the supplied PATH. */
+export function resolveBinary(binary, ctx) {
+    const candidates = isAbsolute(binary) || binary.includes("/") || binary.includes("\\")
+        ? [resolve(ctx.cwd, binary)]
+        : (ctx.env.PATH ?? "").split(delimiter).map((dir) => resolve(ctx.cwd, dir, binary));
+    for (const candidate of candidates) {
+        try {
+            ctx.fs.accessSync(candidate, ctx.fs.constants.X_OK);
+            if (ctx.fs.statSync(candidate).isFile())
+                return candidate;
+        }
+        catch (error) {
+            if (!(error instanceof Error) ||
+                !("code" in error) ||
+                !["ENOENT", "EACCES", "ENOTDIR"].includes(String(error.code)))
+                throw error;
+        }
+    }
+    return undefined;
+}
+export function settingsPath(options, ctx) {
+    if (options.settings !== undefined)
+        return resolve(ctx.cwd, options.settings);
+    const dir = options.profile ?? ctx.env.OPENCHAMBER_DATA_DIR ?? join(ctx.home, ".config", "openchamber");
+    return resolve(ctx.cwd, dir, "settings.json");
+}
+export function readSettings(path, ctx) {
+    let value;
+    try {
+        value = JSON.parse(ctx.fs.readFileSync(path, "utf8"));
+    }
+    catch (error) {
+        if (error instanceof SyntaxError)
+            throw new Error(`Invalid JSON in settings file ${path}: ${error.message}`);
+        throw error;
+    }
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new Error(`Invalid settings file ${path}: expected a JSON object`);
+    }
+    return Object.fromEntries(Object.entries(value));
+}
+export function shellQuote(value) {
+    return /^[\w./:@=-]+$/.test(value) ? value : `'${value.replaceAll("'", "'\\''")}'`;
+}
+export function isPackageBinary(binary, ctx) {
+    const resolved = resolveBinary(binary, ctx);
+    if (resolved === undefined)
+        return false;
+    const target = ctx.fs.realpathSync(resolved);
+    return [ctx.cliPath, ctx.launcherPath].some((path) => ctx.fs.existsSync(path) && ctx.fs.realpathSync(path) === target);
+}

package/dist/commands/doctor.d.ts

@@ -0,0 +1,13 @@
+import { type CommandContext, type SettingsOptions } from "./context.js";
+export interface DoctorCheck {
+    readonly name: string;
+    readonly status: "PASS" | "WARN" | "FAIL" | "INFO";
+    readonly message: string;
+}
+export interface DoctorReport {
+    readonly checks: readonly DoctorCheck[];
+    readonly exitCode: 0 | 1;
+}
+/** Checks capabilities with access/stat only, never creating state or config files. */
+export declare function doctor(options?: SettingsOptions, ctx?: CommandContext): DoctorReport;
+export declare function formatDoctor(report: DoctorReport, json: boolean): string;

package/dist/commands/doctor.js

@@ -0,0 +1,92 @@
+import { dirname, resolve } from "node:path";
+import { piAgentDir } from "../agent-dir.js";
+import { detectAgentName } from "../agent-name.js";
+import { agentBinary, defaultStateDir, envSetting, isPlainPi } from "../config.js";
+import { findPidfdPython } from "../pidfd.js";
+import { createContext, isPackageBinary, readSettings, resolveBinary, settingsPath, } from "./context.js";
+/** Checks capabilities with access/stat only, never creating state or config files. */
+export function doctor(options = {}, ctx = createContext()) {
+    const checks = [];
+    const add = (name, status, message) => {
+        checks.push({ name, status, message });
+    };
+    add("node", Number(ctx.nodeVersion.split(".")[0]) >= 22 ? "PASS" : "FAIL", `Node ${ctx.nodeVersion}; requires >=22`);
+    const backend = agentBinary(ctx.env);
+    const binary = resolveBinary(backend, ctx);
+    if (binary === undefined)
+        add("backend", "FAIL", `${backend} is not an executable on PATH`);
+    else {
+        try {
+            add("backend", "PASS", `${binary}: ${ctx.exec(binary, ["--version"]) || "version command succeeded"}`);
+        }
+        catch (error) {
+            add("backend", "FAIL", `${binary}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    add("backend-kind", isPlainPi(ctx.env) ? "WARN" : "PASS", isPlainPi(ctx.env)
+        ? "plain pi backend: best effort; OmO features unavailable"
+        : `OmO-compatible backend (${backend})`);
+    const agentDir = resolve(ctx.cwd, piAgentDir(ctx.env, ctx.home));
+    add("agent-dir", ctx.fs.existsSync(agentDir) && ctx.fs.statSync(agentDir).isDirectory() ? "PASS" : "FAIL", agentDir);
+    add("agent-name", "PASS", detectAgentName(ctx.env, ctx.home, ctx.fs));
+    const stateDir = resolve(ctx.cwd, envSetting("STATE_DIR", ctx.env) ?? defaultStateDir(ctx.home, ctx.fs.existsSync));
+    try {
+        let ancestor = stateDir;
+        while (!ctx.fs.existsSync(ancestor) && dirname(ancestor) !== ancestor)
+            ancestor = dirname(ancestor);
+        if (!ctx.fs.statSync(ancestor).isDirectory())
+            throw new Error(`${ancestor} is not a directory`);
+        ctx.fs.accessSync(ancestor, ctx.fs.constants.W_OK | ctx.fs.constants.X_OK);
+        add("state-dir", "PASS", `${stateDir}${ancestor === stateDir ? " is writable" : ` can be created under writable ${ancestor}`}`);
+    }
+    catch (error) {
+        add("state-dir", "FAIL", `${stateDir}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const python = ctx.platform === "linux"
+        ? findPidfdPython(ctx.env, (candidate, args) => {
+            try {
+                ctx.exec(candidate, args);
+                return true;
+            }
+            catch (error) {
+                if (!(error instanceof Error))
+                    throw error;
+                return false;
+            }
+        })
+        : undefined;
+    add("private-host-teardown", python === undefined ? "WARN" : "PASS", python === undefined
+        ? "requires Linux and python3 with working pidfd support"
+        : `Linux pidfd support via ${python}`);
+    const openchamber = resolveBinary("openchamber", ctx);
+    if (openchamber === undefined)
+        add("openchamber", "WARN", "openchamber is not on PATH");
+    else {
+        try {
+            add("openchamber", "PASS", `${openchamber}: ${ctx.exec(openchamber, ["--version"]) || "version not reported"}`);
+        }
+        catch (error) {
+            add("openchamber", "WARN", `${openchamber}: version not determinable (${error instanceof Error ? error.message : String(error)})`);
+        }
+    }
+    const settings = settingsPath(options, ctx);
+    if (!ctx.fs.existsSync(settings))
+        add("openchamber-settings", "WARN", `${settings} does not exist; run antechamber setup`);
+    else {
+        try {
+            const configured = readSettings(settings, ctx).opencodeBinary;
+            const matches = typeof configured === "string" && isPackageBinary(configured, ctx);
+            add("openchamber-settings", matches ? "PASS" : "WARN", `${settings}: opencodeBinary=${JSON.stringify(configured ?? null)}${matches ? "" : "; does not point at this antechamber installation"}`);
+        }
+        catch (error) {
+            add("openchamber-settings", "WARN", error instanceof Error ? error.message : String(error));
+        }
+    }
+    add("auth", "INFO", `OPENCODE_SERVER_PASSWORD is ${ctx.env.OPENCODE_SERVER_PASSWORD ? "set" : "not set"}`);
+    return { checks, exitCode: checks.some((check) => check.status === "FAIL") ? 1 : 0 };
+}
+export function formatDoctor(report, json) {
+    return json
+        ? JSON.stringify(report, null, 2)
+        : report.checks.map((check) => `${check.status} ${check.name}: ${check.message}`).join("\n");
+}

package/dist/commands/help.d.ts

@@ -0,0 +1 @@
+export declare const help = "Usage: antechamber [command] [options]\n\nCommands:\n  serve       Run the OpenCode-compatible HTTP/SSE server (also the default)\n  setup       Point OpenChamber at this installation; back up changed files\n  doctor      Read-only installation and backend checks (exit 1 on FAIL)\n  version     Print the npm package and OpenCode API versions\n  help        Show this help (--help, -h)\n\nServe:   --port 4096 --host 127.0.0.1 (or --hostname) --directory <path>\n         --insecure-no-auth\nSetup:   --settings <file> | --profile <dir>\n         --binary <path> --dry-run --systemd [unit] --pi-binary <path> --restart\nDoctor:  --settings <file> | --profile <dir> --json\nProbe:   --version, -v prints the OpenCode compatibility version for OpenChamber";

package/dist/commands/help.js

@@ -0,0 +1,15 @@
+export const help = `Usage: antechamber [command] [options]
+
+Commands:
+  serve       Run the OpenCode-compatible HTTP/SSE server (also the default)
+  setup       Point OpenChamber at this installation; back up changed files
+  doctor      Read-only installation and backend checks (exit 1 on FAIL)
+  version     Print the npm package and OpenCode API versions
+  help        Show this help (--help, -h)
+
+Serve:   --port 4096 --host 127.0.0.1 (or --hostname) --directory <path>
+         --insecure-no-auth
+Setup:   --settings <file> | --profile <dir>
+         --binary <path> --dry-run --systemd [unit] --pi-binary <path> --restart
+Doctor:  --settings <file> | --profile <dir> --json
+Probe:   --version, -v prints the OpenCode compatibility version for OpenChamber`;

package/dist/commands/serve.d.ts

@@ -0,0 +1,8 @@
+export interface ServeOptions {
+    readonly port: number;
+    readonly host: string;
+    readonly directory: string;
+    readonly insecureNoAuth: boolean;
+    readonly compatible: boolean;
+}
+export declare function serve(options: ServeOptions): Promise<void>;

package/dist/commands/serve.js

@@ -0,0 +1,29 @@
+import { envSetting } from "../config.js";
+import { AdapterServer, isLoopbackHost, serverPassword } from "../server.js";
+export async function serve(options) {
+    const { port, host, directory, insecureNoAuth, compatible } = options;
+    if (!isLoopbackHost(host) &&
+        serverPassword() === undefined &&
+        !insecureNoAuth &&
+        envSetting("ALLOW_INSECURE") !== "1") {
+        throw new Error(`refusing to bind ${host} without authentication. Set OPENCODE_SERVER_PASSWORD or ANTECHAMBER_SERVER_PASSWORD, or explicitly use --insecure-no-auth (ANTECHAMBER_ALLOW_INSECURE=1).`);
+    }
+    const server = new AdapterServer({ port, host, defaultDirectory: directory });
+    const shutdown = () => {
+        void server.stop().then(() => process.exit(0), (error) => {
+            console.error("antechamber: shutdown failed:", error);
+            process.exit(1);
+        });
+    };
+    // Install handlers before announcing readiness: a supervisor may signal as
+    // soon as it reads the listening line, before this process runs again.
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    await server.start();
+    if (compatible)
+        console.log(`opencode server listening on ${server.url}`);
+    else {
+        console.log(`antechamber listening on ${server.url}`);
+        console.log(`default directory: ${directory}`);
+    }
+}

package/dist/commands/setup.d.ts

@@ -0,0 +1,14 @@
+import { type CommandContext, type SettingsOptions } from "./context.js";
+export interface SetupOptions extends SettingsOptions {
+    readonly binary?: string;
+    readonly dryRun?: boolean;
+    readonly systemd?: string;
+    readonly piBinary?: string;
+    readonly restart?: boolean;
+    /** User-unit root, overridable without touching the real systemd configuration. */
+    readonly systemdDir?: string;
+}
+/** The bundled OmO Graph extension folder, when this installation has its built files. */
+export declare function omoGraphExtensionDir(ctx: CommandContext): string | undefined;
+/** Plan all inputs before applying changes; dependencies are injected for hermetic tests. */
+export declare function setup(options: SetupOptions, ctx?: CommandContext): string[];

package/dist/commands/setup.js

@@ -0,0 +1,137 @@
+import { dirname, join, resolve } from "node:path";
+import { createContext, isPackageBinary, readSettings, resolveBinary, settingsPath, shellQuote, } from "./context.js";
+function systemdValue(value) {
+    if (/[\r\n\0]/.test(value))
+        throw new Error("systemd environment values cannot contain newlines or NUL");
+    return value.replaceAll("\\", "\\\\").replaceAll('"', '\\"').replaceAll("%", "%%");
+}
+/** The bundled OmO Graph extension folder, when this installation has its built files. */
+export function omoGraphExtensionDir(ctx) {
+    const dir = resolve(dirname(ctx.cliPath), "..", "extensions", "omo-dag");
+    const built = ["package.json", "panel/main.js", "service/main.js"].every((file) => ctx.fs.existsSync(join(dir, file)));
+    return built ? dir : undefined;
+}
+/** Plan all inputs before applying changes; dependencies are injected for hermetic tests. */
+export function setup(options, ctx = createContext()) {
+    const lines = [];
+    const report = (line) => {
+        lines.push(line);
+        ctx.output(line);
+    };
+    if (options.restart && options.systemd === undefined)
+        throw new Error("--restart requires --systemd");
+    const settings = settingsPath(options, ctx);
+    const existing = ctx.fs.existsSync(settings);
+    const data = existing ? readSettings(settings, ctx) : {};
+    const onPath = resolveBinary("antechamber", ctx);
+    const binary = options.binary !== undefined
+        ? resolveBinary(options.binary, ctx)
+        : onPath !== undefined && isPackageBinary(onPath, ctx)
+            ? onPath
+            : ctx.cliPath;
+    if (binary === undefined)
+        throw new Error(`Cannot resolve executable --binary ${options.binary}`);
+    if (binary === ctx.cliPath && !ctx.fs.readFileSync(binary, "utf8").startsWith("#!/usr/bin/env node\n")) {
+        throw new Error(`Package CLI ${binary} is missing its node shebang; run npm run build`);
+    }
+    const updated = `${JSON.stringify({ ...data, opencodeBinary: binary }, null, 2)}\n`;
+    const changed = data.opencodeBinary !== binary;
+    let dropIn;
+    let dropInText;
+    let oldDropIn;
+    if (options.systemd !== undefined) {
+        const unit = options.systemd;
+        if (!/^[a-zA-Z0-9_.@:-]+\.service$/.test(unit))
+            throw new Error(`Invalid systemd service unit: ${unit}`);
+        const backend = resolveBinary(options.piBinary ?? "omo", ctx);
+        if (backend === undefined)
+            throw new Error(`Cannot resolve backend ${options.piBinary ?? "omo"} for --systemd`);
+        const root = options.systemdDir ?? join(ctx.home, ".config", "systemd", "user");
+        const dir = resolve(ctx.cwd, root, `${unit}.d`);
+        dropIn = join(dir, "antechamber.conf");
+        dropInText = [
+            "[Service]",
+            `Environment="PATH=${systemdValue(ctx.env.PATH ?? "")}"`,
+            `Environment="ANTECHAMBER_PI_BINARY=${systemdValue(backend)}"`,
+            "KillMode=control-group",
+            "TimeoutStopSec=20",
+            "",
+        ].join("\n");
+        if (ctx.fs.existsSync(dropIn))
+            oldDropIn = ctx.fs.readFileSync(dropIn, "utf8");
+        if (ctx.fs.existsSync(dir)) {
+            for (const name of ctx.fs.readdirSync(dir).sort()) {
+                if (name === "antechamber.conf" || !name.endsWith(".conf"))
+                    continue;
+                const content = ctx.fs.readFileSync(join(dir, name), "utf8");
+                if (content
+                    .split("\n")
+                    .some((line) => /^\s*Environment(?:File)?\s*=/.test(line) && /\b(?:ANTECHAMBER_|OCPI_)/.test(line))) {
+                    report(`WARN ${join(dir, name)} sets ANTECHAMBER_*/OCPI_*; ${name > "antechamber.conf" ? "later files override this drop-in" : "review earlier settings and legacy fallbacks"}.`);
+                }
+            }
+        }
+    }
+    const stamp = ctx.now().toISOString().replace(/\D/g, "").slice(0, 14);
+    const backup = (path) => {
+        const target = `${path}.bak-antechamber-${stamp}`;
+        if (options.dryRun)
+            report(`Would back up ${path} to ${target}`);
+        else {
+            ctx.fs.copyFileSync(path, target, ctx.fs.constants.COPYFILE_EXCL);
+            report(`Backed up ${path} to ${target}`);
+        }
+    };
+    if (binary === ctx.cliPath && (ctx.fs.statSync(binary).mode & 0o111) === 0) {
+        if (options.dryRun)
+            report(`Would make ${binary} executable`);
+        else {
+            ctx.fs.chmodSync(binary, ctx.fs.statSync(binary).mode | 0o111);
+            report(`Made ${binary} executable`);
+        }
+    }
+    if (changed) {
+        report(`${options.dryRun ? "Would update" : "Updating"} ${settings}`);
+        report(`- opencodeBinary: ${JSON.stringify(data.opencodeBinary ?? null)}`);
+        report(`+ opencodeBinary: ${JSON.stringify(binary)}`);
+        if (existing)
+            backup(settings);
+        if (!options.dryRun) {
+            ctx.fs.mkdirSync(dirname(settings), { recursive: true });
+            ctx.fs.writeFileSync(settings, updated, { mode: 0o600 });
+            report(`Wrote ${settings}`);
+        }
+    }
+    else
+        report(`Already configured: ${settings} points at ${binary}`);
+    if (dropIn !== undefined && dropInText !== undefined) {
+        if (oldDropIn === dropInText)
+            report(`Already configured: ${dropIn}`);
+        else {
+            report(`${options.dryRun ? "Would write" : "Writing"} ${dropIn}:\n${dropInText}`);
+            if (oldDropIn !== undefined)
+                backup(dropIn);
+            if (!options.dryRun) {
+                ctx.fs.mkdirSync(dirname(dropIn), { recursive: true });
+                ctx.fs.writeFileSync(dropIn, dropInText, { mode: 0o600 });
+                report(`Wrote ${dropIn}`);
+            }
+        }
+        const unit = options.systemd ?? "openchamber.service";
+        report(`systemctl --user daemon-reload && systemctl --user restart ${shellQuote(unit)}`);
+        if (options.restart && !options.dryRun) {
+            ctx.exec("systemctl", ["--user", "daemon-reload"]);
+            report("Reloaded systemd user units");
+            ctx.exec("systemctl", ["--user", "restart", unit]);
+            report(`Restarted ${unit}`);
+        }
+    }
+    if (options.profile !== undefined && options.settings === undefined) {
+        report(`OPENCHAMBER_DATA_DIR=${shellQuote(resolve(ctx.cwd, options.profile))} openchamber serve`);
+    }
+    const extension = omoGraphExtensionDir(ctx);
+    if (extension !== undefined) {
+        report(`Optional OmO Graph extension: in OpenChamber, Settings \u2192 Extensions \u2192 Add \u2192 Folder: ${extension}`);
+    }
+    return lines;
+}

package/dist/config.d.ts

@@ -0,0 +1,18 @@
+import { existsSync } from "node:fs";
+/** Environment variable prefix for all antechamber settings. */
+export declare const ENV_PREFIX = "ANTECHAMBER_";
+/**
+ * Reads `ANTECHAMBER_<name>`, falling back to the deprecated `OCPI_<name>`.
+ * Blank values count as unset.
+ */
+export declare function envSetting(name: string, env?: NodeJS.ProcessEnv): string | undefined;
+/**
+ * Default registry/state directory. Prefers `~/.config/antechamber`; when only
+ * the pre-rename directory exists it keeps using that so existing session
+ * mappings survive the upgrade.
+ */
+export declare function defaultStateDir(home?: string, exists?: typeof existsSync): string;
+/** Agent executable spawned per session: OmO by default, plain pi when configured. */
+export declare function agentBinary(env?: NodeJS.ProcessEnv): string;
+/** True when the configured backend is upstream pi rather than OmO. */
+export declare function isPlainPi(env?: NodeJS.ProcessEnv): boolean;