@the-open-engine/zeroshot 6.38.1 → 6.39.1

package/src/config-router.ts

@@ -0,0 +1,131 @@
+/**
+ * Config Router - Maps 2D classification to parameterized templates
+ *
+ * Single source of truth for: Complexity × TaskType → { base, params }
+ * Used by both logic-engine.js (trigger evaluation) and agent-wrapper.js (transform scripts)
+ */
+
+interface AgentConfigModule {
+  DEFAULT_MAX_ITERATIONS: number;
+}
+
+function isAgentConfigModule(value: unknown): value is AgentConfigModule {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'DEFAULT_MAX_ITERATIONS' in value &&
+    typeof value.DEFAULT_MAX_ITERATIONS === 'number'
+  );
+}
+
+const agentConfig: unknown = require('./agent/agent-config');
+if (!isAgentConfigModule(agentConfig)) {
+  throw new TypeError('agent-config must export a numeric DEFAULT_MAX_ITERATIONS');
+}
+const { DEFAULT_MAX_ITERATIONS } = agentConfig;
+
+type BaseConfigName = 'debug-workflow' | 'full-workflow' | 'single-worker' | 'worker-validator';
+type ModelLevel = 'level1' | 'level2' | 'level3';
+
+interface ConfigOptions {
+  autoPr?: boolean;
+}
+
+interface ConfigParams {
+  task_type: string;
+  complexity: string;
+  max_tokens: number;
+  max_iterations: number;
+  worker_level?: ModelLevel;
+  validator_level?: ModelLevel;
+  investigator_level?: ModelLevel;
+  fixer_level?: ModelLevel;
+  tester_level?: ModelLevel;
+  planner_level?: ModelLevel;
+  validator_count?: number;
+}
+
+interface RoutedConfig {
+  base: BaseConfigName;
+  params: ConfigParams;
+}
+
+/**
+ * Get cluster config based on complexity and task type
+ */
+function getConfig(
+  complexity: string,
+  taskType: string,
+  options: ConfigOptions = {}
+): RoutedConfig {
+  const isPrMode = options.autoPr === true || process.env.ZEROSHOT_PR === '1';
+
+  const getBase = (): BaseConfigName => {
+    if (taskType === 'DEBUG' && complexity !== 'TRIVIAL') {
+      return 'debug-workflow';
+    }
+    if (complexity === 'TRIVIAL' && isPrMode && taskType !== 'INQUIRY') {
+      return 'worker-validator';
+    }
+    if (complexity === 'TRIVIAL') {
+      return 'single-worker';
+    }
+    if (complexity === 'SIMPLE') {
+      return 'worker-validator';
+    }
+    return 'full-workflow';
+  };
+
+  const getLevel = (role: string): ModelLevel => {
+    if (complexity === 'CRITICAL' && role === 'planner') return 'level3';
+    if (complexity === 'TRIVIAL') return 'level1';
+    return 'level2';
+  };
+
+  const getValidatorCount = (): number => {
+    if (complexity === 'TRIVIAL') return 0;
+    if (complexity === 'SIMPLE') return 1;
+    if (complexity === 'STANDARD') return 2;
+    // CRITICAL uses two-stage validation pipeline (validators loaded dynamically via meta-coordinator)
+    // Setting validator_count=0 signals that inline validators should be skipped
+    if (complexity === 'CRITICAL') return 0;
+    return 1;
+  };
+
+  const getMaxTokens = (): number => {
+    if (complexity === 'TRIVIAL') return 50000;
+    if (complexity === 'SIMPLE') return 100000;
+    if (complexity === 'STANDARD') return 100000;
+    if (complexity === 'CRITICAL') return 150000;
+    return 100000;
+  };
+
+  const base = getBase();
+
+  const params: ConfigParams = {
+    task_type: taskType,
+    complexity,
+    max_tokens: getMaxTokens(),
+    max_iterations: DEFAULT_MAX_ITERATIONS,
+  };
+
+  if (base === 'single-worker') {
+    params.worker_level = getLevel('worker');
+  } else if (base === 'worker-validator') {
+    params.worker_level = getLevel('worker');
+    params.validator_level = getLevel('validator');
+  } else if (base === 'debug-workflow') {
+    params.investigator_level = getLevel('planner');
+    params.fixer_level = getLevel('worker');
+    params.tester_level = getLevel('validator');
+  } else if (base === 'full-workflow') {
+    params.planner_level = getLevel('planner');
+    params.worker_level = getLevel('worker');
+    params.validator_level = getLevel('validator');
+    params.validator_count = getValidatorCount();
+  }
+
+  return { base, params };
+}
+
+export = { getConfig };

