@the-open-engine/zeroshot 6.39.0 → 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/legacy-lib/detached-startup.ts

@@ -26,6 +26,7 @@ interface RunOptions extends Record<string, unknown> {
   mergeQueue?: unknown;
   pr?: unknown;
   prBase?: unknown;
+  prBody?: unknown;
   ship?: unknown;
   worktree?: unknown;
 }
@@ -236,9 +237,10 @@ async function registerDetachedSetupCluster({
       setupStartedAt: Date.now(),
       setupStage: 'starting',
       autoPr: plan.delivery !== 'none',
-      prOptions: runOptions.prBase
+      prOptions: plan.delivery !== 'none'
         ? {
             prBase: runOptions.prBase,
+            prBody: typeof runOptions.prBody === 'string' ? runOptions.prBody : null,
             mergeQueue: runOptions.mergeQueue || false,
             closeIssue: runOptions.closeIssue || null,
             autoMerge: plan.autoMerge,

package/src/legacy-lib/start-cluster-environment.ts

@@ -10,6 +10,7 @@ interface RunOptions extends Record<string, unknown> {
   mount?: readonly string[] | null;
   noIsolation?: unknown;
   prBase?: unknown;
+  prBody?: unknown;
 }
 
 interface MountSpec {

package/src/legacy-lib/start-cluster-run-options.ts

@@ -28,6 +28,7 @@ interface RunOptions extends Record<string, unknown> {
   noMounts?: unknown;
   pr?: unknown;
   prBase?: unknown;
+  prBody?: unknown;
   preparedWorktree?: unknown;
   requiredQualityGates?: unknown;
   ship?: unknown;
@@ -201,6 +202,7 @@ function buildStartOptionsFromPlan({
     containerHome: optionalValue(options.containerHome),
     forceProvider: optionalValue(forceProvider),
     prBase: environment ? resolvePrBase(options) : optionalValue(options.prBase),
+    prBody: typeof options.prBody === 'string' ? options.prBody : undefined,
     mergeQueue: environment ? resolveMergeQueue(options) : optionalValue(options.mergeQueue),
     closeIssue: environment ? resolveCloseIssue(options) : optionalValue(options.closeIssue),
     ship: plan.delivery === 'ship',

package/src/orchestrator.js

@@ -262,6 +262,7 @@ function buildPrOptions(options, requiredQualityGates) {
     prBase: options.prBase || null,
     mergeQueue: options.mergeQueue || false,
     closeIssue: options.closeIssue || null,
+    prBody: typeof options.prBody === 'string' ? options.prBody : null,
     gitRemote: options.gitRemote || null,
     autoMerge,
     ...(requiredQualityGates.length > 0 ? { requiredQualityGates } : {}),
@@ -2038,6 +2039,7 @@ class Orchestrator {
       prBase: options.prBase,
       mergeQueue: options.mergeQueue,
       closeIssue: options.closeIssue,
+      prBody: options.prBody,
       requiredQualityGates: options.requiredQualityGates,
       autoMerge: resolveRunPlan(options).autoMerge,
       gitRemote: gitContext?.remote || options.gitRemote,
@@ -2155,8 +2157,16 @@ class Orchestrator {
     // 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(worktreePath);
+    let teardown;
+    try {
+      const { resolveWorktreeComposeTeardown } = require('../lib/compose-utils');
+      teardown = resolveWorktreeComposeTeardown(worktreePath);
+    } catch (error) {
+      this._log(
+        `[Orchestrator] Skipping Docker Compose teardown in ${worktreePath}: ${error.message}`
+      );
+      return;
+    }
     if (!teardown.shouldTeardown) {
       if (teardown.composePath) {
         this._log(
@@ -4217,7 +4227,7 @@ Continue from where you left off. Review your previous output to understand what
 
       // Get issue context from ledger
       const issueMsg = cluster.messageBus.ledger.findLast({ topic: 'ISSUE_OPENED' });
-      const issueNumber = issueMsg?.content?.data?.number || 'unknown';
+      const issueNumber = issueMsg?.content?.data?.issue_number || 'unknown';
       const issueTitle = issueMsg?.content?.data?.title || 'Implementation';
 
       // Generate the final prompt in one typed assembly pass. Issue values are

package/src/pr-body-template.js

@@ -0,0 +1,71 @@
+const MAX_PR_BODY_LENGTH = 65536;
+
+function normalizeIssueNumber(value) {
+  const candidate = typeof value === 'number' ? String(value) : value;
+  if (typeof candidate !== 'string') return 'unknown';
+  const trimmed = candidate.trim();
+  return /^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(trimmed) ? trimmed : 'unknown';
+}
+
+function normalizeIssueTitle(value) {
+  if (typeof value !== 'string' || value.trim() === '') return 'Implementation';
+  const normalized = [...value]
+    .map((character) => {
+      const codePoint = character.codePointAt(0);
+      return codePoint < 0x20 || codePoint === 0x7f ? ' ' : character;
+    })
+    .join('')
+    .trim();
+  return normalized || 'Implementation';
+}
+
+function resolveIssueContext(options = {}) {
+  const issueNumber = normalizeIssueNumber(options.issueNumber);
+  const issueTitle = normalizeIssueTitle(options.issueTitle);
+  const issueReference =
+    options.includeIssueReference === false || issueNumber === 'unknown'
+      ? ''
+      : `Closes #${issueNumber}`;
+  return { issueNumber, issueTitle, issueReference };
+}
+
+function normalizePrBodyTemplate(value) {
+  if (value === undefined || value === null) return null;
+  if (typeof value !== 'string') throw new TypeError('PR body template must be a string');
+  if (value.includes('\0')) throw new TypeError('PR body template must not contain NUL bytes');
+  if (value.length > MAX_PR_BODY_LENGTH) {
+    throw new TypeError(`PR body template must not exceed ${MAX_PR_BODY_LENGTH} characters`);
+  }
+  return value;
+}
+
+/**
+ * Render a bounded PR body. Missing issue metadata expands to empty text so
+ * manual tasks never leak internal sentinel values into pull requests.
+ */
+function renderPullRequestBody(template, options = {}) {
+  const issueContext = resolveIssueContext(options);
+  const normalizedTemplate = normalizePrBodyTemplate(template);
+  if (normalizedTemplate === null) return issueContext.issueReference;
+
+  const hasIssue = issueContext.issueNumber !== 'unknown';
+  const substitutions = {
+    '{{issue_number}}': hasIssue ? issueContext.issueNumber : '',
+    '{{issue_title}}': hasIssue ? issueContext.issueTitle : '',
+    '{{issue_reference}}': hasIssue ? issueContext.issueReference : '',
+  };
+  let rendered = normalizedTemplate;
+  for (const [token, replacement] of Object.entries(substitutions)) {
+    rendered = rendered.replaceAll(token, replacement);
+  }
+  if (rendered.length > MAX_PR_BODY_LENGTH) {
+    throw new TypeError(`Rendered PR body must not exceed ${MAX_PR_BODY_LENGTH} characters`);
+  }
+  return rendered;
+}
+
+module.exports = {
+  MAX_PR_BODY_LENGTH,
+  renderPullRequestBody,
+  resolveIssueContext,
+};