antechamber 0.2.3 → 0.2.5

package/CHANGELOG.md

@@ -7,6 +7,38 @@ and this project uses [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.2.5] - 2026-10-15
+
+### Added
+
+- OmO terminal monitors now appear in OpenChamber as read-only child sessions of
+  the session that started them. They are listed under Subagents and keep a live
+  sidebar dot while the watch runs, and their transcript shows the watched
+  command, filter, event count and how the watch ended. A session with a live
+  watch is no longer evicted as idle, which used to stop the watch.
+- MCP servers configured in OmO now appear in OpenChamber's MCP status, and the
+  Authorize button for a server that needs sign-in runs OmO's native
+  `/mcp auth` flow in the running session. Status and authorization use the
+  most recently used live session in the directory. The flow never adds a
+  message to the conversation, and it never revives a dormant session.
+- Completing an MCP sign-in with a pasted code or redirect URL (OpenChamber's
+  callback page or paste box) now works through `/mcp/{name}/auth/callback`.
+  The code goes to OmO's waiting loopback listener, or to
+  `/mcp auth-complete` when OmO parked the flow.
+- OpenChamber 2.x now lists OmO MCP servers (`GET /api/mcp`) and can sign in
+  through `mcp_*` integrations. These run OmO's headless `/mcp auth-start` and
+  `/mcp auth-complete` with a paste-the-code step. A completed sign-in emits
+  `mcp.status.changed`.
+
+## [0.2.4] - 2026-10-15
+
+### Added
+
+- feat(cli): `antechamber setup --auto-update` points OpenChamber at a launcher that installs the latest release in the background on every start; it is now the recommended install path
+- feat(cli): `antechamber upgrade` installs the latest release with the package manager that owns the global install, so OpenChamber 2.3.2's Update button now upgrades antechamber
+- feat(api): `POST /global/upgrade` upgrades antechamber itself instead of returning `UnsupportedError`
+- feat(config): `ANTECHAMBER_AUTO_UPDATE=1` enables the post-start background update
+
 ## [0.2.3] - 2026-10-15
 
 ### Fixed

package/README.md

@@ -73,13 +73,23 @@ Needs Node.js 22+ and OmO's `omo` command on PATH (`bun add -g omo-ai`).
 npm i -g antechamber
 # or: bun add -g antechamber
 antechamber doctor
-antechamber setup
+antechamber setup --auto-update
 ```
 
 `setup` updates OpenChamber's `opencodeBinary`, preserves all other settings,
 and backs up an existing settings file before changing it. Restart OpenChamber
 after setup. Preview changes with `antechamber setup --dry-run`.
 
+`--auto-update` keeps antechamber current without any action from you. It
+writes a small launcher, `~/.config/antechamber/opencode-antechamber`, and points
+OpenChamber at it. Each time OpenChamber starts antechamber, the launcher
+checks npm for a newer release once the server is up and installs it with the
+package manager that owns the global install. The new version runs from the
+next start; startup never waits on the network, and an offline start just
+skips the check. It needs a global npm or bun install, so it is refused for
+source checkouts and `npx`. Drop the flag (plain `antechamber setup`) to point
+OpenChamber back at the `antechamber` bin and stop auto-updates.
+
 Optionally, add the bundled [OmO Graph extension](#openchamber-extension-omo-graph):
 `setup` ends by printing its folder
 (`$(npm root -g)/antechamber/extensions/omo-dag`). In OpenChamber, open
@@ -131,28 +141,33 @@ antechamber serve --hostname 127.0.0.1 --port 4096
 | Command | Purpose / options |
 |---|---|
 | `antechamber serve` | OpenCode-compatible server; `--hostname`/`--host`, `--port`, `--directory`. Bare `antechamber` also starts the server. |
-| `antechamber setup` | Configure OpenChamber; `--settings <file>`, `--profile <dir>`, `--binary <path>`, `--dry-run`, `--systemd [unit]`, `--pi-binary <path>`, `--restart`. |
+| `antechamber setup` | Configure OpenChamber; `--settings <file>`, `--profile <dir>`, `--binary <path>`, `--dry-run`, `--systemd [unit]`, `--pi-binary <path>`, `--restart`, `--auto-update`. |
 | `antechamber doctor` | Read-only Node, backend, agent/state directories, teardown, OpenChamber and auth checks; `--json`, `--settings <file>`, `--profile <dir>`. Exits 1 on any FAIL; warnings do not fail. |
+| `antechamber upgrade` | Install the latest release over a global npm or bun install, with the package manager that owns it. Refused for source checkouts and `npx`. |
 | `antechamber version` | Package version plus OpenCode API contract version. `--version`/`-v` deliberately print exactly `opencode v2.0.20` for OpenChamber. |
 | `antechamber help` | Usage and options; also `--help`/`-h`. |
 
 ## Upgrade, uninstall and rollback
 
+With `setup --auto-update` there is nothing to do: each start installs the
+latest release for the next one. Otherwise:
+
 ```bash
