@kbediako/codex-orchestrator 0.1.2 → 0.1.3

package/dist/packages/orchestrator/src/exec/stdio.js

@@ -0,0 +1,112 @@
+import { Buffer } from 'node:buffer';
+/**
+ * Creates a tracker that sequences stdout/stderr chunks while maintaining
+ * bounded in-memory buffers for each stream.
+ */
+export function createStdioTracker(options = {}) {
+    const encoding = options.encoding ?? 'utf-8';
+    const maxBufferBytes = options.maxBufferBytes ?? 64 * 1024;
+    const now = options.now ?? (() => new Date());
+    let sequence = Math.max(0, options.startSequence ?? 0);
+    const buffers = {
+        stdout: createInternalBuffer(),
+        stderr: createInternalBuffer()
+    };
+    const push = (stream, chunk) => {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding);
+        const target = buffers[stream];
+        appendWithLimit(target, buffer, maxBufferBytes);
+        const chunkRecord = {
+            sequence: ++sequence,
+            stream,
+            bytes: buffer.byteLength,
+            data: buffer.toString(encoding),
+            timestamp: now().toISOString()
+        };
+        return chunkRecord;
+    };
+    const getBuffered = (stream) => {
+        const target = buffers[stream];
+        if (target.byteLength === 0) {
+            return '';
+        }
+        const activeChunks = snapshotChunks(target);
+        if (activeChunks.length === 0) {
+            return '';
+        }
+        if (activeChunks.length === 1) {
+            return activeChunks[0].toString(encoding);
+        }
+        return Buffer.concat(activeChunks, target.byteLength).toString(encoding);
+    };
+    const getBufferedBytes = (stream) => buffers[stream].byteLength;
+    const reset = () => {
+        buffers.stdout = createInternalBuffer();
+        buffers.stderr = createInternalBuffer();
+        sequence = Math.max(0, options.startSequence ?? 0);
+    };
+    return {
+        push,
+        getBuffered,
+        getBufferedBytes,
+        reset
+    };
+}
+function createInternalBuffer() {
+    return { chunks: [], start: 0, byteLength: 0 };
+}
+function snapshotChunks(buffer) {
+    if (buffer.start === 0) {
+        return buffer.chunks;
+    }
+    return buffer.chunks.slice(buffer.start);
+}
+function appendWithLimit(target, incoming, limit) {
+    if (limit <= 0) {
+        target.chunks = [];
+        target.start = 0;
+        target.byteLength = 0;
+        return;
+    }
+    if (!incoming || incoming.byteLength === 0) {
+        trimExcess(target, limit);
+        return;
+    }
+    if (incoming.byteLength >= limit) {
+        const trimmed = Buffer.from(incoming.subarray(incoming.byteLength - limit));
+        target.chunks = [trimmed];
+        target.start = 0;
+        target.byteLength = trimmed.byteLength;
+        return;
+    }
+    target.chunks.push(incoming);
+    target.byteLength += incoming.byteLength;
+    trimExcess(target, limit);
+}
+function trimExcess(target, limit) {
+    if (target.byteLength <= limit) {
+        return;
+    }
+    let startIndex = target.start;
+    const chunks = target.chunks;
+    while (target.byteLength > limit && startIndex < chunks.length) {
+        const head = chunks[startIndex];
+        if (!head) {
+            break;
+        }
+        const overflow = target.byteLength - limit;
+        if (head.byteLength <= overflow) {
+            target.byteLength -= head.byteLength;
+            startIndex += 1;
+            continue;
+        }
+        chunks[startIndex] = head.subarray(overflow);
+        target.byteLength -= overflow;
+        break;
+    }
+    target.start = startIndex;
+    if (target.start > 0 && target.start * 2 >= chunks.length) {
+        target.chunks = chunks.slice(target.start);
+        target.start = 0;
+    }
+}

package/dist/packages/orchestrator/src/exec/unified-exec.js

@@ -1,7 +1,7 @@
 import { spawn } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
 import { ToolInvocationFailedError } from '../tool-orchestrator.js';
