@basein/runner 0.1.0

package/dist/auth/client.js

@@ -0,0 +1,284 @@
+/**
+ * auth client — ported from RRepeat's `src/auth/client.ts` (Phase 4.1).
+ *
+ * Authenticates the CLI user against the BaseIn auth-service and returns a JWT
+ * session. Every recording call carries that access token; the recording's owner
+ * is the JWT subject on the server side, which is what makes tenancy work
+ * without BaseInstRunner knowing anything about it.
+ *
+ * Flow:
+ *   1. Load the cached session from ~/.baseinstrunner/credentials.json.
+ *   2. If the access token is still valid, reuse it.
+ *   3. Else if a refresh token is present, POST /auth/refresh (silent).
+ *   4. Else prompt for email + password and POST /auth/login.
+ *   5. Persist the result (mode 0600) and return it.
+ *
+ * WHY IT NEVER `process.exit`s: `bir-proxy` runs inside the host's process tree.
+ * Failing to authenticate must degrade to not-recording (§10), not kill a server
+ * the host is waiting on. Callers get `undefined` and decide.
+ *
+ * Config:
+ *   BIR_AUTH_URL      base URL of the BaseIn auth-service (required).
+ *   BIR_AUTH_DISABLE  "1" to skip auth entirely (local dev / CI).
+ */
+import { createInterface } from "node:readline";
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { configDir } from "../control/paths.js";
+import { join } from "node:path";
+import { logLine, errText } from "../util/log.js";
+/**
+ * Where the cached session lives.
+ *
+ * A **function**, not a constant: `configDir()` reads `BIR_HOME`, and freezing
+ * this at import time meant the directory we created and the file we wrote could
+ * disagree the moment anything set that variable after load — which surfaced as
+ * an ENOENT deep inside a token refresh.
+ */
+export function credentialsPath() {
+    return join(configDir(), "credentials.json");
+}
+/** Refresh a little early so a request never races token expiry. */
+const EXPIRY_SKEW_MS = 30_000;
+// Control bytes for the muted password prompt.
+const LF = 0x0a;
+const CR = 0x0d;
+const EOT = 0x04; // Ctrl-D
+const ETX = 0x03; // Ctrl-C
+const DEL = 0x7f;
+const BS = 0x08;
+const SPACE = 0x20;
+/** Load the cached session, or undefined if missing/unreadable/malformed. */
+export function loadCredentials() {
+    try {
+        if (!existsSync(credentialsPath()))
+            return undefined;
+        const parsed = JSON.parse(readFileSync(credentialsPath(), "utf8"));
+        if (typeof parsed.accessToken === "string" &&
+            typeof parsed.refreshToken === "string" &&
+            typeof parsed.accessExpiresAt === "number" &&
+            parsed.user &&
+            typeof parsed.user.id === "string") {
+            return parsed;
+        }
+    }
+    catch {
+        // A corrupt cache is not fatal — fall through to a fresh login.
+    }
+    return undefined;
+}
+/** Persist the session with mode 0600. */
+export function saveCredentials(session) {
+    const dir = configDir();
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+    writeFileSync(credentialsPath(), JSON.stringify(session, null, 2), { mode: 0o600 });
+}
+/** Remove the cached session (`bir logout`). No-op if absent. */
+export function clearCredentials() {
+    try {
+        if (existsSync(credentialsPath()))
+            unlinkSync(credentialsPath());
+    }
+    catch {
+        /* best effort */
+    }
+}
+function isAccessValid(session) {
+    return session.accessExpiresAt - EXPIRY_SKEW_MS > Date.now();
+}
+function toSession(res) {
+    return {
+        accessToken: res.accessToken,
+        refreshToken: res.refreshToken,
+        accessExpiresAt: Date.now() + res.expiresIn * 1000,
+        user: res.user,
+    };
+}
+export function resolveAuthUrl(opts) {
+    return (opts?.authUrl ?? process.env.BIR_AUTH_URL ?? "").replace(/\/+$/, "");
+}
+/**
+ * Follow a redirect on the base URL *once*, so a bearer token is never sent to
+ * a URL that will bounce it.
+ *
+ * WHY THIS EXISTS. A service behind a TLS-terminating proxy answers plain HTTP
+ * with `308 → https://…`. Node's `fetch` follows that, and because `http:` and
+ * `https:` are different origins the spec requires it to **strip the
+ * `Authorization` header**. The request arrives unauthenticated.
+ *
+ * The failure is maddening because sign-in works: login sends credentials in the
+ * BODY, which a 308 preserves. So `auth.ok` is printed, and then every
+ * subsequent call fails `401 {"error":"missing_token"}` — the server saying it
+ * saw no token at all, which reads like a bug in the client rather than a
+ * redirect. Observed against a Caddy-fronted deployment; the whole session
+ * recorded nothing.
+ *
+ * A same-host upgrade to https is adopted silently — it is what the operator
+ * meant. Anything else (a different host, a downgrade to http) is reported and
+ * NOT followed: quietly re-sending someone's bearer token to a host they did not
+ * configure is worse than failing.
+ */
+export async function normalizeAuthUrl(baseUrl, fetchImpl = fetch) {
+    const base = baseUrl.replace(/\/+$/, "");
+    if (!base)
+        return base;
+    let res;
+    try {
+        res = await fetchImpl(`${base}/health`, { method: "GET", redirect: "manual" });
+    }
+    catch {
+        return base; // unreachable is the caller's problem, not ours to diagnose here
+    }
+    if (res.status < 300 || res.status >= 400)
+        return base;
+    const location = res.headers.get("location");
+    if (!location)
+        return base;
+    let target;
+    let current;
+    try {
+        current = new URL(base);
+        target = new URL(location, base);
+    }
+    catch {
+        return base;
+    }
+    if (target.host === current.host && target.protocol === "https:" && current.protocol === "http:") {
+        const upgraded = `${target.protocol}//${target.host}`;
+        logLine("auth.url_upgraded", {
+            from: base,
+            to: upgraded,
+            why: "the service redirects to https, and a cross-origin redirect drops the Authorization header",
+        });
+        return upgraded;
+    }
+    logLine("auth.url_redirects", {
+        from: base,
+        to: `${target.protocol}//${target.host}`,
+        why: "not following it — a redirect across origins strips the token, and this one is not a same-host https upgrade. Set BIR_AUTH_URL to the final URL",
+    });
+    return base;
+}
+function prompt(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+/** Prompt for a password without echoing keystrokes. */
+function promptPassword(question) {
+    return new Promise((resolve) => {
+        const stdin = process.stdin;
+        process.stderr.write(question);
+        const wasRaw = stdin.isRaw ?? false;
+        if (stdin.isTTY)
+            stdin.setRawMode(true);
+        stdin.resume();
+        let value = "";
+        const finish = () => {
+            if (stdin.isTTY)
+                stdin.setRawMode(wasRaw);
+            stdin.removeListener("data", onData);
+            stdin.pause();
+            process.stderr.write("\n");
+        };
+        const onData = (chunk) => {
+            for (const byte of chunk) {
+                if (byte === LF || byte === CR || byte === EOT) {
+                    finish();
+                    resolve(value);
+                    return;
+                }
+                if (byte === ETX) {
+                    finish();
+                    process.exit(130);
+                }
+                else if (byte === DEL || byte === BS) {
+                    value = value.slice(0, -1);
+                }
+                else if (byte >= SPACE) {
+                    value += String.fromCharCode(byte);
+                }
+            }
+        };
+        stdin.on("data", onData);
+    });
+}
+async function postJson(url, body) {
+    const res = await fetch(url, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        throw new Error(`HTTP ${res.status} ${res.statusText}${text ? ` — ${text}` : ""}`);
+    }
+    return (await res.json());
+}
+/** Exchange a refresh token for a new session. Undefined on failure. */
+async function tryRefresh(authUrl, refreshToken) {
+    try {
+        return toSession(await postJson(`${authUrl}/auth/refresh`, { refreshToken }));
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Authenticate and return a valid session, or `undefined` when none can be
+ * obtained. Callers degrade to not-recording rather than failing the session.
+ */
+export async function authenticate(opts) {
+    if (process.env.BIR_AUTH_DISABLE === "1") {
+        return {
+            accessToken: "local-dev",
+            refreshToken: "local-dev",
+            accessExpiresAt: Number.MAX_SAFE_INTEGER,
+            user: { id: "local", email: "local@baseinstrunner.dev", name: "Local Dev" },
+        };
+    }
+    const authUrl = resolveAuthUrl(opts);
+    if (!authUrl) {
+        logLine("auth.unconfigured", {
+            why: "BIR_AUTH_URL is not set — nothing will be recorded",
+        });
+        return undefined;
+    }
+    const cached = loadCredentials();
+    if (cached && isAccessValid(cached))
+        return cached;
+    if (cached?.refreshToken) {
+        const refreshed = await tryRefresh(authUrl, cached.refreshToken);
+        if (refreshed) {
+            saveCredentials(refreshed);
+            return refreshed;
+        }
+    }
+    if (opts?.nonInteractive || !process.stdin.isTTY) {
+        logLine("auth.no_session", {
+            why: "no valid session and no terminal to log in on — run `bir login`",
+        });
+        return undefined;
+    }
+    process.stderr.write(`[bir] Sign in to ${authUrl}\n`);
+    const email = await prompt("Email: ");
+    const password = await promptPassword("Password: ");
+    if (!email || !password) {
+        logLine("auth.aborted", { why: "email and password are required" });
+        return undefined;
+    }
+    try {
+        const session = toSession(await postJson(`${authUrl}/auth/login`, { email, password }));
+        saveCredentials(session);
+        return session;
+    }
+    catch (err) {
+        logLine("auth.login_failed", { error: errText(err) });
+        return undefined;
+    }
+}
+//# sourceMappingURL=client.js.map

package/dist/bin/bir-hooks.d.ts

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+/**
+ * bir-hooks — the Claude Code hook receiver and the control server (Tier 1).
+ *
+ * Run it in the project you will launch `claude` from, in its own terminal:
+ *
+ *     bir-hooks                       # start; Ctrl-C to stop
+ *     bir-hooks 2>&1 | tee -a ~/.baseinstrunner/audit.log
+ *
+ * It does three things, and they must share a process because they share the run:
+ *   1. receives Claude Code's HTTP hook events (`bir install` wires them up);
+ *   2. accepts step reports from every `bir-proxy` that finds it;
+ *   3. owns run identity, the monotonic `stepIndex`, and the recorder chain (D5).
+ *
+ * Environment:
+ *   BIR_AUTH_URL              BaseIn auth-service (required to record anything)
+ *   BIR_CONTROL_PORT          preferred port (default 53411; falls back if busy)
+ *   BIR_CORRELATION_DECISION  `allow` (default) or `ask` — see below
+ *   BIR_NO_CORRELATION=1      never inject a call id; join on fingerprints
+ *   BIR_VERBOSE=1             per-step detail lines
+ *
+ *   BIR_REPLAY=1              run a calculated scenario on a similar-meaning
+ *                             match (docs/calculatedReplay.md). OFF by default,
+ *                             and read §13.2 before turning it on: a replayed
+ *                             step is auto-approved, and a directly executed one
+ *                             never reaches the permission system at all.
+ *   BIR_REPLAY_ALLOW_SERVERS  comma-separated server keys eligible for *direct*
+ *                             execution. Unset means every wrapped server
+ *   BIR_MIN_STEER_SIMILARITY  minimum match similarity to replay (default 0.92)
+ *   ANTHROPIC_API_KEY         enables parameter derivation. Without it, replay
+ *                             uses the scenario's recorded sample values — free,
+ *                             and often still correct
+ *   BIR_DERIVE_MODEL          derivation model (default claude-haiku-4-5-…)
+ *   BIR_MATCH_BUDGET_MS       prompt-hook match wait (default 2500)
+ *   BIR_DERIVE_BUDGET_MS      first PreToolUse derivation wait (default 8000)
+ *   BIR_REPLAY_BUDGET_MS      whole-plan ceiling, direct mode (default 120000)
+ *   BIR_STEP_TIMEOUT_MS       one direct tools/call (default 60000)
+ *
+ * ABOUT `BIR_CORRELATION_DECISION`. Correlating a wrapped MCP call means
+ * answering `PreToolUse` with `permissionDecision: "allow"` plus an extra
+ * argument (Phase 6). That is what the design specifies — and it also
+ * **auto-approves the call**, so a tool the user would have been asked about is
+ * no longer asked about. Set `BIR_CORRELATION_DECISION=ask` to keep the prompt;
+ * hosts that ignore `updatedInput` on a non-allow decision then fall back to
+ * fingerprint matching, which is lossy under identical concurrent calls.
+ */
+export {};
+//# sourceMappingURL=bir-hooks.d.ts.map

package/dist/bin/bir-hooks.js

@@ -0,0 +1,201 @@
+#!/usr/bin/env node
+/**
+ * bir-hooks — the Claude Code hook receiver and the control server (Tier 1).
+ *
+ * Run it in the project you will launch `claude` from, in its own terminal:
+ *
+ *     bir-hooks                       # start; Ctrl-C to stop
+ *     bir-hooks 2>&1 | tee -a ~/.baseinstrunner/audit.log
+ *
+ * It does three things, and they must share a process because they share the run:
+ *   1. receives Claude Code's HTTP hook events (`bir install` wires them up);
+ *   2. accepts step reports from every `bir-proxy` that finds it;
+ *   3. owns run identity, the monotonic `stepIndex`, and the recorder chain (D5).
+ *
+ * Environment:
+ *   BIR_AUTH_URL              BaseIn auth-service (required to record anything)
+ *   BIR_CONTROL_PORT          preferred port (default 53411; falls back if busy)
+ *   BIR_CORRELATION_DECISION  `allow` (default) or `ask` — see below
+ *   BIR_NO_CORRELATION=1      never inject a call id; join on fingerprints
+ *   BIR_VERBOSE=1             per-step detail lines
+ *
+ *   BIR_REPLAY=1              run a calculated scenario on a similar-meaning
+ *                             match (docs/calculatedReplay.md). OFF by default,
+ *                             and read §13.2 before turning it on: a replayed
+ *                             step is auto-approved, and a directly executed one
+ *                             never reaches the permission system at all.
+ *   BIR_REPLAY_ALLOW_SERVERS  comma-separated server keys eligible for *direct*
+ *                             execution. Unset means every wrapped server
+ *   BIR_MIN_STEER_SIMILARITY  minimum match similarity to replay (default 0.92)
+ *   ANTHROPIC_API_KEY         enables parameter derivation. Without it, replay
+ *                             uses the scenario's recorded sample values — free,
+ *                             and often still correct
+ *   BIR_DERIVE_MODEL          derivation model (default claude-haiku-4-5-…)
+ *   BIR_MATCH_BUDGET_MS       prompt-hook match wait (default 2500)
+ *   BIR_DERIVE_BUDGET_MS      first PreToolUse derivation wait (default 8000)
+ *   BIR_REPLAY_BUDGET_MS      whole-plan ceiling, direct mode (default 120000)
+ *   BIR_STEP_TIMEOUT_MS       one direct tools/call (default 60000)
+ *
+ * ABOUT `BIR_CORRELATION_DECISION`. Correlating a wrapped MCP call means
+ * answering `PreToolUse` with `permissionDecision: "allow"` plus an extra
+ * argument (Phase 6). That is what the design specifies — and it also
+ * **auto-approves the call**, so a tool the user would have been asked about is
+ * no longer asked about. Set `BIR_CORRELATION_DECISION=ask` to keep the prompt;
+ * hosts that ignore `updatedInput` on a non-allow decision then fall back to
+ * fingerprint matching, which is lossy under identical concurrent calls.
+ */
+import { hostname } from "node:os";
+import { ControlServer, DEFAULT_CONTROL_PORT } from "../control/server.js";
+import { removeDiscovery, writeDiscovery } from "../control/discovery.js";
+import { authenticate, clearCredentials, normalizeAuthUrl } from "../auth/client.js";
+import { NullRecorder } from "../record/recorder.js";
+import { RemoteRecorder } from "../record/remote-recorder.js";
+import { parseAllowList } from "../replay/coverage.js";
+import { readSidecar } from "../config/generate.js";
+import { resolveServers } from "../config/resolve.js";
+import { isWrapped } from "../config/generate.js";
+import { logLine, errText } from "../util/log.js";
+function parsePort(value) {
+    const n = Number(value);
+    return Number.isInteger(n) && n > 0 && n < 65536 ? n : DEFAULT_CONTROL_PORT;
+}
+/** Config keys already wrapped for this cwd, so `/tool/pre` knows what to correlate. */
+function wrappedServersFor(cwd) {
+    try {
+        return resolveServers(cwd)
+            .filter((s) => isWrapped(s.config))
+            .map((s) => s.name);
+    }
+    catch (err) {
+        logLine("config.unreadable", { error: errText(err) });
+        return [];
+    }
+}
+async function buildRecorder() {
+    const configured = (process.env.BIR_AUTH_URL ?? "").replace(/\/+$/, "");
+    if (!configured) {
+        logLine("recorder.disabled", { why: "BIR_AUTH_URL is not set — running without recording" });
+        return { recorder: new NullRecorder() };
+    }
+    // A plain-http URL fronted by a TLS proxy answers `308 → https`, and following
+    // that strips the bearer token: sign-in succeeds and every later call fails
+    // `401 missing_token`. Settle the base URL before anything authenticates.
+    const baseUrl = await normalizeAuthUrl(configured);
+    const session = await authenticate({ authUrl: baseUrl });
+    if (!session) {
+        logLine("recorder.disabled", { why: "no BaseIn session — run `bir login`" });
+        return { recorder: new NullRecorder() };
+    }
+    logLine("auth.ok", { user: session.user.email });
+    return { recorder: new RemoteRecorder({ baseUrl, session }), session, baseUrl };
+}
+function positiveInt(value, fallback) {
+    const n = Number(value);
+    return Number.isFinite(n) && n > 0 ? Math.floor(n) : fallback;
+}
+/**
+ * Assemble the replay configuration (docs/calculatedReplay.md §5.3 of the guide).
+ *
+ * The steer threshold defaults **above** the service's own detection threshold
+ * (0.9). Detection decides "do not record this again", which is cheap — the worst
+ * case is a lost recording. Steering decides "do not think about this again",
+ * which is a much stronger claim, and a 0.90-similar prompt usually covers only
+ * part of the live task.
+ */
+function buildReplayOptions(auth) {
+    const enabled = process.env.BIR_REPLAY === "1";
+    const allowServers = parseAllowList(process.env.BIR_REPLAY_ALLOW_SERVERS);
+    const minSimilarity = Number(process.env.BIR_MIN_STEER_SIMILARITY);
+    const opts = {
+        enabled,
+        minSimilarity: Number.isFinite(minSimilarity) ? minSimilarity : 0.92,
+        allowServers,
+        budgets: {
+            matchMs: positiveInt(process.env.BIR_MATCH_BUDGET_MS, 2_500),
+            deriveMs: positiveInt(process.env.BIR_DERIVE_BUDGET_MS, 8_000),
+            planMs: positiveInt(process.env.BIR_REPLAY_BUDGET_MS, 120_000),
+            stepMs: positiveInt(process.env.BIR_STEP_TIMEOUT_MS, 60_000),
+        },
+        authUrl: auth.baseUrl,
+        // Read late, not captured: `RemoteRecorder` refreshes the access token as the
+        // session outlives it, and a snapshot taken here would go stale mid-run.
+        authToken: auth.session ? () => auth.session.accessToken : undefined,
+    };
+    if (enabled) {
+        // Loud, at startup, on the operator's own terminal. A capability that
+        // auto-approves tool calls must never be discoverable only from a log file.
+        logLine("replay.enabled", {
+            minSimilarity: opts.minSimilarity,
+            allowServers: allowServers ? [...allowServers].join(",") : "(all wrapped)",
+            derive: process.env.ANTHROPIC_API_KEY ? "anthropic" : "recorded sample values",
+            why: "matched prompts will run their calculated scenario — steered steps are auto-approved",
+        });
+    }
+    return opts;
+}
+async function main() {
+    const argv = process.argv.slice(2);
+    if (argv[0] === "logout") {
+        clearCredentials();
+        process.stderr.write("[bir] logged out — cached credentials cleared.\n");
+        return;
+    }
+    const cwd = process.cwd();
+    const sidecar = readSidecar();
+    const auth = await buildRecorder();
+    const server = new ControlServer({
+        recorder: auth.recorder,
+        cwd,
+        port: parsePort(process.env.BIR_CONTROL_PORT ?? String(sidecar.controlPort ?? "")),
+        token: sidecar.token,
+        wrappedServers: wrappedServersFor(cwd),
+        host: { app: "claude-code" },
+        correlationDecision: process.env.BIR_CORRELATION_DECISION === "ask" ? "ask" : "allow",
+        noCorrelation: process.env.BIR_NO_CORRELATION === "1",
+        replay: buildReplayOptions(auth),
+    });
+    const address = await server.listen();
+    const discoveryFile = writeDiscovery({
+        url: address.url,
+        token: address.token,
+        sessionId: address.sessionId,
+        pid: process.pid,
+        startedAt: Date.now(),
+        cwd,
+    });
+    logLine("control.listening", {
+        url: address.url,
+        cwd,
+        discovery: discoveryFile,
+        machine: hostname(),
+        wrapped: wrappedServersFor(cwd).join(",") || "(none)",
+    });
+    if (sidecar.controlPort && sidecar.controlPort !== address.port) {
+        // The hook URLs in settings.json name a port; if we could not take it, the
+        // hooks will POST into the void. Say so rather than looking healthy.
+        logLine("control.port_mismatch", {
+            installed: sidecar.controlPort,
+            actual: address.port,
+            why: "hooks point at the installed port — re-run `bir install` or free that port",
+        });
+    }
+    let closing = false;
+    const shutdown = async () => {
+        if (closing)
+            return;
+        closing = true;
+        await server.close().catch((err) => logLine("control.close_failed", { error: errText(err) }));
+        removeDiscovery(cwd);
+        logLine("control.stopped", {});
+        process.exit(0);
+    };
+    process.on("SIGINT", () => void shutdown());
+    process.on("SIGTERM", () => void shutdown());
+    process.on("uncaughtException", (err) => logLine("control.uncaught", { error: errText(err) }));
+    process.on("unhandledRejection", (err) => logLine("control.unhandled_rejection", { error: errText(err) }));
+}
+void main().catch((err) => {
+    logLine("control.fatal", { error: errText(err) });
+    process.exit(1);
+});
+//# sourceMappingURL=bir-hooks.js.map

package/dist/bin/bir-proxy.d.ts

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+/**
+ * bir-proxy — the recording MCP proxy. One process per wrapped upstream.
+ *
+ * Usage:
+ *   bir-proxy --server-name <key> -- <command> [args…]        # stdio upstream
+ *   bir-proxy --server-name <key> --url <url> [--transport http|sse]
+ *                                 [--header 'K: V']…          # remote upstream
+ *
+ * Options:
+ *   --server-name <key>   the client's config key for this server (required)
+ *   --transport <t>       `http` (default) or `sse`, with `--url`
+ *   --header 'K: V'       extra header for a remote upstream; repeatable
+ *   --standalone          skip control-server discovery; record as Tier 2
+ *   --no-correlation      never relax tool schemas; join on argument fingerprints
+ *   --lazy                create the upstream on the first host message, not at
+ *                         startup (see upstream/lazy-client.ts for the caveat)
+ *   --restart             restart a dead stdio upstream once
+ *   --discovery-ms <n>    how long to look for a control server (default 5000)
+ *
+ * Environment:
+ *   BIR_CONTROL_URL / BIR_CONTROL_TOKEN   control server, bypassing discovery
+ *   BIR_AUTH_URL                          BaseIn service, for Tier 2 recording
+ *   BIR_VERBOSE=1                         per-message detail on stderr
+ *
+ * STDOUT IS SACRED. It is the host's JSON-RPC stream; every log line, every
+ * upstream stderr line and every diagnostic goes to stderr instead. A single
+ * stray byte here corrupts the session and surfaces somewhere else entirely.
+ */
+interface ProxyArgs {
+    serverName: string;
+    url?: string;
+    transport: "http" | "sse";
+    headers: Record<string, string>;
+    command?: string;
+    commandArgs: string[];
+    standalone: boolean;
+    noCorrelation: boolean;
+    lazy: boolean;
+    restart: boolean;
+    discoveryMs?: number;
+}
+export declare function parseArgs(argv: string[]): ProxyArgs;
+export {};
+//# sourceMappingURL=bir-proxy.d.ts.map