package/src/copy-containment.js

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CopyContainmentError = exports.CONTAINMENT_ERROR_CODE = void 0;
+exports.isCopyRecord = isCopyRecord;
+exports.copyErrorCode = copyErrorCode;
+exports.validateRelativePath = validateRelativePath;
+exports.resolveSourcePath = resolveSourcePath;
+exports.createCopyBoundary = createCopyBoundary;
+exports.resolveCopyPath = resolveCopyPath;
+exports.isCopyContainmentError = isCopyContainmentError;
+exports.copyErrorFromPayload = copyErrorFromPayload;
+const fs = require("fs");
+const path = require("path");
+exports.CONTAINMENT_ERROR_CODE = 'ERR_COPY_CONTAINMENT';
+class CopyContainmentError extends Error {
+    code = exports.CONTAINMENT_ERROR_CODE;
+    relativePath;
+    constructor(relativePath, reason) {
+        super(`Copy containment violation for ${JSON.stringify(relativePath)}: ${reason}`);
+        this.name = 'CopyContainmentError';
+        this.relativePath = relativePath;
+    }
+}
+exports.CopyContainmentError = CopyContainmentError;
+function isContained(rootPath, targetPath) {
+    const relative = path.relative(rootPath, targetPath);
+    return (relative === '' ||
+        (!path.isAbsolute(relative) && relative !== '..' && !relative.startsWith(`..${path.sep}`)));
+}
+function containmentError(relativePath, reason, cause) {
+    const error = new CopyContainmentError(relativePath, reason);
+    if (cause !== undefined) {
+        error.cause = cause;
+    }
+    return error;
+}
+function isCopyRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function copyErrorCode(error) {
+    if (isCopyRecord(error) && 'code' in error) {
+        return typeof error.code === 'string' ? error.code : null;
+    }
+    return null;
+}
+function statIdentity(targetPath) {
+    const stats = fs.statSync(targetPath, { bigint: true });
+    return {
+        device: stats.dev.toString(),
+        inode: stats.ino.toString(),
+        directory: stats.isDirectory(),
+    };
+}
+function pinRoot(rootPath, label, expectedRoot) {
+    const requestedPath = path.resolve(rootPath);
+    const canonicalPath = fs.realpathSync.native(requestedPath);
+    const identity = statIdentity(canonicalPath);
+    if (!identity.directory) {
+        throw containmentError('', `${label} root is not a directory`);
+    }
+    const pinnedRoot = {
+        requestedPath,
+        canonicalPath,
+        device: identity.device,
+        inode: identity.inode,
+    };
+    if (expectedRoot &&
+        (expectedRoot.canonicalPath !== pinnedRoot.canonicalPath ||
+            expectedRoot.device !== pinnedRoot.device ||
+            expectedRoot.inode !== pinnedRoot.inode)) {
+        throw containmentError('', `${label} root changed after it was pinned`);
+    }
+    return pinnedRoot;
+}
+function assertPinnedRoot(root, label, relativePath) {
+    let identity;
+    try {
+        identity = statIdentity(root.canonicalPath);
+    }
+    catch (error) {
+        throw containmentError(relativePath, `${label} root can no longer be resolved`, error);
+    }
+    if (identity.device !== root.device || identity.inode !== root.inode || !identity.directory) {
+        throw containmentError(relativePath, `${label} root changed after it was pinned`);
+    }
+}
+function validateRelativePath(relativePath, pathApi = path) {
+    if (typeof relativePath !== 'string' || relativePath.length === 0) {
+        throw containmentError(relativePath, 'path must be a non-empty relative string');
+    }
+    if (relativePath.includes('\0')) {
+        throw containmentError(relativePath, 'path contains a null byte');
+    }
+    if (pathApi.isAbsolute(relativePath) || pathApi.parse(relativePath).root) {
+        throw containmentError(relativePath, 'absolute paths are not allowed');
+    }
+    const components = pathApi.sep === '\\' ? relativePath.split(/[\\/]/) : relativePath.split(pathApi.sep);
+    if (components.some((component) => component === '' || component === '.' || component === '..')) {
+        throw containmentError(relativePath, 'empty, current-directory, and traversal components are not allowed');
+    }
+    return pathApi.normalize(relativePath);
+}
+function resolveSourcePath(boundary, relativePath) {
+    const normalizedPath = validateRelativePath(relativePath);
+    const root = boundary.sourceRoot;
+    assertPinnedRoot(root, 'source', relativePath);
+    const candidatePath = path.resolve(root.canonicalPath, normalizedPath);
+    if (!isContained(root.canonicalPath, candidatePath)) {
+        throw containmentError(relativePath, 'source path escapes its pinned root');
+    }
+    let canonicalPath;
+    try {
+        canonicalPath = fs.realpathSync.native(candidatePath);
+    }
+    catch (error) {
+        if (copyErrorCode(error) === 'ELOOP') {
+            throw containmentError(relativePath, 'source path contains a symlink cycle', error);
+        }
+        throw error;
+    }
+    if (!isContained(root.canonicalPath, canonicalPath)) {
+        throw containmentError(relativePath, 'resolved source path escapes its pinned root');
+    }
+    return canonicalPath;
+}
+function resolveDestinationPath(boundary, relativePath) {
+    const normalizedPath = validateRelativePath(relativePath);
+    const root = boundary.destinationRoot;
+    assertPinnedRoot(root, 'destination', relativePath);
+    const candidatePath = path.resolve(root.canonicalPath, normalizedPath);
+    if (!isContained(root.canonicalPath, candidatePath)) {
+        throw containmentError(relativePath, 'destination path escapes its pinned root');
+    }
+    let existingPath;
+    try {
+        fs.lstatSync(candidatePath);
+        existingPath = candidatePath;
+    }
+    catch (error) {
+        if (copyErrorCode(error) !== 'ENOENT') {
+            throw error;
+        }
+        // The copy pipeline creates directories parent-first in phase two, so the
+        // immediate parent must exist before any mkdir/copy effect is attempted.
+        existingPath = path.dirname(candidatePath);
+    }
+    let canonicalExistingPath;
+    try {
+        canonicalExistingPath = fs.realpathSync.native(existingPath);
+    }
+    catch (error) {
+        throw containmentError(relativePath, 'destination contains an unresolved symlink', error);
+    }
+    if (!isContained(root.canonicalPath, canonicalExistingPath)) {
+        throw containmentError(relativePath, 'resolved destination path escapes its pinned root');
+    }
+    const unresolvedSuffix = path.relative(existingPath, candidatePath);
+    const resolvedPath = unresolvedSuffix
+        ? path.join(canonicalExistingPath, unresolvedSuffix)
+        : canonicalExistingPath;
+    if (!isContained(root.canonicalPath, resolvedPath)) {
+        throw containmentError(relativePath, 'resolved destination path escapes its pinned root');
+    }
+    return resolvedPath;
+}
+function createCopyBoundary(sourceBase, destinationBase, expectedBoundary) {
+    return {
+        sourceRoot: pinRoot(sourceBase, 'source', expectedBoundary?.sourceRoot),
+        destinationRoot: pinRoot(destinationBase, 'destination', expectedBoundary?.destinationRoot),
+    };
+}
+function resolveCopyPath(boundary, relativePath) {
+    return {
+        sourcePath: resolveSourcePath(boundary, relativePath),
+        destinationPath: resolveDestinationPath(boundary, relativePath),
+    };
+}
+function isCopyContainmentError(error) {
+    return isCopyRecord(error) && error.code === exports.CONTAINMENT_ERROR_CODE;
+}
+function copyErrorFromPayload(payload) {
+    const error = payload.code === exports.CONTAINMENT_ERROR_CODE
+        ? new CopyContainmentError(payload.relativePath, 'worker rejected an unsafe path')
+        : new Error(payload.message);
+    error.name = payload.name || error.name;
+    error.message = payload.message;
+    if (payload.code && !(error instanceof CopyContainmentError)) {
+        Object.assign(error, { code: payload.code });
+    }
+    return error;
+}

