@atolis-hq/wake 0.2.96 → 0.3.0

package/dist/src/domain/sources.js

@@ -1,16 +0,0 @@
-/**
- * Names the configured ticket source. This is one decision with several
- * consumers that MUST agree: main.ts names the source it wires into the fan-in
- * and the sink router, while the UI builds `<provider>:issue:<repo>#<n>` URIs
- * to resolve tickets against the index those same events registered. If the
- * two ever disagreed, the UI would resolve against a provider nothing had
- * registered, miss, and report live work items as missing.
- *
- * It lives here, and not inline at each call site, because adding a third
- * source means changing this one function rather than finding every ternary —
- * source-pluggability is the point of the adapter seams, so the choice must
- * not be duplicated across them.
- */
-export function configuredTicketSource(config) {
-    return config.sources.github.enabled ? 'github' : 'fake-ticketing';
-}

package/dist/src/domain/stages.js

@@ -1,36 +0,0 @@
-export const stageValues = ['queue', 'done'];
-export const doneRunnerSentinel = 'DONE';
-export const rejectedRunnerSentinel = 'REJECTED';
-export const blockedRunnerSentinel = 'BLOCKED';
-export const failedRunnerSentinel = 'FAILED';
-export const runnerSentinelValues = [
-    doneRunnerSentinel,
-    rejectedRunnerSentinel,
-    blockedRunnerSentinel,
-    failedRunnerSentinel,
-];
-export const terminalStageValues = ['done'];
-export function isTerminalStage(stage) {
-    return terminalStageValues.includes(stage);
-}
-export const wakeStageLabelPrefix = 'wake:stage.';
-export function stageLabelForStage(stage) {
-    return `${wakeStageLabelPrefix}${stage}`;
-}
-export function stageFromStageLabel(label, configuredStages = stageValues) {
-    if (!label.startsWith(wakeStageLabelPrefix)) {
-        return undefined;
-    }
-    const stage = label.slice(wakeStageLabelPrefix.length);
-    return new Set(configuredStages).has(stage) ? stage : undefined;
-}
-export function stageFromLabels(labels, configuredStages = stageValues) {
-    const stages = new Set();
-    for (const label of labels) {
-        const stage = stageFromStageLabel(label, configuredStages);
-        if (stage !== undefined) {
-            stages.add(stage);
-        }
-    }
-    return stages.size === 1 ? [...stages][0] : undefined;
-}

package/dist/src/domain/work-item-labels.js

@@ -1,48 +0,0 @@
-import { stageLabelForStage } from './stages.js';
-import { FROZEN_WORK_ITEM_LABEL } from './work-item-lifecycle.js';
-import { workflowLabelForWorkflowName, workflowNameForProjection } from './workflows.js';
-// The single place that translates the canonical, typed context fields
-// (status/frozen/deleted/scheduled) into wake:* label strings. Lives in
-// domain/ (not adapters/github/) so core/ can call it directly without
-// importing a concrete adapter — the wake: naming convention is Wake's own,
-// not GitHub-specific, matching stageLabelForStage/workflowLabelForWorkflowName
-// which already live here for the same reason.
-export const SCHEDULED_WORKFLOW_LABEL = 'wake:scheduled-workflow';
-const statusLabelByStatus = {
-    queued: 'wake:status.pending',
-    working: 'wake:status.working',
-    'awaiting-approval': 'wake:status.awaiting-approval',
-    'changes-requested': 'wake:status.changes-requested',
-    blocked: 'wake:status.blocked',
-    done: 'wake:status.completed',
-    failed: 'wake:status.failed',
-};
-// A projection that predates context.status being folded (or hasn't had a
-// run complete yet since this design shipped) has no status field — fall
-// back to the same sentinel+stage heuristic the old statusLabelForOutcome
-// used, so an untouched legacy item is translated to the *same* label it
-// already carries (e.g. still-AWAITING_APPROVAL) instead of drifting to a
-// wrong one just because context.status hasn't been folded onto it yet.
-function legacyStatusFallback(projection) {
-    const sentinel = projection.context.lastRunSentinel;
-    if (sentinel === 'AWAITING_APPROVAL') {
-        return 'awaiting-approval';
-    }
-    if (sentinel === 'BLOCKED') {
-        return 'blocked';
-    }
-    if (sentinel === 'FAILED') {
-        return 'failed';
-    }
-    return projection.wake.stage === 'done' ? 'done' : 'queued';
-}
-export function labelsForWorkItem(projection, config) {
-    const statusLabel = statusLabelByStatus[projection.context.status ?? legacyStatusFallback(projection)];
-    return {
-        statusLabel,
-        stageLabel: stageLabelForStage(projection.wake.stage),
-        workflowLabel: workflowLabelForWorkflowName(workflowNameForProjection(projection, config)),
-        ...(projection.context.frozen !== undefined ? { frozenLabel: FROZEN_WORK_ITEM_LABEL } : {}),
-        ...(projection.context.scheduled === true ? { scheduledLabel: SCHEDULED_WORKFLOW_LABEL } : {}),
-    };
-}

