@opensip-cli/core 0.1.0

package/dist/lib/execution/run-with-timeout.js

@@ -0,0 +1,86 @@
+/**
+ * runWithTimeout — the per-unit timeout/abort/retry wrapper of the execution
+ * substrate (north-star §5.8, launch).
+ *
+ * One unit's lifecycle: install an `AbortController` + `setTimeout`, run the
+ * domain function under that signal (optionally with retry), and classify the
+ * outcome as `ok` / `timeout` / `error`. The single-source abort invariant is
+ * preserved from fitness's `runOneCheck`: the controller is aborted ONLY by the
+ * timeout, so a post-run `signal.aborted` IS a timeout.
+ *
+ * This is the shared primitive that makes "a declared `timeout` actually aborts"
+ * true in every domain — the §4.3 fix for simulation, whose `runSingle` declared
+ * `execution.timeout` but never installed one.
+ */
+import { runWithRetry } from './retry.js';
+/**
+ * Run one unit under a timeout, returning a classified outcome (never throws for
+ * a domain error — it is returned as `status:'error'`). Mirrors the proven
+ * timeout-detection of fitness's `runOneCheck` (clear the timer, then a
+ * `signal.aborted` check is canonical-timeout because the controller has a single
+ * abort source).
+ */
+export async function runWithTimeout(opts) {
+    const controller = new AbortController();
+    const startTime = Date.now();
+    const timeoutId = setTimeout(() => controller.abort(), opts.timeoutMs);
+    const finish = () => {
+        clearTimeout(timeoutId);
+        return Date.now() - startTime;
+    };
+    // Execute the domain work (retry or direct) and always classify to an outcome.
+    // This promise may never settle if the callee ignores the abort signal.
+    const workPromise = (async () => {
+        try {
+            if (opts.retry) {
+                const retry = await runWithRetry(() => opts.run(controller.signal), opts.retry);
+                const durationMs = finish();
+                if (controller.signal.aborted) {
+                    return { status: 'timeout', durationMs, timeoutMs: opts.timeoutMs };
+                }
+                if (retry.result === undefined) {
+                    return { status: 'error', error: retry.lastError, durationMs };
+                }
+                return { status: 'ok', result: retry.result, durationMs };
+            }
+            const result = await opts.run(controller.signal);
+            const durationMs = finish();
+            // A run that resolved AFTER the timeout fired is reported as a timeout
+            // (single-source abort invariant), matching fitness's post-run check.
+            if (controller.signal.aborted) {
+                return { status: 'timeout', durationMs, timeoutMs: opts.timeoutMs };
+            }
+            return { status: 'ok', result, durationMs };
+        }
+        catch (error) {
+            const durationMs = finish();
+            if (controller.signal.aborted) {
+                return { status: 'timeout', durationMs, timeoutMs: opts.timeoutMs };
+            }
+            return { status: 'error', error, durationMs };
+        }
+    })();
+    // Hard timeout: this settles the *function* with a timeout outcome even if
+    // the domain work never settles. We still abort the controller so cooperative
+    // callees can stop. Report the exact budget as duration for the timeout case
+    // (avoids sampling skew from the setTimeout fire time).
+    const hardTimeout = new Promise((resolve) => {
+        setTimeout(() => {
+            controller.abort();
+            resolve({
+                status: 'timeout',
+                durationMs: opts.timeoutMs,
+                timeoutMs: opts.timeoutMs,
+            });
+        }, opts.timeoutMs);
+    });
+    // Race so a non-settling domain cannot hang the scheduler/recipe.
+    const outcome = await Promise.race([workPromise, hardTimeout]);
+    // If the hard timeout won, the domain promise may still settle (or reject) later.
+    // Attach a no-op handler so a late rejection does not become an unhandled promise rejection.
+    workPromise.catch(() => {
+        /* late settlement after timeout is expected and ignored; the abort signal was delivered */
+    });
+    return outcome;
+}
+//# sourceMappingURL=run-with-timeout.js.map

