@the-open-engine/zeroshot 6.38.1 → 6.39.0

package/lib/completion.js

@@ -1,123 +1,113 @@
-const os = require('os');
-const path = require('path');
-const omelette = require('omelette');
-const { readClustersFileSync } = require('./clusters-registry');
-
+"use strict";
+const os = require("os");
+const path = require("path");
+const omelette = require("omelette");
+const clustersRegistry = require("./clusters-registry");
+const { readClustersFileSync } = clustersRegistry;
 const CLUSTER_ID_COMMANDS = new Set([
-  'attach',
-  'export',
-  'finish',
-  'kill',
-  'logs',
-  'resume',
-  'status',
-  'stop',
+    'attach',
+    'export',
+    'finish',
+    'kill',
+    'logs',
+    'resume',
+    'status',
+    'stop',
 ]);
-
 function commandNames(command) {
-  return [command.name(), ...command.aliases()];
+    return [command.name(), ...command.aliases()];
 }
-
 function visibleCommands(command) {
-  return command.createHelp().visibleCommands(command);
+    return command.createHelp().visibleCommands(command);
 }
-
 function visibleOptions(command) {
-  return command.createHelp().visibleOptions(command);
+    return command.createHelp().visibleOptions(command);
 }
-
 function optionNames(option) {
-  return [option.short, option.long].filter(Boolean);
+    return [option.short, option.long].filter((name) => Boolean(name));
 }
-
 function findSubcommand(command, token) {
-  return visibleCommands(command).find((candidate) => commandNames(candidate).includes(token));
+    return visibleCommands(command).find((candidate) => commandNames(candidate).includes(token));
 }
-
 function findOption(command, token) {
-  const optionToken = token.split('=', 1)[0];
-  return visibleOptions(command).find((option) => optionNames(option).includes(optionToken));
+    const optionToken = token.split('=', 1)[0] ?? '';
+    return visibleOptions(command).find((option) => optionNames(option).includes(optionToken));
 }
-
 function parseCompletionLine(line) {
-  const trailingSpace = /\s$/.test(line);
-  const tokens = line.trim().split(/\s+/).filter(Boolean);
-  tokens.shift();
-  const current = trailingSpace ? '' : (tokens.pop() ?? '');
-  return { completed: tokens, current };
+    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, tokens) {
-  let command = program;
-  const pathParts = [];
-  let expectsOptionValue = false;
-  let sawPositional = false;
-
-  for (const token of tokens) {
-    if (expectsOptionValue) {
-      expectsOptionValue = false;
-      continue;
+    let command = program;
+    const pathParts = [];
+    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;
     }
-
-    const option = findOption(command, token);
-    if (option) {
-      expectsOptionValue = !token.includes('=') && (option.required || option.optional);
-      continue;
-    }
-    if (token.startsWith('-')) continue;
-
-    const subcommand = sawPositional ? null : findSubcommand(command, token);
-    if (subcommand) {
-      command = subcommand;
-      pathParts.push(subcommand.name());
-      continue;
-    }
-    sawPositional = true;
-  }
-
-  return { command, commandPath: pathParts.join(' ') };
+    return { command, commandPath: pathParts.join(' ') };
 }
-
 function defaultListClusterIds() {
-  const homeDir =
-    process.env.ZEROSHOT_HOME || process.env.HOME || process.env.USERPROFILE || os.homedir();
-  const registry = readClustersFileSync(path.join(homeDir, '.zeroshot'));
-  return Object.keys(registry);
+    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);
 }
-
 function safeDynamicIds(commandPath, listClusterIds) {
-  if (!CLUSTER_ID_COMMANDS.has(commandPath)) return [];
-  try {
-    const ids = listClusterIds();
-    return Array.isArray(ids) ? ids.filter((id) => typeof id === 'string' && id.length > 0) : [];
-  } catch {
-    return [];
-  }
+    if (!CLUSTER_ID_COMMANDS.has(commandPath))
+        return [];
+    try {
+        const ids = listClusterIds();
+        if (!Array.isArray(ids))
+            return [];
+        const unknownIds = ids;
+        return unknownIds.filter((id) => typeof id === 'string' && id.length > 0);
+    }
+    catch {
+        return [];
+    }
 }