package/dist/src/domain/work-item-lifecycle.js

@@ -1,10 +0,0 @@
-export const FROZEN_WORK_ITEM_LABEL = 'wake:frozen';
-export function isWorkItemDeleted(item) {
-    return item.context.deleted !== undefined;
-}
-export function isWorkItemFrozen(item) {
-    return item.context.frozen !== undefined;
-}
-export function isWorkItemRunnable(item) {
-    return !isWorkItemDeleted(item) && !isWorkItemFrozen(item);
-}

package/dist/src/domain/work-item-status.js

@@ -1,33 +0,0 @@
-import { z } from 'zod';
-// Canonical, typed status for a work item — folded once in
-// projection-updater.ts, translated (never recomputed) everywhere else
-// (e.g. GitHub labels via labelsForWorkItem). See
-// docs/superpowers/specs/2026-07-28-canonical-work-item-status-design.md.
-export const workItemStatusValues = [
-    'queued',
-    'working',
-    'awaiting-approval',
-    'changes-requested',
-    'blocked',
-    'done',
-    'failed',
-];
-export const workItemStatusSchema = z.enum(workItemStatusValues);
-// Mirrors the sentinel/stage mapping that used to live only in
-// tick-runner.ts's statusLabelForOutcome/statusLabelForStage. Folded onto
-// context.status alongside (not replacing) context.lastRunSentinel.
-export function workItemStatusForRunOutcome(input) {
-    if (input.sentinel === 'DONE' && input.approvalGated === true) {
-        return 'awaiting-approval';
-    }
-    if (input.sentinel === 'REJECTED') {
-        return 'changes-requested';
-    }
-    if (input.sentinel === 'BLOCKED') {
-        return 'blocked';
-    }
-    if (input.sentinel === 'FAILED') {
-        return 'failed';
-    }
-    return input.stage === 'done' ? 'done' : 'queued';
-}

package/dist/src/domain/workflows.js