package/dist/lib/execution/run-with-timeout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-with-timeout.js","sourceRoot":"","sources":["../../../src/lib/execution/run-with-timeout.ts"],"names":[],"mappings":"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"}

package/dist/lib/execution/schedule.d.ts

@@ -0,0 +1,62 @@
+/**
+ * scheduleUnits — the bounded scheduler of the execution substrate (north-star
+ * §5.8, launch).
+ *
+ * Owns the scheduling SHAPE — a `parallel` sliding window bounded by `maxParallel`,
+ * or a `sequential` one-at-a-time loop — plus the stop policy and an external
+ * abort check. The per-unit lifecycle (timeout/retry/result) is the caller's
+ * `runUnit`, which returns whether scheduling should stop (the domain's
+ * `stopOnFirstFailure` decision). This is the one loop fit + sim run on, replacing
+ * their hand-rolled parallel pools and `for-of` loops (the `same-recipe-semantics`
+ * guarantee).
+ *
+ * Faithfully generalized from fitness's `executeParallel` (sliding window: launch
+ * up to `maxParallel`, refill on each completion unless stopping/aborted, resolve
+ * when drained) and `executeSequential` (`for-of`, abort-check at the top, break
+ * on stop).
+ */
+/**
+ * Hand control back to the event loop's macrotask queue. `await runUnit()` only
+ * yields to the MICROtask queue, so a `setInterval` timer (the 80ms live-progress
+ * clock) and Ink's repaint never get a turn between back-to-back synchronous
+ * units. A `setImmediate` boundary lets them run — the interim live-view smoothing
+ * (the durable fix runs the engine off the main thread; ADR-0016/ADR-0028).
+ */
+export declare const yieldToEventLoop: () => Promise<void>;
+export interface ScheduleUnitsOptions<Unit> {
+    readonly units: readonly Unit[];
+    readonly mode: 'parallel' | 'sequential';
+    /** Concurrency bound in `parallel` mode (ignored for `sequential`). Default 1. */
+    readonly maxParallel?: number;
+    /**
+     * Run one unit (its full timeout/retry/result lifecycle) and report whether the
+     * scheduler should stop launching further units. Receives the 0-based index.
+     */
+    readonly runUnit: (unit: Unit, index: number) => Promise<{
+        readonly shouldStop: boolean;
+    }>;
+    /** External abort check (e.g. a service-level AbortController); polled before each launch. */
+    readonly shouldAbort?: () => boolean;
+    /**
+     * When true, insert a macrotask boundary ({@link yieldToEventLoop}) after each
+     * unit completes, so a live-progress timer + renderer on the same thread can
+     * paint between units. Opt-in (default off) — only the interactive (TTY) run
+     * paths set it; `--json`/non-TTY callers don't need it.
+     */
+    readonly yieldBetweenUnits?: boolean;
+}
+/**
+ * Schedule `units` through `runUnit` per the mode/concurrency/stop policy.
+ *
+ * Cognitive complexity is high (19) because the implementation unifies two
+ * scheduling shapes (sliding-window parallel with dynamic refill, and
+ * sequential for-of) plus shared abort latching, drain detection, and the
+ * optional yieldToEventLoop wrapper for live UI. This is the single
+ * scheduler used by fitness and simulation engines (the "same-recipe-semantics"
+ * contract). Extracting helpers would make the refill-vs-drain state machine
+ * harder to audit as a whole. Disable is scoped to this function.
+ *
+ * @throws {Error} When `mode` is neither 'sequential' nor 'parallel'.
+ */
+export declare function scheduleUnits<Unit>(opts: ScheduleUnitsOptions<Unit>): Promise<void>;
+//# sourceMappingURL=schedule.d.ts.map