-npm update -g antechamber
-# or: bun add -g antechamber
+antechamber upgrade
+# equivalent: npm update -g antechamber (or: bun add -g antechamber)
 ```
 
 Restart OpenChamber, or `systemctl --user restart openchamber.service` for a
 managed service. Run `antechamber doctor` again. If the executable moved,
 rerun `antechamber setup`.
 
-OpenChamber 2.3.2 may announce a newer OpenCode release. antechamber reports
-OpenCode API 2.0.20, the minimum OpenChamber accepts, and OpenChamber offers
-no signal that keeps that check while hiding the notice. Dismiss it or turn off
-OpenCode update notifications in OpenChamber. Its Update action runs
-`opencode-antechamber upgrade`, which refuses; upgrade antechamber with the
-commands above.
+OpenChamber 2.3.2 shows an "OpenCode update" notice because antechamber
+reports OpenCode API 2.0.20, the minimum OpenChamber accepts. The notice names
+an OpenCode version, but its **Update** button runs `<opencodeBinary> upgrade`,
+which upgrades antechamber itself (a no-op when it is already current). Click
+**Reload OpenCode** afterwards to restart onto the new version. OpenChamber
+1.x shows no notice; its `POST /global/upgrade` call upgrades antechamber the
+same way.
 
 To roll back wiring, copy the backup printed by setup over the settings file:
 

package/bin/opencode-antechamber

@@ -1,7 +1,8 @@
 #!/bin/sh
 # OpenChamber launcher: point `settings.opencodeBinary` (or $OPENCODE_BINARY)
 # at this file. OpenChamber runs `<binary> serve --hostname H --port P` and
-# `<binary> --version`; anything else is rejected.
+# `<binary> --version`, and OpenChamber 2.x's Update action runs `<binary> upgrade`;
+# anything else is rejected.
 # Requires a build (`npm run build`) so that dist/cli.js exists.
 set -eu
 SCRIPT_PATH=$0
@@ -22,10 +23,7 @@ fi
 case "${1:-}" in
   serve) shift; exec node "$CLI" serve "$@" ;;
   --version|-v) exec node "$CLI" --version ;;
-  upgrade)
-    echo "opencode-antechamber: OpenChamber cannot upgrade antechamber; run 'npm update -g antechamber' (or 'bun add -g antechamber') instead" >&2
-    exit 1
-    ;;
+  upgrade) exec node "$CLI" upgrade ;;
 esac
-echo "opencode-antechamber: unsupported command '${1:-}' (only 'serve' and '--version' are implemented)" >&2
+echo "opencode-antechamber: unsupported command '${1:-}' (only 'serve', '--version' and 'upgrade' are implemented)" >&2
 exit 1

package/dist/cli.js

@@ -26,6 +26,7 @@ try {
                 systemd: { type: "boolean" },
                 "pi-binary": { type: "string" },
                 restart: { type: "boolean" },
+                "auto-update": { type: "boolean" },
                 json: { type: "boolean" },
             },
         });
@@ -49,8 +50,15 @@ try {
                 ...(values.systemd ? { systemd: positionals[1] ?? "openchamber.service" } : {}),
                 dryRun: values["dry-run"] ?? false,
                 restart: values.restart ?? false,
+                autoUpdate: values["auto-update"] ?? false,
             });
         }
+        else if (command === "upgrade") {
+            if (positionals.length > 1)
+                throw new Error("Unexpected upgrade argument");
+            const { upgrade } = await import("./commands/upgrade.js");
+            await upgrade();
+        }
         else if (command === "doctor") {
             const { doctor, formatDoctor } = await import("./commands/doctor.js");
             const report = doctor({

package/dist/commands/context.d.ts

@@ -22,4 +22,8 @@ export interface SettingsOptions {
 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;
+/** OpenChamber launcher written by `setup --auto-update`, kept beside the session registry. */
+export declare function autoUpdateLauncherPath(ctx: CommandContext): string;
+export declare function autoUpdateLauncherText(binary: string): string;
+export declare function autoUpdateLauncherTarget(text: string): string | undefined;
 export declare function isPackageBinary(binary: string, ctx: CommandContext): boolean;

package/dist/commands/context.js

@@ -3,6 +3,7 @@ import * as fs from "node:fs";
 import { homedir } from "node:os";
 import { delimiter, isAbsolute, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { defaultStateDir, envSetting } from "../config.js";
 export function createContext(overrides = {}) {
     const env = overrides.env ?? process.env;
     const cwd = overrides.cwd ?? process.cwd();
@@ -80,6 +81,24 @@ export function readSettings(path, ctx) {
 export function shellQuote(value) {
     return /^[\w./:@=-]+$/.test(value) ? value : `'${value.replaceAll("'", "'\\''")}'`;
 }
+/** OpenChamber launcher written by `setup --auto-update`, kept beside the session registry. */
+export function autoUpdateLauncherPath(ctx) {
+    return resolve(ctx.cwd, envSetting("STATE_DIR", ctx.env) ?? defaultStateDir(ctx.home, ctx.fs.existsSync), "opencode-antechamber");
+}
+export function autoUpdateLauncherText(binary) {
+    return [
+        "#!/bin/sh",
+        "# Written by `antechamber setup --auto-update`; rerun `antechamber setup` without it to stop auto-updates.",
+        "ANTECHAMBER_AUTO_UPDATE=1",
+        "export ANTECHAMBER_AUTO_UPDATE",
+        `exec '${binary.replaceAll("'", "'\\''")}' "$@"`,
+        "",
+    ].join("\n");
+}
+export function autoUpdateLauncherTarget(text) {
+    const match = /^exec '((?:[^']|'\\'')*)' "\$@"$/m.exec(text);
+    return match?.[1]?.replaceAll("'\\''", "'");
+}
 export function isPackageBinary(binary, ctx) {
     const resolved = resolveBinary(binary, ctx);
     if (resolved === undefined)

package/dist/commands/doctor.js

@@ -3,7 +3,7 @@ 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";
+import { autoUpdateLauncherPath, autoUpdateLauncherTarget, 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 = [];
@@ -75,8 +75,13 @@ export function doctor(options = {}, ctx = createContext()) {
     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"}`);