@@ -1,159 +0,0 @@
-import { stageLabelForStage } from './stages.js';
-export const universalQueueStage = 'queue';
-export const universalDoneStage = 'done';
-export const workflowChangedBlockReason = 'workflow-changed';
-export const wakeWorkflowLabelPrefix = 'wake:workflow.';
-export const builtInDefaultWorkflowDefinition = {
-    stages: {
-        refine: {
-            action: 'refine',
-            workspace: 'read-only',
-            tier: 'light',
-            onDone: 'implement',
-        },
-        implement: {
-            action: 'implement',
-            workspace: 'branch',
-            tier: 'standard',
-            onDone: 'done',
-        },
-    },
-};
-export function configuredWorkflowNames(config) {
-    return Object.keys(config.workflows);
-}
-export function defaultWorkflowName(config) {
-    const [name] = configuredWorkflowNames(config);
-    if (name === undefined) {
-        throw new Error('Wake config must define at least one workflow.');
-    }
-    return name;
-}
-export function workflowForProjection(projection, config) {
-    const workflowName = workflowNameForProjection(projection, config);
-    return config.workflows[workflowName] ?? null;
-}
-export function workflowNameForProjection(projection, config) {
-    const context = projection.context;
-    return typeof context.workflow === 'string' ? context.workflow : defaultWorkflowName(config);
-}
-function stringArray(value) {
-    return Array.isArray(value)
-        ? value.filter((entry) => typeof entry === 'string')
-        : [];
-}
-function repoFromResourceUri(resourceUri) {
-    if (resourceUri === undefined) {
-        return undefined;
-    }
-    const [, , rest] = resourceUri.split(':', 3);
-    return rest?.split('#')[0];
-}
-export function workflowSelectorInputFromEvent(event) {
-    const resourceUri = event.sourceRefs.resourceUri ?? event.sourceRefs.parentResourceUri;
-    const kind = resourceUri?.split(':')[1];
-    const ticket = (event.payload.ticket ?? event.payload.issue);
-    const pr = event.payload.pr;
-    const repo = (typeof ticket?.repo === 'string' ? ticket.repo : undefined) ??
-        event.sourceRefs.repo ??
-        repoFromResourceUri(resourceUri);
-    return {
-        ...(kind === undefined ? {} : { kind }),
-        sourceEventType: event.sourceEventType,
-        ...(repo === undefined ? {} : { repo }),
-        labels: stringArray(ticket?.labels),
-        assignees: stringArray(ticket?.assignees),
-        ...(typeof pr?.author === 'string' ? { author: pr.author } : {}),
-    };
-}
-function labelsAndAssigneesMatch(input) {
-    const labels = new Set(input.labels);
-    const assignees = new Set(input.assignees);
-    if (input.requiredLabels.some((label) => !labels.has(label))) {
-        return false;
-    }
-    if (input.ignoredLabels.some((label) => labels.has(label))) {
-        return false;
-    }
-    if (input.requiredAssignees.length > 0 &&
-        !input.requiredAssignees.some((login) => assignees.has(login))) {
-        return false;
-    }
-    return true;
-}
-function selectorMatches(selector, input) {
-    const match = selector.match;
-    if (match.kind !== undefined && match.kind !== input.kind) {
-        return false;
-    }
-    if (match.sourceEventType !== undefined && match.sourceEventType !== input.sourceEventType) {
-        return false;
-    }
-    if (match.repo !== undefined && match.repo !== input.repo) {
-        return false;
-    }
-    if (!labelsAndAssigneesMatch({ ...match, labels: input.labels, assignees: input.assignees })) {
-        return false;
-    }
-    if (match.requiredAuthors.length > 0 &&
-        (input.author === undefined || !match.requiredAuthors.includes(input.author))) {
-        return false;
-    }
-    return true;
-}
-export function selectWorkflowForEvent(event, config) {
-    const hintedWorkflow = event.payload.workflow;
-    if (typeof hintedWorkflow === 'string' && config.workflows[hintedWorkflow] !== undefined) {
-        return hintedWorkflow;
-    }
-    const input = workflowSelectorInputFromEvent(event);
-    const selector = config.workflowSelectors.find((candidate) => selectorMatches(candidate, input));
-    return selector?.workflow ?? null;
-}
-export function configuredStageNames(workflow) {
-    return Object.keys(workflow.stages);
-}
-export function workflowStageVocabulary(workflow) {
-    return [universalQueueStage, ...configuredStageNames(workflow), universalDoneStage];
-}
-export function stageLabelsForWorkflow(workflow) {
-    return workflowStageVocabulary(workflow).map((stage) => stageLabelForStage(stage));
-}
-export function workflowLabelForWorkflowName(workflowName) {
-    return `${wakeWorkflowLabelPrefix}${workflowName}`;
-}
-export function isKnownWorkflowStage(stage, workflow) {
-    return workflowStageVocabulary(workflow).includes(stage);
-}
-export function entryStage(workflow) {
-    return workflow.entryStage ?? configuredStageNames(workflow)[0];
-}
-export function stageAfterQueue(workflow) {
-    return entryStage(workflow);
-}
-export function chooseAction(projection, workflow) {
-    const stage = projection.wake.stage === universalQueueStage
-        ? stageAfterQueue(workflow)
-        : projection.wake.stage;
-    const definition = workflow.stages[stage];
-    if (definition === undefined || stage === universalDoneStage) {
-        return null;
-    }
-    return {
-        action: definition.action ?? stage,
-        workspace: definition.workspace,
-        routing: {
-            ...(definition.tier === undefined ? {} : { tier: definition.tier }),
-            ...(definition.runner === undefined ? {} : { runner: definition.runner }),
-        },
-        ...(definition.promptContext === undefined ? {} : { promptContext: definition.promptContext }),
-        stage,
-    };
-}
-export function nextStage(stage, sentinel, workflow) {
-    if (sentinel === 'BLOCKED' || sentinel === 'FAILED' || sentinel === 'REJECTED') {
-        return null;
-    }
-    const runnableStage = stage === universalQueueStage ? stageAfterQueue(workflow) : stage;
-    return workflow.stages[runnableStage]?.onDone ?? null;
-}