-import { createStdioTracker } from '../../../shared/streams/stdio.js';
+import { createStdioTracker } from './stdio.js';
 export class UnifiedExecRunner {
     orchestrator;
     sessionManager;

package/dist/packages/orchestrator/src/index.js

@@ -1,3 +1,4 @@
 export { ToolOrchestrator, SandboxRetryableError, ApprovalRequiredError, ApprovalDeniedError, ToolInvocationFailedError } from './tool-orchestrator.js';
 export { ExecSessionManager } from './exec/session-manager.js';
 export { UnifiedExecRunner } from './exec/unified-exec.js';
+export { RemoteExecHandleService } from './exec/handle-service.js';

package/dist/packages/shared/design-artifacts/writer.js

@@ -1,6 +1,8 @@
-import { mkdir, rename, writeFile } from 'node:fs/promises';
-import { dirname, join, relative as relativePath } from 'node:path';
+import { join, relative as relativePath } from 'node:path';
 import { persistDesignManifest } from '../manifest/writer.js';
+import { writeJsonAtomic } from '../../../orchestrator/src/cli/utils/fs.js';
+import { sanitizeTaskId } from '../../../orchestrator/src/persistence/sanitizeTaskId.js';
+import { sanitizeRunId } from '../../../orchestrator/src/persistence/sanitizeRunId.js';
 export async function writeDesignSummary(options) {
     const now = options.now ?? new Date();
     const context = options.context;
@@ -207,15 +209,3 @@ function accumulateNumericTotals(target, incoming) {
         }
     }
 }
-function sanitizeTaskId(value) {
-    return value.replace(/[^a-zA-Z0-9_-]/g, '').toLowerCase();
-}
-function sanitizeRunId(value) {
-    return value.replace(/[:]/g, '-');
-}
-async function writeJsonAtomic(targetPath, payload) {
-    const tmpPath = `${targetPath}.tmp-${process.pid}-${Date.now()}`;
-    await mkdir(dirname(targetPath), { recursive: true });
-    await writeFile(tmpPath, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
-    await rename(tmpPath, targetPath);
-}

package/dist/packages/shared/streams/stdio.js

@@ -1,112 +1,2 @@
-import { Buffer } from 'node:buffer';
-/**
- * Creates a tracker that sequences stdout/stderr chunks while maintaining
- * bounded in-memory buffers for each stream.
- */
-export function createStdioTracker(options = {}) {
-    const encoding = options.encoding ?? 'utf-8';
-    const maxBufferBytes = options.maxBufferBytes ?? 64 * 1024;
-    const now = options.now ?? (() => new Date());
-    let sequence = Math.max(0, options.startSequence ?? 0);
-    const buffers = {
-        stdout: createInternalBuffer(),
-        stderr: createInternalBuffer()
-    };
-    const push = (stream, chunk) => {
-        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding);
-        const target = buffers[stream];
-        appendWithLimit(target, buffer, maxBufferBytes);
-        const chunkRecord = {
-            sequence: ++sequence,
-            stream,
-            bytes: buffer.byteLength,
-            data: buffer.toString(encoding),
-            timestamp: now().toISOString()
-        };
-        return chunkRecord;
-    };
-    const getBuffered = (stream) => {
-        const target = buffers[stream];
-        if (target.byteLength === 0) {
-            return '';
-        }
-        const activeChunks = snapshotChunks(target);
-        if (activeChunks.length === 0) {
-            return '';
-        }
-        if (activeChunks.length === 1) {
-            return activeChunks[0].toString(encoding);
-        }
-        return Buffer.concat(activeChunks, target.byteLength).toString(encoding);
-    };
-    const getBufferedBytes = (stream) => buffers[stream].byteLength;
-    const reset = () => {
-        buffers.stdout = createInternalBuffer();
-        buffers.stderr = createInternalBuffer();
-        sequence = Math.max(0, options.startSequence ?? 0);
-    };
-    return {
-        push,
-        getBuffered,
-        getBufferedBytes,
-        reset
-    };
-}
-function createInternalBuffer() {
-    return { chunks: [], start: 0, byteLength: 0 };
-}
-function snapshotChunks(buffer) {
-    if (buffer.start === 0) {
-        return buffer.chunks;
-    }
-    return buffer.chunks.slice(buffer.start);
-}
-function appendWithLimit(target, incoming, limit) {
-    if (limit <= 0) {
-        target.chunks = [];
-        target.start = 0;
-        target.byteLength = 0;
-        return;
-    }
-    if (!incoming || incoming.byteLength === 0) {
-        trimExcess(target, limit);
-        return;
-    }
-    if (incoming.byteLength >= limit) {
-        const trimmed = Buffer.from(incoming.subarray(incoming.byteLength - limit));
-        target.chunks = [trimmed];
-        target.start = 0;
-        target.byteLength = trimmed.byteLength;
-        return;
-    }
-    target.chunks.push(incoming);
-    target.byteLength += incoming.byteLength;
-    trimExcess(target, limit);
-}
-function trimExcess(target, limit) {
-    if (target.byteLength <= limit) {
-        return;
-    }
-    let startIndex = target.start;
-    const chunks = target.chunks;
-    while (target.byteLength > limit && startIndex < chunks.length) {
-        const head = chunks[startIndex];
-        if (!head) {
-            break;
-        }
-        const overflow = target.byteLength - limit;
-        if (head.byteLength <= overflow) {
-            target.byteLength -= head.byteLength;
-            startIndex += 1;
-            continue;
-        }
-        chunks[startIndex] = head.subarray(overflow);
-        target.byteLength -= overflow;
-        break;
-    }
-    target.start = startIndex;
-    if (target.start > 0 && target.start * 2 >= chunks.length) {
-        target.chunks = chunks.slice(target.start);
-        target.start = 0;
-    }
-}
+// Deprecated shim: keep exports stable while stdio tracking moves into packages/orchestrator.
+export * from '../../orchestrator/src/exec/stdio.js';