+            const launcher = autoUpdateLauncherPath(ctx);
+            const launcherTarget = configured === launcher && ctx.fs.existsSync(launcher)
+                ? autoUpdateLauncherTarget(ctx.fs.readFileSync(launcher, "utf8"))
+                : undefined;
+            const viaLauncher = launcherTarget !== undefined && isPackageBinary(launcherTarget, ctx);
+            const matches = viaLauncher || (typeof configured === "string" && isPackageBinary(configured, ctx));
+            add("openchamber-settings", matches ? "PASS" : "WARN", `${settings}: opencodeBinary=${JSON.stringify(configured ?? null)}${viaLauncher ? ` (auto-update launcher for ${launcherTarget})` : matches ? "" : "; does not point at this antechamber installation"}`);
         }
         catch (error) {
             add("openchamber-settings", "WARN", error instanceof Error ? error.message : String(error));

package/dist/commands/help.d.ts

@@ -1 +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";
+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  upgrade     Install the latest release over a global npm or bun install\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\n         --auto-update (launch through a wrapper that upgrades on each start)\nDoctor:  --settings <file> | --profile <dir> --json\nProbe:   --version, -v prints the OpenCode compatibility version for OpenChamber";

package/dist/commands/help.js

@@ -4,6 +4,7 @@ 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)
+  upgrade     Install the latest release over a global npm or bun install
   version     Print the npm package and OpenCode API versions
   help        Show this help (--help, -h)
 