package/dist/src/lib/deep-merge.js

@@ -1,14 +0,0 @@
-function isPlainObject(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-export function deepMergeRaw(target, source) {
-    const result = { ...target };
-    for (const [key, sourceValue] of Object.entries(source)) {
-        const targetValue = result[key];
-        result[key] =
-            isPlainObject(sourceValue) && isPlainObject(targetValue)
-                ? deepMergeRaw(targetValue, sourceValue)
-                : sourceValue;
-    }
-    return result;
-}

package/dist/src/lib/detached-process-logging.js

@@ -1,46 +0,0 @@
-import { createWriteStream } from 'node:fs';
-import { DEFAULT_LOG_MAX_BYTES, DEFAULT_LOG_ROTATE_CHECK_INTERVAL_MS, rotateLogFileIfNeeded, } from './log-rotation.js';
-export function createDetachedProcessLogSink(logFile, options) {
-    const maxBytes = options?.maxBytes ?? DEFAULT_LOG_MAX_BYTES;
-    const rotateCheckIntervalMs = options?.rotateCheckIntervalMs ?? DEFAULT_LOG_ROTATE_CHECK_INTERVAL_MS;
-    const stdout = options?.stdout ?? process.stdout;
-    let closed = false;
-    let fileStream = openLogFile(logFile, maxBytes);
-    const rotateInterval = setInterval(() => {
-        if (closed) {
-            return;
-        }
-        const stream = fileStream;
-        stream.end(() => {
-            if (closed) {
-                return;
-            }
-            rotateLogFileIfNeeded(logFile, maxBytes);
-            fileStream = openLogFile(logFile, maxBytes);
-        });
-    }, rotateCheckIntervalMs);
-    rotateInterval.unref();
-    return {
-        write: (chunk) => {
-            if (closed) {
-                return;
-            }
-            fileStream.write(chunk);
-            stdout.write(chunk);
-        },
-        close: () => {
-            if (closed) {
-                return Promise.resolve();
-            }
-            closed = true;
-            clearInterval(rotateInterval);
-            return new Promise((resolve) => {
-                fileStream.end(resolve);
-            });
-        },
-    };
-}
-function openLogFile(logFile, maxBytes) {
-    rotateLogFileIfNeeded(logFile, maxBytes);
-    return createWriteStream(logFile, { flags: 'a' });
-}

package/dist/src/lib/event-log.js

@@ -1,21 +0,0 @@
-export function createEventEnvelope(input) {
-    return {
-        schemaVersion: 1,
-        ...input,
-    };
-}
-/**
- * Builds a source event with no workItemKey. Sources do not self-key; the
- * resolver in tick-runner stamps the canonical key between poll and append
- * (spec D1).
- *
- * The return type is spelled structurally rather than importing
- * core/contracts' `UnkeyedEventEnvelope` — it is the identical type, and lib/
- * must not depend on core/.
- */
-export function createUnkeyedEventEnvelope(input) {
-    return {
-        schemaVersion: 1,
-        ...input,
-    };
-}

package/dist/src/lib/format.js

@@ -1,41 +0,0 @@
-// Presentation-only formatting for run summaries (cost, duration, tokens).
-// Pure functions with no dependency on tick state — kept in lib/ so they are
-// directly unit-testable rather than only reachable through a full run.
-export function extractTokenCount(tokenUsage) {
-    if (tokenUsage === undefined) {
-        return undefined;
-    }
-    // Cache tokens dominate real usage and were previously dropped from this
-    // total entirely, understating the reported figure by roughly an order of
-    // magnitude (#135).
-    return (tokenUsage.inputTokens +
-        tokenUsage.outputTokens +
-        (tokenUsage.cacheCreationInputTokens ?? 0) +
-        (tokenUsage.cacheReadInputTokens ?? 0));
-}
-export function formatCostUsd(costUsd) {
-    return `$${costUsd.toFixed(costUsd < 1 ? 4 : 2)}`;
-}
-export function formatDuration(startedAtStr, finishedAtStr) {
-    const startedAt = new Date(startedAtStr);
-    const finishedAt = new Date(finishedAtStr);
-    const durationMs = finishedAt.getTime() - startedAt.getTime();
-    if (durationMs < 0 || !isFinite(durationMs))
-        return undefined;
-    const totalSeconds = Math.floor(durationMs / 1000);
-    const minutes = Math.floor(totalSeconds / 60);
-    const seconds = totalSeconds % 60;
-    if (minutes > 0) {
-        return `${minutes}m${seconds}s`;
-    }
-    return `${seconds}s`;
-}
-export function formatTokenCount(count) {
-    if (count >= 1000000) {
-        return `${(count / 1000000).toFixed(1)}M`;
-    }
-    if (count >= 1000) {
-        return `${(count / 1000).toFixed(0)}k`;
-    }
-    return String(count);
-}

package/dist/src/lib/json-file.js

@@ -1,23 +0,0 @@
-import { appendFile, mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
-import { randomUUID } from 'node:crypto';
-import { dirname } from 'node:path';
-export async function writeJsonFile(path, value) {
-    await mkdir(dirname(path), { recursive: true });
-    const tempPath = `${path}.${randomUUID()}.tmp`;
-    try {
-        await writeFile(tempPath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
-        await rename(tempPath, path);
-    }
-    catch (error) {
-        await rm(tempPath, { force: true }).catch(() => { });
-        throw error;
-    }
-}
-export async function readJsonFile(path) {
-    const raw = await readFile(path, 'utf8');
-    return JSON.parse(raw);
-}
-export async function appendJsonLine(path, value) {
-    await mkdir(dirname(path), { recursive: true });
-    await appendFile(path, `${JSON.stringify(value)}\n`, 'utf8');
-}

package/dist/src/lib/lock.js

@@ -1,181 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { link, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
-import { randomUUID } from 'node:crypto';
-function parseLockMetadata(raw) {
-    try {
-        const parsed = JSON.parse(raw);
-        if (parsed === null || typeof parsed !== 'object') {
-            return null;
-        }
-        const record = parsed;
-        if (typeof record.pid !== 'number' ||
-            !Number.isInteger(record.pid) ||
-            typeof record.acquiredAt !== 'string') {
-            return null;
-        }
-        const acquiredAtMs = Date.parse(record.acquiredAt);
-        if (!Number.isFinite(acquiredAtMs)) {
-            return null;
-        }
-        return {
-            pid: record.pid,
-            acquiredAt: record.acquiredAt,
-            ...(typeof record.lockId === 'string' ? { lockId: record.lockId } : {}),
-            ...(typeof record.commandLine === 'string' ? { commandLine: record.commandLine } : {}),
-        };
-    }
-    catch {
-        return null;
-    }
-}
-function isPidAlive(pid) {
-    if (pid <= 0) {
-        return false;
-    }
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (error) {
-        const code = error.code;
-        if (code === 'ESRCH') {
-            return false;
-        }
-        return true;
-    }
-}
-function readProcessCommandLine(pid) {
-    if (pid === process.pid) {
-        return process.argv.join(' ');
-    }
-    try {
-        return readFileSyncProcessCommandLine(pid);
-    }
-    catch {
-        return undefined;
-    }
-}
-function readFileSyncProcessCommandLine(pid) {
-    const raw = readFileSync(`/proc/${pid}/cmdline`, 'utf8');
-    const commandLine = raw.replace(/\0/g, ' ').trim();
-    return commandLine.length === 0 ? undefined : commandLine;
-}
-function defaultProcessInspector() {
-    return {
-        isPidAlive,
-        readCommandLine: readProcessCommandLine,
-    };
-}
-async function readLockMetadata(path) {
-    try {
-        return parseLockMetadata(await readFile(path, 'utf8'));
-    }
-    catch {
-        return null;
-    }
-}
-export async function readFileLockStatus(path, options) {
-    const metadata = await readLockMetadata(path);
-    if (metadata === null) {
-        try {
-            await readFile(path, 'utf8');
-            return { present: true, active: false, staleReason: 'invalid-metadata' };
-        }
-        catch {
-            return { present: false, active: false, staleReason: 'missing' };
-        }
-    }
-    const now = options?.now ?? new Date();
-    const ageMs = now.getTime() - Date.parse(metadata.acquiredAt);
-    if (options?.staleAfterMs !== undefined && ageMs >= options.staleAfterMs) {
-        return { present: true, active: false, metadata, ageMs, staleReason: 'expired' };
-    }
-    const inspector = options?.processInspector ?? defaultProcessInspector();
-    if (!inspector.isPidAlive(metadata.pid)) {
-        return { present: true, active: false, metadata, ageMs, staleReason: 'pid-not-alive' };
-    }
-    const commandLine = inspector.readCommandLine(metadata.pid);
-    if (commandLine !== undefined &&
-        ((metadata.commandLine !== undefined && commandLine !== metadata.commandLine) ||
-            (metadata.commandLine === undefined &&
-                options?.expectedCommandIncludes !== undefined &&
-                !options.expectedCommandIncludes.every((fragment) => commandLine.includes(fragment))))) {
-        return {
-            present: true,
-            active: false,
-            metadata,
-            ageMs,
-            commandLine,
-            staleReason: 'pid-command-mismatch',
-        };
-    }
-    return {
-        present: true,
-        active: true,
-        metadata,
-        ageMs,
-        ...(commandLine === undefined ? {} : { commandLine }),
-    };
-}
-export async function acquireFileLock(path, options) {
-    await mkdir(dirname(path), { recursive: true });
-    const metadata = {
-        pid: process.pid,
-        acquiredAt: (options?.now ?? new Date()).toISOString(),
-        lockId: randomUUID(),
-        commandLine: process.argv.join(' '),
-    };
-    async function tryAcquire() {
-        const tempPath = join(dirname(path), `.tick-lock-${metadata.lockId}.tmp`);
-        await writeFile(tempPath, `${JSON.stringify(metadata)}\n`, {
-            encoding: 'utf8',
-            flag: 'wx',
-        });
-        try {
-            await link(tempPath, path);
-        }
-        finally {
-            await rm(tempPath, { force: true });
-        }
-        return {
-            acquired: true,
-            metadata,
-            async release() {
-                const current = await readLockMetadata(path);
-                if (current?.pid === metadata.pid &&
-                    current.acquiredAt === metadata.acquiredAt &&
-                    current.lockId === metadata.lockId) {
-                    await rm(path, { force: true });
-                }
-            },
-        };
-    }
-    try {
-        return await tryAcquire();
-    }
-    catch (error) {
-        if (error.code === 'EEXIST') {
-            const status = await readFileLockStatus(path, {
-                ...(options?.staleAfterMs === undefined ? {} : { staleAfterMs: options.staleAfterMs }),
-                now: options?.now ?? new Date(),
-            });
-            if (!status.active) {
-                await rm(path, { force: true });
-                try {
-                    return await tryAcquire();
-                }
-                catch (retryError) {
-                    if (retryError.code !== 'EEXIST') {
-                        throw retryError;
-                    }
-                }
-            }
-            return {
-                acquired: false,
-                async release() { },
-            };
-        }
-        throw error;
-    }
-}

package/dist/src/lib/log-rotation.js

@@ -1,42 +0,0 @@
-import { renameSync, rmSync, statSync } from 'node:fs';
-export const DEFAULT_LOG_MAX_BYTES = 20 * 1024 * 1024;
-export const DEFAULT_LOG_ROTATE_CHECK_INTERVAL_MS = 5 * 60 * 1000;
-export function resolveLogMaxBytes(env = process.env) {
-    const raw = env.WAKE_LOG_MAX_BYTES;
-    if (raw === undefined || raw.trim() === '') {
-        return DEFAULT_LOG_MAX_BYTES;
-    }
-    const parsed = Number(raw);
-    if (!Number.isFinite(parsed) || parsed <= 0) {
-        return DEFAULT_LOG_MAX_BYTES;
-    }
-    return Math.floor(parsed);
-}
-export function resolveLogRotateCheckIntervalMs(env = process.env) {
-    const raw = env.WAKE_LOG_ROTATE_CHECK_INTERVAL_MS;
-    if (raw === undefined || raw.trim() === '') {
-        return DEFAULT_LOG_ROTATE_CHECK_INTERVAL_MS;
-    }
-    const parsed = Number(raw);
-    if (!Number.isFinite(parsed) || parsed <= 0) {
-        return DEFAULT_LOG_ROTATE_CHECK_INTERVAL_MS;
-    }
-    return Math.floor(parsed);
-}
-export function rotateLogFileIfNeeded(logFile, maxBytes = DEFAULT_LOG_MAX_BYTES) {
-    try {
-        if (statSync(logFile).size < maxBytes) {
-            return false;
-        }
-    }
-    catch (error) {
-        if (error.code === 'ENOENT') {
-            return false;
-        }
-        throw error;
-    }
-    const backupFile = `${logFile}.1`;
-    rmSync(backupFile, { force: true });
-    renameSync(logFile, backupFile);
-    return true;
-}