package/src/copy-containment.ts

@@ -0,0 +1,259 @@
+import fs = require('fs');
+import path = require('path');
+
+export const CONTAINMENT_ERROR_CODE = 'ERR_COPY_CONTAINMENT';
+
+export interface PinnedCopyRoot {
+  requestedPath: string;
+  canonicalPath: string;
+  device: string;
+  inode: string;
+}
+
+export interface CopyBoundary {
+  sourceRoot: PinnedCopyRoot;
+  destinationRoot: PinnedCopyRoot;
+}
+
+interface PathIdentity {
+  device: string;
+  inode: string;
+  directory: boolean;
+}
+
+interface CopyPathApi {
+  isAbsolute(targetPath: string): boolean;
+  normalize(targetPath: string): string;
+  parse(targetPath: string): { root: string };
+  readonly sep: string;
+}
+
+export class CopyContainmentError extends Error {
+  readonly code = CONTAINMENT_ERROR_CODE;
+  readonly relativePath: unknown;
+
+  constructor(relativePath: unknown, reason: string) {
+    super(`Copy containment violation for ${JSON.stringify(relativePath)}: ${reason}`);
+    this.name = 'CopyContainmentError';
+    this.relativePath = relativePath;
+  }
+}
+
+function isContained(rootPath: string, targetPath: string): boolean {
+  const relative = path.relative(rootPath, targetPath);
+  return (
+    relative === '' ||
+    (!path.isAbsolute(relative) && relative !== '..' && !relative.startsWith(`..${path.sep}`))
+  );
+}
+
+function containmentError(
+  relativePath: unknown,
+  reason: string,
+  cause?: unknown
+): CopyContainmentError {
+  const error = new CopyContainmentError(relativePath, reason);
+  if (cause !== undefined) {
+    error.cause = cause;
+  }
+  return error;
+}
+
+export function isCopyRecord(value: unknown): value is Record<PropertyKey, unknown> {
+  return typeof value === 'object' && value !== null;
+}
+
+export function copyErrorCode(error: unknown): string | null {
+  if (isCopyRecord(error) && 'code' in error) {
+    return typeof error.code === 'string' ? error.code : null;
+  }
+  return null;
+}
+
+function statIdentity(targetPath: string): PathIdentity {
+  const stats = fs.statSync(targetPath, { bigint: true });
+  return {
+    device: stats.dev.toString(),
+    inode: stats.ino.toString(),
+    directory: stats.isDirectory(),
+  };
+}
+
+function pinRoot(rootPath: string, label: string, expectedRoot?: PinnedCopyRoot): PinnedCopyRoot {
+  const requestedPath = path.resolve(rootPath);
+  const canonicalPath = fs.realpathSync.native(requestedPath);
+  const identity = statIdentity(canonicalPath);
+
+  if (!identity.directory) {
+    throw containmentError('', `${label} root is not a directory`);
+  }
+
+  const pinnedRoot = {
+    requestedPath,
+    canonicalPath,
+    device: identity.device,
+    inode: identity.inode,
+  };
+
+  if (
+    expectedRoot &&
+    (expectedRoot.canonicalPath !== pinnedRoot.canonicalPath ||
+      expectedRoot.device !== pinnedRoot.device ||
+      expectedRoot.inode !== pinnedRoot.inode)
+  ) {
+    throw containmentError('', `${label} root changed after it was pinned`);
+  }
+
+  return pinnedRoot;
+}
+
+function assertPinnedRoot(root: PinnedCopyRoot, label: string, relativePath: string): void {
+  let identity: PathIdentity;
+  try {
+    identity = statIdentity(root.canonicalPath);
+  } catch (error: unknown) {
+    throw containmentError(relativePath, `${label} root can no longer be resolved`, error);
+  }
+
+  if (identity.device !== root.device || identity.inode !== root.inode || !identity.directory) {
+    throw containmentError(relativePath, `${label} root changed after it was pinned`);
+  }
+}
+
+export function validateRelativePath(relativePath: unknown, pathApi: CopyPathApi = path): string {
+  if (typeof relativePath !== 'string' || relativePath.length === 0) {
+    throw containmentError(relativePath, 'path must be a non-empty relative string');
+  }
+  if (relativePath.includes('\0')) {
+    throw containmentError(relativePath, 'path contains a null byte');
+  }
+  if (pathApi.isAbsolute(relativePath) || pathApi.parse(relativePath).root) {
+    throw containmentError(relativePath, 'absolute paths are not allowed');
+  }
+
+  const components =
+    pathApi.sep === '\\' ? relativePath.split(/[\\/]/) : relativePath.split(pathApi.sep);
+  if (components.some((component) => component === '' || component === '.' || component === '..')) {
+    throw containmentError(
+      relativePath,
+      'empty, current-directory, and traversal components are not allowed'
+    );
+  }
+
+  return pathApi.normalize(relativePath);
+}
+
+export function resolveSourcePath(boundary: CopyBoundary, relativePath: string): string {
+  const normalizedPath = validateRelativePath(relativePath);
+  const root = boundary.sourceRoot;
+  assertPinnedRoot(root, 'source', relativePath);
+
+  const candidatePath = path.resolve(root.canonicalPath, normalizedPath);
+  if (!isContained(root.canonicalPath, candidatePath)) {
+    throw containmentError(relativePath, 'source path escapes its pinned root');
+  }
+
+  let canonicalPath: string;
+  try {
+    canonicalPath = fs.realpathSync.native(candidatePath);
+  } catch (error: unknown) {
+    if (copyErrorCode(error) === 'ELOOP') {
+      throw containmentError(relativePath, 'source path contains a symlink cycle', error);
+    }
+    throw error;
+  }
+
+  if (!isContained(root.canonicalPath, canonicalPath)) {
+    throw containmentError(relativePath, 'resolved source path escapes its pinned root');
+  }
+  return canonicalPath;
+}
+
+function resolveDestinationPath(boundary: CopyBoundary, relativePath: string): string {
+  const normalizedPath = validateRelativePath(relativePath);
+  const root = boundary.destinationRoot;
+  assertPinnedRoot(root, 'destination', relativePath);
+
+  const candidatePath = path.resolve(root.canonicalPath, normalizedPath);
+  if (!isContained(root.canonicalPath, candidatePath)) {
+    throw containmentError(relativePath, 'destination path escapes its pinned root');
+  }
+
+  let existingPath: string;
+  try {
+    fs.lstatSync(candidatePath);
+    existingPath = candidatePath;
+  } catch (error: unknown) {
+    if (copyErrorCode(error) !== 'ENOENT') {
+      throw error;
+    }
+    // The copy pipeline creates directories parent-first in phase two, so the
+    // immediate parent must exist before any mkdir/copy effect is attempted.
+    existingPath = path.dirname(candidatePath);
+  }
+
+  let canonicalExistingPath: string;
+  try {
+    canonicalExistingPath = fs.realpathSync.native(existingPath);
+  } catch (error: unknown) {
+    throw containmentError(relativePath, 'destination contains an unresolved symlink', error);
+  }
+
+  if (!isContained(root.canonicalPath, canonicalExistingPath)) {
+    throw containmentError(relativePath, 'resolved destination path escapes its pinned root');
+  }
+
+  const unresolvedSuffix = path.relative(existingPath, candidatePath);
+  const resolvedPath = unresolvedSuffix
+    ? path.join(canonicalExistingPath, unresolvedSuffix)
+    : canonicalExistingPath;
+  if (!isContained(root.canonicalPath, resolvedPath)) {
+    throw containmentError(relativePath, 'resolved destination path escapes its pinned root');
+  }
+  return resolvedPath;
+}
+
+export function createCopyBoundary(
+  sourceBase: string,
+  destinationBase: string,
+  expectedBoundary?: CopyBoundary
+): CopyBoundary {
+  return {
+    sourceRoot: pinRoot(sourceBase, 'source', expectedBoundary?.sourceRoot),
+    destinationRoot: pinRoot(destinationBase, 'destination', expectedBoundary?.destinationRoot),
+  };
+}
+
+export function resolveCopyPath(
+  boundary: CopyBoundary,
+  relativePath: string
+): { sourcePath: string; destinationPath: string } {
+  return {
+    sourcePath: resolveSourcePath(boundary, relativePath),
+    destinationPath: resolveDestinationPath(boundary, relativePath),
+  };
+}
+
+export function isCopyContainmentError(error: unknown): boolean {
+  return isCopyRecord(error) && error.code === CONTAINMENT_ERROR_CODE;
+}
+
+interface CopyErrorPayload {
+  code?: string | null;
+  relativePath?: unknown;
+  name?: string;
+  message: string;
+}
+
+export function copyErrorFromPayload(payload: CopyErrorPayload): Error {
+  const error =
+    payload.code === CONTAINMENT_ERROR_CODE
+      ? new CopyContainmentError(payload.relativePath, 'worker rejected an unsafe path')
+      : new Error(payload.message);
+  error.name = payload.name || error.name;
+  error.message = payload.message;
+  if (payload.code && !(error instanceof CopyContainmentError)) {
+    Object.assign(error, { code: payload.code });
+  }
+  return error;
+}