-
 function getCompletionCandidates(program, line, deps = {}) {
-  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));
+    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, deps = {}) {
-  const complete = omelette('zeroshot');
-  complete.on('complete', (_fragment, data) => {
-    data.reply(getCompletionCandidates(program, data.line, deps));
-  });
-  complete.init();
-  return complete;
+    const complete = omelette('zeroshot');
+    complete.on('complete', (_fragment, data) => {
+        data.reply(getCompletionCandidates(program, data.line, deps));
+    });
+    complete.init();
+    return complete;
 }
-
 module.exports = {
-  getCompletionCandidates,
-  setupCompletion,
+    getCompletionCandidates,
+    setupCompletion,
 };

package/lib/compose-utils.d.ts

@@ -0,0 +1,32 @@
+/**
+ * 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).
+ */
+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 '_'/'-').
+ */
+declare function normalizeComposeProjectName(name: string): string;
+/**
+ * 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.
+ */
+declare function resolveWorktreeComposeTeardown(worktreePath: string): ComposeTeardownResolution;
+declare const _default: {
+    resolveWorktreeComposeTeardown: typeof resolveWorktreeComposeTeardown;
+    normalizeComposeProjectName: typeof normalizeComposeProjectName;
+};
+export = _default;

package/lib/compose-utils.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Docker Compose teardown resolution for worktree cleanup.
  *
@@ -6,96 +7,80 @@
  * 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).
  */
-
-const fs = require('fs');
-const path = require('path');
-
+const fs = require("fs");
+const path = require("path");
+const yaml = require("js-yaml");
 const COMPOSE_FILENAMES = [
-  'docker-compose.yml',
-  'docker-compose.yaml',
-  'compose.yml',
-  'compose.yaml',
+    'docker-compose.yml',
+    'docker-compose.yaml',
+    'compose.yml',
+    'compose.yaml',
 ];
-
 /**
  * Reproduce Docker Compose's default project-name normalization
  * (compose-go NormalizeProjectName: lowercase -> keep [a-z0-9_-] -> trim leading '_'/'-').
- *
- * @param {string} name
- * @returns {string}
  */
 function normalizeComposeProjectName(name) {
-  return name
-    .toLowerCase()
-    .replace(/[^a-z0-9_-]/g, '')
-    .replace(/^[-_]+/, '');
+    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.
- *
- * @param {string} worktreePath - Path to the worktree directory
- * @returns {{ shouldTeardown: boolean, reason?: string, composePath?: string, args?: string[] }}
  */
 function resolveWorktreeComposeTeardown(worktreePath) {
-  let composePath = null;
-  for (const filename of COMPOSE_FILENAMES) {
-    const candidate = path.join(worktreePath, filename);
-    if (fs.existsSync(candidate)) {
-      composePath = candidate;
-      break;
+    let composePath = 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 };
     }
-  }
-
-  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 yaml = require('js-yaml');
-    const contents = fs.readFileSync(composePath, 'utf8');
-    const parsed = yaml.load(contents);
-    if (parsed && typeof parsed === 'object' && parsed.name) {
-      return {
-        shouldTeardown: false,
-        reason: 'pinned compose project name (shared host project)',
+        shouldTeardown: true,
         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',
-    ],
-  };
+        args: [
+            'compose',
+            '-p',
+            normalizeComposeProjectName(path.basename(worktreePath)),
+            'down',
+            '--remove-orphans',
+            '--timeout',
+            '10',
+        ],
+    };
 }
-
 module.exports = { resolveWorktreeComposeTeardown, normalizeComposeProjectName };

package/lib/detached-startup.d.ts