package/dist/packages/shared/utils/strings.js

@@ -0,0 +1,17 @@
+export function slugify(value, options = {}) {
+    const fallback = typeof options.fallback === 'string' ? options.fallback : 'command';
+    const maxLength = Number.isFinite(options.maxLength)
+        ? Math.max(1, Math.floor(options.maxLength))
+        : 80;
+    const lowercase = options.lowercase ?? false;
+    const pattern = options.pattern ?? /[^a-zA-Z0-9]+/g;
+    const collapseDashes = options.collapseDashes ?? true;
+    const base = lowercase ? value.toLowerCase() : value;
+    const cleaned = base.trim().replace(pattern, '-');
+    const collapsed = collapseDashes ? cleaned.replace(/-+/g, '-') : cleaned;
+    const normalized = collapsed.replace(/^-+|-+$/g, '');
+    if (!normalized) {
+        return fallback;
+    }
+    return normalized.slice(0, maxLength);
+}

package/dist/scripts/design/pipeline/advanced-assets.js

@@ -8,7 +8,7 @@ import { loadDesignContext } from './context.js';
 import { appendApprovals, appendArtifacts, ensureToolkitState, loadDesignRunState, saveDesignRunState, upsertStage } from './state.js';
 import { stageArtifacts } from '../../../orchestrator/src/persistence/ArtifactStager.js';
 import { runDefaultInteractions } from './toolkit/snapshot.js';
-import { loadPlaywright } from './optionalDeps.js';
+import { loadPlaywright } from './optional-deps.js';
 const execFileAsync = promisify(execFile);
 const MOTION_USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36';
 const DEFAULT_CAPTURE_SECONDS = 12;

package/dist/scripts/design/pipeline/context.js

@@ -3,13 +3,13 @@ import { mkdir } from 'node:fs/promises';
 import { loadDesignConfig, designPipelineId } from '../../../packages/shared/config/index.js';
 import { sanitizeTaskId } from '../../../orchestrator/src/persistence/sanitizeTaskId.js';
 import { sanitizeRunId } from '../../../orchestrator/src/persistence/sanitizeRunId.js';
