@basein/runner 0.1.0

package/dist/util/log.d.ts

@@ -0,0 +1,27 @@
+/**
+ * log — the audit line format, ported from RRepeat's `log-line.ts`.
+ *
+ * WHY ALWAYS `console.error`: `bir-proxy` writes JSON-RPC frames to
+ * `process.stdout`. A single stray stdout byte corrupts the host's message
+ * stream, and it surfaces as an unrelated MCP error nowhere near the cause.
+ * Writing every line to stderr makes that impossible by construction.
+ *
+ * WHY TEXT AND NOT JSON: `grep` and `awk` are the tools, and the same line an
+ * operator watches live is the line that lands in a file. Durability is the
+ * shell's job — `bir-hooks 2>&1 | tee -a ~/.baseinstrunner/audit.log`.
+ */
+/** `BIR_VERBOSE=1` adds per-message detail lines. Decisions are logged either way. */
+export declare const VERBOSE: boolean;
+/**
+ * `BIR_QUIET=1` silences the audit log. For test runs, where a hundred lines of
+ * correct behaviour bury the one assertion that failed. Never set it in a real
+ * session: the audit log is the only record of what the recorder decided.
+ */
+export declare const QUIET: boolean;
+/** Print one audit line: `[bir] <iso ts> <event> key=value …`. */
+export declare function logLine(event: string, fields?: Record<string, unknown>): void;
+/** A detail line, printed only under `BIR_VERBOSE=1`. */
+export declare function logDetail(event: string, fields?: Record<string, unknown>): void;
+export declare function logOnce(key: string, event: string, fields?: Record<string, unknown>): void;
+export declare function errText(err: unknown): string;
+//# sourceMappingURL=log.d.ts.map

package/dist/util/log.js

@@ -0,0 +1,51 @@
+/**
+ * log — the audit line format, ported from RRepeat's `log-line.ts`.
+ *
+ * WHY ALWAYS `console.error`: `bir-proxy` writes JSON-RPC frames to
+ * `process.stdout`. A single stray stdout byte corrupts the host's message
+ * stream, and it surfaces as an unrelated MCP error nowhere near the cause.
+ * Writing every line to stderr makes that impossible by construction.
+ *
+ * WHY TEXT AND NOT JSON: `grep` and `awk` are the tools, and the same line an
+ * operator watches live is the line that lands in a file. Durability is the
+ * shell's job — `bir-hooks 2>&1 | tee -a ~/.baseinstrunner/audit.log`.
+ */
+/** `BIR_VERBOSE=1` adds per-message detail lines. Decisions are logged either way. */
+export const VERBOSE = process.env.BIR_VERBOSE === "1";
+/**
+ * `BIR_QUIET=1` silences the audit log. For test runs, where a hundred lines of
+ * correct behaviour bury the one assertion that failed. Never set it in a real
+ * session: the audit log is the only record of what the recorder decided.
+ */
+export const QUIET = process.env.BIR_QUIET === "1";
+/** Print one audit line: `[bir] <iso ts> <event> key=value …`. */
+export function logLine(event, fields = {}) {
+    if (QUIET)
+        return;
+    const pairs = [];
+    for (const [key, value] of Object.entries(fields)) {
+        if (value === undefined || value === null)
+            continue;
+        const text = String(value);
+        pairs.push(/[\s"]/.test(text) ? `${key}=${JSON.stringify(text)}` : `${key}=${text}`);
+    }
+    const line = `[bir] ${new Date().toISOString()} ${event}${pairs.length ? ` ${pairs.join(" ")}` : ""}`;
+    console.error(line);
+}
+/** A detail line, printed only under `BIR_VERBOSE=1`. */
+export function logDetail(event, fields = {}) {
+    if (VERBOSE)
+        logLine(event, fields);
+}
+/** Log a message once per process, keyed by `key`. For degradation notices. */
+const seen = new Set();
+export function logOnce(key, event, fields = {}) {
+    if (seen.has(key))
+        return;
+    seen.add(key);
+    logLine(event, fields);
+}
+export function errText(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+//# sourceMappingURL=log.js.map

package/dist/util/version.d.ts

@@ -0,0 +1,2 @@
+export declare function packageVersion(): string;
+//# sourceMappingURL=version.d.ts.map

package/dist/util/version.js

@@ -0,0 +1,40 @@
+/**
+ * This package's own version, read from the nearest `package.json`.
+ *
+ * Every binary needs it for a different reason — `bir` prints it and pins the
+ * npx spec it writes into configs, a proxy reports it when it registers, and the
+ * control server compares the two — so it lives here rather than in any one of
+ * them.
+ *
+ * A walk, not a constant: the module sits at `dist/util/version.js` when
+ * installed and `.test-build/src/util/version.js` under test, and the package
+ * root is a different number of levels up in each. Five is enough for both with
+ * room to spare.
+ */
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+let cached;
+export function packageVersion() {
+    if (cached)
+        return cached;
+    let dir = dirname(fileURLToPath(import.meta.url));
+    for (let i = 0; i < 5; i += 1) {
+        try {
+            const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+            if (pkg.version) {
+                cached = pkg.version;
+                return cached;
+            }
+        }
+        catch {
+            /* keep walking */
+        }
+        dir = dirname(dir);
+    }
+    // Unknown, not fatal. A missing version must never stop a session: the worst
+    // it costs is a skew check that cannot fire.
+    cached = "0.0.0";
+    return cached;
+}
+//# sourceMappingURL=version.js.map