stageflow 0.25.0 → 0.27.0

package/dist/git/exec.js

@@ -0,0 +1,135 @@
+import { execFile, execFileSync } from "node:child_process";
+import { classifyGitFailure, GitError, redactGitText, } from "./errors.js";
+const DEFAULT_TIMEOUT_MS = 30_000;
+const DEFAULT_MAX_BUFFER = 16 * 1024 * 1024;
+function buildEnv(extra) {
+    return {
+        ...process.env,
+        ...extra,
+        GIT_TERMINAL_PROMPT: "0",
+    };
+}
+function toErrorMessage(code) {
+    switch (code) {
+        case "auth_failed":
+            return "git authentication failed";
+        case "ref_not_found":
+            return "git ref not found";
+        case "repo_not_found":
+            return "git repository not found";
+        case "network":
+            return "git network error";
+        case "disk_full":
+            return "git disk full";
+        case "git_missing":
+            return "git binary not found";
+        case "timeout":
+            return "git command timed out";
+        default:
+            return "git command failed";
+    }
+}
+function fail(options) {
+    const stderr = redactGitText(options.stderrRaw, options.env);
+    const code = classifyGitFailure({
+        stderr: options.stderrRaw,
+        exitCode: options.exitCode,
+        errno: options.errno,
+        timedOut: options.timedOut,
+    });
+    throw new GitError(toErrorMessage(code), {
+        code,
+        argv: options.argv,
+        stderr,
+        exitCode: options.exitCode,
+    });
+}
+function normalizeStderr(stderr) {
+    if (Buffer.isBuffer(stderr))
+        return stderr.toString("utf8").trim();
+    if (typeof stderr === "string")
+        return stderr.trim();
+    return "";
+}
+export function runGitSync(options) {
+    const gitBin = options.gitBin ?? "git";
+    const argv = [gitBin, ...options.args];
+    const env = buildEnv(options.env);
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    try {
+        const stdout = execFileSync(gitBin, options.args, {
+            cwd: options.cwd,
+            env,
+            encoding: "utf8",
+            timeout: timeoutMs,
+            maxBuffer: options.maxBuffer ?? DEFAULT_MAX_BUFFER,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        return { stdout, stderr: "", exitCode: 0 };
+    }
+    catch (error) {
+        const err = error;
+        const timedOut = err.killed === true ||
+            err.signal === "SIGTERM" ||
+            (typeof err.message === "string" && /TIMEDOUT|timed out/i.test(err.message));
+        fail({
+            argv,
+            stderrRaw: normalizeStderr(err.stderr) || (timedOut ? "git command timed out" : err.message),
+            exitCode: typeof err.status === "number" ? err.status : null,
+            errno: err.code ?? null,
+            timedOut,
+            env,
+        });
+    }
+}
+export function runGit(options) {
+    const gitBin = options.gitBin ?? "git";
+    const argv = [gitBin, ...options.args];
+    const env = buildEnv(options.env);
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    return new Promise((resolve, reject) => {
+        execFile(gitBin, options.args, {
+            cwd: options.cwd,
+            env,
+            encoding: "utf8",
+            timeout: timeoutMs,
+            maxBuffer: options.maxBuffer ?? DEFAULT_MAX_BUFFER,
+            signal: options.signal,
+            killSignal: "SIGTERM",
+        }, (error, stdout, stderr) => {
+            if (!error) {
+                resolve({
+                    stdout: typeof stdout === "string" ? stdout : String(stdout ?? ""),
+                    stderr: normalizeStderr(stderr),
+                    exitCode: 0,
+                });
+                return;
+            }
+            const err = error;
+            const timedOut = err.killed === true ||
+                err.signal === "SIGTERM" ||
+                err.code === "ETIMEDOUT" ||
+                (typeof err.message === "string" && /TIMEDOUT|timed out/i.test(err.message));
+            const errno = typeof err.code === "string" ? err.code : null;
+            const exitCode = typeof err.status === "number"
+                ? err.status
+                : typeof err.code === "number"
+                    ? err.code
+                    : null;
+            try {
+                fail({
+                    argv,
+                    stderrRaw: normalizeStderr(stderr) ||
+                        (timedOut ? "git command timed out" : err.message),
+                    exitCode,
+                    errno,
+                    timedOut,
+                    env,
+                });
+            }
+            catch (gitError) {
+                reject(gitError);
+            }
+        });
+    });
+}

package/dist/git/operations.d.ts

@@ -0,0 +1,29 @@
+export type GitCallOptions = {
+    env?: NodeJS.ProcessEnv;
+    gitBin?: string;
+    signal?: AbortSignal;
+};
+export declare const BARE_ORIGIN_FETCH_HEADS = "+refs/heads/*:refs/remotes/origin/*";
+export declare const BARE_ORIGIN_FETCH_TAGS = "+refs/tags/*:refs/tags/*";
+export declare function configureBareOriginFetch(repoDir: string, opts?: GitCallOptions): Promise<void>;
+export declare function pruneNonStageflowLocalHeads(repoDir: string, opts?: GitCallOptions): Promise<void>;
+export declare function cloneBare(url: string, dest: string, opts?: GitCallOptions): Promise<void>;
+export declare function fetch(repoDir: string, refspecs?: string[], opts?: GitCallOptions): Promise<void>;
+export declare function remoteUpdate(repoDir: string, opts?: GitCallOptions): Promise<void>;
+export declare function resolveRef(repoDir: string, ref: string, opts?: GitCallOptions): Promise<string>;
+export declare function catFileCommit(repoDir: string, sha: string, opts?: GitCallOptions): Promise<boolean>;
+export declare function worktreeAdd(repoDir: string, input: {
+    worktreePath: string;
+    branch: string;
+    startPoint: string;
+}, opts?: GitCallOptions): Promise<void>;
+export declare function worktreeRemove(repoDir: string, worktreePath: string, opts?: GitCallOptions): Promise<void>;
+export declare function worktreePrune(repoDir: string, opts?: GitCallOptions): Promise<void>;
+export declare function deleteBranch(repoDir: string, branch: string, opts?: GitCallOptions): Promise<void>;
+export declare function revParse(repoDir: string, args: string[], opts?: GitCallOptions): Promise<string>;
+export declare function diff(repoDir: string, args?: string[], opts?: GitCallOptions): Promise<string>;
+export declare function statusPorcelain(repoDir: string, pathspec?: string, opts?: GitCallOptions): string;
+export declare function statusPorcelainZ(repoDir: string, opts?: GitCallOptions): Promise<string>;
+export declare function lsFilesOthersZ(repoDir: string, opts?: GitCallOptions): Promise<string>;
+export declare function checkRefFormat(branchName: string, opts?: GitCallOptions): Promise<boolean>;
+export declare function revParseSync(cwd: string, args: string[], opts?: GitCallOptions): string;

package/dist/git/operations.js

@@ -0,0 +1,153 @@
+import { GitError } from "./errors.js";
+import { runGit, runGitSync } from "./exec.js";
+const TIMEOUT = {
+    resolve: 30_000,
+    worktree: 120_000,
+    fetch: 300_000,
+    clone: 900_000,
+    default: 30_000,
+};
+const FULL_SHA_RE = /^[0-9a-f]{40}$/i;
+function baseOpts(cwd, args, timeoutMs, opts) {
+    return {
+        cwd,
+        args,
+        timeoutMs,
+        env: opts?.env,
+        gitBin: opts?.gitBin,
+        signal: opts?.signal,
+    };
+}
+export const BARE_ORIGIN_FETCH_HEADS = "+refs/heads/*:refs/remotes/origin/*";
+export const BARE_ORIGIN_FETCH_TAGS = "+refs/tags/*:refs/tags/*";
+export async function configureBareOriginFetch(repoDir, opts) {
+    try {
+        await runGit(baseOpts(repoDir, ["config", "--unset", "remote.origin.mirror"], TIMEOUT.default, opts));
+    }
+    catch {
+        // unset fails when the key is absent
+    }
+    try {
+        await runGit(baseOpts(repoDir, ["config", "--unset-all", "remote.origin.fetch"], TIMEOUT.default, opts));
+    }
+    catch {
+        // unset-all fails when the key is absent
+    }
+    await runGit(baseOpts(repoDir, ["config", "--add", "remote.origin.fetch", BARE_ORIGIN_FETCH_HEADS], TIMEOUT.default, opts));
+    await runGit(baseOpts(repoDir, ["config", "--add", "remote.origin.fetch", BARE_ORIGIN_FETCH_TAGS], TIMEOUT.default, opts));
+}
+export async function pruneNonStageflowLocalHeads(repoDir, opts) {
+    const listed = await runGit(baseOpts(repoDir, ["for-each-ref", "--format=%(refname)", "refs/heads/"], TIMEOUT.default, opts));
+    const refs = listed.stdout
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    for (const ref of refs) {
+        if (ref === "refs/heads/stageflow" || ref.startsWith("refs/heads/stageflow/")) {
+            continue;
+        }
+        try {
+            await runGit(baseOpts(repoDir, ["update-ref", "-d", ref], TIMEOUT.default, opts));
+        }
+        catch {
+            // best-effort prune under heal lock
+        }
+    }
+}
+export async function cloneBare(url, dest, opts) {
+    await runGit(baseOpts(undefined, ["clone", "--bare", url, dest], TIMEOUT.clone, opts));
+    await configureBareOriginFetch(dest, opts);
+}
+export async function fetch(repoDir, refspecs = [], opts) {
+    await runGit(baseOpts(repoDir, ["fetch", "--prune", "origin", ...refspecs], TIMEOUT.fetch, opts));
+}
+export async function remoteUpdate(repoDir, opts) {
+    await runGit(baseOpts(repoDir, ["remote", "update", "--prune"], TIMEOUT.fetch, opts));
+}
+async function revParseCommit(repoDir, ref, opts) {
+    const result = await runGit(baseOpts(repoDir, ["rev-parse", "--verify", "--end-of-options", `${ref}^{commit}`], TIMEOUT.resolve, opts));
+    return result.stdout.trim();
+}
+async function tryRevParseCommit(repoDir, ref, opts) {
+    try {
+        return await revParseCommit(repoDir, ref, opts);
+    }
+    catch (err) {
+        if (err instanceof GitError && err.code === "ref_not_found") {
+            return null;
+        }
+        throw err;
+    }
+}
+export async function resolveRef(repoDir, ref, opts) {
+    if (FULL_SHA_RE.test(ref) || ref.startsWith("refs/")) {
+        return revParseCommit(repoDir, ref, opts);
+    }
+    const candidates = [
+        `refs/remotes/origin/${ref}`,
+        `origin/${ref}`,
+        `refs/tags/${ref}`,
+    ];
+    for (const candidate of candidates) {
+        const sha = await tryRevParseCommit(repoDir, candidate, opts);
+        if (sha !== null)
+            return sha;
+    }
+    return revParseCommit(repoDir, candidates[0], opts);
+}
+export async function catFileCommit(repoDir, sha, opts) {
+    try {
+        await runGit(baseOpts(repoDir, ["cat-file", "-e", `${sha}^{commit}`], TIMEOUT.resolve, opts));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function worktreeAdd(repoDir, input, opts) {
+    await runGit(baseOpts(repoDir, ["worktree", "add", "-b", input.branch, input.worktreePath, input.startPoint], TIMEOUT.worktree, opts));
+}
+export async function worktreeRemove(repoDir, worktreePath, opts) {
+    await runGit(baseOpts(repoDir, ["worktree", "remove", "--force", worktreePath], TIMEOUT.worktree, opts));
+}
+export async function worktreePrune(repoDir, opts) {
+    await runGit(baseOpts(repoDir, ["worktree", "prune"], TIMEOUT.worktree, opts));
+}
+export async function deleteBranch(repoDir, branch, opts) {
+    await runGit(baseOpts(repoDir, ["branch", "-D", branch], TIMEOUT.default, opts));
+}
+export async function revParse(repoDir, args, opts) {
+    const result = await runGit(baseOpts(repoDir, ["rev-parse", ...args], TIMEOUT.resolve, opts));
+    return result.stdout.trim();
+}
+export async function diff(repoDir, args = [], opts) {
+    const result = await runGit(baseOpts(repoDir, ["diff", ...args], TIMEOUT.default, opts));
+    return result.stdout;
+}
+export function statusPorcelain(repoDir, pathspec, opts) {
+    const args = ["status", "--porcelain"];
+    if (pathspec !== undefined) {
+        args.push("--", pathspec);
+    }
+    return runGitSync(baseOpts(repoDir, args, TIMEOUT.default, opts)).stdout;
+}
+export async function statusPorcelainZ(repoDir, opts) {
+    const result = await runGit(baseOpts(repoDir, ["status", "--porcelain=v1", "-z", "--untracked-files=all"], TIMEOUT.default, opts));
+    return result.stdout;
+}
+export async function lsFilesOthersZ(repoDir, opts) {
+    const result = await runGit(baseOpts(repoDir, ["ls-files", "--others", "--exclude-standard", "-z"], TIMEOUT.default, opts));
+    return result.stdout;
+}
+export async function checkRefFormat(branchName, opts) {
+    try {
+        await runGit(baseOpts(undefined, ["check-ref-format", "--branch", branchName], TIMEOUT.resolve, opts));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function revParseSync(cwd, args, opts) {
+    return runGitSync(baseOpts(cwd, ["rev-parse", ...args], TIMEOUT.resolve, opts)).stdout.trim();
+}

package/dist/git/version.d.ts

@@ -0,0 +1 @@
+export declare function gitVersion(gitBin?: string): Promise<string>;

package/dist/git/version.js

@@ -0,0 +1,10 @@
+import { runGit } from "./exec.js";
+export async function gitVersion(gitBin = "git") {
+    const result = await runGit({
+        gitBin,
+        args: ["version"],
+        timeoutMs: 5_000,
+    });
+    const match = result.stdout.match(/git version\s+(\S+)/i);
+    return match?.[1] ?? result.stdout.trim();
+}

package/dist/logging/audit.d.ts

@@ -0,0 +1,16 @@
+import type { Logger } from "./logger.js";
+import type { CallerSurface } from "../server/requestAuthContext.js";
+export type AuditOutcome = "ok" | "error";
+export type AuditRecord = {
+    caller_id: string | null;
+    surface: CallerSurface;
+    action: string;
+    target_run_id?: string;
+    outcome: AuditOutcome;
+    error_code?: string;
+};
+/**
+ * Append-only mutating-call audit on the Slot 4 JSON logger.
+ * Allowlisted fields only — never Authorization, pipeline_body, or skills.
+ */
+export declare function writeAudit(log: Logger, record: AuditRecord): void;

package/dist/logging/audit.js

@@ -0,0 +1,19 @@
+/**
+ * Append-only mutating-call audit on the Slot 4 JSON logger.
+ * Allowlisted fields only — never Authorization, pipeline_body, or skills.
+ */
+export function writeAudit(log, record) {
+    const fields = {
+        caller_id: record.caller_id,
+        surface: record.surface,
+        action: record.action,
+        outcome: record.outcome,
+    };
+    if (record.target_run_id !== undefined) {
+        fields.target_run_id = record.target_run_id;
+    }
+    if (record.error_code !== undefined) {
+        fields.error_code = record.error_code;
+    }
+    log.info("audit", `${record.action} ${record.outcome}`, fields);
+}

package/dist/logging/commonWords.d.ts

@@ -0,0 +1,2 @@
+/** Common words that must not be value-redacted even if length ≥ 8. */
+export declare const COMMON_WORDS: ReadonlySet<string>;

package/dist/logging/commonWords.js

@@ -0,0 +1,13 @@
+/** Common words that must not be value-redacted even if length ≥ 8. */
+export const COMMON_WORDS = new Set([
+    "password",
+    "username",
+    "localhost",
+    "127.0.0.1",
+    "true",
+    "false",
+    "undefined",
+    "development",
+    "production",
+    "staging",
+]);

package/dist/logging/logger.d.ts

@@ -0,0 +1,49 @@
+export type LogLevel = "debug" | "info" | "warn" | "error";
+export type LogFormat = "json" | "pretty";
+export type LoggerBindings = {
+    component?: string;
+    run_id?: string;
+    stage_id?: string;
+    attempt?: number;
+};
+export type LogFields = Record<string, unknown>;
+export type LogRecord = {
+    ts: string;
+    level: LogLevel;
+    event: string;
+    msg: string;
+    component?: string;
+    run_id?: string;
+    stage_id?: string;
+    attempt?: number;
+    truncated?: boolean;
+    original_bytes?: number;
+} & LogFields;
+export type Logger = {
+    debug(event: string, msg: string, fields?: LogFields): void;
+    info(event: string, msg: string, fields?: LogFields): void;
+    warn(event: string, msg: string, fields?: LogFields): void;
+    error(event: string, msg: string, fields?: LogFields): void;
+    child(bindings: LoggerBindings): Logger;
+};
+export declare const LOG_FORMAT_ENV = "STAGEFLOW_LOG_FORMAT";
+export declare const LOG_LEVEL_ENV = "STAGEFLOW_LOG_LEVEL";
+export declare const LOG_MAX_LINE_BYTES_ENV = "STAGEFLOW_LOG_MAX_LINE_BYTES";
+export declare const DEFAULT_LOG_LEVEL: LogLevel;
+export declare const DEFAULT_LOG_MAX_LINE_BYTES = 8192;
+export type CreateLoggerOptions = {
+    env?: Record<string, string | undefined>;
+    stdoutIsTTY?: boolean;
+    format?: LogFormat;
+    level?: LogLevel;
+    maxLineBytes?: number;
+    knownSecrets?: readonly string[];
+    bindings?: LoggerBindings;
+    write?: (line: string) => void;
+    now?: () => Date;
+};
+export declare function resolveLogFormat(env?: Record<string, string | undefined>, stdoutIsTTY?: boolean): LogFormat;
+export declare function resolveLogLevel(env?: Record<string, string | undefined>): LogLevel;
+export declare function resolveLogMaxLineBytes(env?: Record<string, string | undefined>): number;
+export declare function createLogger(options?: CreateLoggerOptions): Logger;
+export declare const logger: Logger;

package/dist/logging/logger.js

@@ -0,0 +1,193 @@
+import { redact } from "./redact.js";
+import { getNamedSecrets } from "./namedSecrets.js";
+export const LOG_FORMAT_ENV = "STAGEFLOW_LOG_FORMAT";
+export const LOG_LEVEL_ENV = "STAGEFLOW_LOG_LEVEL";
+export const LOG_MAX_LINE_BYTES_ENV = "STAGEFLOW_LOG_MAX_LINE_BYTES";
+export const DEFAULT_LOG_LEVEL = "info";
+export const DEFAULT_LOG_MAX_LINE_BYTES = 8192;
+const LEVEL_RANK = {
+    debug: 10,
+    info: 20,
+    warn: 30,
+    error: 40,
+};
+export function resolveLogFormat(env = process.env, stdoutIsTTY = Boolean(process.stdout.isTTY)) {
+    const raw = env[LOG_FORMAT_ENV]?.trim().toLowerCase();
+    if (raw === "json" || raw === "pretty")
+        return raw;
+    return stdoutIsTTY ? "pretty" : "json";
+}
+export function resolveLogLevel(env = process.env) {
+    const raw = env[LOG_LEVEL_ENV]?.trim().toLowerCase();
+    if (raw === "debug" || raw === "info" || raw === "warn" || raw === "error") {
+        return raw;
+    }
+    return DEFAULT_LOG_LEVEL;
+}
+export function resolveLogMaxLineBytes(env = process.env) {
+    const raw = env[LOG_MAX_LINE_BYTES_ENV];
+    if (raw === undefined || raw.trim() === "")
+        return DEFAULT_LOG_MAX_LINE_BYTES;
+    const n = Number.parseInt(raw, 10);
+    if (!Number.isFinite(n) || n < 64)
+        return DEFAULT_LOG_MAX_LINE_BYTES;
+    return n;
+}
+function formatPretty(record) {
+    const parts = [
+        record.ts,
+        record.level.toUpperCase(),
+        record.component !== undefined ? `[${record.component}]` : undefined,
+        `${record.event}:`,
+        record.msg,
+    ].filter((part) => part !== undefined && part !== "");
+    const correlation = [];
+    if (record.run_id !== undefined)
+        correlation.push(`run_id=${record.run_id}`);
+    if (record.stage_id !== undefined) {
+        correlation.push(`stage_id=${record.stage_id}`);
+    }
+    if (record.attempt !== undefined) {
+        correlation.push(`attempt=${record.attempt}`);
+    }
+    if (record.truncated === true)
+        correlation.push("truncated=true");
+    const reserved = new Set([
+        "ts",
+        "level",
+        "event",
+        "msg",
+        "component",
+        "run_id",
+        "stage_id",
+        "attempt",
+        "truncated",
+        "original_bytes",
+    ]);
+    for (const [key, value] of Object.entries(record)) {
+        if (reserved.has(key))
+            continue;
+        if (value === undefined)
+            continue;
+        correlation.push(`${key}=${typeof value === "string" ? value : JSON.stringify(value)}`);
+    }
+    return correlation.length > 0
+        ? `${parts.join(" ")} ${correlation.join(" ")}`
+        : parts.join(" ");
+}
+function serializeRecord(record, format, maxLineBytes) {
+    if (format === "pretty") {
+        let line = formatPretty(record);
+        const bytes = Buffer.byteLength(line, "utf8");
+        if (bytes <= maxLineBytes)
+            return line;
+        const overhead = bytes - Buffer.byteLength(record.msg, "utf8");
+        const msgBudget = Math.max(0, maxLineBytes - overhead - 1);
+        const truncatedMsg = Buffer.from(record.msg, "utf8")
+            .subarray(0, msgBudget)
+            .toString("utf8");
+        return formatPretty({
+            ...record,
+            msg: truncatedMsg,
+            truncated: true,
+            original_bytes: bytes,
+        });
+    }
+    let payload = { ...record };
+    let line = JSON.stringify(payload);
+    let bytes = Buffer.byteLength(line, "utf8");
+    if (bytes <= maxLineBytes)
+        return line;
+    const originalBytes = bytes;
+    let lo = 0;
+    let hi = Buffer.byteLength(record.msg, "utf8");
+    let bestMsg = "";
+    while (lo <= hi) {
+        const mid = Math.floor((lo + hi) / 2);
+        const candidateMsg = Buffer.from(record.msg, "utf8")
+            .subarray(0, mid)
+            .toString("utf8");
+        payload = {
+            ...record,
+            msg: candidateMsg,
+            truncated: true,
+            original_bytes: originalBytes,
+        };
+        line = JSON.stringify(payload);
+        bytes = Buffer.byteLength(line, "utf8");
+        if (bytes <= maxLineBytes) {
+            bestMsg = candidateMsg;
+            lo = mid + 1;
+        }
+        else {
+            hi = mid - 1;
+        }
+    }
+    return JSON.stringify({
+        ...record,
+        msg: bestMsg,
+        truncated: true,
+        original_bytes: originalBytes,
+    });
+}
+export function createLogger(options = {}) {
+    const env = options.env ?? process.env;
+    const format = options.format ??
+        resolveLogFormat(env, options.stdoutIsTTY ?? Boolean(process.stdout.isTTY));
+    const level = options.level ?? resolveLogLevel(env);
+    const maxLineBytes = options.maxLineBytes ?? resolveLogMaxLineBytes(env);
+    const knownSecrets = options.knownSecrets ?? [];
+    const bindings = options.bindings ?? {};
+    const write = options.write ??
+        ((line) => {
+            process.stdout.write(`${line}\n`);
+        });
+    const now = options.now ?? (() => new Date());
+    const emit = (recordLevel, event, msg, fields) => {
+        if (LEVEL_RANK[recordLevel] < LEVEL_RANK[level])
+            return;
+        const record = {
+            ts: now().toISOString(),
+            level: recordLevel,
+            event,
+            msg,
+            ...bindings,
+            ...fields,
+        };
+        const redacted = redact(record, {
+            knownSecrets,
+            namedSecrets: getNamedSecrets(),
+        });
+        write(serializeRecord(redacted, format, maxLineBytes));
+    };
+    const logger = {
+        debug(event, msg, fields) {
+            emit("debug", event, msg, fields);
+        },
+        info(event, msg, fields) {
+            emit("info", event, msg, fields);
+        },
+        warn(event, msg, fields) {
+            emit("warn", event, msg, fields);
+        },
+        error(event, msg, fields) {
+            emit("error", event, msg, fields);
+        },
+        child(childBindings) {
+            return createLogger({
+                env,
+                format,
+                level,
+                maxLineBytes,
+                knownSecrets,
+                write,
+                now,
+                bindings: { ...bindings, ...childBindings },
+            });
+        },
+    };
+    return logger;
+}
+export const logger = createLogger({
+    bindings: { component: "host" },
+});

package/dist/logging/namedSecrets.d.ts

@@ -0,0 +1,6 @@
+import type { NamedSecret } from "../logging/redact.js";
+export declare const REDACTION_SECRETS_FILENAME = "redaction-secrets.json";
+export declare function registerNamedSecrets(secrets: readonly NamedSecret[]): void;
+export declare function clearNamedSecretsForTests(): void;
+export declare function getNamedSecrets(): readonly NamedSecret[];
+export declare function loadNamedSecretsFromAttemptDir(attemptDir: string): void;