package/src/copy-worker.js

@@ -1,43 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * Copy Worker - Worker thread for parallel file copying
  *
  * Handles copying a batch of files from source to destination.
  * Used by IsolationManager._copyDirExcluding() for parallel copying.
  */
-
-const { parentPort, workerData } = require('worker_threads');
-const fs = require('fs');
-const path = require('path');
-
-const { files, sourceBase, destBase } = workerData;
-
+const fs = require("fs");
+const worker_threads_1 = require("worker_threads");
+const copy_containment_1 = require("./copy-containment");
+function isCopyWorkerData(value) {
+    if (!(0, copy_containment_1.isCopyRecord)(value)) {
+        return false;
+    }
+    return (Array.isArray(value.files) &&
+        value.files.every((entry) => typeof entry === 'string') &&
+        typeof value.sourceBase === 'string' &&
+        typeof value.destBase === 'string' &&
+        (0, copy_containment_1.isCopyRecord)(value.expectedBoundary));
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+const rawWorkerData = worker_threads_1.workerData;
+if (!isCopyWorkerData(rawWorkerData)) {
+    throw new TypeError('copy worker requires files, sourceBase, and destBase');
+}
+const { files, sourceBase, destBase, expectedBoundary } = rawWorkerData;
+const copyBoundary = (0, copy_containment_1.createCopyBoundary)(sourceBase, destBase, expectedBoundary);
 let copied = 0;
 let skipped = 0;
-const errors = [];
-
+let error = null;
 for (const relativePath of files) {
-  const srcPath = path.join(sourceBase, relativePath);
-  const destPath = path.join(destBase, relativePath);
-
-  try {
-    // Ensure parent directory exists
-    const destDir = path.dirname(destPath);
-    if (!fs.existsSync(destDir)) {
-      fs.mkdirSync(destDir, { recursive: true });
+    try {
+        // Phase two creates every parent directory. Re-resolve the source and
+        // destination immediately before the only worker filesystem effect.
+        const { sourcePath, destinationPath } = (0, copy_containment_1.resolveCopyPath)(copyBoundary, relativePath);
+        fs.copyFileSync(sourcePath, destinationPath);
+        copied++;
     }
-
-    // Copy the file
-    fs.copyFileSync(srcPath, destPath);
-    copied++;
-  } catch (err) {
-    // Skip files we can't copy (permission denied, broken symlinks, etc.)
-    if (err.code === 'EACCES' || err.code === 'EPERM' || err.code === 'ENOENT') {
-      skipped++;
-      continue;
+    catch (caughtError) {
+        // Skip files we can't copy (permission denied, broken symlinks, etc.)
+        const code = (0, copy_containment_1.copyErrorCode)(caughtError);
+        if (!(0, copy_containment_1.isCopyContainmentError)(caughtError) &&
+            (code === 'EACCES' || code === 'EPERM' || code === 'ENOENT')) {
+            skipped++;
+            continue;
+        }
+        error = {
+            file: relativePath,
+            name: caughtError instanceof Error ? caughtError.name : 'Error',
+            code,
+            message: errorMessage(caughtError),
+            relativePath: (0, copy_containment_1.isCopyRecord)(caughtError) && 'relativePath' in caughtError
+                ? caughtError.relativePath
+                : relativePath,
+        };
+        break;
     }
-    errors.push({ file: relativePath, error: err.message });
-  }
 }
-
 // Report results back to main thread
-parentPort.postMessage({ copied, skipped, errors });
+if (!worker_threads_1.parentPort) {
+    throw new Error('copy worker requires a parent port');
+}
+worker_threads_1.parentPort.postMessage({ copied, skipped, error });