@the-open-engine/zeroshot 6.10.0 → 6.10.2

package/src/task-spawn-cleanup-ownership.js

@@ -0,0 +1,82 @@
+const { randomUUID } = require('node:crypto');
+
+const TASK_SPAWN_OWNERSHIP_TOKEN_ENV = 'ZEROSHOT_TASK_SPAWN_OWNERSHIP_TOKEN';
+
+const COMMAND_CLEANUP_OWNER = Object.freeze({
+  CALLER: 'caller',
+  TASK_LIFECYCLE: 'task-lifecycle',
+});
+
+function normalizeError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+
+/**
+ * Mark a wrapper failure after the detached task record durably accepted the
+ * launch ownership token. Human stdout and process spawn events are not
+ * ownership receipts.
+ */
+function transferCommandCleanupOwnership(error) {
+  const normalized = normalizeError(error);
+  normalized.commandCleanupOwner = COMMAND_CLEANUP_OWNER.TASK_LIFECYCLE;
+  return normalized;
+}
+
+function callerOwnsCommandCleanup(error) {
+  return error?.commandCleanupOwner !== COMMAND_CLEANUP_OWNER.TASK_LIFECYCLE;
+}
+
+function cleanupCallerOwnedCommand(error, cleanup) {
+  if (callerOwnsCommandCleanup(error)) cleanup();
+}
+
+function requireTaskIdFromWrapperResult({
+  code,
+  stdout,
+  stderr,
+  parseTaskId,
+  persistedTaskId = null,
+}) {
+  if (code !== 0) {
+    throw new Error(`zeroshot task run failed with code ${code}: ${stderr}`);
+  }
+  if (!persistedTaskId) {
+    const printedTaskId = parseTaskId(stdout);
+    throw new Error(
+      `Detached task ownership receipt was not persisted${
+        printedTaskId ? ` for wrapper output ${printedTaskId}` : ''
+      }.`
+    );
+  }
+  const printedTaskId = parseTaskId(stdout);
+  if (printedTaskId && printedTaskId !== persistedTaskId) {
+    throw new Error(
+      `Task ownership receipt ${persistedTaskId} did not match wrapper output ${printedTaskId}.`
+    );
+  }
+  return persistedTaskId;
+}
+
+function createTaskSpawnOwnershipToken() {
+  return randomUUID();
+}
+
+function trackTaskWrapperCleanupOwnership(findPersistedTaskId) {
+  return (error) => {
+    try {
+      return findPersistedTaskId() ? transferCommandCleanupOwnership(error) : error;
+    } catch {
+      return transferCommandCleanupOwnership(error);
+    }
+  };
+}
+
+module.exports = {
+  COMMAND_CLEANUP_OWNER,
+  TASK_SPAWN_OWNERSHIP_TOKEN_ENV,
+  cleanupCallerOwnedCommand,
+  callerOwnsCommandCleanup,
+  createTaskSpawnOwnershipToken,
+  requireTaskIdFromWrapperResult,
+  trackTaskWrapperCleanupOwnership,
+};

package/src/worktree-claude-config.js

@@ -3,127 +3,202 @@ const os = require('os');
 const path = require('path');
 
 const { resolveWorktreeRoot } = require('./worktree-tooling-env');
-const { provisionClaudeCredentials } = require('./claude-credentials');
 
 const CLAUDE_DIRNAME = '.claude';
-const SETTINGS_BASENAME = 'settings.json';
 const MCP_BASENAME = '.mcp.json';
+const SETTINGS_BASENAME = 'settings.json';
+const OVERLAY_PREFIX = 'zeroshot-claude-settings-';
+const CLAUDE_SETTINGS_ENV = 'ZEROSHOT_CLAUDE_SETTINGS_FILE';
+const CLAUDE_MCP_CONFIG_ENV = 'ZEROSHOT_CLAUDE_MCP_CONFIG_FILE';
+const ASK_USER_HOOK = 'block-ask-user-question.py';
+const DANGEROUS_GIT_HOOK = 'block-dangerous-git.py';
 
-function isPlainObject(value) {
-  return value && typeof value === 'object' && !Array.isArray(value);
-}
 