package/dist/lib/execution/schedule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schedule.d.ts","sourceRoot":"","sources":["../../../src/lib/execution/schedule.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,QAAO,OAAO,CAAC,IAAI,CAG5C,CAAC;AAEL,MAAM,WAAW,oBAAoB,CAAC,IAAI;IACxC,QAAQ,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,CAAC;IAChC,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,YAAY,CAAC;IACzC,kFAAkF;IAClF,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;QAAE,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IAC3F,8FAA8F;IAC9F,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,OAAO,CAAC;IACrC;;;;;OAKG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAC;CACtC;AAGD;;;;;;;;;;;;GAYG;AACH,wBAAsB,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,oBAAoB,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CA2FzF"}

package/dist/lib/execution/schedule.js

@@ -0,0 +1,130 @@
+/**
+ * scheduleUnits — the bounded scheduler of the execution substrate (north-star
+ * §5.8, launch).
+ *
+ * Owns the scheduling SHAPE — a `parallel` sliding window bounded by `maxParallel`,
+ * or a `sequential` one-at-a-time loop — plus the stop policy and an external
+ * abort check. The per-unit lifecycle (timeout/retry/result) is the caller's
+ * `runUnit`, which returns whether scheduling should stop (the domain's
+ * `stopOnFirstFailure` decision). This is the one loop fit + sim run on, replacing
+ * their hand-rolled parallel pools and `for-of` loops (the `same-recipe-semantics`
+ * guarantee).
+ *
+ * Faithfully generalized from fitness's `executeParallel` (sliding window: launch
+ * up to `maxParallel`, refill on each completion unless stopping/aborted, resolve
+ * when drained) and `executeSequential` (`for-of`, abort-check at the top, break
+ * on stop).
+ */
+/**
+ * Hand control back to the event loop's macrotask queue. `await runUnit()` only
+ * yields to the MICROtask queue, so a `setInterval` timer (the 80ms live-progress
+ * clock) and Ink's repaint never get a turn between back-to-back synchronous
+ * units. A `setImmediate` boundary lets them run — the interim live-view smoothing
+ * (the durable fix runs the engine off the main thread; ADR-0016/ADR-0028).
+ */
+export const yieldToEventLoop = () => new Promise((resolve) => {
+    setImmediate(resolve);
+});
+/* eslint-disable sonarjs/cognitive-complexity -- unifies parallel sliding-window and sequential scheduling with shared abort/drain latching; one scheduler for fitness and simulation (rationale below) */
+/**
+ * Schedule `units` through `runUnit` per the mode/concurrency/stop policy.
+ *
+ * Cognitive complexity is high (19) because the implementation unifies two
+ * scheduling shapes (sliding-window parallel with dynamic refill, and
+ * sequential for-of) plus shared abort latching, drain detection, and the
+ * optional yieldToEventLoop wrapper for live UI. This is the single
+ * scheduler used by fitness and simulation engines (the "same-recipe-semantics"
+ * contract). Extracting helpers would make the refill-vs-drain state machine
+ * harder to audit as a whole. Disable is scoped to this function.
+ *
+ * @throws {Error} When `mode` is neither 'sequential' nor 'parallel'.
+ */
+export async function scheduleUnits(opts) {
+    const { units, mode, shouldAbort } = opts;
+    if (units.length === 0)
+        return;
+    if (mode !== 'sequential' && mode !== 'parallel') {
+        throw new Error(`scheduleUnits: mode must be 'parallel' or 'sequential' (got '${String(mode)}')`);
+    }
+    // Each unit's promise resolves AFTER a macrotask yield when requested, so a
+    // same-thread live-progress timer + renderer paint between units. Wrapping
+    // `runUnit` (rather than the scheduling logic) keeps the parallel sliding
+    // window's activeCount/relaunch bookkeeping synchronous and correct in both modes.
+    const runUnit = opts.yieldBetweenUnits === true
+        ? async (unit, index) => {
+            // @fitness-ignore-next-line async-waterfall-detection -- deliberately sequential: the macrotask yield MUST run AFTER the unit completes (it is the between-units boundary); parallelizing with Promise.all would defeat the purpose.
+            const outcome = await opts.runUnit(unit, index);
+            await yieldToEventLoop();
+            return outcome;
+        }
+        : opts.runUnit;
+    // Shared abort observation that also latches a local flag so that once an
+    // external abort is seen we treat it as a terminal drain condition (prevents
+    // the "no more refills + active drains but resolve condition never fires"
+    // hang when there are still unlaunched units).
+    let aborted = false;
+    const observeAbort = () => {
+        if (shouldAbort?.() === true) {
+            aborted = true;
+            return true;
+        }
+        return false;
+    };
+    if (mode === 'sequential') {
+        for (const [index, unit] of units.entries()) {
+            if (observeAbort())
+                break;
+            const { shouldStop } = await runUnit(unit, index);
+            if (shouldStop)
+                break;
+        }
+        return;
+    }
+    // Parallel sliding window — mirrors fitness's executeParallel.
+    // Defensive: even though recipe authors go through defineSimulationRecipe (and
+    // fitness through its own paths), a direct caller or future plugin could pass
+    // NaN/0/negative. Force a safe minimum.
+    const maxParallel = Math.max(1, Number.isFinite(opts.maxParallel) ? opts.maxParallel : 1);
+    let nextIndex = 0;
+    let activeCount = 0;
+    let stopping = false;
+    await new Promise((resolve) => {
+        const launch = (unit, index) => {
+            activeCount++;
+            void runUnit(unit, index)
+                .then(({ shouldStop }) => {
+                if (shouldStop)
+                    stopping = true;
+            })
+                .finally(() => {
+                activeCount--;
+                // Only refill if we are not in any terminal state (stopping, list done, or aborted).
+                if (!stopping && !aborted && nextIndex < units.length && !observeAbort()) {
+                    const next = units[nextIndex];
+                    if (next !== undefined) {
+                        const idx = nextIndex;
+                        nextIndex++;
+                        launch(next, idx);
+                    }
+                }
+                // Drain condition now includes external abort as a terminal reason.
+                // Once all in-flight units complete, we resolve even if units remain.
+                if (activeCount === 0 && (nextIndex >= units.length || stopping || aborted)) {
+                    resolve();
+                }
+            });
+        };
+        const initialBatch = Math.min(maxParallel, units.length);
+        for (let i = 0; i < initialBatch; i++) {
+            if (observeAbort())
+                break;
+            const unit = units[i];
+            if (unit !== undefined) {
+                nextIndex = i + 1;
+                launch(unit, i);
+            }
+        }
+    });
+}
+/* eslint-enable sonarjs/cognitive-complexity */
+//# sourceMappingURL=schedule.js.map

