@the-open-engine/zeroshot 6.38.0 → 6.39.0

package/lib/git-remote-utils.js

@@ -1,248 +1,182 @@
+"use strict";
 /**
  * Git remote URL parsing and provider detection.
  * Automatically detects issue provider from git remote URL.
  */
-
-const { execSync } = require('../src/lib/safe-exec');
-
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const safeExec = require('../src/lib/safe-exec');
+const { execSync } = safeExec;
 function hasInvalidGitRefCharacter(value) {
-  for (const character of value) {
-    const codePoint = character.codePointAt(0);
-    if (codePoint <= 0x20 || codePoint === 0x7f || '~^:?*[\\'.includes(character)) {
-      return true;
+    for (const character of value) {
+        const codePoint = character.codePointAt(0);
+        if (codePoint === undefined ||
+            codePoint <= 0x20 ||
+            codePoint === 0x7f ||
+            '~^:?*[\\'.includes(character)) {
+            return true;
+        }
     }
-  }
-  return false;
+    return false;
 }
-
 /**
  * Normalize a Git remote name using the same ref-format rules Git applies to
  * refs/remotes/<name>. Keeping this next to detection prevents a discovered
  * remote from being rejected later by a narrower consumer-specific allowlist.
- *
- * @param {unknown} value - Candidate remote name
- * @returns {string|null} Normalized remote name, or null when invalid
  */
 function normalizeGitRemoteName(value) {
-  if (typeof value !== 'string') {
-    return null;
-  }
-
-  const name = value.trim();
-  if (
-    name.length === 0 ||
-    name.endsWith('.') ||
-    name.includes('..') ||
-    name.includes('@{') ||
-    hasInvalidGitRefCharacter(name)
-  ) {
-    return null;
-  }
-
-  const components = name.split('/');
-  if (
-    components.some(
-      (component) =>
-        component.length === 0 || component.startsWith('.') || component.endsWith('.lock')
-    )
-  ) {
-    return null;
-  }
-
-  return name;
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const name = value.trim();
+    if (name.length === 0 ||
+        name.endsWith('.') ||
+        name.includes('..') ||
+        name.includes('@{') ||
+        hasInvalidGitRefCharacter(name)) {
+        return null;
+    }
+    const components = name.split('/');
+    if (components.some((component) => component.length === 0 || component.startsWith('.') || component.endsWith('.lock'))) {
+        return null;
+    }
+    return name;
 }
-
-/**
- * Quote one argument for the POSIX shell snippets embedded in agent prompts.
- *
- * @param {string} value - Argument to quote
- * @returns {string} Single-quoted shell argument
- */
+/** Quote one argument for the POSIX shell snippets embedded in agent prompts. */
 function quoteShellArgument(value) {
-  return `'${value.replaceAll("'", `'"'"'`)}'`;
+    return `'${value.replaceAll("'", `'"'"'`)}'`;
 }
-
 /**
  * Parse git remote URL into structured provider context.
  * Supports GitHub, GitLab, and Azure DevOps (cloud + self-hosted).
  * Handles both HTTPS and SSH URL formats.
- *
- * @param {string} remoteUrl - Git remote URL
- * @returns {Object|null} Provider context or null if unparseable
- *
- * @example
- * parseGitRemoteUrl('https://github.com/org/repo.git')
- * // → { provider: 'github', host: 'github.com', org: 'org', repo: 'repo', fullRepo: 'org/repo' }
- *
- * @example
- * parseGitRemoteUrl('git@gitlab.com:org/repo.git')
- * // → { provider: 'gitlab', host: 'gitlab.com', org: 'org', repo: 'repo', fullRepo: 'org/repo' }
- *
- * @example
- * parseGitRemoteUrl('https://dev.azure.com/myorg/myproject/_git/myrepo')
- * // → { provider: 'azure-devops', host: 'dev.azure.com', azureOrg: 'https://dev.azure.com/myorg', azureProject: 'myproject', repo: 'myrepo' }
  */
 function parseGitRemoteUrl(remoteUrl) {
-  if (!remoteUrl || typeof remoteUrl !== 'string') {
-    return null;
-  }
-
-  const url = remoteUrl.trim();
-
-  // Normalize SSH URLs to HTTPS format for easier parsing
-  // git@host:path → https://host/path
-  let normalizedUrl = url;
-  const sshMatch = url.match(/^git@([^:]+):(.+)$/);
-  if (sshMatch) {
-    const [, host, path] = sshMatch;
-    normalizedUrl = `https://${host}/${path}`;
-  }
-
-  // Remove .git suffix if present
-  normalizedUrl = normalizedUrl.replace(/\.git$/, '');
-
-  // Azure DevOps: https://dev.azure.com/org/project/_git/repo
-  // Azure Legacy: https://org.visualstudio.com/project/_git/repo
-  // Azure SSH: git@ssh.dev.azure.com:v3/org/project/repo
-  const azureMatch =
-    normalizedUrl.match(/https:\/\/dev\.azure\.com\/([^/]+)\/([^/]+)\/_git\/([^/]+)/) ||
-    normalizedUrl.match(/https:\/\/([^.]+)\.visualstudio\.com\/([^/]+)\/_git\/([^/]+)/) ||
-    // After normalization, `git@ssh.dev.azure.com:v3/org/project/repo` becomes
-    // `https://ssh.dev.azure.com/v3/org/project/repo`
-    normalizedUrl.match(/https:\/\/ssh\.dev\.azure\.com\/v3\/([^/]+)\/([^/]+)\/([^/]+)/);
-
-  if (azureMatch) {
-    const [, orgPart, project, repo] = azureMatch;
-    // For dev.azure.com, org is the first path segment
-    // For visualstudio.com, org is the subdomain
-    const isLegacy = normalizedUrl.includes('visualstudio.com');
-    const azureOrg = isLegacy
-      ? `https://${orgPart}.visualstudio.com`
-      : `https://dev.azure.com/${orgPart}`;
-
-    return {
-      provider: 'azure-devops',
-      host: isLegacy ? `${orgPart}.visualstudio.com` : 'dev.azure.com',
-      azureOrg,
-      azureProject: project,
-      repo,
-    };
-  }
-
-  // GitHub: https://github.com/org/repo
-  // GitLab: https://gitlab.com/org/repo (or self-hosted)
-  // Generic: https://host/org/repo
-  const httpsMatch = normalizedUrl.match(/https?:\/\/([^/]+)\/([^/]+)\/([^/]+)/);
-  if (httpsMatch) {
-    const [, host, org, repo] = httpsMatch;
-
-    let provider = null;
-    if (host === 'github.com') {
-      provider = 'github';
-    } else if (host.includes('gitlab')) {
-      // Matches gitlab.com or any gitlab.* subdomain or *gitlab* in hostname
-      provider = 'gitlab';
-    } else {
-      // Unknown provider - could be self-hosted GitLab or other
-      // Return null to fall back to settings
-      return null;
+    if (!remoteUrl || typeof remoteUrl !== 'string') {
+        return null;
     }
-
-    return {
-      provider,
-      host,
-      org,
-      repo,
-      fullRepo: `${org}/${repo}`,
-    };
-  }
-
-  return null;
+    const url = remoteUrl.trim();
+    // Normalize SSH URLs to HTTPS format for easier parsing
+    // git@host:path → https://host/path
+    let normalizedUrl = url;
+    const sshMatch = /^git@([^:]+):(.+)$/.exec(url);
+    if (sshMatch) {
+        const host = sshMatch[1];
+        const remotePath = sshMatch[2];
+        if (host !== undefined && remotePath !== undefined) {
+            normalizedUrl = `https://${host}/${remotePath}`;
+        }
+    }
+    // Remove .git suffix if present
+    normalizedUrl = normalizedUrl.replace(/\.git$/, '');
+    // Azure DevOps: https://dev.azure.com/org/project/_git/repo
+    // Azure Legacy: https://org.visualstudio.com/project/_git/repo
+    // Azure SSH: git@ssh.dev.azure.com:v3/org/project/repo
+    const azureMatch = /https:\/\/dev\.azure\.com\/([^/]+)\/([^/]+)\/_git\/([^/]+)/.exec(normalizedUrl) ||
+        /https:\/\/([^.]+)\.visualstudio\.com\/([^/]+)\/_git\/([^/]+)/.exec(normalizedUrl) ||
+        /https:\/\/ssh\.dev\.azure\.com\/v3\/([^/]+)\/([^/]+)\/([^/]+)/.exec(normalizedUrl);
+    if (azureMatch) {
+        const orgPart = azureMatch[1];
+        const project = azureMatch[2];
+        const repo = azureMatch[3];
+        if (orgPart === undefined || project === undefined || repo === undefined) {
+            return null;
+        }
+        const isLegacy = normalizedUrl.includes('visualstudio.com');
+        const azureOrg = isLegacy
+            ? `https://${orgPart}.visualstudio.com`
+            : `https://dev.azure.com/${orgPart}`;
+        return {
+            provider: 'azure-devops',
+            host: isLegacy ? `${orgPart}.visualstudio.com` : 'dev.azure.com',
+            azureOrg,
+            azureProject: project,
+            repo,
+        };
+    }
+    // GitHub: https://github.com/org/repo
+    // GitLab: https://gitlab.com/org/repo (or self-hosted)
+    // Generic: https://host/org/repo
+    const httpsMatch = /https?:\/\/([^/]+)\/([^/]+)\/([^/]+)/.exec(normalizedUrl);
+    if (httpsMatch) {
+        const host = httpsMatch[1];
+        const org = httpsMatch[2];
+        const repo = httpsMatch[3];
+        if (host === undefined || org === undefined || repo === undefined) {
+            return null;
+        }
+        let provider;
+        if (host === 'github.com') {
+            provider = 'github';
+        }
+        else if (host.includes('gitlab')) {
+            provider = 'gitlab';
+        }
+        else {
+            return null;
+        }
+        return {
+            provider,
+            host,
+            org,
+            repo,
+            fullRepo: `${org}/${repo}`,
+        };
+    }
+    return null;
 }
-
 /**
  * Detect git repository context from current working directory.
  * Returns provider context extracted from git remote URL.
- *
- * @param {string} [cwd=process.cwd()] - Directory to check
- * @returns {Object|null} Git context or null
- *
- * Gracefully returns null for:
- * - Not in git repository
- * - No remote configured
- * - Remote URL unparseable
- * - Git command fails
- *
- * @example
- * // In a GitHub repo with remote
- * detectGitContext()
- * // → { provider: 'github', host: 'github.com', org: 'myorg', repo: 'myrepo', fullRepo: 'myorg/myrepo' }
- *
- * @example
- * // Not in git repo or no remote
- * detectGitContext()
- * // → null
  */
 function detectGitContext(cwd = process.cwd()) {
-  try {
-    // Check if we're in a git repository
-    execSync('git rev-parse --git-dir', {
-      cwd,
-      stdio: 'pipe',
-      encoding: 'utf8',
-    });
-  } catch {
-    // Not a git repository
-    return null;
-  }
-
-  try {
-    const remoteOutput = execSync('git remote -v', {
-      cwd,
-      stdio: 'pipe',
-      encoding: 'utf8',
-    });
-
-    const supportedRemotes = new Map();
-    for (const line of remoteOutput.split(/\r?\n/)) {
-      const match = line.match(/^(\S+)\s+(.+)\s+\(fetch\)$/);
-      if (!match) {
-        continue;
-      }
-
-      const [, remoteCandidate, remoteUrl] = match;
-      const remote = normalizeGitRemoteName(remoteCandidate);
-      if (!remote) {
-        continue;
-      }
-      const context = parseGitRemoteUrl(remoteUrl);
-      if (context && !supportedRemotes.has(remote)) {
-        supportedRemotes.set(remote, { ...context, remote });
-      }
+    try {
+        execSync('git rev-parse --git-dir', {
+            cwd,
+            stdio: 'pipe',
+            encoding: 'utf8',
+        });
     }
-
-    // Preserve existing behavior whenever origin is usable. Without origin,
-    // select a remote only when there is exactly one supported target. Guessing
-    // between multiple repositories could push code or create a PR in the wrong
-    // place, so ambiguous configurations deliberately fail closed.
-    if (supportedRemotes.has('origin')) {
-      return supportedRemotes.get('origin');
+    catch {
+        return null;
     }
-
-    if (supportedRemotes.size === 1) {
-      return supportedRemotes.values().next().value;
+    try {
+        const remoteOutput = execSync('git remote -v', {
+            cwd,
+            stdio: 'pipe',
+            encoding: 'utf8',
+        });
+        const supportedRemotes = new Map();
+        for (const line of remoteOutput.split(/\r?\n/)) {
+            const match = /^(\S+)\s+(.+)\s+\(fetch\)$/.exec(line);
+            if (!match) {
+                continue;
+            }
+            const remoteCandidate = match[1];
+            const remoteUrl = match[2];
+            const remote = normalizeGitRemoteName(remoteCandidate);
+            if (!remote || remoteUrl === undefined) {
+                continue;
+            }
+            const context = parseGitRemoteUrl(remoteUrl);
+            if (context && !supportedRemotes.has(remote)) {
+                supportedRemotes.set(remote, { ...context, remote });
+            }
+        }
+        if (supportedRemotes.has('origin')) {
+            return supportedRemotes.get('origin') ?? null;
+        }
+        if (supportedRemotes.size === 1) {
+            return supportedRemotes.values().next().value ?? null;
+        }
+        return null;
+    }
+    catch {
+        return null;
     }
-
-    return null;
-  } catch {
-    // No remote configured or command failed
-    return null;
-  }
 }
-
 module.exports = {
-  normalizeGitRemoteName,
-  quoteShellArgument,
-  parseGitRemoteUrl,
-  detectGitContext,
+    normalizeGitRemoteName,
+    quoteShellArgument,
+    parseGitRemoteUrl,
+    detectGitContext,
 };

package/lib/id-detector.d.ts

@@ -0,0 +1,15 @@
+/**
+ * ID Detector - Determines if an ID is a task or cluster
+ *
+ * Strategy:
+ * 1. Check if ID exists in cluster storage
+ * 2. If not, check if ID exists in task storage (SQLite)
+ * 3. Return type: 'cluster', 'task', or null
+ */
+type IdType = 'cluster' | 'task' | null;
+/** Detect if an ID belongs to a cluster or task. */
+declare function detectIdType(id: string): IdType;
+declare const _default: {
+    detectIdType: typeof detectIdType;
+};
+export = _default;

package/lib/id-detector.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * ID Detector - Determines if an ID is a task or cluster
  *
@@ -6,49 +7,44 @@
  * 2. If not, check if ID exists in task storage (SQLite)
  * 3. Return type: 'cluster', 'task', or null
  */
-
-const path = require('path');
-const fs = require('fs');
-const os = require('os');
-const Database = require('better-sqlite3');
-const { readClustersFileSync } = require('./clusters-registry');
-
-/**
- * Detect if ID is a cluster or task
- * @param {string} id - The ID to check
- * @returns {'cluster'|'task'|null} - Type of ID or null if not found
- */
+const path = require("path");
+const fs = require("fs");
+const os = require("os");
+const Database = require("better-sqlite3");
+const clustersRegistry = require("./clusters-registry");
+function hasClusterId(clusters, id) {
+    return Boolean(Reflect.get(Object(clusters), id));
+}
+/** Detect if an ID belongs to a cluster or task. */
 function detectIdType(id) {
-  const homeDir =
-    process.env.ZEROSHOT_HOME || process.env.HOME || process.env.USERPROFILE || os.homedir();
-  const storageDir = path.join(homeDir, '.zeroshot');
-  const taskDbFile = path.join(homeDir, '.claude-zeroshot', 'store.db');
-
-  // Check clusters
-  try {
-    const clusters = readClustersFileSync(storageDir);
-    if (clusters[id]) {
-      return 'cluster';
-    }
-  } catch {
-    // Ignore parse errors
-  }
-
-  // Check tasks in SQLite
-  if (fs.existsSync(taskDbFile)) {
+    const homeDir = process.env.ZEROSHOT_HOME ||
+        process.env.HOME ||
+        process.env.USERPROFILE ||
+        os.homedir();
+    const storageDir = path.join(homeDir, '.zeroshot');
+    const taskDbFile = path.join(homeDir, '.claude-zeroshot', 'store.db');
     try {
-      const db = new Database(taskDbFile, { readonly: true, timeout: 5000 });
-      const row = db.prepare('SELECT id FROM tasks WHERE id = ?').get(id);
-      db.close();
-      if (row) {
-        return 'task';
-      }
-    } catch {
-      // Ignore DB errors
+        const clusters = clustersRegistry.readClustersFileSync(storageDir);
+        if (hasClusterId(clusters, id)) {
+            return 'cluster';
+        }
+    }
+    catch {
+        // Ignore parse errors
+    }
+    if (fs.existsSync(taskDbFile)) {
+        try {
+            const db = new Database(taskDbFile, { readonly: true, timeout: 5000 });
+            const row = db.prepare('SELECT id FROM tasks WHERE id = ?').get(id);
+            db.close();
+            if (row) {
+                return 'task';
+            }
+        }
+        catch {
+            // Ignore DB errors
+        }
     }
-  }
-
-  return null;
+    return null;
 }
-
 module.exports = { detectIdType };

package/lib/path-check.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Detects whether the npm global bin directory is on PATH, so we can warn
+ * the user when `npm install -g` succeeds but the `zeroshot` binary is
+ * unreachable (e.g. non-standard Node installs whose global bin dir isn't
+ * exported).
+ */
+interface PathCheckOptions {
+    readonly installPrefix?: string;
+    readonly pathEnv?: string;
+}
+type PathCheckResult = {
+    readonly onPath: true;
+    readonly binDir: null;
+} | {
+    readonly onPath: boolean;
+    readonly binDir: string;
+};
+declare function getGlobalBinDir(installPrefix: string): string;
+declare function isDirOnPath(dir: string, pathEnv?: string): boolean;
+declare function getPathExportLine(dir: string): string;
+declare function checkBinDirOnPath(options?: PathCheckOptions): PathCheckResult;
+declare function printPathWarning(binDir: string): void;
+declare const _default: {
+    getGlobalBinDir: typeof getGlobalBinDir;
+    isDirOnPath: typeof isDirOnPath;
+    getPathExportLine: typeof getPathExportLine;
+    checkBinDirOnPath: typeof checkBinDirOnPath;
+    printPathWarning: typeof printPathWarning;
+};
+export = _default;

package/lib/path-check.js

@@ -1,63 +1,60 @@
+"use strict";
 /**
  * Detects whether the npm global bin directory is on PATH, so we can warn
  * the user when `npm install -g` succeeds but the `zeroshot` binary is
  * unreachable (e.g. non-standard Node installs whose global bin dir isn't
  * exported).
  */
-
-const path = require('path');
-
+const path = require("path");
+function isUpdateCheckerModule(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'getInstallPrefix' in value &&
+        typeof value.getInstallPrefix === 'function');
+}
 function getGlobalBinDir(installPrefix) {
-  if (process.platform === 'win32') {
-    return installPrefix;
-  }
-
-  return path.join(installPrefix, 'bin');
+    if (process.platform === 'win32') {
+        return installPrefix;
+    }
+    return path.join(installPrefix, 'bin');
 }
-
 function isDirOnPath(dir, pathEnv = process.env.PATH || '') {
-  const resolvedDir = path.resolve(dir);
-
-  return pathEnv
-    .split(path.delimiter)
-    .filter((entry) => entry.length > 0)
-    .some((entry) => path.resolve(entry) === resolvedDir);
+    const resolvedDir = path.resolve(dir);
+    return pathEnv
+        .split(path.delimiter)
+        .filter((entry) => entry.length > 0)
+        .some((entry) => path.resolve(entry) === resolvedDir);
 }
-
 function getPathExportLine(dir) {
-  return `export PATH="${dir}:$PATH"`;
+    return `export PATH="${dir}:$PATH"`;
 }
-
 function checkBinDirOnPath(options = {}) {
-  if (process.platform === 'win32') {
-    return { onPath: true, binDir: null };
-  }
-
-  try {
-    const { getInstallPrefix } = require('../cli/lib/update-checker');
-    const installPrefix = options.installPrefix || getInstallPrefix(options);
-    const binDir = getGlobalBinDir(installPrefix);
-
-    return { onPath: isDirOnPath(binDir, options.pathEnv), binDir };
-  } catch {
-    return { onPath: true, binDir: null };
-  }
+    if (process.platform === 'win32') {
+        return { onPath: true, binDir: null };
+    }
+    try {
+        const updateChecker = require('../cli/lib/update-checker');
+        if (!isUpdateCheckerModule(updateChecker)) {
+            throw new TypeError('update-checker must export getInstallPrefix');
+        }
+        const { getInstallPrefix } = updateChecker;
+        const installPrefix = options.installPrefix || getInstallPrefix(options);
+        const binDir = getGlobalBinDir(installPrefix);
+        return { onPath: isDirOnPath(binDir, options.pathEnv), binDir };
+    }
+    catch {
+        return { onPath: true, binDir: null };
+    }
 }
-
 function printPathWarning(binDir) {
-  console.error(
-    `[zeroshot] Warning: ${binDir} is not on your PATH — the 'zeroshot' command may not be found.`
-  );
-  console.error(`  ${getPathExportLine(binDir)}`);
-  console.error(
-    '  Add this line to your shell profile (~/.zshrc, ~/.bashrc, or ~/.profile) to fix this permanently.'
-  );
+    console.error(`[zeroshot] Warning: ${binDir} is not on your PATH — the 'zeroshot' command may not be found.`);
+    console.error(`  ${getPathExportLine(binDir)}`);
+    console.error('  Add this line to your shell profile (~/.zshrc, ~/.bashrc, or ~/.profile) to fix this permanently.');
 }
-
 module.exports = {
-  getGlobalBinDir,
-  isDirOnPath,
-  getPathExportLine,
-  checkBinDirOnPath,
-  printPathWarning,
+    getGlobalBinDir,
+    isDirOnPath,
+    getPathExportLine,
+    checkBinDirOnPath,
+    printPathWarning,
 };

package/lib/process-liveness.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Single source of truth for "is this PID actually alive?"
+ *
+ * Previously this check was reimplemented separately in src/orchestrator.js
+ * (_isProcessRunning) and lib/detached-startup.js (isProcessAlive), plus an
+ * inline copy in _getActiveClustersForIssue. Four of those call sites agreed
+ * on the answer; the resume() eligibility guard trusted persisted cluster
+ * state instead of asking the OS, which is what let a dead-PID cluster be
+ * simultaneously reported as "zombie" by status and "still running" by
+ * resume. Consolidating avoids a sixth call site reintroducing that split.
+ */
+declare function isProcessRunning(pid: unknown): boolean;
+declare const _default: {
+    isProcessRunning: typeof isProcessRunning;
+};
+export = _default;