@the-open-engine/zeroshot 6.31.3 → 6.32.1

package/cli/lib/setup-provider-readiness.js

@@ -0,0 +1,86 @@
+const { getProviderMetadata, providerSupportsCapability } = require('../../lib/provider-names');
+
+const PROVIDER_READINESS = Object.freeze([
+  'ready',
+  'login-required',
+  'incompatible',
+  'unavailable',
+  'unknown',
+]);
+
+function incompatible(reason) {
+  return { status: 'incompatible', selectable: false, reason };
+}
+
+function executionCompatibility(providerId, isolation, settings) {
+  const capability = isolation === 'docker' ? 'dockerIsolation' : 'worktreeIsolation';
+  if (isolation !== 'none' && !providerSupportsCapability(providerId, capability)) {
+    return incompatible(`${isolation} isolation is not supported`);
+  }
+  const metadata = getProviderMetadata(providerId);
+  const providerSettings = settings.providerSettings?.[providerId];
+  if (!metadata.settingsValidator || !providerSettings || typeof providerSettings !== 'object') {
+    return null;
+  }
+  const executionContext = isolation === 'docker' ? 'docker' : 'detached';
+  try {
+    const error = metadata.settingsValidator(providerSettings, { executionContext });
+    return error ? incompatible(error) : null;
+  } catch (error) {
+    return { status: 'unknown', selectable: false, reason: error.message };
+  }
+}
+function unavailableReadiness(probe) {
+  const status = probe.commandAvailable ? 'unknown' : 'unavailable';
+  const fallback = probe.commandAvailable ? 'CLI probe failed' : 'CLI is not installed';
+  return { status, selectable: false, reason: probe.error || fallback };
+}
+
+function authReadiness(probe) {
+  if (probe.authStatus === 'login-required') {
+    return { status: 'login-required', selectable: false, reason: probe.authReason };
+  }
+  if (probe.authStatus !== 'ready') {
+    return {
+      status: 'unknown',
+      selectable: false,
+      reason: probe.authReason || 'readiness is unknown',
+    };
+  }
+  return { status: 'ready', selectable: true, reason: probe.path || 'available' };
+}
+
+function assessProviderReadiness({ providerId, probe, isolation, settings }) {
+  if (!probe) return { status: 'unknown', selectable: false, reason: 'probe did not complete' };
+  if (!probe.available) return unavailableReadiness(probe);
+  const compatibility = executionCompatibility(providerId, isolation, settings);
+  return compatibility || authReadiness(probe);
+}
+
+function providerChoices({ plan, probes, isolation, settings }) {
+  return Object.keys(plan.facts.providers).map((providerId) => {
+    const metadata = getProviderMetadata(providerId);
+    const readiness = assessProviderReadiness({
+      providerId,
+      probe: probes[`provider:${providerId}`],
+      isolation,
+      settings,
+    });
+    return {
+      value: providerId,
+      label: metadata.displayName,
+      detail: readiness.reason,
+      status: readiness.status,
+      disabled: !readiness.selectable,
+      installInstructions: metadata.installInstructions,
+      authInstructions: metadata.authInstructions,
+    };
+  });
+}
+
+module.exports = {
+  PROVIDER_READINESS,
+  assessProviderReadiness,
+  executionCompatibility,
+  providerChoices,
+};

package/cli/lib/setup-scanner-worker.js