@@ -0,0 +1,83 @@
+interface RunOptions extends Record<string, unknown> {
+    autoMerge?: unknown;
+    closeIssue?: unknown;
+    docker?: unknown;
+    mergeQueue?: unknown;
+    pr?: unknown;
+    prBase?: unknown;
+    ship?: unknown;
+    worktree?: unknown;
+}
+interface DetachedSetupParams {
+    clusterId: string;
+    pid?: number;
+    storageDir?: string;
+    logPath?: string | null;
+    worktree?: unknown;
+    runOptions?: RunOptions;
+    cwd?: string;
+}
+interface ClusterIdentityParams {
+    clusterId: string;
+    storageDir?: string;
+}
+interface SetupFailureParams extends ClusterIdentityParams {
+    error: unknown;
+    logPath?: string | null;
+}
+interface ResumePatchParams extends ClusterIdentityParams {
+    daemonPid: number;
+}
+interface RegistrationWaitParams extends ClusterIdentityParams {
+    timeoutMs?: number;
+    pollMs?: number;
+    daemonPid?: number;
+    logPath?: string | null;
+}
+interface OwnershipWaitParams extends ResumePatchParams {
+    timeoutMs?: number;
+    pollMs?: number;
+}
+declare function getClustersFilePath(storageDir?: string | null): string;
+declare function resolveWaitTimeoutMs(waitTimeoutSeconds: unknown): number;
+declare function isClusterRegistered(clusterId: string, storageDir?: string): boolean;
+declare function registerDetachedSetupCluster({ clusterId, pid, storageDir, logPath, worktree, runOptions, cwd, }: DetachedSetupParams): Promise<void>;
+declare function removeDetachedSetupCluster({ clusterId, storageDir, }: ClusterIdentityParams): Promise<void>;
+declare function markDetachedSetupFailed({ clusterId, storageDir, error, logPath, }: SetupFailureParams): Promise<void>;
+declare function waitForClusterRegistration({ clusterId, timeoutMs, pollMs, storageDir, daemonPid, logPath, }: RegistrationWaitParams): Promise<{
+    ready: true;
+    elapsedMs: number;
+}>;
+/**
+ * Atomically claim the right to resume-daemon an existing cluster record.
+ * Ownership for the handoff is tracked separately from cluster.pid/state so
+ * orchestrator.resume() can still perform its own eligibility check.
+ */
+declare function patchDetachedResumeCluster({ clusterId, daemonPid, storageDir, }: ResumePatchParams): Promise<void>;
+/**
+ * Undo a resume handoff that did not complete so a dead daemon cannot leave
+ * the cluster stuck in a running state.
+ */
+declare function revertDetachedResumeCluster({ clusterId, storageDir, error, }: SetupFailureParams): Promise<void>;
+declare function getRegisteredResumeDaemonPid(clusterId: string, storageDir?: string): number | null;
+/**
+ * Daemon-side half of the resume handoff: wait until the registry shows this
+ * process's PID as resumeDaemonPid before touching the cluster.
+ */
+declare function waitForResumeOwnership({ clusterId, daemonPid, storageDir, timeoutMs, pollMs, }: OwnershipWaitParams): Promise<boolean>;
+declare const _default: {
+    DEFAULT_WAIT_TIMEOUT_SECONDS: number;
+    getClustersFilePath: typeof getClustersFilePath;
+    getRegisteredResumeDaemonPid: typeof getRegisteredResumeDaemonPid;
+    isClusterRegistered: typeof isClusterRegistered;
+    isProcessAlive: (pid: unknown) => boolean;
+    markDetachedSetupFailed: typeof markDetachedSetupFailed;
+    patchDetachedResumeCluster: typeof patchDetachedResumeCluster;
+    registerDetachedSetupCluster: typeof registerDetachedSetupCluster;
+    removeDetachedSetupCluster: typeof removeDetachedSetupCluster;
+    resolveWaitTimeoutMs: typeof resolveWaitTimeoutMs;
+    revertDetachedResumeCluster: typeof revertDetachedResumeCluster;
+    waitForClusterRegistration: typeof waitForClusterRegistration;
+    waitForResumeOwnership: typeof waitForResumeOwnership;
+};
+export = _default;