package/dist/lib/execution/schedule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schedule.js","sourceRoot":"","sources":["../../../src/lib/execution/schedule.ts"],"names":[],"mappings":"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"}

package/dist/lib/format.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @fileoverview Shared presentation formatters.
+ *
+ * Small, dependency-free helpers used by more than one tool's CLI/report
+ * layer. Kept in core because tools sit in a peer layer and cannot depend on
+ * each other — core is their only shared home.
+ */
+/**
+ * Format a millisecond duration as `"Xms"` under one second, `"X.Ys"` for
+ * sub-minute durations, or `"Xm Y.Ys"` at minute scale.
+ *
+ * @example formatDuration(450)  // "450ms"
+ * @example formatDuration(1500) // "1.5s"
+ * @example formatDuration(1471600) // "24m 31.6s"
+ */
+export declare function formatDuration(ms: number): string;
+//# sourceMappingURL=format.d.ts.map

package/dist/lib/format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../src/lib/format.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CASjD"}

package/dist/lib/format.js

@@ -0,0 +1,26 @@
+/**
+ * @fileoverview Shared presentation formatters.
+ *
+ * Small, dependency-free helpers used by more than one tool's CLI/report
+ * layer. Kept in core because tools sit in a peer layer and cannot depend on
+ * each other — core is their only shared home.
+ */
+/**
+ * Format a millisecond duration as `"Xms"` under one second, `"X.Ys"` for
+ * sub-minute durations, or `"Xm Y.Ys"` at minute scale.
+ *
+ * @example formatDuration(450)  // "450ms"
+ * @example formatDuration(1500) // "1.5s"
+ * @example formatDuration(1471600) // "24m 31.6s"
+ */
+export function formatDuration(ms) {
+    if (ms < 1000)
+        return `${String(ms)}ms`;
+    const totalTenths = Math.round(ms / 100);
+    if (totalTenths < 600)
+        return `${(totalTenths / 10).toFixed(1)}s`;
+    const minutes = Math.floor(totalTenths / 600);
+    const remainingTenths = totalTenths % 600;
+    return `${minutes}m ${(remainingTenths / 10).toFixed(1)}s`;
+}
+//# sourceMappingURL=format.js.map