@@ -0,0 +1,120 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { parentPort, workerData } = require('worker_threads');
+
+const { commandExists, getCommandPath } = require('../../lib/provider-detection');
+const { getProviderMetadata, resolveProviderCommand } = require('../../lib/provider-names');
+const { execSync } = require('../../src/lib/safe-exec');
+
+function safeExec(command, cwd) {
+  try {
+    return execSync(command, { cwd, stdio: 'pipe', encoding: 'utf8' }).trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+function probeGit() {
+  const cwd = workerData.payload.cwd || process.cwd();
+  const isRepo = safeExec('git rev-parse --is-inside-work-tree', cwd) === 'true';
+  if (!isRepo) {
+    return { isRepo: false, branch: null, remote: null, defaultBranch: null, clean: null };
+  }
+  const defaultRef = safeExec('git rev-parse --abbrev-ref origin/HEAD', cwd);
+  return {
+    isRepo: true,
+    branch: safeExec('git rev-parse --abbrev-ref HEAD', cwd),
+    remote: safeExec('git remote get-url origin', cwd),
+    defaultBranch: defaultRef ? defaultRef.replace(/^origin\//, '') : null,
+    clean: safeExec('git status --porcelain', cwd) === null,
+  };
+}
+
+function probeDocker() {
+  const { checkDocker } = require('../../src/preflight');
+  return checkDocker();
+}
+
+function probeIssue() {
+  const { checkGhAuth } = require('../../src/preflight');
+  return checkGhAuth();
+}
+
+function expandCredentialPath(value) {
+  if (value === '~') return os.homedir();
+  if (value.startsWith('~/')) return path.join(os.homedir(), value.slice(2));
+  return value;
+}
+
+function hasCredentialEvidence(metadata) {
+  const hasEnvironment = metadata.credentialEnvKeys.some((key) => {
+    const value = process.env[key];
+    return typeof value === 'string' && value.trim().length > 0;
+  });
+  if (hasEnvironment) return true;
+  return metadata.credentialPaths.some((item) => fs.existsSync(expandCredentialPath(item)));
+}
+
+function providerAuthStatus(id, metadata, available) {
+  if (!available) return { authStatus: 'unknown', authReason: null };
+  if (id === 'gateway') return { authStatus: 'ready', authReason: null };
+  if (id === 'claude') {
+    const { checkClaudeAuth } = require('../../src/preflight');
+    const auth = checkClaudeAuth();
+    return auth.authenticated
+      ? { authStatus: 'ready', authReason: null }
+      : { authStatus: 'login-required', authReason: auth.error || 'authentication not found' };
+  }
+  return hasCredentialEvidence(metadata)
+    ? { authStatus: 'ready', authReason: null }
+    : { authStatus: 'login-required', authReason: metadata.authInstructions };
+}
+
+function probeProvider() {
+  const id = workerData.payload.id;
+  const metadata = getProviderMetadata(id);
+  const { command } = resolveProviderCommand(id);
+  const commandAvailable = commandExists(command);
+  let available = false;
+  let error = null;
+  try {
+    const { getProvider } = require('../../src/providers');
+    available = getProvider(id).isAvailable() === true;
+  } catch (probeError) {
+    error = probeError.message;
+  }
+  const auth = providerAuthStatus(id, metadata, available);
+  return {
+    id,
+    available,
+    commandAvailable,
+    command,
+    path: available ? getCommandPath(command) : null,
+    displayName: metadata.displayName,
+    authStatus: auth.authStatus,
+    authReason: auth.authReason,
+    error,
+  };
+}
+
+function runProbe() {
+  switch (workerData.kind) {
+    case 'git':
+      return probeGit();
+    case 'docker':
+      return probeDocker();
+    case 'issue':
+      return probeIssue();
+    case 'provider':
+      return probeProvider();
+    default:
+      throw new Error(`Unknown setup probe: ${workerData.kind}`);
+  }
+}
+
+try {
+  parentPort.postMessage({ ok: true, result: runProbe() });
+} catch (error) {
+  parentPort.postMessage({ ok: false, error: error.message });
+}

package/cli/lib/setup-scanner.js

@@ -0,0 +1,185 @@
+const path = require('path');
+const { Worker } = require('worker_threads');
+
+const { buildSetupPlan } = require('../../lib/setup-plan');
+const { getProviderDefaults } = require('../../lib/provider-defaults');
+const {
+  getDefaultProviderId,
+  getProviderMetadata,
+  listProviderMetadata,
+  resolveProviderCommand,
+} = require('../../lib/provider-names');
+const packageJson = require('../../package.json');
+
+const PROBE_TIMEOUT_MS = 15_000;
+
+function workerProbe(kind, payload = {}) {
+  return new Promise((resolve) => {
+    const worker = new Worker(path.join(__dirname, 'setup-scanner-worker.js'), {
+      workerData: { kind, payload },
+    });
+    let settled = false;
+    let timer;
+    const settle = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      worker.terminate().catch(() => {});
+      resolve(result);
+    };
+    timer = setTimeout(() => settle({ ok: false, error: 'probe timed out' }), PROBE_TIMEOUT_MS);
+    timer.unref?.();
+    worker.once('message', settle);
+    worker.once('error', (error) => settle({ ok: false, error: error.message }));
+    worker.once('exit', (code) => {
+      if (code !== 0) settle({ ok: false, error: `probe worker exited ${code}` });
+    });
+  });
+}
+
+function commandResult(command, providers, issue) {
+  if (command === 'gh') return issue.installed;
+  const provider = Object.values(providers).find((item) => item.command === command);
+  return provider ? provider.commandAvailable : false;
+}
+
+function commandPath(command, providers) {
+  const provider = Object.values(providers).find((item) => item.command === command);
+  return provider?.path || null;
+}
+
+function gitExecResult(command, git) {
+  if (command.includes('is-inside-work-tree')) return git.isRepo ? 'true\n' : null;
+  if (command.includes('abbrev-ref origin/HEAD')) {
+    return git.defaultBranch ? `origin/${git.defaultBranch}\n` : null;
+  }
+  if (command.includes('abbrev-ref HEAD')) return git.branch ? `${git.branch}\n` : null;
+  if (command.includes('remote get-url origin')) return git.remote ? `${git.remote}\n` : null;
+  return null;
+}
+
+function createPlanDeps({ git, docker, issue, providers }) {
+  const providerIds = Object.keys(providers);
+  return {
+    commandExists: (command) => commandResult(command, providers, issue),
+    getCommandPath: (command) => commandPath(command, providers),
+    checkDocker: () => ({ available: docker.available }),
+    checkGhAuth: () => ({ authenticated: issue.authenticated }),
+    execSync: (command) => {
+      const result = gitExecResult(command, git);
+      if (result === null) throw new Error(`setup scan has no result for: ${command}`);
+      return result;
+    },
+    listProviders: () => providerIds,
+    getProvider: (name) => ({
+      cliCommand: providers[name].command,
+      isAvailable: () => providers[name].available,
+    }),
+    getProviderDefaults,
+    getDefaultProviderId,
+    getProviderMetadata,
+    getNodeVersion: () => process.version,
+    getPackageVersion: () => packageJson.version,
+  };
+}
+
+function fallbackResult(probe) {
+  if (probe.kind === 'git') {
+    return { isRepo: false, branch: null, remote: null, defaultBranch: null, clean: null };
+  }
+  if (probe.kind === 'docker') return { available: false, error: probe.error };
+  if (probe.kind === 'issue') {
+    return { installed: false, authenticated: false, error: probe.error };
+  }
+  const metadata = getProviderMetadata(probe.id);
+  const { command } = resolveProviderCommand(probe.id);
+  return {
+    id: probe.id,
+    available: false,
+    commandAvailable: false,
+    command,
+    path: null,
+    authStatus: 'unknown',
+    authReason: probe.error,
+    displayName: metadata.displayName,
+  };
+}
+
+async function trackedProbe(spec, probe, onProgress, startedAt, cwd) {
+  let response;
+  try {
+    response = await probe(spec.kind, { cwd, ...(spec.id ? { id: spec.id } : {}) });
+  } catch (error) {
+    response = { ok: false, error: error.message };
+  }
+  const result = response?.ok
+    ? response.result
+    : fallbackResult({ ...spec, error: response?.error });
+  onProgress?.({
+    type: 'complete',
+    id: spec.id ? `provider:${spec.id}` : spec.kind,
+    kind: spec.kind,
+    providerId: spec.id || null,
+    ok: response?.ok === true,
+    elapsedMs: Date.now() - startedAt,
+    result,
+  });
+  return [spec, result];
+}
+function probeSpecs(metadata) {
+  return [
+    { kind: 'git' },
+    { kind: 'docker' },
+    { kind: 'issue' },
+    ...metadata.map((provider) => ({ kind: 'provider', id: provider.id })),
+  ];
+}
+
+function indexProbeResults(entries, metadata) {
+  const probes = Object.fromEntries(
+    entries.map(([spec, result]) => [spec.id ? `provider:${spec.id}` : spec.kind, result])
+  );
+  const providers = Object.fromEntries(
+    metadata.map((provider) => [provider.id, probes[`provider:${provider.id}`]])
+  );
+  return { probes, providers };
+}
+
+function planFromScan({ cwd, settings, repoSettings, env, probes, providers, deps }) {
+  const planDeps = (deps.createPlanDeps || createPlanDeps)({
+    git: probes.git,
+    docker: probes.docker,
+    issue: probes.issue,
+    providers,
+  });
+  return (deps.buildSetupPlan || buildSetupPlan)({
+    cwd,
+    settings,
+    repoSettings,
+    env: { ...env, __isTTY: true },
+    deps: planDeps,
+  });
+}
+
+async function scanSetupEnvironment({ cwd, settings, repoSettings, env, onProgress, deps = {} }) {
+  const probe = deps.probe || workerProbe;
+  const metadata = (deps.listProviderMetadata || listProviderMetadata)();
+  const specs = probeSpecs(metadata);
+  const startedAt = Date.now();
+  if (onProgress) onProgress({ type: 'start', probes: specs, elapsedMs: 0 });
+  const entries = await Promise.all(
+    specs.map((spec) => trackedProbe(spec, probe, onProgress, startedAt, cwd))
+  );
+  const { probes, providers } = indexProbeResults(entries, metadata);
+  const plan = planFromScan({ cwd, settings, repoSettings, env, probes, providers, deps });
+  const elapsedMs = Date.now() - startedAt;
+  if (onProgress) onProgress({ type: 'finish', elapsedMs, plan, probes });
+  return { plan, probes, elapsedMs };
+}
+
+module.exports = {
+  PROBE_TIMEOUT_MS,
+  createPlanDeps,
+  scanSetupEnvironment,
+  workerProbe,
+};

package/cli/lib/setup-wizard-input.js

@@ -0,0 +1,146 @@
+const CANCEL_KEYS = new Set(['escape', 'ctrl-c', 'q']);
+
+function keyForCharacter(character) {
+  if (character === '\x03') return 'ctrl-c';
+  if (character === '\x1b') return 'escape';
+  if (character === '\r' || character === '\n') return 'enter';
+  if (character === ' ') return 'space';
+  if (/^[1-9]$/.test(character)) return character;
+  const aliases = { j: 'down', k: 'up', h: 'left', l: 'right', q: 'q' };
+  return aliases[character] || null;
+}
+
+function parseKeys(chunk) {
+  const text = Buffer.isBuffer(chunk) ? chunk.toString('utf8') : String(chunk);
+  const keys = [];
+  let index = 0;
+  while (index < text.length) {
+    if (text.startsWith('\x1b[A', index)) {
+      keys.push('up');
+      index += 3;
+      continue;
+    }
+    if (text.startsWith('\x1b[B', index)) {
+      keys.push('down');
+      index += 3;
+      continue;
+    }
+    if (text.startsWith('\x1b[C', index)) {
+      keys.push('right');
+      index += 3;
+      continue;
+    }
+    if (text.startsWith('\x1b[D', index)) {
+      keys.push('left');
+      index += 3;
+      continue;
+    }
+    const key = keyForCharacter(text[index]);
+    if (key) keys.push(key);
+    index += 1;
+  }
+  return keys;
+}
+
+function createKeyReader(stdin, stdout) {
+  const queued = [];
+  const waiters = [];
+  const deliver = (key) => {
+    const waiter = waiters.shift();
+    if (waiter) waiter(key);
+    else queued.push(key);
+  };
+  const onData = (chunk) => {
+    for (const key of parseKeys(chunk)) deliver(key);
+  };
+  const onResize = () => deliver('resize');
+  stdin.on('data', onData);
+  if (stdout && typeof stdout.on === 'function') stdout.on('resize', onResize);
+  return {
+    read() {
+      if (queued.length > 0) return Promise.resolve(queued.shift());
+      return new Promise((resolve) => waiters.push(resolve));
+    },
+    close() {
+      stdin.off('data', onData);
+      if (stdout && typeof stdout.off === 'function') stdout.off('resize', onResize);
+    },
+  };
+}
+
+function beginTerminal(stdin, stdout) {
+  const wasRaw = stdin.isRaw === true;
+  let restored = false;
+  if (typeof stdin.setRawMode === 'function') stdin.setRawMode(true);
+  if (typeof stdin.resume === 'function') stdin.resume();
+  stdout.write('\x1b[?25l');
+  return () => {
+    if (restored) return;
+    restored = true;
+    stdout.write('\x1b[?25h');
+    if (typeof stdin.setRawMode === 'function') stdin.setRawMode(wasRaw);
+    if (typeof stdin.pause === 'function') stdin.pause();
+  };
+}
+
+function firstEnabledChoice(choices, initial) {
+  for (let offset = 0; offset < choices.length; offset += 1) {
+    const index = (Math.max(0, initial) + offset) % choices.length;
+    if (!choices[index].disabled) return index;
+  }
+  return -1;
+}
+
+function nextEnabledChoice(choices, selected, direction) {
+  if (choices.length === 0 || selected < 0) return selected;
+  let next = selected;
+  do {
+    next = (next + direction + choices.length) % choices.length;
+    if (!choices[next].disabled) return next;
+  } while (next !== selected);
+  return selected;
+}
+
+function createSelectionState(choices, initial = 0) {
+  return { selected: firstEnabledChoice(choices, initial), status: 'active', value: undefined };
+}
+
+function numberedSelection(state, key, choices) {
+  if (!/^[1-9]$/.test(key)) return null;
+  const index = Number(key) - 1;
+  if (!choices[index] || choices[index].disabled) return state;
+  return { selected: index, status: 'confirmed', value: choices[index].value };
+}
+
+function selectionDirection(key, orientation) {
+  if (orientation === 'horizontal') {
+    if (key === 'left' || key === 'up') return -1;
+    if (key === 'right' || key === 'down') return 1;
+    return 0;
+  }
+  if (key === 'up') return -1;
+  if (key === 'down') return 1;
+  return 0;
+}
+
+function reduceSelection(state, key, choices, orientation = 'vertical') {
+  if (state.status !== 'active') return state;
+  if (CANCEL_KEYS.has(key)) return { ...state, status: 'cancelled', value: null };
+  const numbered = numberedSelection(state, key, choices);
+  if (numbered) return numbered;
+  const direction = selectionDirection(key, orientation);
+  if (direction !== 0) {
+    return { ...state, selected: nextEnabledChoice(choices, state.selected, direction) };
+  }
+  if (key !== 'enter' || state.selected < 0 || choices[state.selected].disabled) return state;
+  return { ...state, status: 'confirmed', value: choices[state.selected].value };
+}
+
+module.exports = {
+  CANCEL_KEYS,
+  beginTerminal,
+  createKeyReader,
+  createSelectionState,
+  parseKeys,
+  reduceSelection,
+};