+import { resolveEnvironmentPaths } from '../../lib/run-manifests.js';
 export async function loadDesignContext() {
-    const repoRoot = process.env.CODEX_ORCHESTRATOR_REPO_ROOT ?? process.cwd();
-    const runsRoot = process.env.CODEX_ORCHESTRATOR_RUNS_DIR ?? join(repoRoot, '.runs');
-    const outRoot = process.env.CODEX_ORCHESTRATOR_OUT_DIR ?? join(repoRoot, 'out');
+    const { repoRoot, runsRoot, outRoot } = resolveEnvironmentPaths();
     const taskId = sanitizeTaskId(process.env.CODEX_ORCHESTRATOR_TASK_ID ?? process.env.MCP_RUNNER_TASK_ID ?? 'unknown-task');
-    const runId = process.env.CODEX_ORCHESTRATOR_RUN_ID ?? 'run-local';
-    const runDir = process.env.CODEX_ORCHESTRATOR_RUN_DIR ?? join(runsRoot, taskId, sanitizeRunId(runId));
+    const rawRunId = process.env.CODEX_ORCHESTRATOR_RUN_ID ?? 'run-local';
+    const runId = sanitizeRunId(rawRunId);
+    const runDir = process.env.CODEX_ORCHESTRATOR_RUN_DIR ?? join(runsRoot, taskId, runId);
     const manifestPath = process.env.CODEX_ORCHESTRATOR_MANIFEST_PATH ?? join(runDir, 'manifest.json');
     const designConfigPath = process.env.DESIGN_CONFIG_PATH ?? join(repoRoot, 'design.config.yaml');
     const config = await loadDesignConfig({ rootDir: repoRoot, filePath: designConfigPath });

package/dist/scripts/design/pipeline/extract.js

@@ -4,7 +4,8 @@ import { tmpdir } from 'node:os';
 import { loadDesignContext } from './context.js';
 import { appendArtifacts, loadDesignRunState, saveDesignRunState, upsertStage } from './state.js';
 import { stageArtifacts } from '../../../orchestrator/src/persistence/ArtifactStager.js';
-import { loadPlaywright } from './optionalDeps.js';
+import { slugify as sharedSlugify } from '../../../packages/shared/utils/strings.js';
+import { loadPlaywright } from './optional-deps.js';
 async function main() {
     const context = await loadDesignContext();
     const state = await loadDesignRunState(context.statePath);
@@ -232,11 +233,13 @@ function defaultBreakpoints() {
     ];
 }
 function slugify(value) {
-    return value
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, '-')
-        .replace(/^-+|-+$/g, '')
-        .slice(0, 60) || 'capture';
+    return sharedSlugify(value, {
+        fallback: 'capture',
+        maxLength: 60,
+        lowercase: true,
+        pattern: /[^a-z0-9]+/g,
+        collapseDashes: true
+    });
 }
 function sanitizeSegment(value) {
     const slug = slugify(value);

package/dist/scripts/design/pipeline/{optionalDeps.js → optional-deps.js}

@@ -4,18 +4,17 @@ import { join } from 'node:path';
 import { pathToFileURL } from 'node:url';
 const DESIGN_SETUP_HINT = 'Run "npm run setup:design-tools" and "npx playwright install" to enable design tooling.';
 function isModuleNotFound(error) {
-    const candidate = error;
-    if (!candidate) {
+    if (!error) {
         return false;
     }
-    const message = candidate.message ?? '';
-    return (candidate.code === 'ERR_MODULE_NOT_FOUND' ||
-        candidate.code === 'MODULE_NOT_FOUND' ||
+    const message = error.message ?? '';
+    return (error.code === 'ERR_MODULE_NOT_FOUND' ||
+        error.code === 'MODULE_NOT_FOUND' ||
         message.includes('Cannot find package') ||
         message.includes('Cannot find module'));
 }
-function missingDependency(specifier) {
-    return new Error(`[design-tools] Missing optional dependency "${specifier}". ${DESIGN_SETUP_HINT}`);
+function missingDependency(specifier, label, hint) {
+    return new Error(`[${label}] Missing optional dependency "${specifier}". ${hint}`);
 }
 function resolveWithRequire(specifier, base) {
     try {
@@ -62,46 +61,58 @@ function toModuleUrl(resolved) {
     }
     return pathToFileURL(resolved).href;
 }
-async function loadOptionalDependency(specifier) {
+async function loadOptionalDependency(specifier, label, hint) {
     const resolved = resolveOptionalDependency(specifier);
     if (!resolved) {
-        throw missingDependency(specifier);
+        throw missingDependency(specifier, label, hint);
     }
     try {
-        return (await import(toModuleUrl(resolved)));
+        return await import(toModuleUrl(resolved));
     }
     catch (error) {
         if (isModuleNotFound(error)) {
-            throw missingDependency(specifier);
+            throw missingDependency(specifier, label, hint);
         }
         throw error;
     }
 }
-let playwrightPromise = null;
-let pngPromise = null;
-let pixelmatchPromise = null;
-let cheerioPromise = null;
-export async function loadPlaywright() {
-    if (!playwrightPromise) {
-        playwrightPromise = loadOptionalDependency('playwright');
-    }
-    return playwrightPromise;
-}
-export async function loadPngjs() {
-    if (!pngPromise) {
-        pngPromise = loadOptionalDependency('pngjs');
-    }
-    return pngPromise;
-}
-export async function loadPixelmatch() {
-    if (!pixelmatchPromise) {
-        pixelmatchPromise = loadOptionalDependency('pixelmatch');
-    }
-    return pixelmatchPromise;
-}
-export async function loadCheerio() {
-    if (!cheerioPromise) {
-        cheerioPromise = loadOptionalDependency('cheerio');
-    }
-    return cheerioPromise;
+export function createOptionalDependencyLoader({ label, hint }) {
+    let playwrightPromise = null;
+    let pngPromise = null;
+    let pixelmatchPromise = null;
+    let cheerioPromise = null;
+    return {
+        async loadPlaywright() {
+            if (!playwrightPromise) {
+                playwrightPromise = loadOptionalDependency('playwright', label, hint);
+            }
+            return playwrightPromise;
+        },
+        async loadPngjs() {
+            if (!pngPromise) {
+                pngPromise = loadOptionalDependency('pngjs', label, hint);
+            }
+            return pngPromise;
+        },
+        async loadPixelmatch() {
+            if (!pixelmatchPromise) {
+                pixelmatchPromise = loadOptionalDependency('pixelmatch', label, hint);
+            }
+            return pixelmatchPromise;
+        },
+        async loadCheerio() {
+            if (!cheerioPromise) {
+                cheerioPromise = loadOptionalDependency('cheerio', label, hint);
+            }
+            return cheerioPromise;
+        }
+    };
 }
+const designLoader = createOptionalDependencyLoader({
+    label: 'design-tools',
+    hint: DESIGN_SETUP_HINT
+});
+export const loadPlaywright = designLoader.loadPlaywright;
+export const loadPngjs = designLoader.loadPngjs;
+export const loadPixelmatch = designLoader.loadPixelmatch;
+export const loadCheerio = designLoader.loadCheerio;

package/dist/scripts/design/pipeline/permit.js

@@ -0,0 +1,59 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+export async function loadPermitFile(repoRoot) {
+    const permitPath = join(repoRoot, 'compliance', 'permit.json');
+    try {
+        const raw = await readFile(permitPath, 'utf8');
+        return { status: 'found', permit: JSON.parse(raw), path: permitPath, error: null };
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT') {
+            return { status: 'missing', permit: { allowedSources: [] }, path: permitPath, error: null };
+        }
+        return {
+            status: 'error',
+            permit: null,
+            path: permitPath,
+            error: error?.message ?? String(error)
+        };
+    }
+}
+export function buildAllowedOriginSet(permit) {
+    const allowed = new Set();
+    const sources = Array.isArray(permit?.allowedSources) ? permit.allowedSources : [];
+    for (const entry of sources) {
+        if (!entry || typeof entry.origin !== 'string') {
+            continue;
+        }
+        try {
+            allowed.add(new URL(entry.origin).origin);
+        }
+        catch {
+            continue;
+        }
+    }
+    return allowed;
+}
+export function findPermitEntry(permit, origin) {
+    const sources = Array.isArray(permit?.allowedSources) ? permit.allowedSources : [];
+    let originKey = origin;
+    try {
+        originKey = new URL(origin).origin;
+    }
+    catch {
+        // ignore invalid origin
+    }
+    return (sources.find((entry) => entry?.origin === originKey) ??
+        sources.find((entry) => {
+            if (!entry?.origin) {
+                return false;
+            }
+            try {
+                return new URL(entry.origin).origin === originKey;
+            }
+            catch {
+                return false;
+            }
+        }) ??
+        null);
+}

package/dist/scripts/design/pipeline/toolkit/common.js

@@ -1,31 +1,18 @@
-import { readFile } from 'node:fs/promises';
-import { join } from 'node:path';
+import { buildAllowedOriginSet, loadPermitFile } from '../permit.js';
+import { slugify as sharedSlugify } from '../../../../packages/shared/utils/strings.js';
 export async function loadToolkitPermit(repoRoot) {
-    const permitPath = join(repoRoot, 'compliance', 'permit.json');
-    try {
-        const raw = await readFile(permitPath, 'utf8');
-        return JSON.parse(raw);
+    const permitResult = await loadPermitFile(repoRoot);
+    if (permitResult.status === 'missing') {
+        console.warn('[design-toolkit] compliance/permit.json not found; proceeding without permit enforcement');
+        return { allowedSources: [] };
     }
-    catch (error) {
-        const nodeError = error;
-        if (nodeError?.code === 'ENOENT') {
-            console.warn('[design-toolkit] compliance/permit.json not found; proceeding without permit enforcement');
-            return { allowedSources: [] };
-        }
-        throw error;
+    if (permitResult.status === 'error') {
+        throw new Error(permitResult.error ?? 'Unable to read compliance/permit.json');
     }
+    return permitResult.permit ?? { allowedSources: [] };
 }
 export function ensureSourcePermitted(url, permit) {
-    const allowed = new Set((permit.allowedSources ?? [])
-        .map((entry) => {
-        try {
-            return new URL(entry.origin).origin;
-        }
-        catch {
-            return null;
-        }
-    })
-        .filter((origin) => Boolean(origin)));
+    const allowed = buildAllowedOriginSet(permit);
     const origin = new URL(url).origin;
     if (allowed.size === 0 || allowed.has(origin)) {
         return true;
@@ -64,15 +51,14 @@ export function buildRetentionMetadata(retention, now) {
     };
 }
 export function slugifyToolkitValue(value, index) {
-    const normalized = value
-        .toLowerCase()
-        .replace(/[^a-z0-9-_]+/g, '-')
-        .replace(/^-+|-+$/g, '')
-        .slice(0, 48);
-    if (normalized.length > 0) {
-        return normalized;
-    }
-    return `source-${index + 1}`;
+    const normalized = sharedSlugify(value, {
+        fallback: '',
+        maxLength: 48,
+        lowercase: true,
+        pattern: /[^a-z0-9-_]+/g,
+        collapseDashes: false
+    });
+    return normalized.length > 0 ? normalized : `source-${index + 1}`;
 }
 function defaultBreakpoints() {
     return [

package/dist/scripts/design/pipeline/toolkit/reference.js

@@ -2,7 +2,7 @@ import { access, cp, mkdir, readFile, readdir, symlink, writeFile } from 'node:f
 import { dirname, isAbsolute, join, relative } from 'node:path';
 import { tmpdir } from 'node:os';
 import { pathToFileURL } from 'node:url';
-import { loadPixelmatch, loadPlaywright, loadPngjs } from '../optionalDeps.js';
+import { loadPixelmatch, loadPlaywright, loadPngjs } from '../optional-deps.js';
 import { loadDesignContext } from '../context.js';
 import { appendApprovals, appendToolkitArtifacts, ensureToolkitState, loadDesignRunState, saveDesignRunState, upsertStage, upsertToolkitContext } from '../state.js';
 import { stageArtifacts } from '../../../../orchestrator/src/persistence/ArtifactStager.js';

package/dist/scripts/design/pipeline/toolkit/snapshot.js

@@ -1,5 +1,5 @@
 import { Buffer } from 'node:buffer';
-import { loadCheerio, loadPlaywright } from '../optionalDeps.js';
+import { loadCheerio, loadPlaywright } from '../optional-deps.js';
 const DEFAULT_MAX_STYLESHEETS = 24;
 const DEFAULT_VIEWPORT = { width: 1440, height: 900 };
 const USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36';

package/dist/scripts/design/pipeline/visual-regression.js

@@ -1,11 +1,11 @@
 import { spawn } from 'node:child_process';
-import { access, mkdir, readFile, writeFile } from 'node:fs/promises';
-import { constants } from 'node:fs';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { join, relative } from 'node:path';
 import { tmpdir } from 'node:os';
 import { loadDesignContext } from './context.js';
 import { appendArtifacts, loadDesignRunState, saveDesignRunState, upsertStage } from './state.js';
 import { stageArtifacts } from '../../../orchestrator/src/persistence/ArtifactStager.js';
+import { pathExists } from '../../lib/docs-helpers.js';
 const DESIGN_SYSTEM_DIR = 'packages/design-system';
 const SUMMARY_FILE = join(DESIGN_SYSTEM_DIR, '.codex', 'visual-regression-summary.json');
 async function main() {
@@ -75,15 +75,6 @@ async function main() {
     const statusText = exitCode === 0 ? 'passed' : 'failed';
     console.log(`[design-visual-regression] ${statusText}; summary staged at ${staged.path}`);
 }
-async function pathExists(path) {
-    try {
-        await access(path, constants.F_OK);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
 async function runVisualRegression() {
     return new Promise((resolve) => {
         const child = spawn('npm', ['--prefix', DESIGN_SYSTEM_DIR, 'run', 'test:visual'], {