package/dist/lib/format.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.js","sourceRoot":"","sources":["../../src/lib/format.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;;;GAOG;AACH,MAAM,UAAU,cAAc,CAAC,EAAU;IACvC,IAAI,EAAE,GAAG,IAAI;QAAE,OAAO,GAAG,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC;IAExC,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,GAAG,GAAG,CAAC,CAAC;IACzC,IAAI,WAAW,GAAG,GAAG;QAAE,OAAO,GAAG,CAAC,WAAW,GAAG,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC;IAElE,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,GAAG,GAAG,CAAC,CAAC;IAC9C,MAAM,eAAe,GAAG,WAAW,GAAG,GAAG,CAAC;IAC1C,OAAO,GAAG,OAAO,KAAK,CAAC,eAAe,GAAG,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC;AAC7D,CAAC"}

package/dist/lib/ids.d.ts

@@ -0,0 +1,13 @@
+/**
+ * ID generation for opensip-cli.
+ * Uses ULID for time-sortable, unique identifiers.
+ */
+/** Generate a ULID (time-sortable, 26 lowercase crockford base32 chars) */
+export declare function generateId(prefix?: string): string;
+/** Generate a prefixed ULID — e.g., generatePrefixedId('run') → 'RUN_01HXYZ...' */
+export declare function generatePrefixedId(prefix: string): string;
+/** Extract the timestamp from a ULID string. Returns null if invalid. */
+export declare function extractTimestamp(id: string): Date | null;
+/** Generate a standard UUID v4 (for cases where ULID is not appropriate) */
+export declare function generateUUID(): string;
+//# sourceMappingURL=ids.d.ts.map

package/dist/lib/ids.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ids.d.ts","sourceRoot":"","sources":["../../src/lib/ids.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,2EAA2E;AAC3E,wBAAgB,UAAU,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAGlD;AAED,mFAAmF;AACnF,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEzD;AAED,yEAAyE;AACzE,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAwBxD;AAED,4EAA4E;AAC5E,wBAAgB,YAAY,IAAI,MAAM,CAErC"}

package/dist/lib/ids.js