-function readJsonIfExists(filePath) {
-  if (!fs.existsSync(filePath)) {
-    return null;
+function readSettings(settingsPath) {
+  if (!fs.existsSync(settingsPath)) {
+    return {};
   }
 
   try {
-    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
-  } catch {
-    return null;
+    return JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+  } catch (error) {
+    throw new Error(`Could not parse Claude settings overlay ${settingsPath}: ${error.message}`);
   }
 }
 
-function mergeJson(baseValue, overrideValue) {
-  if (Array.isArray(baseValue) && Array.isArray(overrideValue)) {
-    const seen = new Set();
-    const merged = [];
-
-    for (const entry of [...baseValue, ...overrideValue]) {
-      const key = JSON.stringify(entry);
-      if (seen.has(key)) {
-        continue;
-      }
-      seen.add(key);
-      merged.push(entry);
-    }
+function writeSettings(settingsPath, settings) {
+  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), { mode: 0o600 });
+}
 
-    return merged;
+function requireTargetClaudeDir(targetClaudeDir) {
+  if (typeof targetClaudeDir !== 'string' || !targetClaudeDir) {
+    throw new Error('Claude safety hooks require an explicit per-run settings directory.');
+  }
+  if (!isClaudeSettingsOverlayDirectory(targetClaudeDir)) {
+    throw new Error(
+      `Claude safety hooks require a Zeroshot-owned Claude settings overlay: ${targetClaudeDir}`
+    );
   }
+  return targetClaudeDir;
+}
 
-  if (isPlainObject(baseValue) && isPlainObject(overrideValue)) {
-    const merged = { ...baseValue };
-    for (const [key, value] of Object.entries(overrideValue)) {
-      if (Object.prototype.hasOwnProperty.call(merged, key)) {
-        merged[key] = mergeJson(merged[key], value);
-      } else {
-        merged[key] = value;
-      }
-    }
-    return merged;
+function copyHookScript(targetClaudeDir, hookScriptName) {
+  const hooksDir = path.join(targetClaudeDir, 'hooks');
+  fs.mkdirSync(hooksDir, { recursive: true });
+
+  const sourcePath = path.join(__dirname, '..', 'cluster-hooks', hookScriptName);
+  if (!fs.existsSync(sourcePath)) {
+    throw new Error(
+      `Claude safety hook ${hookScriptName} is missing from the Zeroshot installation.`
+    );
   }
 
-  return overrideValue === undefined ? baseValue : overrideValue;
+  const destinationPath = path.join(hooksDir, hookScriptName);
+  fs.copyFileSync(sourcePath, destinationPath);
+  fs.chmodSync(destinationPath, 0o755);
+  return destinationPath;
 }
 
-function ensureDir(dirPath) {
-  fs.mkdirSync(dirPath, { recursive: true });
+function ensurePreToolUseHooks(settings) {
+  settings.hooks ||= {};
+  settings.hooks.PreToolUse ||= [];
+  return settings.hooks.PreToolUse;
 }
 
-function resolveRepoClaudeConfig(worktreeRoot) {
-  const configDir = path.join(worktreeRoot, CLAUDE_DIRNAME);
-  const settingsPath = path.join(configDir, SETTINGS_BASENAME);
-  const mcpPath = path.join(configDir, MCP_BASENAME);
+function ensureAskUserQuestionHook(targetClaudeDir) {
+  const overlayDir = requireTargetClaudeDir(targetClaudeDir);
+
+  const hookScriptPath = copyHookScript(overlayDir, ASK_USER_HOOK);
+  const settingsPath = path.join(overlayDir, SETTINGS_BASENAME);
+  const settings = readSettings(settingsPath);
+  const hooks = ensurePreToolUseHooks(settings);
+  const hasHook = hooks.some(
+    (entry) =>
+      entry.matcher === 'AskUserQuestion' ||
+      entry.hooks?.some((hook) => hook.command?.includes(ASK_USER_HOOK))
+  );
+
+  if (!hasHook) {
+    hooks.push({
+      matcher: 'AskUserQuestion',
+      hooks: [{ type: 'command', command: hookScriptPath }],
+    });
+    writeSettings(settingsPath, settings);
+  }
+
+}
 
-  if (!fs.existsSync(settingsPath) && !fs.existsSync(mcpPath)) {
-    return null;
+function ensureDangerousGitHook(targetClaudeDir) {
+  const overlayDir = requireTargetClaudeDir(targetClaudeDir);
+
+  const hookScriptPath = copyHookScript(overlayDir, DANGEROUS_GIT_HOOK);
+  const settingsPath = path.join(overlayDir, SETTINGS_BASENAME);
+  const settings = readSettings(settingsPath);
+  const hooks = ensurePreToolUseHooks(settings);
+  const hasHook = hooks.some(
+    (entry) =>
+      entry.matcher === 'Bash' &&
+      entry.hooks?.some((hook) => hook.command?.includes(DANGEROUS_GIT_HOOK))
+  );
+
+  if (!hasHook) {
+    hooks.push({
+      matcher: 'Bash',
+      hooks: [{ type: 'command', command: hookScriptPath }],
+    });
+    writeSettings(settingsPath, settings);
   }
 
-  return {
-    configDir,
-    settingsPath,
-    mcpPath,
-  };
 }
 
-function prepareClaudeConfigDir(options = {}) {
-  const worktreeRoot = resolveWorktreeRoot(options.worktreePath || options.cwd);
-  if (!worktreeRoot) {
-    return null;
+function prepareClaudeSettingsOverlay(options = {}) {
+  const overlayDir = fs.mkdtempSync(path.join(os.tmpdir(), OVERLAY_PREFIX));
+  fs.chmodSync(overlayDir, 0o700);
+  try {
+    ensureAskUserQuestionHook(overlayDir);
+    if (options.includeDangerousGit) {
+      ensureDangerousGitHook(overlayDir);
+    }
+    return path.join(overlayDir, SETTINGS_BASENAME);
+  } catch (error) {
+    fs.rmSync(overlayDir, { recursive: true, force: true });
+    throw error;
   }
+}
 
-  const repoConfig = resolveRepoClaudeConfig(worktreeRoot);
-  if (!repoConfig) {
-    return null;
+function cleanupClaudeSettingsOverlay(settingsPath) {
+  if (!isCanonicalClaudeSettingsOverlayPath(settingsPath)) {
+    return false;
   }
 
-  const sourceDir =
-    options.sourceDir || process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), CLAUDE_DIRNAME);
-  const tempRoot = path.join(os.tmpdir(), 'zeroshot-claude-configs');
-  ensureDir(tempRoot);
+  const overlayDir = path.dirname(settingsPath);
+  if (!fs.existsSync(overlayDir)) {
+    return true;
+  }
+  if (!isClaudeSettingsOverlayPath(settingsPath)) {
+    return false;
+  }
 
-  const overlayDir = fs.mkdtempSync(path.join(tempRoot, 'config-'));
-  ensureDir(path.join(overlayDir, 'hooks'));
-  ensureDir(path.join(overlayDir, 'projects'));
+  fs.rmSync(overlayDir, { recursive: true, force: true });
+  return true;
+}
 
-  provisionClaudeCredentials({ sourceDir, destDir: overlayDir });
+function isCanonicalClaudeSettingsOverlayPath(settingsPath) {
+  if (typeof settingsPath !== 'string' || !settingsPath) {
+    return false;
+  }
+  const resolvedSettingsPath = path.resolve(settingsPath);
+  const overlayDir = path.dirname(resolvedSettingsPath);
+  return (
+    resolvedSettingsPath === settingsPath &&
+    path.basename(resolvedSettingsPath) === SETTINGS_BASENAME &&
+    path.dirname(overlayDir) === path.resolve(os.tmpdir()) &&
+    path.basename(overlayDir).startsWith(OVERLAY_PREFIX)
+  );
+}
 
-  const sourceSettings = readJsonIfExists(path.join(sourceDir, SETTINGS_BASENAME)) || {};
-  const repoSettings = readJsonIfExists(repoConfig.settingsPath) || {};
-  const mergedSettings = mergeJson(sourceSettings, repoSettings);
-  if (Object.keys(mergedSettings).length > 0) {
-    fs.writeFileSync(
-      path.join(overlayDir, SETTINGS_BASENAME),
-      JSON.stringify(mergedSettings, null, 2)
-    );
+function isClaudeSettingsOverlayPath(settingsPath, platform = process.platform) {
+  if (!isCanonicalClaudeSettingsOverlayPath(settingsPath)) {
+    return false;
   }
 
-  const sourceMcp = readJsonIfExists(path.join(sourceDir, MCP_BASENAME)) || {};
-  const repoMcp = readJsonIfExists(repoConfig.mcpPath) || {};
-  const mergedMcp = mergeJson(sourceMcp, repoMcp);
-  if (Object.keys(mergedMcp).length > 0) {
-    fs.writeFileSync(path.join(overlayDir, MCP_BASENAME), JSON.stringify(mergedMcp, null, 2));
+  const resolvedSettingsPath = path.resolve(settingsPath);
+  const overlayDir = path.dirname(resolvedSettingsPath);
+
+  try {
+    const stat = fs.lstatSync(overlayDir);
+    const ownedByProcess =
+      typeof process.getuid !== 'function' || stat.uid === process.getuid();
+    const privateMode = platform === 'win32' || (stat.mode & 0o777) === 0o700;
+    return stat.isDirectory() && !stat.isSymbolicLink() && ownedByProcess && privateMode;
+  } catch {
+    return false;
   }
+}
 
-  return overlayDir;
+function isCanonicalClaudeSettingsOverlayDirectory(overlayDir) {
+  if (
+    typeof overlayDir !== 'string' ||
+    !overlayDir ||
+    path.resolve(overlayDir) !== overlayDir
+  ) {
+    return false;
+  }
+  return isCanonicalClaudeSettingsOverlayPath(path.join(overlayDir, SETTINGS_BASENAME));
+}
+
+function isClaudeSettingsOverlayDirectory(overlayDir) {
+  if (typeof overlayDir !== 'string' || !overlayDir) {
+    return false;
+  }
+  return isClaudeSettingsOverlayPath(path.join(overlayDir, SETTINGS_BASENAME));
 }
 
 /**
- * Resolve the repo's `.mcp.json` path (the same MCP-server source Claude consumes via
- * prepareClaudeConfigDir) for a given worktree/cwd, or null if none exists. Reused by providers
- * that consume MCP servers through a CLI flag instead of the Claude config-dir overlay (e.g.
- * Copilot's `--additional-mcp-config`), so both providers share one MCP config surface.
+ * Resolve the repo's MCP config for a given worktree/cwd. The project-root
+ * `.mcp.json` is Claude's current convention. `.claude/.mcp.json` remains a
+ * deliberate compatibility fallback for repositories created by Zeroshot's
+ * earlier worktree integration.
  */
 function resolveRepoMcpConfigPath(options = {}) {
   const worktreeRoot = resolveWorktreeRoot(options.worktreePath || options.cwd);
@@ -131,11 +206,44 @@ function resolveRepoMcpConfigPath(options = {}) {
     return null;
   }
 
-  const mcpPath = path.join(worktreeRoot, CLAUDE_DIRNAME, MCP_BASENAME);
-  return fs.existsSync(mcpPath) ? mcpPath : null;
+  const candidates = [
+    path.join(worktreeRoot, MCP_BASENAME),
+    path.join(worktreeRoot, CLAUDE_DIRNAME, MCP_BASENAME),
+  ];
+  return candidates.find((candidate) => fs.existsSync(candidate)) || null;
+}
+
+function resolveContainerMcpConfigPath(options = {}) {
+  const worktreeRoot = resolveWorktreeRoot(options.worktreePath || options.cwd);
+  const hostConfigPath = resolveRepoMcpConfigPath(options);
+  if (!worktreeRoot || !hostConfigPath) {
+    return null;
+  }
+
+  const relativePath = path.relative(worktreeRoot, hostConfigPath);
+  if (
+    !relativePath ||
+    path.isAbsolute(relativePath) ||
+    relativePath === '..' ||
+    relativePath.startsWith(`..${path.sep}`)
+  ) {
+    throw new Error(`Repository MCP config is outside the mounted workspace: ${hostConfigPath}`);
+  }
+
+  return path.posix.join('/workspace', relativePath.split(path.sep).join('/'));
 }
 
 module.exports = {
-  prepareClaudeConfigDir,
+  CLAUDE_MCP_CONFIG_ENV,
+  CLAUDE_SETTINGS_ENV,
+  cleanupClaudeSettingsOverlay,
+  ensureAskUserQuestionHook,
+  ensureDangerousGitHook,
+  isCanonicalClaudeSettingsOverlayDirectory,
+  isCanonicalClaudeSettingsOverlayPath,
+  isClaudeSettingsOverlayDirectory,
+  isClaudeSettingsOverlayPath,
+  prepareClaudeSettingsOverlay,
+  resolveContainerMcpConfigPath,
   resolveRepoMcpConfigPath,
 };

package/src/worktree-tooling-env.js

@@ -6,6 +6,9 @@ const DEFAULT_TOOL_BIN_RELATIVE_PATHS = ['.zeroshot/bin', '.worktree-tool-bin'];
 const FALLBACK_BIN_PREFIX = '.worktree-tool-bin.';
 
 function pathKeyForEnv(env) {
+  if (Object.prototype.hasOwnProperty.call(env, 'PATH')) {
+    return 'PATH';
+  }
   return Object.keys(env).find((key) => key.toUpperCase() === 'PATH') || 'PATH';
 }