@the-open-engine/zeroshot 6.38.1 → 6.39.1

package/src/isolation-manager.js

@@ -34,6 +34,14 @@ const { resolveProviderCredentialPaths } = require('../lib/provider-credential-p
 const { getProvider } = require('./providers');
 const { readRepoSettings } = require('../lib/repo-settings');
 const { provisionClaudeCredentials } = require('./claude-credentials');
+const {
+  CopyContainmentError,
+  copyErrorFromPayload,
+  createCopyBoundary,
+  resolveCopyPath,
+  resolveSourcePath,
+  validateRelativePath,
+} = require('./copy-containment');
 
 const DEFAULT_WORKTREE_SETUP_TIMEOUT_MS = 15 * 60 * 1000;
 const FRESH_BASE_REF_PREFIX = 'refs/zeroshot/base-fetch';
@@ -1298,6 +1306,7 @@ class IsolationManager {
     // Phase 1: Collect all files and directories
     const files = [];
     const directories = new Set();
+    const copyBoundary = createCopyBoundary(src, dest);
 
     const shouldIgnoreFsError = (err) =>
       err.code === 'EACCES' || err.code === 'EPERM' || err.code === 'ENOENT';
@@ -1328,12 +1337,13 @@ class IsolationManager {
       }
     };
 
-    function handleEntry(entry, srcPath, relPath, relativePath) {
+    function handleEntry(entry, relPath, relativePath, ancestorDirectories) {
       if (entry.isSymbolicLink()) {
-        const targetStats = fs.statSync(srcPath);
+        const resolvedSourcePath = resolveSourcePath(copyBoundary, relPath);
+        const targetStats = fs.statSync(resolvedSourcePath);
         if (targetStats.isDirectory()) {
           directories.add(relPath);
-          collectFiles(srcPath, relPath);
+          collectFiles(relPath, ancestorDirectories);
           return;
         }
 
@@ -1344,7 +1354,7 @@ class IsolationManager {
 
       if (entry.isDirectory()) {
         directories.add(relPath);
-        collectFiles(srcPath, relPath);
+        collectFiles(relPath, ancestorDirectories);
         return;
       }
 
@@ -1352,7 +1362,15 @@ class IsolationManager {
       ensureParentDirTracked(relativePath);
     }
 
-    function collectFiles(currentSrc, relativePath = '') {
+    function collectFiles(relativePath = '', ancestorDirectories = new Set()) {
+      const currentSrc = relativePath
+        ? resolveSourcePath(copyBoundary, relativePath)
+        : copyBoundary.sourceRoot.canonicalPath;
+      if (ancestorDirectories.has(currentSrc)) {
+        throw new CopyContainmentError(relativePath, 'source directory symlink creates a cycle');
+      }
+      const childAncestors = new Set(ancestorDirectories);
+      childAncestors.add(currentSrc);
       const entries = readEntries(currentSrc);
 
       for (const entry of entries) {
@@ -1360,11 +1378,11 @@ class IsolationManager {
           continue;
         }
 
-        const srcPath = path.join(currentSrc, entry.name);
-        const relPath = relativePath ? path.join(relativePath, entry.name) : entry.name;
+        const entryName = validateRelativePath(entry.name);
+        const relPath = relativePath ? path.join(relativePath, entryName) : entryName;
 
         try {
-          handleEntry(entry, srcPath, relPath, relativePath);
+          handleEntry(entry, relPath, relativePath, childAncestors);
         } catch (err) {
           if (shouldIgnoreFsError(err)) {
             continue;
@@ -1374,7 +1392,7 @@ class IsolationManager {
       }
     }
 
-    collectFiles(src);
+    collectFiles();
 
     // Phase 2: Create directory structure (sequential - must exist before file copy)
     // Sort directories by depth to ensure parents are created before children
@@ -1385,7 +1403,7 @@ class IsolationManager {
     });
 
     for (const dir of sortedDirs) {
-      const destDir = path.join(dest, dir);
+      const { destinationPath: destDir } = resolveCopyPath(copyBoundary, dir);
       try {
         fs.mkdirSync(destDir, { recursive: true });
       } catch (err) {
@@ -1399,10 +1417,9 @@ class IsolationManager {
     // For small file counts (<100), use synchronous copy (worker overhead not worth it)
     if (files.length < 100) {
       for (const relPath of files) {
-        const srcPath = path.join(src, relPath);
-        const destPath = path.join(dest, relPath);
         try {
-          fs.copyFileSync(srcPath, destPath);
+          const { sourcePath, destinationPath } = resolveCopyPath(copyBoundary, relPath);
+          fs.copyFileSync(sourcePath, destinationPath);
         } catch (err) {
           if (err.code !== 'EACCES' && err.code !== 'EPERM' && err.code !== 'ENOENT') {
             throw err;
@@ -1424,18 +1441,22 @@ class IsolationManager {
     }
 
     // Spawn workers and wait for completion
+    const workers = [];
     const workerPromises = chunks.map((chunk) => {
       return new Promise((resolve, reject) => {
         const worker = new Worker(workerPath, {
           workerData: {
             files: chunk,
-            sourceBase: src,
-            destBase: dest,
+            sourceBase: copyBoundary.sourceRoot.canonicalPath,
+            destBase: copyBoundary.destinationRoot.canonicalPath,
+            expectedBoundary: copyBoundary,
           },
         });
+        workers.push(worker);
+        let result = null;
 
-        worker.on('message', (result) => {
-          resolve(result);
+        worker.on('message', (workerResult) => {
+          result = workerResult;
         });
 
         worker.on('error', (err) => {
@@ -1445,6 +1466,12 @@ class IsolationManager {
         worker.on('exit', (code) => {
           if (code !== 0) {
             reject(new Error(`Worker exited with code ${code}`));
+          } else if (!result) {
+            reject(new Error('Copy worker exited without reporting a result'));
+          } else if (result.error) {
+            reject(copyErrorFromPayload(result.error));
+          } else {
+            resolve(result);
           }
         });
       });
@@ -1453,7 +1480,12 @@ class IsolationManager {
     // Wait for all workers to complete (proper async/await - no busy-wait!)
     // FIX: Previous version used busy-wait which blocked the event loop,
     // preventing worker thread messages from being processed (timeout bug)
-    await Promise.all(workerPromises);
+    try {
+      await Promise.all(workerPromises);
+    } catch (err) {
+      await Promise.all(workers.map((worker) => worker.terminate().catch(() => undefined)));
+      throw err;
+    }
   }
 
   /**
@@ -2383,8 +2415,15 @@ class IsolationManager {
     // NEVER pass --volumes (irreversible data loss) and NEVER tear down a pinned/shared
     // Compose project — only a project scoped to the worktree directory basename, which is
     // the only kind zeroshot could itself have created, is touched.
-    const { resolveWorktreeComposeTeardown } = require('../lib/compose-utils');
-    const teardown = resolveWorktreeComposeTeardown(worktreeInfo.path);
+    let teardown = { shouldTeardown: false };
+    try {
+      const { resolveWorktreeComposeTeardown } = require('../lib/compose-utils');
+      teardown = resolveWorktreeComposeTeardown(worktreeInfo.path);
+    } catch (error) {
+      console.warn(
+        `[IsolationManager] Skipping Docker Compose teardown in ${worktreeInfo.path}: ${error.message}`
+      );
+    }
     if (teardown.shouldTeardown) {
       try {
         runSync('docker', teardown.args, {

package/src/ledger-sequence.js

@@ -1,63 +1,60 @@
+"use strict";
 const MAX_SQLITE_ROWID = 9223372036854775807n;
 const CANONICAL_SEQUENCE = /^(0|[1-9][0-9]*)$/;
-
 function canonicalMessageSequence(value, name = 'message sequence') {
-  let sequence;
-  if (typeof value === 'string' && CANONICAL_SEQUENCE.test(value)) {
-    sequence = value;
-  } else if (Number.isSafeInteger(value) && value >= 0) {
-    // Accept legacy JSON state while normalizing every new boundary to a
-    // JSON-safe decimal string.
-    sequence = String(value);
-  } else {
-    throw new TypeError(`${name} must be a canonical non-negative decimal string`);
-  }
-
-  if (BigInt(sequence) > MAX_SQLITE_ROWID) {
-    throw new RangeError(`${name} exceeds the SQLite rowid range`);
-  }
-  return sequence;
+    let sequence;
+    if (typeof value === 'string' && CANONICAL_SEQUENCE.test(value)) {
+        sequence = value;
+    }
+    else if (typeof value === 'number' && Number.isSafeInteger(value) && value >= 0) {
+        // Accept legacy JSON state while normalizing every new boundary to a
+        // JSON-safe decimal string.
+        sequence = String(value);
+    }
+    else {
+        throw new TypeError(`${name} must be a canonical non-negative decimal string`);
+    }
+    if (BigInt(sequence) > MAX_SQLITE_ROWID) {
+        throw new RangeError(`${name} exceeds the SQLite rowid range`);
+    }
+    return sequence;
 }
-
 function messageSequenceFromSql(value, name = 'message sequence') {
-  if (typeof value === 'bigint') {
-    if (value < 0n || value > MAX_SQLITE_ROWID) {
-      throw new RangeError(`${name} is outside the SQLite rowid range`);
+    if (typeof value === 'bigint') {
+        if (value < 0n || value > MAX_SQLITE_ROWID) {
+            throw new RangeError(`${name} is outside the SQLite rowid range`);
+        }
+        return value.toString();
     }
-    return value.toString();
-  }
-  return canonicalMessageSequence(value, name);
+    return canonicalMessageSequence(value, name);
 }
-
 function messageSequenceToSql(value, name = 'message sequence') {
-  return BigInt(canonicalMessageSequence(value, name));
+    return BigInt(canonicalMessageSequence(value, name));
 }
-
 function compareMessageSequences(left, right) {
-  const leftValue = messageSequenceToSql(left, 'left message sequence');
-  const rightValue = messageSequenceToSql(right, 'right message sequence');
-  if (leftValue < rightValue) {
-    return -1;
-  }
-  if (leftValue > rightValue) {
-    return 1;
-  }
-  return 0;
+    const leftValue = messageSequenceToSql(left, 'left message sequence');
+    const rightValue = messageSequenceToSql(right, 'right message sequence');
+    if (leftValue < rightValue) {
+        return -1;
+    }
+    if (leftValue > rightValue) {
+        return 1;
+    }
+    return 0;
 }
-
 function tryCanonicalMessageSequence(value) {
-  try {
-    return canonicalMessageSequence(value);
-  } catch {
-    return null;
-  }
+    try {
+        return canonicalMessageSequence(value);
+    }
+    catch {
+        return null;
+    }
 }
-
 module.exports = {
-  MAX_SQLITE_ROWID,
-  canonicalMessageSequence,
-  compareMessageSequences,
-  messageSequenceFromSql,
-  messageSequenceToSql,
-  tryCanonicalMessageSequence,
+    MAX_SQLITE_ROWID,
+    canonicalMessageSequence,
+    compareMessageSequences,
+    messageSequenceFromSql,
+    messageSequenceToSql,
+    tryCanonicalMessageSequence,
 };

package/src/ledger-sequence.ts

@@ -0,0 +1,63 @@
+const MAX_SQLITE_ROWID = 9223372036854775807n;
+const CANONICAL_SEQUENCE = /^(0|[1-9][0-9]*)$/;
+
+function canonicalMessageSequence(value: unknown, name = 'message sequence'): string {
+  let sequence: string;
+  if (typeof value === 'string' && CANONICAL_SEQUENCE.test(value)) {
+    sequence = value;
+  } else if (typeof value === 'number' && Number.isSafeInteger(value) && value >= 0) {
+    // Accept legacy JSON state while normalizing every new boundary to a
+    // JSON-safe decimal string.
+    sequence = String(value);
+  } else {
+    throw new TypeError(`${name} must be a canonical non-negative decimal string`);
+  }
+
+  if (BigInt(sequence) > MAX_SQLITE_ROWID) {
+    throw new RangeError(`${name} exceeds the SQLite rowid range`);
+  }
+  return sequence;
+}
+
+function messageSequenceFromSql(value: unknown, name = 'message sequence'): string {
+  if (typeof value === 'bigint') {
+    if (value < 0n || value > MAX_SQLITE_ROWID) {
+      throw new RangeError(`${name} is outside the SQLite rowid range`);
+    }
+    return value.toString();
+  }
+  return canonicalMessageSequence(value, name);
+}
+
+function messageSequenceToSql(value: unknown, name = 'message sequence'): bigint {
+  return BigInt(canonicalMessageSequence(value, name));
+}
+
+function compareMessageSequences(left: unknown, right: unknown): -1 | 0 | 1 {
+  const leftValue = messageSequenceToSql(left, 'left message sequence');
+  const rightValue = messageSequenceToSql(right, 'right message sequence');
+  if (leftValue < rightValue) {
+    return -1;
+  }
+  if (leftValue > rightValue) {
+    return 1;
+  }
+  return 0;
+}
+
+function tryCanonicalMessageSequence(value: unknown): string | null {
+  try {
+    return canonicalMessageSequence(value);
+  } catch {
+    return null;
+  }
+}
+
+export = {
+  MAX_SQLITE_ROWID,
+  canonicalMessageSequence,
+  compareMessageSequences,
+  messageSequenceFromSql,
+  messageSequenceToSql,
+  tryCanonicalMessageSequence,
+};

package/src/legacy-lib/clusters-registry.ts

@@ -0,0 +1,40 @@
+/**
+ * Single read/write path for clusters.json.
+ *
+ * All callers that need the raw registry (Orchestrator, id-detector, gc,
+ * socket-discovery, CLI) go through readClustersFileSync/writeClustersFileAtomic
+ * instead of ad-hoc JSON.parse(fs.readFileSync(...)) / fs.writeFileSync(...).
+ *
+ * Writes are atomic (temp file + rename) so a reader can never observe a
+ * partially-written file, even without taking the write lock. Callers that
+ * read-modify-write (Orchestrator._saveClusters) still need proper-lockfile
+ * around the whole operation to avoid losing concurrent updates.
+ */
+
+import fs = require('fs');
+import path = require('path');
+
+function clustersFilePath(storageDir: string): string {
+  return path.join(storageDir, 'clusters.json');
+}
+
+/** Read clusters.json. Returns an empty registry if the file is missing. */
+function readClustersFileSync(storageDir: string): unknown {
+  const clustersFile = clustersFilePath(storageDir);
+  if (!fs.existsSync(clustersFile)) {
+    return {};
+  }
+  const raw = fs.readFileSync(clustersFile, 'utf8');
+  const parsed: unknown = JSON.parse(raw);
+  return parsed;
+}
+
+/** Write clusters.json atomically through a process-scoped temporary file. */
+function writeClustersFileAtomic(storageDir: string, data: unknown): void {
+  const clustersFile = clustersFilePath(storageDir);
+  const tmpPath = `${clustersFile}.tmp-${process.pid}`;
+  fs.writeFileSync(tmpPath, JSON.stringify(data, null, 2));
+  fs.renameSync(tmpPath, clustersFile);
+}
+
+export = { clustersFilePath, readClustersFileSync, writeClustersFileAtomic };

package/src/legacy-lib/completion.ts

@@ -0,0 +1,148 @@
+import os = require('os');
+import path = require('path');
+import type { Command, Option } from 'commander';
+import omelette = require('omelette');
+import clustersRegistry = require('./clusters-registry');
+
+interface ClustersRegistryFacade {
+  readClustersFileSync(storageDir: string): unknown;
+}
+
+interface CompletionDependencies {
+  listClusterIds?: () => unknown;
+}
+
+const { readClustersFileSync }: ClustersRegistryFacade = clustersRegistry;
+
+const CLUSTER_ID_COMMANDS = new Set([
+  'attach',
+  'export',
+  'finish',
+  'kill',
+  'logs',
+  'resume',
+  'status',
+  'stop',
+]);
+
+function commandNames(command: Command): string[] {
+  return [command.name(), ...command.aliases()];
+}
+
+function visibleCommands(command: Command): Command[] {
+  return command.createHelp().visibleCommands(command);
+}
+
+function visibleOptions(command: Command): Option[] {
+  return command.createHelp().visibleOptions(command);
+}
+
+function optionNames(option: Option): string[] {
+  return [option.short, option.long].filter((name): name is string => Boolean(name));
+}
+
+function findSubcommand(command: Command, token: string): Command | undefined {
+  return visibleCommands(command).find((candidate) => commandNames(candidate).includes(token));
+}
+
+function findOption(command: Command, token: string): Option | undefined {
+  const optionToken = token.split('=', 1)[0] ?? '';
+  return visibleOptions(command).find((option) => optionNames(option).includes(optionToken));
+}
+
+function parseCompletionLine(line: string): { completed: string[]; current: string } {
+  const trailingSpace = /\s$/.test(line);
+  const tokens = line.trim().split(/\s+/).filter(Boolean);
+  tokens.shift();
+  const current = trailingSpace ? '' : (tokens.pop() ?? '');
+  return { completed: tokens, current };
+}
+
+function resolveCommandContext(
+  program: Command,
+  tokens: string[]
+): { command: Command; commandPath: string } {
+  let command = program;
+  const pathParts: string[] = [];
+  let expectsOptionValue = false;
+  let sawPositional = false;
+
+  for (const token of tokens) {
+    if (expectsOptionValue) {
+      expectsOptionValue = false;
+      continue;
+    }
+
+    const option = findOption(command, token);
+    if (option) {
+      expectsOptionValue = !token.includes('=') && (option.required || option.optional);
+      continue;
+    }
+    if (token.startsWith('-')) continue;
+
+    const subcommand = sawPositional ? undefined : findSubcommand(command, token);
+    if (subcommand) {
+      command = subcommand;
+      pathParts.push(subcommand.name());
+      continue;
+    }
+    sawPositional = true;
+  }
+
+  return { command, commandPath: pathParts.join(' ') };
+}
+
+function defaultListClusterIds(): string[] {
+  const homeDir =
+    process.env.ZEROSHOT_HOME || process.env.HOME || process.env.USERPROFILE || os.homedir();
+  const registry = readClustersFileSync(path.join(homeDir, '.zeroshot'));
+  // Preserve the legacy failure behavior if a corrupt registry is not an object.
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+  return Object.keys(registry as object);
+}
+
+function safeDynamicIds(commandPath: string, listClusterIds: () => unknown): string[] {
+  if (!CLUSTER_ID_COMMANDS.has(commandPath)) return [];
+  try {
+    const ids = listClusterIds();
+    if (!Array.isArray(ids)) return [];
+    const unknownIds: unknown[] = ids;
+    return unknownIds.filter((id): id is string => typeof id === 'string' && id.length > 0);
+  } catch {
+    return [];
+  }
+}
+
+function getCompletionCandidates(
+  program: Command,
+  line: string,
+  deps: CompletionDependencies = {}
+): string[] {
+  const { completed, current } = parseCompletionLine(line);
+  const { command, commandPath } = resolveCommandContext(program, completed);
+  const listClusterIds = deps.listClusterIds || defaultListClusterIds;
+  const candidates = [
+    ...visibleCommands(command).flatMap(commandNames),
+    ...visibleOptions(command).flatMap(optionNames),
+    ...safeDynamicIds(commandPath, listClusterIds),
+  ];
+
+  return [...new Set(candidates)].filter((candidate) => candidate.startsWith(current));
+}
+
+function setupCompletion(
+  program: Command,
+  deps: CompletionDependencies = {}
+): ReturnType<typeof omelette> {
+  const complete = omelette('zeroshot');
+  complete.on('complete', (_fragment, data) => {
+    data.reply(getCompletionCandidates(program, data.line, deps));
+  });
+  complete.init();
+  return complete;
+}
+
+export = {
+  getCompletionCandidates,
+  setupCompletion,
+};

package/src/legacy-lib/compose-utils.ts

@@ -0,0 +1,102 @@
+/**
+ * Docker Compose teardown resolution for worktree cleanup.
+ *
+ * Zeroshot never runs `docker compose up` — any compose file found in a worktree
+ * belongs to the target repo, not to zeroshot. Tearing it down is only safe when
+ * the resolved Compose project name is scoped to the worktree directory itself
+ * (i.e. nothing pins it to the host's real, possibly-already-running project).
+ */
+
+import fs = require('fs');
+import path = require('path');
+import yaml = require('js-yaml');
+
+const COMPOSE_FILENAMES = [
+  'docker-compose.yml',
+  'docker-compose.yaml',
+  'compose.yml',
+  'compose.yaml',
+] as const;
+
+interface ComposeTeardownResolution {
+  readonly args?: string[];
+  readonly composePath?: string;
+  readonly reason?: string;
+  readonly shouldTeardown: boolean;
+}
+
+/**
+ * Reproduce Docker Compose's default project-name normalization
+ * (compose-go NormalizeProjectName: lowercase -> keep [a-z0-9_-] -> trim leading '_'/'-').
+ */
+function normalizeComposeProjectName(name: string): string {
+  return name
+    .toLowerCase()
+    .replace(/[^a-z0-9_-]/g, '')
+    .replace(/^[-_]+/, '');
+}
+
+/**
+ * Decide whether it's safe to run `docker compose down` in a worktree, and with what args.
+ * Never includes `--volumes` — automatic cleanup must not delete named volumes.
+ * Skips teardown entirely when the Compose project name is pinned (top-level `name:`
+ * in the compose file, or `COMPOSE_PROJECT_NAME` env var), since that resolves to a
+ * shared/host project zeroshot did not create.
+ */
+function resolveWorktreeComposeTeardown(worktreePath: string): ComposeTeardownResolution {
+  let composePath: string | null = null;
+  for (const filename of COMPOSE_FILENAMES) {
+    const candidate = path.join(worktreePath, filename);
+    if (fs.existsSync(candidate)) {
+      composePath = candidate;
+      break;
+    }
+  }
+
+  if (!composePath) {
+    return { shouldTeardown: false, reason: 'no compose file' };
+  }
+
+  if (
+    typeof process.env.COMPOSE_PROJECT_NAME === 'string' &&
+    process.env.COMPOSE_PROJECT_NAME.trim() !== ''
+  ) {
+    return {
+      shouldTeardown: false,
+      reason: 'pinned compose project name (shared host project)',
+      composePath,
+    };
+  }
+
+  try {
+    const contents = fs.readFileSync(composePath, 'utf8');
+    const parsed = yaml.load(contents);
+    if (parsed && typeof parsed === 'object' && Reflect.get(parsed, 'name')) {
+      return {
+        shouldTeardown: false,
+        reason: 'pinned compose project name (shared host project)',
+        composePath,
+      };
+    }
+  } catch {
+    // Fail safe: if the compose file can't be read/parsed, we cannot confirm project
+    // identity is worktree-scoped, so never tear down.
+    return { shouldTeardown: false, reason: 'compose file unreadable or unparsable', composePath };
+  }
+
+  return {
+    shouldTeardown: true,
+    composePath,
+    args: [
+      'compose',
+      '-p',
+      normalizeComposeProjectName(path.basename(worktreePath)),
+      'down',
+      '--remove-orphans',
+      '--timeout',
+      '10',
+    ],
+  };
+}
+
+export = { resolveWorktreeComposeTeardown, normalizeComposeProjectName };