@@ -0,0 +1,48 @@
+/**
+ * ID generation for opensip-cli.
+ * Uses ULID for time-sortable, unique identifiers.
+ */
+import { randomUUID } from 'node:crypto';
+import { ulid } from 'ulid';
+/** Generate a ULID (time-sortable, 26 lowercase crockford base32 chars) */
+export function generateId(prefix) {
+    const id = ulid();
+    return prefix ? `${prefix}_${id}` : id;
+}
+/** Generate a prefixed ULID — e.g., generatePrefixedId('run') → 'RUN_01HXYZ...' */
+export function generatePrefixedId(prefix) {
+    return `${prefix.toUpperCase()}_${ulid()}`;
+}
+/** Extract the timestamp from a ULID string. Returns null if invalid. */
+export function extractTimestamp(id) {
+    // ULIDs are exactly 26 Crockford Base32 chars; the prefix (if any) may
+    // contain underscores itself — e.g. `generatePrefixedId('my_tool')`
+    // produces `MY_TOOL_<ulid>`. Splitting on the first '_' would slice off
+    // only `MY` and leave `TOOL_<ulid>`, failing the length check. Take the
+    // trailing 26 chars instead, since ULIDs never contain underscores.
+    const ulidPart = id.length >= 26 ? id.slice(-26) : id;
+    if (ulidPart.length !== 26)
+        return null;
+    try {
+        // ULID encodes timestamp in first 10 chars as Crockford Base32
+        const ENCODING = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
+        const upper = ulidPart.toUpperCase();
+        let time = 0;
+        for (let i = 0; i < 10; i++) {
+            const idx = ENCODING.indexOf(upper[i]);
+            if (idx === -1)
+                return null;
+            time = time * 32 + idx;
+        }
+        return new Date(time);
+    }
+    catch {
+        // @fitness-ignore-next-line error-handling-quality -- parse-or-null helper; exception → null is the function's contract, caller checks for null.
+        return null;
+    }
+}
+/** Generate a standard UUID v4 (for cases where ULID is not appropriate) */
+export function generateUUID() {
+    return randomUUID();
+}
+//# sourceMappingURL=ids.js.map

package/dist/lib/ids.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ids.js","sourceRoot":"","sources":["../../src/lib/ids.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzC,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAE5B,2EAA2E;AAC3E,MAAM,UAAU,UAAU,CAAC,MAAe;IACxC,MAAM,EAAE,GAAG,IAAI,EAAE,CAAC;IAClB,OAAO,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;AACzC,CAAC;AAED,mFAAmF;AACnF,MAAM,UAAU,kBAAkB,CAAC,MAAc;IAC/C,OAAO,GAAG,MAAM,CAAC,WAAW,EAAE,IAAI,IAAI,EAAE,EAAE,CAAC;AAC7C,CAAC;AAED,yEAAyE;AACzE,MAAM,UAAU,gBAAgB,CAAC,EAAU;IACzC,uEAAuE;IACvE,oEAAoE;IACpE,wEAAwE;IACxE,wEAAwE;IACxE,oEAAoE;IACpE,MAAM,QAAQ,GAAG,EAAE,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IACtD,IAAI,QAAQ,CAAC,MAAM,KAAK,EAAE;QAAE,OAAO,IAAI,CAAC;IAExC,IAAI,CAAC;QACH,+DAA+D;QAC/D,MAAM,QAAQ,GAAG,kCAAkC,CAAC;QACpD,MAAM,KAAK,GAAG,QAAQ,CAAC,WAAW,EAAE,CAAC;QACrC,IAAI,IAAI,GAAG,CAAC,CAAC;QACb,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC;YAC5B,MAAM,GAAG,GAAG,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;YACvC,IAAI,GAAG,KAAK,CAAC,CAAC;gBAAE,OAAO,IAAI,CAAC;YAC5B,IAAI,GAAG,IAAI,GAAG,EAAE,GAAG,GAAG,CAAC;QACzB,CAAC;QACD,OAAO,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC;IACxB,CAAC;IAAC,MAAM,CAAC;QACP,iJAAiJ;QACjJ,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC;AAED,4EAA4E;AAC5E,MAAM,UAAU,YAAY;IAC1B,OAAO,UAAU,EAAE,CAAC;AACtB,CAAC"}

package/dist/lib/logger.d.ts