@@ -11,5 +12,6 @@ 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
+         --auto-update (launch through a wrapper that upgrades on each start)
 Doctor:  --settings <file> | --profile <dir> --json
 Probe:   --version, -v prints the OpenCode compatibility version for OpenChamber`;

package/dist/commands/serve.js

@@ -1,4 +1,5 @@
 import { envSetting } from "../config.js";
+import { selfUpdate } from "../self-update.js";
 import { AdapterServer, isLoopbackHost, serverPassword } from "../server.js";
 export async function serve(options) {
     const { port, host, directory, insecureNoAuth, compatible } = options;
@@ -26,4 +27,17 @@ export async function serve(options) {
         console.log(`antechamber listening on ${server.url}`);
         console.log(`default directory: ${directory}`);
     }
+    // After the listening line: OpenChamber's startup timeout must not wait on the registry.
+    if (envSetting("AUTO_UPDATE") === "1")
+        void autoUpdate();
+}
+async function autoUpdate() {
+    try {
+        const result = await selfUpdate();
+        if (result.updated)
+            console.error(`antechamber: auto-update installed ${result.to} (running ${result.from}); it starts next time`);
+    }
+    catch (error) {
+        console.error(`antechamber: auto-update skipped: ${error instanceof Error ? error.message : String(error)}`);
+    }
 }

package/dist/commands/setup.d.ts

@@ -5,6 +5,7 @@ interface SetupOptions extends SettingsOptions {
     readonly systemd?: string;
     readonly piBinary?: string;
     readonly restart?: boolean;
+    readonly autoUpdate?: boolean;
     /** User-unit root, overridable without touching the real systemd configuration. */
     readonly systemdDir?: string;
 }

package/dist/commands/setup.js

@@ -1,6 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { dirname, join, resolve } from "node:path";
-import { createContext, isPackageBinary, readSettings, resolveBinary, settingsPath, shellQuote, } from "./context.js";
+import { installMethod, npmBinaryFor } from "../self-update.js";
+import { autoUpdateLauncherPath, autoUpdateLauncherText, 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");
@@ -40,8 +41,24 @@ export function setup(options, ctx = createContext()) {
     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 launcher;
+    let launcherText;
+    let oldLauncher;
+    if (options.autoUpdate) {
+        installMethod({
+            packageRoot: resolve(dirname(ctx.cliPath), ".."),
+            env: ctx.env,
+            home: ctx.home,
+            realpath: (path) => ctx.fs.realpathSync(path),
+        }, () => ctx.exec(npmBinaryFor(), ["root", "-g"]));
+        launcher = autoUpdateLauncherPath(ctx);
+        launcherText = autoUpdateLauncherText(binary);
+        if (ctx.fs.existsSync(launcher))
+            oldLauncher = ctx.fs.readFileSync(launcher, "utf8");
+    }
+    const configured = launcher ?? binary;
+    const updated = `${JSON.stringify({ ...data, opencodeBinary: configured }, null, 2)}\n`;
+    const changed = data.opencodeBinary !== configured;
     let dropIn;
     let dropInText;
     let oldDropIn;
@@ -102,10 +119,22 @@ export function setup(options, ctx = createContext()) {
             report(`Made ${binary} executable`);
         }
     }
+    if (launcher !== undefined && launcherText !== undefined) {
+        if (oldLauncher === launcherText && (ctx.fs.statSync(launcher).mode & 0o111) !== 0)
+            report(`Already configured: ${launcher}`);
+        else if (options.dryRun)
+            report(`Would write auto-update launcher ${launcher} for ${binary}`);
+        else {
+            ctx.fs.mkdirSync(dirname(launcher), { recursive: true });
+            writeAtomically(launcher, launcherText, ctx);
+            ctx.fs.chmodSync(launcher, 0o755);
+            report(`Wrote auto-update launcher ${launcher} for ${binary}`);
+        }
+    }
     if (changed) {
         report(`${options.dryRun ? "Would update" : "Updating"} ${settings}`);
         report(`- opencodeBinary: ${JSON.stringify(data.opencodeBinary ?? null)}`);
-        report(`+ opencodeBinary: ${JSON.stringify(binary)}`);
+        report(`+ opencodeBinary: ${JSON.stringify(configured)}`);
         if (existing)
             backup(settings);
         if (!options.dryRun) {
@@ -115,7 +144,7 @@ export function setup(options, ctx = createContext()) {
         }
     }
     else
-        report(`Already configured: ${settings} points at ${binary}`);
+        report(`Already configured: ${settings} points at ${configured}`);
     if (dropIn !== undefined && dropInText !== undefined) {
         if (oldDropIn === dropInText)
             report(`Already configured: ${dropIn}`);

package/dist/commands/upgrade.d.ts

@@ -0,0 +1,2 @@
+import { type SelfUpdateResult } from "../self-update.js";
+export declare function upgrade(update?: () => Promise<SelfUpdateResult>, output?: (line: string) => void): Promise<void>;

package/dist/commands/upgrade.js

@@ -0,0 +1,7 @@
+import { selfUpdate } from "../self-update.js";
+export async function upgrade(update = selfUpdate, output = console.log) {
+    const result = await update();
+    output(result.updated
+        ? `Updated antechamber ${result.from} -> ${result.to} with ${result.method}; restart OpenChamber to use it.`
+        : `antechamber ${result.from} is already the latest release.`);
+}

package/dist/lifecycle.d.ts

@@ -30,6 +30,7 @@ export declare class SessionLifecycle {
     private stopping;
     constructor(sessions: () => Iterable<ManagedSession>, options?: LifecycleOptions);
     touch(s: ManagedSession): void;
+    lastUsed(s: ManagedSession): number;
     private idle;
     /** Protect the caller across awaits, including admission of a dormant session. */
     use<T>(s: ManagedSession, action: () => Promise<T>): Promise<T>;

package/dist/lifecycle.js

@@ -45,6 +45,9 @@ export class SessionLifecycle {
     touch(s) {
         this.used.set(s, this.clock.now());
     }
+    lastUsed(s) {
+        return this.used.get(s) ?? 0;
+    }
     idle(s) {
         return (!this.active.has(s) &&
             s.pi !== undefined &&
@@ -52,6 +55,7 @@ export class SessionLifecycle {
             s.status.type === "idle" &&
             !s.hasPendingInteraction() &&
             !s.hasRunningChildren() &&
+            !s.hasBackgroundWork?.() &&
             s.piSessionId !== undefined &&
             s.piPath !== undefined);
     }

package/dist/mcp.d.ts

@@ -0,0 +1,70 @@
+/**
+ * OpenCode MCP routes (v1 `/mcp*`, v2 `/api/mcp` and `mcp_*` integrations) backed by OmO's MCP service.
+ *
+ * OpenChamber scopes MCP calls by directory only, while OmO owns MCP per session process.
+ * Everything therefore targets the most recently used LIVE session in the directory; a
+ * dormant session is never revived just to answer an MCP request.
+ *
+ * Status comes from the read-only `get_loaded_surfaces` RPC. Authorization drives OmO's
+ * documented `/mcp` subcommands (docs/mcp.md "Auth"):
+ * - `/mcp auth <name>`: OmO opens a loopback listener and the browser, exchanges the code
+ *   and reconnects. With `mcp.oauthCallbackUrl` set it parks a pending flow instead.
+ * - `/mcp auth-start <name>` then `/mcp auth-complete <name> <redirect-url>`: the headless
+ *   paste flow; the pending PKCE state lives in that session process, so completion must
+ *   reach the same process.
+ * Commands are sent straight to the agent, outside the conversation queue: they neither
+ * wait behind a running turn nor create a user message, and the session is held active so
+ * the reaper cannot stop the process (and its listener or pending state) mid-flow.
+ */
+import type { RouteServices } from "./route-services.js";
+type OCMcpStatus = {
+    status: "connected";
+} | {
+    status: "disabled";
+} | {
+    status: "failed";
+    error: string;
+} | {
+    status: "needs_auth";
+} | {
+    status: "needs_client_registration";
+    error: string;
+};
+type V2McpStatus = {
+    status: "connected";
+} | {
+    status: "pending";
+} | {
+    status: "disabled";
+} | {
+    status: "failed";
+    error: string;
+} | {
+    status: "needs_auth";
+    error: string;
+};
+interface OmoMcpServer {
+    name: string;
+    status?: string;
+    authStatus?: string;
+}
+interface RouteResult {
+    status: number;
+    body?: unknown;
+}
+/** OmO's loopback listener gives up after 5 minutes; leave room for the reconnect that follows. */
+export declare const MCP_AUTH_COMMAND_TIMEOUT_MS: number;
+/** OmO's runtime states fold onto OpenCode's; lazy servers are usable, so they read as connected. */
+export declare function openCodeMcpStatus(server: OmoMcpServer): OCMcpStatus;
+export declare function v2McpStatus(server: OmoMcpServer): V2McpStatus;
+/** The URL OmO prints on its own line after naming the server (`auth` and `auth-start` both do). */
+export declare function authorizationUrl(text: string, name: string): string | undefined;
+/**
+ * The redirect `/mcp auth-complete` expects. OpenChamber sends either the bare code (callback
+ * page, v1 paste box) or the whole redirect address; a bare code is rebuilt from the
+ * authorization request's own `redirect_uri` and `state`.
+ */
+export declare function redirectInput(authorization: string, input: string): string | undefined;
+export declare function mcpRoute(services: RouteServices, method: string, path: string, directory: string, body: () => Promise<unknown>): Promise<RouteResult | undefined>;
+export declare function mcpRouteV2(services: RouteServices, method: string, path: string, directory: string, body: () => Promise<unknown>): Promise<RouteResult | undefined>;
+export {};