@@ -0,0 +1,166 @@
+/**
+ * Structured logger for opensip-cli.
+ *
+ * Outputs JSON log lines with:
+ * - ts: ISO timestamp
+ * - level: debug | info | warn | error
+ * - evt: event name (e.g., 'cli.start', 'cli.check.complete')
+ * - runId: correlation ID for the current CLI invocation
+ * - msg: human-readable message
+ * - ...data: additional structured fields
+ *
+ * Destinations:
+ * - File: <project>/opensip-cli/.runtime/logs/{YYYY-MM-DD}.jsonl
+ *   The CLI bootstrap supplies this path via configureLogger({ logDir }).
+ *   Without that, file output is disabled — user-global state
+ *   (`~/.opensip-cli/`) is reserved for config.yml only.
+ * - stderr: when debug mode is enabled (Ink renders to stdout, logs to stderr)
+ *
+ * The `silent: true` option only suppresses stderr output, NOT file output.
+ *
+ * Two access patterns:
+ *
+ *   1. The exported `logger` singleton + `configureLogger(opts)`. Used
+ *      by the CLI bootstrap and any production caller that wants the
+ *      process-wide configuration. The four prior free mutators
+ *      (`setSilent`, `setDebugMode`, `setRunId`, `initLogFile`) were
+ *      collapsed into `configureLogger` in T1 deferred Item C.
+ *
+ *   2. The exported `LoggerImpl` class. Used by tests (or tools that
+ *      need an isolated logger) to construct a fresh instance whose
+ *      state is independent of the singleton.
+ */
+/** Structured logger surface; accepts a message string or a structured record. */
+export interface Logger {
+    debug(msgOrObj: string | Record<string, unknown>, data?: Record<string, unknown>): void;
+    info(msgOrObj: string | Record<string, unknown>, data?: Record<string, unknown>): void;
+    warn(msgOrObj: string | Record<string, unknown>, data?: Record<string, unknown>): void;
+    error(msgOrObj: string | Record<string, unknown>, data?: Record<string, unknown>): void;
+}
+/** Log severity levels, ordered from most to least verbose. */
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+/**
+ * Concrete logger implementation. Production code uses the exported
+ * `logger` singleton (typed as the `Logger` interface so the
+ * configuration surface is hidden from generic call sites); tests
+ * (or tools that need an isolated logger) can construct a fresh
+ * `LoggerImpl()` to exercise the logger without polluting (or being
+ * polluted by) the singleton's state.
+ *
+ * @remarks Treat this class as advanced / discouraged for general
+ * production use — the `Logger` interface is the seam. Importing
+ * `LoggerImpl` is appropriate for tests and for tools that genuinely
+ * need an isolated logger; everywhere else the typed `logger`
+ * singleton is the right import.
+ */
+/**
+ * Construction-time options for `LoggerImpl`. Also the shape accepted
+ * by `configureLogger(opts)`, the single bootstrap-time configuration
+ * seam that replaced the four free mutators (`setSilent`,
+ * `setDebugMode`, `setRunId`, `initLogFile`) — T1 deferred Item C.
+ */
+export interface LoggerOptions {
+    /** Initial log level. Defaults to `'warn'`. */
+    readonly level?: LogLevel;
+    /** Suppress stderr output (file output still occurs). Defaults to `false`. */
+    readonly silent?: boolean;
+    /** Enable debug-level output to stderr. Defaults to `false`. */
+    readonly debugMode?: boolean;
+    /** Correlation id for the current CLI invocation. */
+    readonly runId?: string;
+    /**
+     * Directory the daily `.jsonl` log file is written to. When provided,
+     * the logger initialises the file path and prunes logs older than
+     * 7 days. Best-effort; failures are swallowed.
+     */
+    readonly logDir?: string;
+}
+/**
+ * Optional indirection for the runId on each log entry. The CLI binds
+ * this to `() => currentScope()?.runId` at module init (in run-scope.ts,
+ * which already depends on logger.ts — this preserves the dependency
+ * direction and avoids a logger→run-scope import cycle that depcruise
+ * would reject). Returns `undefined` when no scope is bound, in which
+ * case `LoggerImpl.log` falls back to its instance-level `runId`.
+ *
+ * Tests that construct an isolated `new LoggerImpl()` skip this path
+ * entirely — they call `setRunId(...)` on the instance.
+ */
+export type RunIdProvider = () => string | undefined;
+/** Concrete logger writing JSONL to stderr and an optional daily file. */
+export declare class LoggerImpl implements Logger {
+    private currentLevel;
+    private silent;
+    private debugMode;
+    private runId;
+    private logFilePath;
+    private runIdProvider;
+    constructor(opts?: LoggerOptions);
+    /**
+     * Apply a `LoggerOptions` bag to this instance. Used by the singleton
+     * via `configureLogger(opts)` — the bootstrap-time configuration seam
+     * that collapsed the four prior free mutators into one shot. Each
+     * field is independent: an `applyOptions({ silent: true })` leaves
+     * `debugMode` and `runId` alone.
+     */
+    applyOptions(opts: LoggerOptions): void;
+    debug(msgOrObj: string | Record<string, unknown>, data?: Record<string, unknown>): void;
+    info(msgOrObj: string | Record<string, unknown>, data?: Record<string, unknown>): void;
+    warn(msgOrObj: string | Record<string, unknown>, data?: Record<string, unknown>): void;
+    error(msgOrObj: string | Record<string, unknown>, data?: Record<string, unknown>): void;
+    /**
+     * Suppress stderr output. File output still occurs. Used by the CLI
+     * to silence the logger during Ink renders (Ink owns stdout; stderr
+     * is reserved for `--debug` traces). Tests use this on fresh
+     * `new LoggerImpl()` instances to verify the silent-mode contract.
+     */
+    setSilent(value: boolean): void;
+    /**
+     * Enable debug-level output to stderr. Sets the current level to
+     * `'debug'` when enabled. Disabling does NOT restore a prior level.
+     */
+    setDebugMode(value: boolean): void;
+    /** Set the correlation id stamped on each log entry. */
+    setRunId(id: string): void;
+    getRunId(): string | undefined;
+    /**
+     * Inject a runId source consulted on every `log()`. Lets the kernel
+     * route the singleton through the RunScope-bound runId without the
+     * logger module having to import run-scope.ts (which would create a
+     * cycle, since run-scope already imports the logger).
+     */
+    setRunIdProvider(provider: RunIdProvider | undefined): void;
+    /**
+     * Initialize the log file for this instance.
+     *
+     * Writes to `<dir>/<YYYY-MM-DD>.jsonl`; the CLI bootstrap supplies
+     * the path from `resolveProjectPaths(cwd).logsDir`. Without a call
+     * to this function, file output is disabled (logs still hit stderr
+     * in debug mode).
+     *
+     * Prunes log files older than 7 days inside the chosen directory.
+     *
+     * @internal — production callers route through `configureLogger`'s
+     * `logDir` option. The method is `private` from a domain-design
+     * standpoint but TypeScript can't mark it `private` because the
+     * constructor calls it via `applyOptions`.
+     */
+    initLogFile(dir: string): void;
+    private shouldLog;
+    private shouldWriteToFile;
+    private log;
+}
+export declare const logger: Logger;
+/**
+ * One-shot configuration for the process-wide `logger` singleton.
+ * Replaces the four free mutators that previously each mutated one
+ * field. The CLI's pre-action-hook calls this once with all relevant
+ * options after flags are parsed and the project context is resolved.
+ *
+ * SaaS hosts that run multiple invocations concurrently should NOT use
+ * this — they construct per-invocation `new LoggerImpl({...})` and
+ * wire it into the `RunScope.logger` field so each run has its own
+ * file path and runId.
+ */
+export declare function configureLogger(opts: LoggerOptions): void;
+//# sourceMappingURL=logger.d.ts.map

package/dist/lib/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/lib/logger.ts"],"names":[],"mappings":"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"}