infra-kit 0.8.0 → 0.10.0

package/dist/dev-wizard-run-ITRFKMTL.js

@@ -0,0 +1,2 @@
+import{d as x,g as f,k as g}from"./chunk-WUTG6VMP.js";import{N as u,Z as y,aa as k,ba as v,da as w,na as C}from"./chunk-7AMRJ4IW.js";import"./chunk-MFAFQVTW.js";import{f as b}from"./chunk-MOVRKV3I.js";import"./chunk-QWVLAZ6N.js";import B from"@inquirer/checkbox";import _ from"@inquirer/confirm";import j,{Separator as I}from"@inquirer/select";import{loadDev as K}from"@slip-stream-kit/config/internal";import q from"node:path";import m from"node:process";var W=e=>e.split("/")[0],A=e=>new Map(e.apps.map(r=>[r.name,r])),D=e=>e.localCapable&&e.cloudCapable,N=(e,r,a)=>D(r)?a[`${e} ${r.path}`]??(r.cloudCapable?"cloud":"local"):r.localCapable?"local":"cloud",$=(e,r,a)=>{let t=new Set,o=new Map;for(let n of e){let s=r.get(W(n));for(let c of s?.backends??[]){o.set(c.packageName,c.ownerApp);for(let l of c.routes)N(n,l,a)==="local"&&t.add(c.packageName)}}return{localPkgs:t,ownerByPkg:o}},O=(e,r)=>{let a={},t=!1;for(let o of e?.backends??[]){let n=r.has(o.packageName);for(let s of o.routes){let c=s.localCapable&&n?"local":"cloud";a[s.path]=c,c==="cloud"&&(t=!0)}}return{overrides:a,anyCloud:t}},z=(e,r)=>{let a=A(r),t=e.targets.filter(p=>p.endsWith("/ui")),o=e.targets.filter(p=>p.endsWith("/api")),{localPkgs:n,ownerByPkg:s}=$(t,a,e.sources),c={},l=!1;for(let p of t){let{overrides:d,anyCloud:i}=O(a.get(W(p)),n);i&&(l=!0),c[p]=Object.keys(d).length>0?{proxy:d}:{}}for(let p of o)c[p]??={};for(let p of n){let d=s.get(p);d!=null&&(c[`${d}/api`]??={})}return{presetDef:{apps:c,orca:e.orca},anyCloudRoute:l,targetKeys:Object.keys(c).sort()}},R=(e,r)=>{let a=[`--target=${e.targetKeys.join(",")}`];return r.watch&&a.push("--watch"),r.orca&&a.push("--orca"),{flags:a.join(" ")}};var h={output:m.stderr,clearPromptOnDone:!0},E={select:e=>g(r=>j({message:e.message,choices:e.choices,default:e.default},r),{...h,whenHeadless:"refuse"}),checkbox:e=>g(r=>B({message:e.message,choices:e.choices},r),{...h,whenHeadless:"refuse"}),confirm:e=>g(r=>_({message:e.message,default:e.default},r),{...h,whenHeadless:"refuse"})},T=(e,r)=>{let a=new Map;for(let[t,o]of Object.entries(e)){let n={path:t,localCapable:o.from.includes("local"),cloudCapable:o.from.includes("cloud"),default:o.default},s=a.get(o.packageName);s?(s.routes.push(n),s.localCapable=s.localCapable||n.localCapable,s.cloudCapable=s.cloudCapable||n.cloudCapable):a.set(o.packageName,{packageName:o.packageName,routes:[n],localCapable:n.localCapable,cloudCapable:n.cloudCapable,ownerApp:r.get(o.packageName)})}return[...a.values()]},U=async(e,r,a)=>{try{let t=(await K(e))?.proxy?.routes;return t?T(t,a):[]}catch(t){return u.warn(`\u26A0\uFE0F  Skipping ${r}: its dev config failed to load \u2014 ${t instanceof Error?t.message:String(t)}`),[]}},H=async e=>{let r=v(e),a=w(e),t=await y(),o=new Map(r.map(i=>[i.packageName,i.name])),n=new Map(r.map(i=>[i.name,i.packageName])),s=new Set(a.map(i=>i.name)),c=new Set(r.map(i=>i.name)),l=[...new Set([...c,...s])].sort(),p=await Promise.all(l.map(async i=>{let P=s.has(i);return{name:i,hasApi:c.has(i),hasUi:P,apiPackage:n.get(i),backends:P?await U(q.join(e,"apps",i,"ui"),i,o):[]}})),d=await x();return{apps:p,presets:Object.keys(t.devServersPresets??{}),environments:Object.keys(d?.envs??{}).sort()}},V=e=>{let r=[];for(let a of e.apps){if(a.hasUi){let t=a.backends.flatMap(n=>n.routes.map(s=>s.path)),o=t.length>0?`frontend \u2014 proxies ${[...t].sort().join(", ")}`:"frontend";r.push({name:`${a.name}/ui`,value:`${a.name}/ui`,description:o})}a.hasApi&&!a.hasUi&&r.push({name:`${a.name}/api`,value:`${a.name}/api`,description:"backend"})}return r},F=e=>{let r={api:e.apps.filter(o=>o.hasApi).map(o=>o.name),ui:e.apps.filter(o=>o.hasUi).map(o=>o.name)},a={},t=new Map;for(let o of e.apps){o.apiPackage!=null&&(a[o.name]=o.apiPackage);for(let n of o.backends)for(let s of n.routes)t.set(`${o.name} ${s.path}`,n.packageName)}return{discovered:r,apiPkgByApp:a,routePkg:(o,n)=>t.get(`${o} ${n}`)}},L=(e,r)=>C({__wizard__:e},F(r)).map(a=>a.message),Z="INFRA_KIT_DEV_WIZARD_ORCA",G=()=>m.env[Z]==="1",J=async(e,r,a)=>{let t=new Map(r.apps.map(n=>[n.name,n])),o={};for(let n of a){let s=t.get(n.split("/")[0]);for(let c of s?.backends??[])for(let l of c.routes){if(!l.localCapable||!l.cloudCapable)continue;let p=await e.select({message:`\u{1F500} ${n} ${l.path} \u2192 local or cloud?`,choices:[{name:"local (this machine)",value:"local"},{name:"cloud",value:"cloud"}],default:l.default??"local"});o[`${n} ${l.path}`]=p}}return o},Q=(e,r,a)=>e.apps.find(t=>t.name===r)?.backends.flatMap(t=>t.routes).find(t=>t.path===a),X=(e,r)=>{let a=[];for(let[t,o]of Object.entries(e.presetDef.apps??{})){if(!t.endsWith("/ui")||!o.proxy)continue;let n=t.split("/")[0];for(let[s,c]of Object.entries(o.proxy)){let l=Q(r,n,s),p=l&&l.localCapable&&l.cloudCapable?"":" (only option)";a.push(`  ${t} ${s} \u2192 ${c}${p}`)}}if(a.length!==0){u.info("Resolved routes:");for(let t of[...a].sort())u.info(t)}},M=async(e,r)=>{if(r.apps.length===0)return u.warn("No apps discovered to run."),null;let a=await e.checkbox({message:"\u{1F4E6} Which packages?",choices:V(r)});if(a.length===0)return u.warn("No packages selected."),null;let t=a.filter(i=>i.endsWith("/ui")),o=await J(e,r,t),n=await e.confirm({message:"\u{1F440} Rebuild & restart on save (watch)?",default:!1}),s=G()?await e.confirm({message:"\u{1F9E9} Run each app in its own Orca pane?",default:!1}):!1,c={targets:a,sources:o,watch:n,orca:s},l=z(c,r);if(l.anyCloudRoute){if(r.environments.length===0)return u.warn("\u2601\uFE0F  This selection routes to a cloud environment, but no environment token is loaded."),u.warn("   Run `infra-kit env-load` to add one, then re-run the wizard."),null;c.env=await e.select({message:"\u2601\uFE0F  Point cloud routes at which environment?",choices:r.environments.map(i=>({name:i,value:i}))}),m.env[b]=c.env}let p=L(l.presetDef,r);if(p.length>0){u.warn("\u26A0\uFE0F  Proxy audit found issues with this selection:");for(let i of p)u.warn(`   \u2022 ${i}`);return null}X(l,r),Y(l,c);let d=l.targetKeys.filter(i=>i.endsWith("/api")).map(i=>i.split("/")[0]);return s&&d.length>0?{include:d,presetDef:l.presetDef,watch:n,orca:!0}:(s&&u.info("\u2139\uFE0F  Orca needs at least one local backend (panes are backend-only) \u2014 running in-process instead."),{presetDef:l.presetDef,watch:n,orca:!1})},Y=(e,r)=>{f.setInteractive();let a=R(e,r);f.addOption(a.flags,!0),f.print(),u.info("\u2139\uFE0F  Prefer a short name? Save this selection as a devPreset and run `infra-kit dev <name>`.")},ee=async(e,r)=>{let a=await e.confirm({message:"\u{1F440} Rebuild & restart on save (watch)?",default:!1});return f.setInteractive(),f.addOption(r,!0),a&&f.addOption("--watch",!0),f.print(),{preset:r,watch:a,orca:!1}},S=" manual",re=async(e,r)=>{if(r.presets.length===0)return M(e,r);let a=await e.select({message:"\u{1F680} Start from a preset, or configure manually?",choices:[...r.presets.map(t=>({name:t,value:t})),new I(" "),{name:"Manual (custom)\u2026",value:S}]});return a===S?M(e,r):ee(e,a)},be=async(e=E,r=k(m.cwd()))=>re(e,await H(r));export{S as MANUAL_CHOICE,Z as WIZARD_ORCA_VAR,L as auditManualPlan,E as defaultPrompts,H as gatherWizardModel,U as loadBackends,be as runDevWizard,re as runWizardFlow};
+//# sourceMappingURL=dev-wizard-run-ITRFKMTL.js.map

package/dist/dev-wizard-run-ITRFKMTL.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/dev/dev-wizard-run.ts", "../src/dev/dev-wizard.ts"],
+  "sourcesContent": ["/**\n * Impure driver for the interactive `infra-kit dev` wizard: filesystem/config discovery, the inquirer\n * prompt flow (step-0 preset-or-manual, then the manual matrix), the pre-flight proxy audit, and the\n * `commandEcho` teaching line. The pure answer\u2192plan mapping lives in {@link file://./dev-wizard.ts}.\n *\n * Prompts are behind the injectable {@link WizardPrompts} seam so the flow is testable without a TTY.\n * This module is reached ONLY from the bare-invocation TTY branch of the entry point; every flagged /\n * non-TTY / `--json` / `--agent` invocation bypasses it entirely.\n */\nimport inquirerCheckbox from '@inquirer/checkbox'\nimport inquirerConfirm from '@inquirer/confirm'\nimport inquirerSelect, { Separator } from '@inquirer/select'\nimport { loadDev } from '@slip-stream-kit/config/internal'\nimport path from 'node:path'\nimport process from 'node:process'\n\nimport { discoverApiApps, discoverUiApps, findMonorepoRoot } from 'src/dev/discovery'\nimport { commandEcho } from 'src/lib/command-echo'\nimport { INFRA_KIT_ENV_VAR } from 'src/lib/constants'\nimport { readTokenStore } from 'src/lib/env-tokens'\nimport { getInfraKitConfig } from 'src/lib/infra-kit-config'\nimport type { DevPreset, ProxySource } from 'src/lib/infra-kit-config'\nimport { logger } from 'src/lib/logger'\nimport { withEscape } from 'src/lib/prompts/escapable-context'\n\nimport { deriveManualPlan, equivalentCommand } from './dev-wizard.js'\nimport type { DerivedPlan, ManualSelection, ProxyBackend, RouteCap, WizardApp, WizardModel } from './dev-wizard.js'\nimport { validatePresetProxy } from './presets.js'\nimport type { DiscoveredParts, PresetProxyContext } from './presets.js'\n\n/** A wizard prompt choice \u2014 all values are strings, so the seam needs no generics. */\nexport interface WizardChoice {\n  name: string\n  value: string\n  description?: string\n  checked?: boolean\n  disabled?: boolean | string\n}\n\n/**\n * Injectable prompt seam (a string-valued subset of `@inquirer/*`). The default implementation\n * ({@link defaultPrompts}) delegates to the real prompts, rendering to stderr so the dev-server's\n * stdout stays clean. Tests pass a scripted object.\n */\nexport interface WizardPrompts {\n  select: (cfg: { message: string; choices: (WizardChoice | Separator)[]; default?: string }) => Promise<string>\n  checkbox: (cfg: { message: string; choices: WizardChoice[] }) => Promise<string[]>\n  confirm: (cfg: { message: string; default?: boolean }) => Promise<boolean>\n}\n\n/**\n * Shared `@inquirer/*` context. Rendered to stderr (mirrors the bare-`infra-kit` command palette).\n *\n * `clearPromptOnDone` erases each answered prompt instead of leaving a `\u2714 <question> <answer>` line\n * behind, so the wizard collapses to nothing once it finishes and the dev-server's ready header lands\n * at the top of a clean screen. The choices are not lost: {@link echoManual} / {@link runPresetBranch}\n * print the equivalent flag command, which is the durable record of what was picked.\n */\nconst promptContext = { output: process.stderr, clearPromptOnDone: true }\n\n/**\n * Real `@inquirer/*` prompts, rendered to stderr and erased once answered.\n *\n * Every one goes through {@link withEscape}, which binds Esc to cancellation. The wrap is here rather\n * than around the {@link WizardPrompts} seam so the scripted prompts the tests inject stay untouched:\n * the seam is the test boundary, `defaultPrompts` is the only implementation that talks to a terminal.\n *\n * Esc rejects with an `AbortPromptError`, which `entry/cli.ts` catches as a cancellation \u2192 exit 0. The\n * wizard therefore needs no cancel branch of its own: a cancelled prompt never returns here at all, so\n * no server is started.\n */\nexport const defaultPrompts: WizardPrompts = {\n  select: (cfg) => {\n    // The wizard is TTY-only by construction (`shouldRunWizard`); the declaration is for the sweep,\n    // which roots `entry/dev-server.ts` and reads the policy off the literal.\n    return withEscape(\n      (context) => {\n        return inquirerSelect({ message: cfg.message, choices: cfg.choices, default: cfg.default }, context)\n      },\n      { ...promptContext, whenHeadless: 'refuse' },\n    )\n  },\n  checkbox: (cfg) => {\n    return withEscape(\n      (context) => {\n        return inquirerCheckbox({ message: cfg.message, choices: cfg.choices }, context)\n      },\n      { ...promptContext, whenHeadless: 'refuse' },\n    )\n  },\n  confirm: (cfg) => {\n    return withEscape(\n      (context) => {\n        return inquirerConfirm({ message: cfg.message, default: cfg.default }, context)\n      },\n      { ...promptContext, whenHeadless: 'refuse' },\n    )\n  },\n}\n\n/** What the wizard hands back to the entry point (merged into `DevServerOptions`), or null on cancel. */\nexport interface WizardResult {\n  /** Named preset (preset branch) \u2014 passed through as `options.preset`. */\n  preset?: string\n  /** In-memory preset (manual branch, non-Orca) \u2014 passed through as `options.presetDef`. */\n  presetDef?: DevPreset\n  /**\n   * App-name include list for the Orca path only: which discovered API apps get a pane. Paired with\n   * `presetDef`, which tells each pane the exact parts to run. An app selected UI-only gets no pane\n   * (Orca panes are opened per API app). Unset for the non-Orca manual path.\n   */\n  include?: string[]\n  watch: boolean\n  orca: boolean\n}\n\n/** Group one frontend's `dev.proxy.routes` into {@link ProxyBackend}s keyed by backend package. */\nconst groupBackends = (\n  routes: Record<string, { packageName: string; from: readonly string[]; default?: 'local' | 'cloud' }>,\n  ownerByPkg: Map<string, string>,\n): ProxyBackend[] => {\n  const byPkg = new Map<string, ProxyBackend>()\n\n  for (const [route, def] of Object.entries(routes)) {\n    const cap: RouteCap = {\n      path: route,\n      localCapable: def.from.includes('local'),\n      cloudCapable: def.from.includes('cloud'),\n      default: def.default,\n    }\n    const existing = byPkg.get(def.packageName)\n\n    if (existing) {\n      existing.routes.push(cap)\n      existing.localCapable = existing.localCapable || cap.localCapable\n      existing.cloudCapable = existing.cloudCapable || cap.cloudCapable\n    } else {\n      byPkg.set(def.packageName, {\n        packageName: def.packageName,\n        routes: [cap],\n        localCapable: cap.localCapable,\n        cloudCapable: cap.cloudCapable,\n        ownerApp: ownerByPkg.get(def.packageName),\n      })\n    }\n  }\n\n  return [...byPkg.values()]\n}\n\n/**\n * Load one frontend's proxy routes and group them into backends. A config that throws \u2014 schema-invalid\n * or an import-time error \u2014 degrades THAT app to zero backends with a named warning instead of rejecting.\n * Without this, a single broken `apps/<x>/ui/infra-kit.config.ts` fails the whole `Promise.all` in\n * {@link gatherWizardModel} and takes the entire wizard down, so `infra-kit dev` becomes unusable for every\n * other app in the monorepo. Mirrors the audit path's per-app guard ({@link file://../commands/audit/preset-proxy-check.ts}).\n */\nexport const loadBackends = async (\n  uiDir: string,\n  name: string,\n  ownerByPkg: Map<string, string>,\n): Promise<ProxyBackend[]> => {\n  try {\n    const routes = (await loadDev(uiDir))?.proxy?.routes\n\n    return routes ? groupBackends(routes, ownerByPkg) : []\n  } catch (error) {\n    logger.warn(\n      `\u26A0\uFE0F  Skipping ${name}: its dev config failed to load \u2014 ${error instanceof Error ? error.message : String(error)}`,\n    )\n\n    return []\n  }\n}\n\n/** Discover apps + configs and assemble the {@link WizardModel} (backends resolved per frontend). */\nexport const gatherWizardModel = async (root: string): Promise<WizardModel> => {\n  const apiApps = discoverApiApps(root)\n  const uiApps = discoverUiApps(root)\n  const config = await getInfraKitConfig()\n\n  const ownerByPkg = new Map(\n    apiApps.map((a) => {\n      return [a.packageName, a.name] as const\n    }),\n  )\n  const apiPkgByName = new Map(\n    apiApps.map((a) => {\n      return [a.name, a.packageName] as const\n    }),\n  )\n  const uiNames = new Set(\n    uiApps.map((a) => {\n      return a.name\n    }),\n  )\n  const apiNames = new Set(\n    apiApps.map((a) => {\n      return a.name\n    }),\n  )\n  const allNames = [...new Set([...apiNames, ...uiNames])].sort()\n\n  const apps: WizardApp[] = await Promise.all(\n    allNames.map(async (name): Promise<WizardApp> => {\n      const hasUi = uiNames.has(name)\n\n      return {\n        name,\n        hasApi: apiNames.has(name),\n        hasUi,\n        apiPackage: apiPkgByName.get(name),\n        backends: hasUi ? await loadBackends(path.join(root, 'apps', name, 'ui'), name, ownerByPkg) : [],\n      }\n    }),\n  )\n\n  // The cloud-env choices are the envs we hold a token for \u2014 the same authority as `env-load`, because\n  // it is the same question. This picker writes INFRA_KIT_ENV, which `@slip-stream-kit/config/vite`\n  // reads to build the cloud backend's URL, and whose only other writer is `env-load` (which cannot run\n  // without a Doppler token). Sourcing it from the workflow options instead would put `prod` in the list\n  // for everyone \u2014 including a developer holding no prod credential \u2014 and point a local UI at\n  // production. No token, no entry.\n  const store = await readTokenStore()\n\n  return {\n    apps,\n    presets: Object.keys(config.devServersPresets ?? {}),\n    environments: Object.keys(store?.envs ?? {}).sort(),\n  }\n}\n\n/**\n * Build the checkbox choices: one `<app>/ui` per frontend, plus `<app>/api` ONLY for api-only apps\n * (an api with no ui). A full-stack `<app>/api` is deliberately NOT offered \u2014 a full-stack backend is\n * launched by choosing `local` for one of its frontend's routes (asked per-route afterwards), so the\n * checkbox stays a pick of frontends + standalone backends.\n *\n * Nothing starts checked: the manual branch is opt-in, so a run only ever launches what was explicitly\n * ticked. Pre-checking every part would make the fast path (accept the defaults) boot the whole monorepo\n * \u2014 the exact opposite of why someone reached for \"Manual\" over a preset.\n */\nconst buildPartChoices = (model: WizardModel): WizardChoice[] => {\n  const choices: WizardChoice[] = []\n\n  for (const app of model.apps) {\n    if (app.hasUi) {\n      const paths = app.backends.flatMap((b) => {\n        return b.routes.map((r) => {\n          return r.path\n        })\n      })\n      const description = paths.length > 0 ? `frontend \u2014 proxies ${[...paths].sort().join(', ')}` : 'frontend'\n\n      choices.push({ name: `${app.name}/ui`, value: `${app.name}/ui`, description })\n    }\n    if (app.hasApi && !app.hasUi) {\n      choices.push({ name: `${app.name}/api`, value: `${app.name}/api`, description: 'backend' })\n    }\n  }\n\n  return choices\n}\n\n/** Build the audit context from the gathered model (no re-reading of configs). */\nconst buildAuditContext = (model: WizardModel): PresetProxyContext => {\n  const discovered: DiscoveredParts = {\n    api: model.apps\n      .filter((a) => {\n        return a.hasApi\n      })\n      .map((a) => {\n        return a.name\n      }),\n    ui: model.apps\n      .filter((a) => {\n        return a.hasUi\n      })\n      .map((a) => {\n        return a.name\n      }),\n  }\n  const apiPkgByApp: Record<string, string> = {}\n  const routeToPkg = new Map<string, string>()\n\n  for (const app of model.apps) {\n    // Map EVERY discovered api app to its own api package \u2014 including api-only apps a frontend proxies\n    // to cross-app \u2014 so `launchedPkgs` in validatePresetProxy is faithful (mirrors preset-proxy-check.ts).\n    // Deriving this from proxy backends alone would miss api-only owners and false-positive the audit.\n    if (app.apiPackage != null) apiPkgByApp[app.name] = app.apiPackage\n    for (const b of app.backends) {\n      for (const route of b.routes) {\n        routeToPkg.set(`${app.name} ${route.path}`, b.packageName)\n      }\n    }\n  }\n\n  return {\n    discovered,\n    apiPkgByApp,\n    routePkg: (app, route) => {\n      return routeToPkg.get(`${app} ${route}`)\n    },\n  }\n}\n\n/**\n * Run the assembled plan through the SAME proxy-locality rule the root audit uses. Returns issue\n * messages (empty when clean). Catches a `local` override whose backend won't launch \u2014 the wizard's\n * derivation launches owners, so a hit means the backend has no discoverable owning app.\n */\nexport const auditManualPlan = (presetDef: DevPreset, model: WizardModel): string[] => {\n  return validatePresetProxy({ __wizard__: presetDef }, buildAuditContext(model)).map((i) => {\n    return i.message\n  })\n}\n\n/**\n * Opt back into the Orca question: set to exactly `'1'`. The prompt is temporarily off \u2014 the manual\n * branch always runs in-process \u2014 but the derivation below is kept whole for when it returns. `--orca`\n * on the command line is a separate path and stays live either way.\n */\nexport const WIZARD_ORCA_VAR = 'INFRA_KIT_DEV_WIZARD_ORCA'\n\nconst asksOrca = (): boolean => {\n  return process.env[WIZARD_ORCA_VAR] === '1'\n}\n\n/**\n * Ask, per selected frontend, an EXPLICIT local/cloud choice for every TWO-OPTION route (its `from`\n * lists both). Single-option routes are auto-picked in the pure mapping, so they are never prompted.\n * The answers are keyed `${app}/ui ${routePath}` to match {@link ManualSelection.sources}; the select's\n * default seeds from the route's declared `default` when it has one.\n */\nconst promptRouteSources = async (\n  prompts: WizardPrompts,\n  model: WizardModel,\n  uiKeys: string[],\n): Promise<Record<string, ProxySource>> => {\n  const apps = new Map(\n    model.apps.map((a) => {\n      return [a.name, a] as const\n    }),\n  )\n  const sources: Record<string, ProxySource> = {}\n\n  for (const key of uiKeys) {\n    const app = apps.get(key.split('/')[0]!)\n\n    for (const backend of app?.backends ?? []) {\n      for (const route of backend.routes) {\n        if (!route.localCapable || !route.cloudCapable) continue\n\n        const answer = await prompts.select({\n          message: `\uD83D\uDD00 ${key} ${route.path} \u2192 local or cloud?`,\n          choices: [\n            { name: 'local (this machine)', value: 'local' },\n            { name: 'cloud', value: 'cloud' },\n          ],\n          default: route.default ?? 'local',\n        })\n\n        sources[`${key} ${route.path}`] = answer as ProxySource\n      }\n    }\n  }\n\n  return sources\n}\n\n/** Look up a frontend route's capability in the model (for the recap's \"only option\" annotation). */\nconst findRouteCap = (model: WizardModel, app: string, routePath: string): RouteCap | undefined => {\n  return model.apps\n    .find((a) => {\n      return a.name === app\n    })\n    ?.backends.flatMap((b) => {\n      return b.routes\n    })\n    .find((r) => {\n      return r.path === routePath\n    })\n}\n\n/**\n * Print a one-line-per-route recap of what each frontend route resolved to, so the chosen sources are\n * visible before launch. A single-option route is annotated `(only option)` \u2014 it was auto-picked, not\n * asked. This is in addition to {@link echoManual}'s pasteable `--target` command.\n */\nconst recapSources = (plan: DerivedPlan, model: WizardModel): void => {\n  const lines: string[] = []\n\n  for (const [key, cfg] of Object.entries(plan.presetDef.apps ?? {})) {\n    if (!key.endsWith('/ui') || !cfg.proxy) continue\n\n    const app = key.split('/')[0]!\n\n    for (const [routePath, source] of Object.entries(cfg.proxy)) {\n      const cap = findRouteCap(model, app, routePath)\n      const suffix = cap && cap.localCapable && cap.cloudCapable ? '' : ' (only option)'\n\n      lines.push(`  ${key} ${routePath} \u2192 ${source}${suffix}`)\n    }\n  }\n\n  if (lines.length === 0) return\n  logger.info('Resolved routes:')\n  for (const line of [...lines].sort()) {\n    logger.info(line)\n  }\n}\n\n/** The manual-branch flow: frontends + per-route source + env + watch + orca \u2192 audited plan \u2192 recap \u2192 echo. */\nconst runManualBranch = async (prompts: WizardPrompts, model: WizardModel): Promise<WizardResult | null> => {\n  if (model.apps.length === 0) {\n    logger.warn('No apps discovered to run.')\n\n    return null\n  }\n\n  const selectedTargets = await prompts.checkbox({ message: '\uD83D\uDCE6 Which packages?', choices: buildPartChoices(model) })\n\n  if (selectedTargets.length === 0) {\n    logger.warn('No packages selected.')\n\n    return null\n  }\n\n  const uiKeys = selectedTargets.filter((t) => {\n    return t.endsWith('/ui')\n  })\n  const sources = await promptRouteSources(prompts, model, uiKeys)\n\n  const watch = await prompts.confirm({ message: '\uD83D\uDC40 Rebuild & restart on save (watch)?', default: false })\n  const orca = asksOrca()\n    ? await prompts.confirm({ message: '\uD83E\uDDE9 Run each app in its own Orca pane?', default: false })\n    : false\n\n  const selection: ManualSelection = { targets: selectedTargets, sources, watch, orca }\n  const plan = deriveManualPlan(selection, model)\n\n  if (plan.anyCloudRoute) {\n    // A cloud route needs an environment to point at, and the only environments we can offer are those we\n    // hold a token for. With none loaded, the `select` below would be handed zero choices and `@inquirer/select`\n    // throws `No selectable choices` \u2014 a raw stack on a realistic first-run path (fresh clone, no `env-load`).\n    // Back out cleanly with guidance instead, and BEFORE mutating `process.env`, so a refused run leaks nothing.\n    if (model.environments.length === 0) {\n      logger.warn('\u2601\uFE0F  This selection routes to a cloud environment, but no environment token is loaded.')\n      logger.warn('   Run `infra-kit env-load` to add one, then re-run the wizard.')\n\n      return null\n    }\n\n    selection.env = await prompts.select({\n      message: '\u2601\uFE0F  Point cloud routes at which environment?',\n      choices: model.environments.map((e) => {\n        return { name: e, value: e }\n      }),\n    })\n    process.env[INFRA_KIT_ENV_VAR] = selection.env\n  }\n\n  const issues = auditManualPlan(plan.presetDef, model)\n\n  if (issues.length > 0) {\n    logger.warn('\u26A0\uFE0F  Proxy audit found issues with this selection:')\n    for (const issue of issues) {\n      logger.warn(`   \u2022 ${issue}`)\n    }\n\n    return null\n  }\n\n  recapSources(plan, model)\n  echoManual(plan, selection)\n\n  // Orca opens one pane per selected API app. `include` picks WHICH apps get a pane; `presetDef` tells\n  // each pane exactly which of its parts to run. Without the latter a pane runs `--app=<name>`, which\n  // expands to every part the app has \u2014 silently starting a UI the user just unticked.\n  const apiApps = plan.targetKeys\n    .filter((k) => {\n      return k.endsWith('/api')\n    })\n    .map((k) => {\n      return k.split('/')[0]!\n    })\n\n  // An empty include would collapse to `null` in `normalizeAppInclude` and make Orca run EVERY api app,\n  // so an Orca run with no selected backends (e.g. an all-frontend selection) falls back to in-process.\n  if (orca && apiApps.length > 0) {\n    return { include: apiApps, presetDef: plan.presetDef, watch, orca: true }\n  }\n\n  if (orca) {\n    logger.info('\u2139\uFE0F  Orca needs at least one local backend (panes are backend-only) \u2014 running in-process instead.')\n  }\n\n  return { presetDef: plan.presetDef, watch, orca: false }\n}\n\n/** Print the equivalent (`--target=\u2026`) flag command, plus a save-as-preset ergonomics hint. */\nconst echoManual = (plan: DerivedPlan, selection: ManualSelection): void => {\n  commandEcho.setInteractive()\n\n  const eq = equivalentCommand(plan, selection)\n\n  commandEcho.addOption(eq.flags, true)\n  commandEcho.print()\n\n  // The `--target=\u2026` line reproduces the selection exactly; the preset is pure convenience \u2014 a short,\n  // memorable name instead of retyping the target keys.\n  logger.info('\u2139\uFE0F  Prefer a short name? Save this selection as a devPreset and run `infra-kit dev <name>`.')\n}\n\n/** The preset-branch flow: run a named preset, asking only whether to watch (presets can't encode it). */\nconst runPresetBranch = async (prompts: WizardPrompts, preset: string): Promise<WizardResult> => {\n  const watch = await prompts.confirm({ message: '\uD83D\uDC40 Rebuild & restart on save (watch)?', default: false })\n\n  commandEcho.setInteractive()\n  commandEcho.addOption(preset, true)\n  if (watch) commandEcho.addOption('--watch', true)\n  commandEcho.print()\n\n  return { preset, watch, orca: false }\n}\n\n/** Sentinel value for the \"Manual (custom)\" step-0 choice (a preset name can never be empty). */\nexport const MANUAL_CHOICE = ' manual'\n\n/**\n * Drive the wizard's branch flow over an ALREADY-gathered model (no disk/config access). Split from\n * {@link runDevWizard} so the flow is unit-testable with scripted prompts + a fixture model.\n */\nexport const runWizardFlow = async (prompts: WizardPrompts, model: WizardModel): Promise<WizardResult | null> => {\n  if (model.presets.length === 0) {\n    return runManualBranch(prompts, model)\n  }\n\n  const choice = await prompts.select({\n    message: '\uD83D\uDE80 Start from a preset, or configure manually?',\n    choices: [\n      ...model.presets.map((p) => {\n        return { name: p, value: p }\n      }),\n      new Separator(' '),\n      { name: 'Manual (custom)\u2026', value: MANUAL_CHOICE },\n    ],\n  })\n\n  return choice === MANUAL_CHOICE ? runManualBranch(prompts, model) : runPresetBranch(prompts, choice)\n}\n\n/**\n * Gather the model from disk/config, then drive the wizard flow, returning the resolved run options (or\n * null on cancel / empty selection). The entry point calls this on a bare TTY `infra-kit dev`.\n */\nexport const runDevWizard = async (\n  prompts: WizardPrompts = defaultPrompts,\n  root: string = findMonorepoRoot(process.cwd()),\n): Promise<WizardResult | null> => {\n  return runWizardFlow(prompts, await gatherWizardModel(root))\n}\n", "/**\n * Pure core of the interactive `infra-kit dev` wizard (the no-args, TTY path).\n *\n * The wizard is FRONTEND-CENTRIC: you pick which frontends to run, and for each frontend you choose,\n * every proxy route that has TWO real options (its `from` lists both `local` and `cloud`) is decided\n * EXPLICITLY \u2014 local (its backend is launched \u2192 the route resolves local) or cloud (the route proxies\n * to the `<env>` cloud target). Single-option routes are auto-picked. Because a backend runs local OR\n * cloud as a whole, routes that share one backend package RECONCILE: if any of them resolved local, the\n * backend runs local and all its local-capable routes follow. This module turns those answers into an\n * in-memory {@link DevPreset} the runner consumes verbatim (part-level targets the app-name-only `--app`\n * include cannot express) \u2014 and is side-effect-free so the mapping is fully unit-testable. The impure\n * I/O (discovery, inquirer prompts, audit, launch) lives in {@link file://./dev-wizard-run.ts}.\n */\nimport type { DevPreset, ProxySource } from 'src/lib/infra-kit-config'\n\n/**\n * One proxy route's per-route capability, carried through grouping so the wizard can decide whether it\n * even needs to ask about the route (only a `local`+`cloud` route is a real choice).\n */\nexport interface RouteCap {\n  /** Route path (e.g. `/api`). */\n  path: string\n  /** `from` includes `local` \u2014 the route can resolve to a locally-launched backend. */\n  localCapable: boolean\n  /** `from` includes `cloud` \u2014 the route can resolve to the cloud target. */\n  cloudCapable: boolean\n  /** The route's declared `default` source when it has one (present iff `from` lists >1 source) \u2014 seeds the prompt's default. */\n  default?: ProxySource\n}\n\n/**\n * One backend a frontend's proxy routes can be pointed at, grouped by the backend package. A frontend\n * that maps `/api` and `/media` to the same package yields ONE {@link ProxyBackend} with both routes \u2014\n * launching the package flips every one of its `local`-capable routes together (the reconcile in\n * {@link deriveManualPlan}).\n */\nexport interface ProxyBackend {\n  /** Backend package name (a route's `packageName`). */\n  packageName: string\n  /** The routes that resolve to this package, each with its own local/cloud capability. */\n  routes: RouteCap[]\n  /** True when at least one of `routes` lists `local` in its `from` capabilities \u2014 i.e. it is launchable-local. */\n  localCapable: boolean\n  /** True when at least one of `routes` lists `cloud` \u2014 i.e. it can stay on the cloud target. */\n  cloudCapable: boolean\n  /** App folder whose `api` package is {@link packageName}, or undefined when no discovered app owns it (a `local` choice then has nothing to launch \u2014 the audit flags it). */\n  ownerApp?: string\n}\n\n/** A discovered app as the wizard sees it: which parts exist + which backends its frontend proxies to. */\nexport interface WizardApp {\n  /** App folder name (e.g. `client`). */\n  name: string\n  /** Has `apps/<app>/api` (a launchable backend). */\n  hasApi: boolean\n  /** Has `apps/<app>/ui` (a launchable frontend). */\n  hasUi: boolean\n  /**\n   * This app's OWN `api` package name (from `apps/<app>/api`), or undefined when it has no api. Carried\n   * so the audit can build a faithful `app \u2192 apiPackage` map for EVERY discovered api app \u2014 including\n   * api-only apps a frontend proxies to cross-app \u2014 mirroring the root audit (`preset-proxy-check.ts`).\n   */\n  apiPackage?: string\n  /** Backends this app's frontend proxies to (empty for api-only apps or a frontend with no `dev.proxy`). */\n  backends: ProxyBackend[]\n}\n\n/** Everything the wizard needs, gathered impurely by {@link file://./dev-wizard-run.ts}. */\nexport interface WizardModel {\n  /** All discovered apps (api and/or ui), sorted by name. */\n  apps: WizardApp[]\n  /** `devServersPresets` names (drives the preset-or-manual step-0). */\n  presets: string[]\n  /** Configured `environments` (the cloud-env `select` options). */\n  environments: string[]\n}\n\n/** The manual-branch answers collected from the prompts, fed to {@link deriveManualPlan}. */\nexport interface ManualSelection {\n  /**\n   * The target keys the user ticked directly: every selected `<app>/ui` frontend, plus any api-only\n   * `<app>/api` backend (apps with an api but no ui). A full-stack backend is NOT ticked here \u2014 it is\n   * launched by choosing `local` for one of its frontend's routes (recorded in {@link sources}).\n   */\n  targets: string[]\n  /**\n   * Explicit per-route choice for every TWO-OPTION route, keyed `${app}/ui ${routePath}` (e.g.\n   * `client/ui /api`). Single-option routes are absent (auto-picked). Missing two-option answers fall\n   * back to the route's cloud/local capability in {@link deriveManualPlan}.\n   */\n  sources: Record<string, ProxySource>\n  /** Chosen cloud env for cloud routes (undefined when nothing resolves cloud). */\n  env?: string\n  /** Rebuild + restart on save. */\n  watch: boolean\n  /** One Orca pane per app. */\n  orca: boolean\n}\n\n/** The resolved run plan derived from a {@link ManualSelection}. */\nexport interface DerivedPlan {\n  /** In-memory preset handed to the runner (`options.presetDef`). */\n  presetDef: DevPreset\n  /** At least one route resolves to cloud \u2192 an env must be chosen (pre-flight gate). */\n  anyCloudRoute: boolean\n  /** Resolved `<app>/<part>` target keys, sorted \u2014 for the echo + audit display. */\n  targetKeys: string[]\n}\n\n/** App folder name from an `<app>/<part>` target key. */\nconst appOf = (key: string): string => {\n  return key.split('/')[0]!\n}\n\n/** Index a model's apps by folder name for O(1) lookup. */\nconst byName = (model: WizardModel): Map<string, WizardApp> => {\n  return new Map(\n    model.apps.map((a) => {\n      return [a.name, a]\n    }),\n  )\n}\n\n/** Is this route a real choice (both local and cloud reachable)? */\nconst isTwoOption = (route: RouteCap): boolean => {\n  return route.localCapable && route.cloudCapable\n}\n\n/**\n * The source a single route resolves to BEFORE per-backend reconciliation:\n *  - two-option: the user's recorded answer, else 'cloud' when cloud-capable else 'local';\n *  - single local-only: always 'local';\n *  - single cloud-only: always 'cloud'.\n */\nconst rawSource = (uiKey: string, route: RouteCap, sources: Record<string, ProxySource>): ProxySource => {\n  if (isTwoOption(route)) {\n    return sources[`${uiKey} ${route.path}`] ?? (route.cloudCapable ? 'cloud' : 'local')\n  }\n\n  return route.localCapable ? 'local' : 'cloud'\n}\n\n/**\n * Pass 1: which backend packages resolve local (any of their routes did), plus each package's owner app.\n * A package's local verdict is shared across every frontend that proxies to it \u2014 that is the reconcile.\n */\nconst collectLocalPackages = (\n  uiKeys: string[],\n  apps: Map<string, WizardApp>,\n  sources: Record<string, ProxySource>,\n): { localPkgs: Set<string>; ownerByPkg: Map<string, string | undefined> } => {\n  const localPkgs = new Set<string>()\n  const ownerByPkg = new Map<string, string | undefined>()\n\n  for (const key of uiKeys) {\n    const app = apps.get(appOf(key))\n\n    for (const backend of app?.backends ?? []) {\n      ownerByPkg.set(backend.packageName, backend.ownerApp)\n      for (const route of backend.routes) {\n        if (rawSource(key, route, sources) === 'local') localPkgs.add(backend.packageName)\n      }\n    }\n  }\n\n  return { localPkgs, ownerByPkg }\n}\n\n/**\n * Pass 2 for ONE frontend: its per-route overrides after the per-package verdict, and whether any route\n * went cloud. A local-capable route on a local package is `local` (reconciled up); everything else `cloud`.\n */\nconst frontendOverrides = (\n  app: WizardApp | undefined,\n  localPkgs: ReadonlySet<string>,\n): { overrides: Record<string, ProxySource>; anyCloud: boolean } => {\n  const overrides: Record<string, ProxySource> = {}\n  let anyCloud = false\n\n  for (const backend of app?.backends ?? []) {\n    const backendLocal = localPkgs.has(backend.packageName)\n\n    for (const route of backend.routes) {\n      const source: ProxySource = route.localCapable && backendLocal ? 'local' : 'cloud'\n\n      overrides[route.path] = source\n      if (source === 'cloud') anyCloud = true\n    }\n  }\n\n  return { overrides, anyCloud }\n}\n\n/**\n * Turn the manual {@link ManualSelection} into an in-memory {@link DevPreset}. The frontend checkbox picks\n * which UIs (and standalone api-only backends) to run; the per-route answers in {@link ManualSelection.sources}\n * decide each two-option route. Resolution is two passes so same-backend routes stay coherent:\n *\n *  1. Resolve every route of every selected frontend to its raw source; a package is LOCAL iff any of its\n *     routes resolved local.\n *  2. Re-resolve each route against that per-package verdict: a local-capable route on a local package is\n *     `local` (reconciled up even if it was individually answered cloud); a cloud-only route stays `cloud`.\n *\n * Launched backends are the ticked api-only parts \u222A every package that resolved local (added as\n * `${ownerApp}/api` when the owner is discoverable \u2014 a local override on an owner-less package is still\n * emitted, and the audit flags it).\n *\n * @example\n * // client frontend, its /api answered local \u2192 launches client/api + client/ui, /api resolves local:\n * deriveManualPlan(\n *   { targets: ['client/ui'], sources: { 'client/ui /api': 'local' }, watch: false, orca: false },\n *   { apps: [{ name: 'client', hasApi: true, hasUi: true, backends: [{ packageName: 'client-api',\n *              cloudCapable: true, localCapable: true, ownerApp: 'client',\n *              routes: [{ path: '/api', localCapable: true, cloudCapable: true }] }] }],\n *     presets: [], environments: ['dev'] },\n * ).targetKeys // => ['client/api', 'client/ui']\n */\nexport const deriveManualPlan = (selection: ManualSelection, model: WizardModel): DerivedPlan => {\n  const apps = byName(model)\n  const uiKeys = selection.targets.filter((t) => {\n    return t.endsWith('/ui')\n  })\n  const apiOnlyKeys = selection.targets.filter((t) => {\n    return t.endsWith('/api')\n  })\n\n  // Pass 1: a package is local iff any of its routes (across every selected frontend) resolved local.\n  const { localPkgs, ownerByPkg } = collectLocalPackages(uiKeys, apps, selection.sources)\n\n  // Pass 2: re-resolve each route against the per-package verdict + build per-frontend overrides.\n  const presetApps: Record<string, { proxy?: Record<string, ProxySource> }> = {}\n  let anyCloud = false\n\n  for (const key of uiKeys) {\n    const { overrides, anyCloud: cloud } = frontendOverrides(apps.get(appOf(key)), localPkgs)\n\n    if (cloud) anyCloud = true\n    presetApps[key] = Object.keys(overrides).length > 0 ? { proxy: overrides } : {}\n  }\n\n  // Launch: the ticked api-only backends, plus every package that resolved local (via its owner app).\n  for (const key of apiOnlyKeys) {\n    presetApps[key] ??= {}\n  }\n  for (const pkg of localPkgs) {\n    const owner = ownerByPkg.get(pkg)\n\n    if (owner != null) presetApps[`${owner}/api`] ??= {}\n  }\n\n  return {\n    presetDef: { apps: presetApps, orca: selection.orca },\n    anyCloudRoute: anyCloud,\n    targetKeys: Object.keys(presetApps).sort(),\n  }\n}\n\n/** The equivalent non-interactive command for a derived plan. */\nexport interface EquivalentCommand {\n  /** The `--target=<app>/<part>,\u2026`-form flag string (no leading `infra-kit dev`). */\n  flags: string\n}\n\n/**\n * Build the equivalent `infra-kit dev --target=\u2026 [--watch] [--orca]` flag string for a derived plan.\n * Always exact: `--target` names packages at `<app>/<part>` granularity \u2014 the same grammar the plan's\n * `targetKeys` already use \u2014 so every wizard selection, whole-app or part-level, round-trips into a\n * pasteable command. (`--app` is deliberately NOT used here: its app-name granularity over-launches a\n * part-level pick \u2014 `--app=client` starts `client/api` even when only `client/ui` was ticked.)\n */\nexport const equivalentCommand = (plan: DerivedPlan, selection: ManualSelection): EquivalentCommand => {\n  const parts = [`--target=${plan.targetKeys.join(',')}`]\n\n  if (selection.watch) parts.push('--watch')\n  if (selection.orca) parts.push('--orca')\n\n  return { flags: parts.join(' ') }\n}\n"],
+  "mappings": "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",
+  "names": ["inquirerCheckbox", "inquirerConfirm", "inquirerSelect", "Separator", "loadDev", "path", "process", "appOf", "key", "byName", "model", "a", "isTwoOption", "route", "rawSource", "uiKey", "sources", "collectLocalPackages", "uiKeys", "apps", "localPkgs", "ownerByPkg", "app", "backend", "frontendOverrides", "overrides", "anyCloud", "backendLocal", "source", "deriveManualPlan", "selection", "t", "apiOnlyKeys", "presetApps", "cloud", "pkg", "owner", "equivalentCommand", "plan", "parts", "promptContext", "process", "defaultPrompts", "cfg", "withEscape", "context", "inquirerSelect", "inquirerCheckbox", "inquirerConfirm", "groupBackends", "routes", "ownerByPkg", "byPkg", "route", "def", "cap", "existing", "loadBackends", "uiDir", "name", "loadDev", "error", "logger", "gatherWizardModel", "root", "apiApps", "discoverApiApps", "uiApps", "discoverUiApps", "config", "getInfraKitConfig", "a", "apiPkgByName", "uiNames", "apiNames", "allNames", "apps", "hasUi", "path", "store", "readTokenStore", "buildPartChoices", "model", "choices", "app", "paths", "b", "r", "description", "buildAuditContext", "discovered", "apiPkgByApp", "routeToPkg", "auditManualPlan", "presetDef", "validatePresetProxy", "i", "WIZARD_ORCA_VAR", "asksOrca", "promptRouteSources", "prompts", "uiKeys", "sources", "key", "backend", "answer", "findRouteCap", "routePath", "recapSources", "plan", "lines", "source", "suffix", "line", "runManualBranch", "selectedTargets", "t", "watch", "orca", "selection", "deriveManualPlan", "e", "INFRA_KIT_ENV_VAR", "issues", "issue", "echoManual", "k", "commandEcho", "eq", "equivalentCommand", "runPresetBranch", "preset", "MANUAL_CHOICE", "runWizardFlow", "choice", "p", "Separator", "runDevWizard", "findMonorepoRoot"]
+}

package/dist/mcp-proxy.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import{u as G}from"./chunk-6OFUVD7F.js";import{a as M}from"./chunk-MFAFQVTW.js";import"./chunk-HHWP3YXW.js";import{a as W,d as H,n as T,p as E,t as K}from"./chunk-75URROMU.js";import m from"node:process";var ve=/^[a-z][a-z0-9-]*$/,ye=/^[A-Z_]\w*$/i,Pe=(e,n,r)=>n==="--name"?e.name!==null?"--name given twice":ve.test(r)?(e.name=r,null):`--name "${r}" must be lowercase letters, digits and hyphens`:n==="--env"||n==="--unset"?ye.test(r)?M.has(r)?`${n} "${r}" is process plumbing, not a credential`:(n==="--env"?e.env.push(r):e.unset.push(r),null):`${n} "${r}" is not an environment-variable name`:`unknown flag ${n}`,Se=(e,n)=>{let r=0;for(;r<e.length;){let o=e[r];if(o==="--")return{separator:r};if(!o.startsWith("--"))return{problem:`missing "--" before the upstream command (saw "${o}")`};let a=e[r+1];if(a===void 0||a.startsWith("--"))return{problem:`${o} needs a value`};let p=Pe(n,o,a);if(p!==null)return{problem:p};r+=2}return{problem:'missing "--" before the upstream command'}},Q=e=>{let n={name:null,env:[],unset:[]},r=Se(e,n);if("problem"in r)return{ok:!1,problem:r.problem};if(n.name===null)return{ok:!1,problem:"missing --name"};if(n.env.length===0)return{ok:!1,problem:"missing --env (at least one variable to read)"};let o=e[r.separator+1];return o===void 0||o.length===0?{ok:!1,problem:'missing upstream command after "--"'}:{ok:!0,spec:{name:n.name,command:o,args:e.slice(r.separator+2),env:n.env,unset:n.unset}}};import{spawnSync as xe}from"node:child_process";import C from"node:fs";import x from"node:path";import O from"node:process";var Y=e=>x.join(E(),"mcp-proxy",e),be=e=>e.replaceAll(/[^\w.-]/g,"_").slice(0,64),Z=(e,n)=>x.join(n,`profile-${be(e)}.json`),A=(e,n)=>{let r=x.isAbsolute(e)?[e]:(n??O.env.PATH??"").split(x.delimiter).map(o=>x.join(o,e));for(let o of r)try{let a=C.statSync(o);return`stat-${a.size}-${Math.trunc(a.mtimeMs)}`}catch{}return"unknown"},X=(e,n=["--version"],r)=>{try{let o=xe(e,[...n],{encoding:"utf8",timeout:5e3,env:r==null?O.env:{...O.env,PATH:r}});if(o.status!==0)return A(e,r);let a=`${o.stdout}`.trim().split(`
+import{u as G}from"./chunk-YYC3QGGC.js";import"./chunk-AWFGP6GY.js";import{a as M}from"./chunk-MFAFQVTW.js";import{a as W,d as H,n as T,o as E,s as K}from"./chunk-MOVRKV3I.js";import m from"node:process";var ve=/^[a-z][a-z0-9-]*$/,ye=/^[A-Z_]\w*$/i,Pe=(e,n,r)=>n==="--name"?e.name!==null?"--name given twice":ve.test(r)?(e.name=r,null):`--name "${r}" must be lowercase letters, digits and hyphens`:n==="--env"||n==="--unset"?ye.test(r)?M.has(r)?`${n} "${r}" is process plumbing, not a credential`:(n==="--env"?e.env.push(r):e.unset.push(r),null):`${n} "${r}" is not an environment-variable name`:`unknown flag ${n}`,Se=(e,n)=>{let r=0;for(;r<e.length;){let o=e[r];if(o==="--")return{separator:r};if(!o.startsWith("--"))return{problem:`missing "--" before the upstream command (saw "${o}")`};let a=e[r+1];if(a===void 0||a.startsWith("--"))return{problem:`${o} needs a value`};let p=Pe(n,o,a);if(p!==null)return{problem:p};r+=2}return{problem:'missing "--" before the upstream command'}},Q=e=>{let n={name:null,env:[],unset:[]},r=Se(e,n);if("problem"in r)return{ok:!1,problem:r.problem};if(n.name===null)return{ok:!1,problem:"missing --name"};if(n.env.length===0)return{ok:!1,problem:"missing --env (at least one variable to read)"};let o=e[r.separator+1];return o===void 0||o.length===0?{ok:!1,problem:'missing upstream command after "--"'}:{ok:!0,spec:{name:n.name,command:o,args:e.slice(r.separator+2),env:n.env,unset:n.unset}}};import{spawnSync as xe}from"node:child_process";import C from"node:fs";import x from"node:path";import O from"node:process";var Y=e=>x.join(E(),"mcp-proxy",e),be=e=>e.replaceAll(/[^\w.-]/g,"_").slice(0,64),Z=(e,n)=>x.join(n,`profile-${be(e)}.json`),A=(e,n)=>{let r=x.isAbsolute(e)?[e]:(n??O.env.PATH??"").split(x.delimiter).map(o=>x.join(o,e));for(let o of r)try{let a=C.statSync(o);return`stat-${a.size}-${Math.trunc(a.mtimeMs)}`}catch{}return"unknown"},X=(e,n=["--version"],r)=>{try{let o=xe(e,[...n],{encoding:"utf8",timeout:5e3,env:r==null?O.env:{...O.env,PATH:r}});if(o.status!==0)return A(e,r);let a=`${o.stdout}`.trim().split(`
 `)[0]?.trim()??"";return a.length>0?a:A(e,r)}catch{return A(e,r)}},ee=(e,n)=>{try{let r=JSON.parse(C.readFileSync(Z(e,n),"utf8"));return r.version!==e||!Array.isArray(r.tools)?null:{version:e,protocolVersion:typeof r.protocolVersion=="string"?r.protocolVersion:"",capabilities:r.capabilities??{},tools:r.tools}}catch{return null}},re=(e,n)=>{try{return C.mkdirSync(n,{recursive:!0}),K(Z(e.version,n),`${JSON.stringify(e)}
 `,384),!0}catch{return!1}};import we from"node:path";import L from"node:process";var Ee="no-session",Me="IK_MCP_ENV_FILE",Re=()=>{let e=L.env[H];return e!=null&&e.length>0?e:Ee},R=()=>{let e=L.env[Me];return e!=null&&e.length>0?e:we.join(E(),Re(),W)},$e=(e,n)=>{let r=e[n];if(r!=null&&r.length>0)return r;let o=L.env[n];return o!=null&&o.length>0?o:""},ne=(e,n=R())=>{let r=T(n),o={};for(let a of e){let p=$e(r,a);if(p.length===0)return null;o[a]=p}return o},te=(e,n=R())=>{let r=new Set(e);return Object.keys(T(n)).filter(o=>!r.has(o))};var $=(e,n)=>{let r="";e.setEncoding("utf8"),e.on("data",o=>{r+=o;let a=r.indexOf(`
 `);for(;a!==-1;){let p=r.slice(0,a);r=r.slice(a+1);let f=p.endsWith("\r")?p.slice(0,-1):p;f.trim().length>0&&n(f),a=r.indexOf(`

package/dist/update-check.js

@@ -1,2 +1,2 @@
-import{l as t,q as i}from"./chunk-AEVL5XWO.js";import"./chunk-HHWP3YXW.js";import"./chunk-75URROMU.js";import a from"node:fs";import o from"node:process";import{fileURLToPath as s}from"node:url";var m=r=>{let n=r.indexOf("--parent-pid");if(n===-1)return;let e=Number(r[n+1]);return Number.isInteger(e)&&e>0?e:void 0},p=()=>a.realpathSync(s(new URL("./cli.js",import.meta.url))),d=async()=>{await i(t.version,{selfRealPath:p(),parentPid:m(o.argv)})};d().catch(()=>{o.exitCode=0});
+import{l as t,q as i}from"./chunk-JUNJK2YC.js";import"./chunk-AWFGP6GY.js";import"./chunk-MOVRKV3I.js";import a from"node:fs";import o from"node:process";import{fileURLToPath as s}from"node:url";var m=r=>{let n=r.indexOf("--parent-pid");if(n===-1)return;let e=Number(r[n+1]);return Number.isInteger(e)&&e>0?e:void 0},p=()=>a.realpathSync(s(new URL("./cli.js",import.meta.url))),d=async()=>{await i(t.version,{selfRealPath:p(),parentPid:m(o.argv)})};d().catch(()=>{o.exitCode=0});
 //# sourceMappingURL=update-check.js.map

package/dist/update-check.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../src/entry/update-check.ts"],
-  "sourcesContent": ["/**\n * Background auto-update worker. Spawned detached by `maybeAutoUpdate` as\n * `node dist/update-check.js --parent-pid <pid>`, and NEVER run by a human.\n *\n * This is a dedicated bundle, a sibling of `dist/cli.js`, for the same reason `dist/mcp.js` is: booting\n * `cli.js` here would re-run commander, the command catalog, `warnIfLocalInstall()`, and\n * `maybeAutoUpdate()` itself as top-level side effects \u2014 the last of which would spawn another child,\n * and another. Importing nothing from `src/entry/cli.ts` is a hard invariant, guarded by a test.\n *\n * It carries NO hashbang: nothing execs it directly, and `dist-shebang.test.ts` asserts its absence.\n * It writes nothing to stdout (it is spawned with `stdio: 'ignore'`, so there is nowhere to write).\n */\nimport fs from 'node:fs'\nimport process from 'node:process'\nimport { fileURLToPath } from 'node:url'\n\n// Deep import, not the `src/lib/update-check` barrel: the barrel re-exports `maybeAutoUpdate`, which would\n// drag the parent-side spawn path (and pino) into this worker's bundle for no reason.\nimport { runUpdateCheck } from 'src/lib/update-check/run-update-check'\n\nimport packageJson from '../../package.json' with { type: 'json' }\n\n/** `--parent-pid <pid>`, or undefined when absent/malformed (then we install without waiting). */\nconst parseParentPid = (argv: string[]): number | undefined => {\n  const index = argv.indexOf('--parent-pid')\n\n  if (index === -1) return undefined\n\n  const pid = Number(argv[index + 1])\n\n  return Number.isInteger(pid) && pid > 0 ? pid : undefined\n}\n\n/** The installed `dist/cli.js` beside this bundle \u2014 the path whose owning package manager we detect. */\nconst selfRealPath = (): string => {\n  return fs.realpathSync(fileURLToPath(new URL('./cli.js', import.meta.url)))\n}\n\nconst main = async (): Promise<void> => {\n  await runUpdateCheck(packageJson.version, {\n    selfRealPath: selfRealPath(),\n    parentPid: parseParentPid(process.argv),\n  })\n}\n\n// A detached background worker must never surface a crash, a non-zero exit, or an unhandled rejection \u2014\n// there is no one to see it and nothing depends on it. `runUpdateCheck` already swallows its own\n// failures; this is the last line of defence around path resolution and JSON import.\nmain().catch(() => {\n  process.exitCode = 0\n})\n"],
+  "sourcesContent": ["/**\n * Background auto-update worker. Spawned detached by `maybeAutoUpdate` as\n * `node dist/update-check.js --parent-pid <pid>`, and NEVER run by a human.\n *\n * This is a dedicated bundle, a sibling of `dist/cli.js`, for the same reason `dist/mcp-proxy.js` is: booting\n * `cli.js` here would re-run commander, the command catalog, `warnIfLocalInstall()`, and\n * `maybeAutoUpdate()` itself as top-level side effects \u2014 the last of which would spawn another child,\n * and another. Importing nothing from `src/entry/cli.ts` is a hard invariant, guarded by a test.\n *\n * It carries NO hashbang: nothing execs it directly, and `dist-shebang.test.ts` asserts its absence.\n * It writes nothing to stdout (it is spawned with `stdio: 'ignore'`, so there is nowhere to write).\n */\nimport fs from 'node:fs'\nimport process from 'node:process'\nimport { fileURLToPath } from 'node:url'\n\n// Deep import, not the `src/lib/update-check` barrel: the barrel re-exports `maybeAutoUpdate`, which would\n// drag the parent-side spawn path (and pino) into this worker's bundle for no reason.\nimport { runUpdateCheck } from 'src/lib/update-check/run-update-check'\n\nimport packageJson from '../../package.json' with { type: 'json' }\n\n/** `--parent-pid <pid>`, or undefined when absent/malformed (then we install without waiting). */\nconst parseParentPid = (argv: string[]): number | undefined => {\n  const index = argv.indexOf('--parent-pid')\n\n  if (index === -1) return undefined\n\n  const pid = Number(argv[index + 1])\n\n  return Number.isInteger(pid) && pid > 0 ? pid : undefined\n}\n\n/** The installed `dist/cli.js` beside this bundle \u2014 the path whose owning package manager we detect. */\nconst selfRealPath = (): string => {\n  return fs.realpathSync(fileURLToPath(new URL('./cli.js', import.meta.url)))\n}\n\nconst main = async (): Promise<void> => {\n  await runUpdateCheck(packageJson.version, {\n    selfRealPath: selfRealPath(),\n    parentPid: parseParentPid(process.argv),\n  })\n}\n\n// A detached background worker must never surface a crash, a non-zero exit, or an unhandled rejection \u2014\n// there is no one to see it and nothing depends on it. `runUpdateCheck` already swallows its own\n// failures; this is the last line of defence around path resolution and JSON import.\nmain().catch(() => {\n  process.exitCode = 0\n})\n"],
   "mappings": "uGAYA,OAAOA,MAAQ,UACf,OAAOC,MAAa,eACpB,OAAS,iBAAAC,MAAqB,WAS9B,IAAMC,EAAkBC,GAAuC,CAC7D,IAAMC,EAAQD,EAAK,QAAQ,cAAc,EAEzC,GAAIC,IAAU,GAAI,OAElB,IAAMC,EAAM,OAAOF,EAAKC,EAAQ,CAAC,CAAC,EAElC,OAAO,OAAO,UAAUC,CAAG,GAAKA,EAAM,EAAIA,EAAM,MAClD,EAGMC,EAAe,IACZC,EAAG,aAAaC,EAAc,IAAI,IAAI,WAAY,YAAY,GAAG,CAAC,CAAC,EAGtEC,EAAO,SAA2B,CACtC,MAAMC,EAAeC,EAAY,QAAS,CACxC,aAAcL,EAAa,EAC3B,UAAWJ,EAAeU,EAAQ,IAAI,CACxC,CAAC,CACH,EAKAH,EAAK,EAAE,MAAM,IAAM,CACjBG,EAAQ,SAAW,CACrB,CAAC",
   "names": ["fs", "process", "fileURLToPath", "parseParentPid", "argv", "index", "pid", "selfRealPath", "fs", "fileURLToPath", "main", "runUpdateCheck", "package_default", "process"]
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "infra-kit",
   "type": "module",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "files": [
     "dist"
   ],
@@ -21,8 +21,7 @@
     "@inquirer/input": "^5.1.6",
     "@inquirer/password": "^5.2.2",
     "@inquirer/select": "^5.2.5",
-    "@modelcontextprotocol/server": "^2.0.0",
-    "@slip-stream-kit/config": "^0.8.0",
+    "@slip-stream-kit/config": "^0.10.0",
     "chalk": "^6.0.0",
     "chokidar": "^5.0.0",
     "commander": "^15.0.0",
@@ -37,9 +36,7 @@
     "zx": "^8.8.5"
   },
   "devDependencies": {
-    "@modelcontextprotocol/client": "^2.0.0",
-    "@modelcontextprotocol/sdk": "^1.30.0",
-    "@slip-stream-kit/eslint-plugin": "0.8.0",
+    "@slip-stream-kit/eslint-plugin": "0.10.0",
     "@types/aws-lambda": "^8.10.163",
     "@types/react": "19.3.0",
     "@wl/eslint-config": "0.1.0",
@@ -49,7 +46,6 @@
     "typescript": "^6.0.3"
   },
   "scripts": {
-    "inspector": "npx @modelcontextprotocol/inspector node ./dist/mcp.js --debug",
     "build": "pnpm run clean-artifacts && node ./scripts/build.js",
     "infra-kit-check": "pnpm exec infra-kit audit",
     "clean-artifacts": "rm -rf dist",

package/readme.md

@@ -66,7 +66,6 @@ Strict schema file that declares audit rules (`requiredScripts`, `requiredFiles`
 |                   | `worktrees list`                                                        | List all worktrees                                                                                                                                                                                                                                                                                                                                                                                                           |
 |                   | `worktrees remove`                                                      | Remove a worktree (no `--force`; a branch git refuses is reported and the command exits non-zero; a leftover git already unregistered that holds only `.omc/state`, `.omc/sessions` or `.DS_Store` is swept automatically)                                                                                                                                                                                                   |
 |                   | `worktrees sync`                                                        | Sync worktree state (same removal and failure reporting as `worktrees remove`)                                                                                                                                                                                                                                                                                                                                               |
-|                   | `reopen`                                                                | Reopen a closed worktree                                                                                                                                                                                                                                                                                                                                                                                                     |
 | **Environment**   | `env-status`                                                            | Show Doppler env status                                                                                                                                                                                                                                                                                                                                                                                                      |
 |                   | `env-list`                                                              | List secrets in current env                                                                                                                                                                                                                                                                                                                                                                                                  |
 |                   | `env-load`                                                              | Load env secrets into shell                                                                                                                                                                                                                                                                                                                                                                                                  |
@@ -111,7 +110,7 @@ When infra-kit runs as an MCP server (via `.mcp.json`), these commands are avail
 - `gh-merge-dev`, `gh-release-list`, `release-create`, `release-remove`, `release-desc-edit`, `gh-release-deploy-all`, `gh-release-deploy-selected`
 - `release-create` offers an argument form when `releases` is omitted (one release; batches are arguments-only).
 - `local-deploy-all`, `local-deploy-selected`
-- `worktrees-add`, `worktrees-list`, `reopen`, `worktrees-remove`, `worktrees-sync`
+- `worktrees-add`, `worktrees-list`, `worktrees-remove`, `worktrees-sync`
 - `env-status`, `env-list`, `env-load`, `env-clear`, `env-token-list`
 - `config-get`, `vendor-check`
 - `audit`, `version`

package/dist/boot-BL4EQMZV.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/tui/boot.tsx", "../src/tui/screens/branch-multi-picker.tsx", "../src/tui/hooks/use-list-filter.ts", "../src/tui/screens/palette-window.ts", "../src/tui/screens/branch-picker.tsx", "../src/tui/screens/command-palette.tsx"],
-  "sourcesContent": ["import { render } from 'ink'\nimport process from 'node:process'\nimport type { ReactElement } from 'react'\n\nimport { stdinReaderCount } from 'src/lib/prompts/stdin-ref'\nimport type { BranchPickerItem } from 'src/lib/prompts/types'\nimport { suspendForeground } from 'src/lib/session/suspend-foreground'\n\nimport { safeStderr } from './safe-stderr'\nimport { BranchMultiPicker } from './screens/branch-multi-picker'\nimport { BranchPicker } from './screens/branch-picker'\nimport { CommandPalette } from './screens/command-palette'\nimport type { PaletteItem } from './types'\n\n/**\n * Entry point for the Ink TUI. This module (and everything under `src/tui/`) is\n * the ONLY place allowed to import `ink`/`react`; it is reached exclusively via a\n * dynamic `await import('src/tui/boot')` from the TTY branch of entry/cli.ts, so\n * React never loads on the MCP / `--json` / non-TTY paths. Build splitting keeps\n * it in a separate lazy chunk (see scripts/build.js).\n */\n\n/**\n * Render an Ink element to stderr and resolve once it tears down. Frames are\n * written to stderr so stdout stays clean for the command that runs afterwards\n * (mirrors the previous Inquirer menu).\n *\n * STDIN \u2014 Ink is self-balancing (it refs when it arms raw mode, unrefs on teardown), so the common\n * paths need nothing from here. The re-assert below is CONDITIONAL on the reader counter and is a\n * net for the one case Ink cannot see: an Ink screen rendered INSIDE a `withEscape` callback, whose\n * teardown would unref the handle the outer prompt is still reading from and kill it with exit 13.\n * See lib/prompts/stdin-ref.\n */\n// Where the balance comes from: ink/build/components/App.js:225 (`ref` on raw mode) and :137\n// (`unref` on teardown). A later Ink render refs itself again on mount, and an `@inquirer/*`\n// prompt \u2014 which refs nothing on its own \u2014 gets its ref from `withEscape`. The re-assert is a net\n// for a boundary nothing structurally enforces, not the mechanism that keeps prompts alive.\n//\n// It replaces an UNCONDITIONAL `process.stdin.ref()`, whose stated premise \u2014 \"an idle ref'd stdin\n// does not block exit\" \u2014 is simply false: a ref'd tty ReadStream holds the event loop open whether\n// or not anything is listening to it. That re-ref bought the next prompt its handle and cost the\n// session shell its exit, so every quit key in the palette tore the frame down correctly and then\n// hung forever.\nconst renderToStderr = async (element: ReactElement): Promise<void> => {\n  const stdout = safeStderr()\n  const { waitUntilExit } = render(element, {\n    stdout,\n    // Ink's default is `exitOnCtrlC: true`, which intercepts the 0x03 byte in its own App and calls\n    // `handleExit()` BEFORE it ever reaches `useInput`. That makes every screen's own ctrl+c branch\n    // dead code, and \u2014 worse \u2014 it tears down on the CURRENT frame, so `log.done()` freezes the drawn\n    // command list into the scrollback instead of erasing it (Esc, which goes through the screens'\n    // own quit path, erases correctly; Ctrl-C left a corpse). Every screen rendered here already\n    // handles ctrl+c itself, so hand them the key.\n    exitOnCtrlC: false,\n    // Ink's default is `!isInCi && stdout.isTTY`. We drop the isInCi term: a developer with CI\n    // exported in their shell would otherwise get a NON-interactive Ink on a real terminal, and Ink\n    // skips ALL terminal management in that mode \u2014 `beginSuspend` returns before it can drop raw mode\n    // or erase the frame, and `endSuspend` never redraws. Ctrl-Z would hand the shell a raw-mode tty\n    // with a stranded frame and a hidden cursor, and `fg` would come back to nothing. Whether we own\n    // the terminal is a question about the tty, and only about the tty.\n    interactive: Boolean(stdout.isTTY),\n  })\n\n  try {\n    await waitUntilExit()\n  } catch {\n    // Swallow a teardown rejection: the caller reports cancellation via its own\n    // captured sentinel (which stays at its initial value), not via a throw.\n  } finally {\n    if (stdinReaderCount() > 0) {\n      process.stdin.ref()\n    } else {\n      // STOP READING, not just \"stop holding the loop open\". `unref()` answers \"may node exit?\", not\n      // \"is anyone still consuming this fd?\" \u2014 and Ink's teardown only drops its `readable` listener\n      // and unrefs (App.js:136-137). The session shell then spawns the next command with\n      // `stdio: 'inherit'`, so parent and child hold the SAME tty and each keystroke goes to exactly\n      // one of them. Left unpaused, the parent wins often enough to eat the user's Esc; the child then\n      // never cancels, `waitForExit` never resolves, and `childOwnsSigint` (lib/session/run-session)\n      // swallows every Ctrl-C that follows. That is the \"Esc worked, then nothing does\" wedge.\n      //\n      // WHY `pause()` REACHES libuv AT ALL \u2014 it looks inert, and on a generic stream it is. The chain:\n      //   1. `Readable.prototype.pause()` (node internal/streams/readable.js) emits `'pause'` ONLY IF\n      //      `readableFlowing !== false`.\n      //   2. `process.stdin` \u2014 and ONLY `process.stdin`, ONLY on the main thread \u2014 carries a `'pause'`\n      //      listener installed by node's bootstrap (internal/bootstrap/switches/is_main_thread.js:263).\n      //   3. That listener defers to `onpause` (:267), which calls `stdin._handle.readStop()` (:273).\n      // `net.Socket.prototype.pause` never calls `readStop` itself (it does so only under `kBuffer`,\n      // which is unset here), so a harness built on a CONSTRUCTED `tty.ReadStream`, or run in a worker\n      // thread, measures a stream with ZERO `'pause'` listeners and correctly reports no effect. That\n      // is a false negative about a different object, not evidence against this line.\n      //\n      // THE PRECONDITION, AND WHY THIS CALL SITE MEETS IT \u2014 Ink reads via a `readable` listener\n      // (App.js:206, removed at :126), where `readableFlowing === false`, which would fail step 1 and\n      // make this a silent no-op. It does not, because `removeListener('readable')` schedules\n      // `updateReadableListening` on the NEXTTICK queue (clearing flowing to `null`), while this\n      // `finally` runs in the PROMISE MICROTASK behind `await waitUntilExit()` above \u2014 and node drains\n      // nextTick before microtasks. Ink resolves no earlier than it detaches (App.js:126 <- unmount\n      // ink.js:300 <- resolveExitPromise ink.js:580). Measured on a pty: synchronous call => 0 `'pause'`\n      // events, 0 readStops; behind the await => 1 and 1, flowing `null`, 3/3.\n      //\n      // SO: KEEP THIS BEHIND THE `await`. Making it synchronous silently disarms it with every test\n      // still green \u2014 which is what src/tui/__tests__/stdin-pause-semantics.test.ts exists to catch.\n      // Deferring it by a tick is NOT a hardening: `readStop` already lands after the `spawn` in\n      // run-session.ts (pause -> spawn -> readStop) and deferring only widens that window. Verified\n      // against ink 7.1.0; if Ink ever resolves before detaching, this reverts to a no-op.\n      process.stdin.pause()\n    }\n  }\n}\n\n/**\n * Render the command palette and resolve to the chosen command name, or `null`\n * if the user cancels. A Ctrl-Z suspends the job and resolves nothing \u2014 the same\n * palette redraws, filter and all, when the user brings it back with `fg`.\n */\nexport const runCommandPalette = async (items: PaletteItem[]): Promise<string | null> => {\n  let selected: string | null = null\n\n  await renderToStderr(\n    <CommandPalette\n      items={items}\n      onSelect={(name) => {\n        selected = name\n      }}\n      onCancel={() => {\n        selected = null\n      }}\n      // This module is the platform authority: `undefined` tells the palette that suspending is\n      // impossible here, so it neither binds Ctrl-Z nor advertises it in the footer. (`suspendForeground`\n      // guards win32 again on its own \u2014 the palette itself must stay free of `process`.)\n      onSuspend={\n        process.platform === 'win32'\n          ? undefined\n          : () => {\n              suspendForeground()\n            }\n      }\n    />,\n  )\n\n  return selected\n}\n\n/**\n * Render the searchable single-select branch picker and resolve to the chosen\n * value, or `null` if the user cancels.\n */\nexport const runBranchPicker = async (items: BranchPickerItem[]): Promise<string | null> => {\n  let selected: string | null = null\n\n  await renderToStderr(\n    <BranchPicker\n      items={items}\n      onSelect={(value) => {\n        selected = value\n      }}\n      onCancel={() => {\n        selected = null\n      }}\n    />,\n  )\n\n  return selected\n}\n\n/**\n * Render the searchable multi-select branch picker and resolve to the chosen\n * values, or `null` if the user cancels. The captured variable starts as `null`\n * and is only assigned an array in `onSubmit`, so a cancel is distinguishable\n * from an empty submit.\n */\nexport const runBranchMultiPicker = async (\n  items: BranchPickerItem[],\n  opts?: { required?: boolean; allowSelectAll?: boolean },\n): Promise<string[] | null> => {\n  let selected: string[] | null = null\n\n  await renderToStderr(\n    <BranchMultiPicker\n      items={items}\n      required={opts?.required}\n      allowSelectAll={opts?.allowSelectAll}\n      onSubmit={(values) => {\n        selected = values\n      }}\n      onCancel={() => {\n        selected = null\n      }}\n    />,\n  )\n\n  return selected\n}\n", "import { Box, Text, useApp, useInput, useWindowSize } from 'ink'\nimport { useEffect, useState } from 'react'\n\nimport type { BranchPickerItem } from '../../lib/prompts/types'\nimport { useListFilter } from '../hooks/use-list-filter'\nimport { listLayout, paletteWindow } from './palette-window'\n\ninterface BranchMultiPickerProps {\n  items: BranchPickerItem[]\n  /** Called with the selected item values; the app then exits. */\n  onSubmit: (values: string[]) => void\n  /** Called when the user cancels (Esc / Ctrl-C); the app then exits. */\n  onCancel: () => void\n  /** When true (default), Enter with an empty selection is ignored. */\n  required?: boolean\n  /** When true (default), Ctrl-A toggles select-all across all items. */\n  allowSelectAll?: boolean\n}\n\n/**\n * Searchable multi-select branch picker rendered with Ink. Same filter/move/cancel\n * behaviour as `BranchPicker`, plus a selection `Set` keyed by item *value* so the\n * selection survives filter changes. Space toggles the active row; Ctrl-A toggles\n * select-all across all items; Enter submits the selected values.\n *\n * The list is WINDOWED to the terminal height for the same safety reason as the\n * palette and the single picker: an overflowing Ink frame corrupts the cursor and\n * welds later output onto the transcript. See `palette-window.ts`.\n */\nexport const BranchMultiPicker = (props: BranchMultiPickerProps) => {\n  const { items, onSubmit, onCancel, required = true, allowSelectAll = true } = props\n\n  const T = BRANCH_MULTI_PICKER_TEXT\n  const labelWidth = items.reduce((max, item) => {\n    return Math.max(max, item.label.length)\n  }, 0)\n\n  const { exit } = useApp()\n  const { rows } = useWindowSize()\n  const { filtered, activeIndex, query, handleNavigation, clearQuery } = useListFilter(items, filterText)\n  // Selection keyed by value so it persists across filter changes.\n  const [selected, setSelected] = useState<Set<string>>(() => {\n    return new Set()\n  })\n  const [showRequiredHint, setShowRequiredHint] = useState(false)\n  // First branch in the visible window; kept in state so the list scrolls by the minimum needed.\n  const [windowStart, setWindowStart] = useState(0)\n  // When set, the component renders `null` for one frame so Ink erases the list\n  // before unmount commits its final frame.\n  const [submitted, setSubmitted] = useState(false)\n\n  // Exit only after the empty frame has committed, so the list is wiped first.\n  useEffect(() => {\n    if (submitted) {\n      exit()\n    }\n  }, [submitted, exit])\n\n  // The extra chrome row is this screen's `select at least one` hint: counted unconditionally, because\n  // it appears on a keystroke and a budget that shrinks mid-frame is a budget that overflows.\n  const layout = listLayout(rows, 1)\n  // No `groupOf`: a branch list has no headers, so every branch costs exactly one row.\n  const view = paletteWindow(filtered, windowStart, activeIndex, rows, { chromeRows: layout.chromeRows })\n\n  // Commit the scroll position once the frame that used it has rendered.\n  useEffect(() => {\n    if (view.start !== windowStart) {\n      setWindowStart(view.start)\n    }\n  }, [view.start, windowStart])\n\n  const toggleValue = (value: string) => {\n    setSelected((prev) => {\n      const next = new Set(prev)\n\n      if (next.has(value)) {\n        next.delete(value)\n      } else {\n        next.add(value)\n      }\n\n      return next\n    })\n  }\n\n  const toggleSelectAll = () => {\n    setSelected((prev) => {\n      // Clear only when every item (all, not just filtered) is already selected.\n      const allSelected = items.every((item) => {\n        return prev.has(item.value)\n      })\n\n      if (allSelected) {\n        return new Set()\n      }\n\n      return new Set(\n        items.map((item) => {\n          return item.value\n        }),\n      )\n    })\n  }\n\n  const cancel = () => {\n    onCancel()\n    setSubmitted(true)\n  }\n\n  const submit = () => {\n    if (required && selected.size === 0) {\n      setShowRequiredHint(true)\n\n      return\n    }\n\n    onSubmit([...selected])\n    setSubmitted(true)\n  }\n\n  useInput((input, key) => {\n    if (submitted) {\n      return\n    }\n\n    if (key.ctrl && input === 'c') {\n      cancel()\n\n      return\n    }\n\n    // Esc pops the innermost stateful thing: the typed filter first, the picker only once\n    // there is no filter left to clear. It never touches `selected` \u2014 a filter keystroke is\n    // not a selection, so clearing one must not discard the other. Stage 2 discards it, as before.\n    if (key.escape) {\n      if (!clearQuery()) {\n        cancel()\n      }\n\n      return\n    }\n\n    if (key.ctrl && input === 'a') {\n      if (allowSelectAll) {\n        toggleSelectAll()\n      }\n\n      return\n    }\n\n    if (input === ' ') {\n      const active = filtered[activeIndex]\n\n      if (active) {\n        toggleValue(active.value)\n      }\n\n      return\n    }\n\n    if (key.return) {\n      submit()\n\n      return\n    }\n\n    handleNavigation(input, key)\n  })\n\n  // Final frame: render nothing so Ink erases the list on its way out.\n  if (submitted) {\n    return null\n  }\n\n  // Too short for even one branch row plus a prompt. One truncated line always fits.\n  if (layout.mode === 'tiny') {\n    return (\n      <Text dimColor wrap=\"truncate\">\n        {T.tiny}\n      </Text>\n    )\n  }\n\n  return (\n    <Box flexDirection=\"column\">\n      {layout.mode === 'full' ? (\n        <Text dimColor wrap=\"truncate\">\n          {T.hint}\n        </Text>\n      ) : null}\n      <Box>\n        <Text color=\"cyan\">{T.prompt}</Text>\n        {/* truncate-START: overflow must eat the head of the filter, never the character being typed. */}\n        <Text wrap=\"truncate-start\">{query}</Text>\n      </Box>\n      <Box flexDirection=\"column\" marginTop={layout.mode === 'full' ? 1 : 0}>\n        {filtered.length === 0 ? (\n          <Text dimColor wrap=\"truncate\">\n            {T.empty}\n          </Text>\n        ) : null}\n        {view.hiddenBefore > 0 ? <Text dimColor wrap=\"truncate\">{`${T.more} ${view.hiddenBefore} above`}</Text> : null}\n        {view.visible.map((item, position) => {\n          const isActive = view.start + position === activeIndex\n          const isChecked = selected.has(item.value)\n\n          // `wrap=\"truncate\"` keeps one branch = one row at any width. Ink reads the wrap style off the\n          // OUTER <Text> only, so it must live here, not on the nested description.\n          return (\n            <Text color={isActive ? 'green' : undefined} key={item.value} wrap=\"truncate\">\n              {isActive ? '\u203A ' : '  '}\n              {isChecked ? '[x] ' : '[ ] '}\n              {item.label.padEnd(labelWidth)} <Text dimColor>{item.description ?? ''}</Text>\n            </Text>\n          )\n        })}\n        {view.hiddenAfter > 0 ? <Text dimColor wrap=\"truncate\">{`${T.more} ${view.hiddenAfter} below`}</Text> : null}\n      </Box>\n      {showRequiredHint ? (\n        <Text dimColor wrap=\"truncate\">\n          {T.requiredHint}\n        </Text>\n      ) : null}\n    </Box>\n  )\n}\n\nfunction filterText(item: BranchPickerItem): string {\n  return `${item.label} ${item.description ?? ''}`\n}\n\n/**\n * Static screen copy. Module-scoped and exported so the hint-width guard can measure it:\n * these strings render under `wrap=\"truncate\"`, so a hint of \u226580 columns silently loses\n * its tail at the common terminal width \u2014 and the tail is where the Esc hint lives.\n */\nexport const BRANCH_MULTI_PICKER_TEXT = {\n  hint: 'filter \u00B7 \u2191\u2193 move \u00B7 Space toggle \u00B7 Ctrl-A all \u00B7 Enter submit \u00B7 Esc clear/cancel',\n  prompt: '\u276F ',\n  empty: 'No matching branches',\n  tiny: 'terminal too short \u2014 resize to pick branches',\n  requiredHint: 'select at least one',\n  more: '\u2026',\n}\n", "import type { Key } from 'ink'\nimport { useMemo, useState } from 'react'\n\ninterface ListFilter<T> {\n  /** Items matching the current query (all items when the query is empty). */\n  filtered: T[]\n  /** Active row index, always clamped into `filtered`'s bounds. */\n  activeIndex: number\n  /** Current filter query. */\n  query: string\n  /**\n   * Handle the shared navigation/filter keys (\u2191\u2193 wrap-around, backspace/delete,\n   * printable chars). Returns true when the key was consumed so the caller can\n   * `return` early; false leaves the key for the component's own handlers.\n   */\n  handleNavigation: (input: string, key: Key) => boolean\n  /**\n   * Stage 1 of the Esc ladder: clears a non-empty query (back to the first row) and\n   * returns true. Returns false when the query is already empty \u2014 the boolean IS the\n   * ladder, and a false tells the caller there is nothing left to cancel but the screen.\n   *\n   * Deliberately NOT folded into `handleNavigation`: the two pickers want different\n   * stage-2 actions, so the escape branch belongs to each screen, not to the shared handler.\n   */\n  clearQuery: () => boolean\n}\n\n/**\n * Shared list-filter state for the branch pickers: substring filtering,\n * wrap-around \u2191\u2193 movement, and query editing. Extracted so each `useInput`\n * handler stays under the sonarjs cognitive-complexity \u226415 gate.\n */\nexport const useListFilter = <T>(items: T[], toText: (item: T) => string): ListFilter<T> => {\n  const [query, setQuery] = useState('')\n  const [index, setIndex] = useState(0)\n\n  const filtered = useMemo(() => {\n    const q = query.trim().toLowerCase()\n\n    if (!q) {\n      return items\n    }\n\n    return items.filter((item) => {\n      return toText(item).toLowerCase().includes(q)\n    })\n  }, [items, query, toText])\n\n  const activeIndex = Math.min(index, Math.max(0, filtered.length - 1))\n\n  const handleNavigation = (input: string, key: Key): boolean => {\n    const n = filtered.length\n\n    if (key.upArrow) {\n      // `+ n` sidesteps JS negative modulo (e.g. -1 % 5 === -1, not 4).\n      if (n > 0) {\n        setIndex((activeIndex - 1 + n) % n)\n      }\n\n      return true\n    }\n\n    if (key.downArrow) {\n      if (n > 0) {\n        setIndex((activeIndex + 1) % n)\n      }\n\n      return true\n    }\n\n    if (key.backspace || key.delete) {\n      setQuery(query.slice(0, -1))\n      setIndex(0)\n\n      return true\n    }\n\n    // Printable character: append to the filter and reset to the first row.\n    if (input && !key.ctrl && !key.meta) {\n      setQuery(query + input)\n      setIndex(0)\n\n      return true\n    }\n\n    return false\n  }\n\n  const clearQuery = (): boolean => {\n    if (!query) {\n      return false\n    }\n\n    setQuery('')\n    setIndex(0)\n\n    return true\n  }\n\n  return { filtered, activeIndex, query, handleNavigation, clearQuery }\n}\n", "/**\n * @fileoverview\n *\n * Pure viewport arithmetic shared by every Ink list screen (the command palette and both branch\n * pickers): which slice of the (already filtered) list fits the terminal, and how much chrome the\n * screen may spend around it.\n *\n * This is a SAFETY guard, not a readability one. Ink's cleanup walks the cursor upward one line at a\n * time (`ESC[2K ESC[1A` per row) and `ESC[1A` SATURATES AT ROW 0. So the moment a frame is taller than\n * the viewport, the terminal scrolls while Ink draws, the upward walk erases the wrong rows, and the\n * cursor is left parked ABOVE live content \u2014 after which every later write (the session's status\n * footer, the next palette frame) is deposited on top of the transcript. That is the \"welded rows\" bug:\n * `\u276F ` printed over the head of `ERROR: \u2026`, leaving `ROR: \u2026` behind.\n *\n * The invariant this module exists to enforce, for every (columns, rows):\n *\n *     rendered frame height  <  terminal rows\n *\n * Hold that, and Ink never takes its overflow path: `clearTerminal` never fires, `eraseLines` never\n * saturates, the cursor stays below the transcript, and a fresh (cold) Ink instance \u2014 which erases\n * NOTHING before its first frame \u2014 simply appends below the transcript like any other CLI. No new\n * escape bytes required.\n *\n * Two things make the row count knowable at all:\n *   - Every list row is rendered `wrap=\"truncate\"`, so one item is always exactly one row. Without that\n *     a long description wraps to two rows and this arithmetic silently under-counts (Ink wraps text\n *     itself and measures the WRAPPED height, so it, not us, would be right).\n *   - Chrome is counted unconditionally, even when a given row is not drawn (see `CHROME_ROWS`). Over-\n *     counting shrinks the list; under-counting overflows. Only one of those is a bug.\n *\n * `src/tui/safe-stderr.ts` (the `ESC[3J` byte filter) remains the last-resort backstop for the case\n * this cannot cover \u2014 a SIGWINCH that invalidates a frame's height retroactively.\n */\nimport type { PaletteItem } from '../types'\n\n/**\n * Reads an item's group label. Omitted by the branch pickers, whose lists have no headers at all.\n * (Passed as an accessor rather than constrained with a `{ group?: string }` marker interface: a type\n * whose properties are ALL optional is \"weak\", and TypeScript refuses to match a `BranchPickerItem`\n * against it \u2014 inference silently falls back to the constraint and every field access breaks.)\n */\nexport type GroupOf<T> = (item: T) => string | undefined\n\n/** The slice to render, plus how many rows fell off each end (for the `\u2026 n more` affordances). */\nexport interface ListWindow<T> {\n  visible: T[]\n  /** Index the window starts at \u2014 the component stores it so the list does not jump between frames. */\n  start: number\n  hiddenBefore: number\n  hiddenAfter: number\n}\n\n/** Back-compat alias: the command palette's window is a window of `PaletteItem`s. */\nexport type PaletteWindow = ListWindow<PaletteItem>\n\n/**\n * Rows a screen spends on everything that is not a list row, counted UNCONDITIONALLY (a `\u2026 n above`\n * that is not drawn today may be drawn on the next keystroke, and re-deriving the budget mid-frame is\n * how you get an off-by-one that only bites on a full list):\n *   hint, `\u276F` prompt, the list's `marginTop`, `\u2026 n above`, `\u2026 n below`, and one row of headroom.\n *\n * The headroom row is what makes the frame strictly SHORTER than the viewport: Ink treats a frame\n * exactly as tall as the terminal as fullscreen and clears the screen.\n */\nexport const CHROME_ROWS = 6\n\n/** Compact chrome: the hint and the list's `marginTop` are dropped. Prompt + affordances + headroom. */\nexport const COMPACT_CHROME_ROWS = 4\n\n/** Below this many rows a screen drops its hint, its `marginTop`, and its group headers. */\nexport const COMPACT_BELOW_ROWS = 10\n\n/** Below this many rows no usable list fits at all; the screen renders a single-line notice instead. */\nexport const TINY_BELOW_ROWS = 5\n\n/** How a screen must lay itself out to keep its frame shorter than `rows`. */\nexport type ListLayoutMode = 'full' | 'compact' | 'tiny'\n\nexport interface ListLayout {\n  mode: ListLayoutMode\n  /** Rows reserved for chrome. Pass to `paletteWindow` as `chromeRows`. */\n  chromeRows: number\n  /** Whether group headers may be drawn (they cost a row each, so a compact frame drops them). */\n  groups: boolean\n}\n\n/** A list with no group headers: every item costs exactly one row. */\nconst NO_GROUPS = (): undefined => {\n  return undefined\n}\n\n/**\n * The layout a screen must use at this terminal height. `extraChromeRows` is for chrome a screen has\n * that the others do not \u2014 the multi-picker's `select at least one` hint is the only one today.\n *\n * A `tiny` frame is one truncated line, which is strictly shorter than any terminal of 2+ rows. (At\n * `rows === 1` nothing can be shorter than the viewport; Ink will clear. That is a degenerate terminal,\n * and `safe-stderr` keeps even that harmless.)\n *\n * @example\n * listLayout(24)    // => { mode: 'full',    chromeRows: 6, groups: true }\n * listLayout(8)     // => { mode: 'compact', chromeRows: 4, groups: false }\n * listLayout(8, 1)  // => { mode: 'compact', chromeRows: 5, groups: false }  (multi-picker)\n * listLayout(4)     // => { mode: 'tiny',    chromeRows: 0, groups: false }\n */\nexport const listLayout = (rows: number, extraChromeRows = 0): ListLayout => {\n  if (rows < TINY_BELOW_ROWS) {\n    return { mode: 'tiny', chromeRows: 0, groups: false }\n  }\n\n  if (rows < COMPACT_BELOW_ROWS) {\n    return { mode: 'compact', chromeRows: COMPACT_CHROME_ROWS + extraChromeRows, groups: false }\n  }\n\n  return { mode: 'full', chromeRows: CHROME_ROWS + extraChromeRows, groups: true }\n}\n\n/**\n * How many rows rendering `items[start..end)` costs: one per item (guaranteed by `wrap=\"truncate\"`),\n * plus, when `groups` is on, one for each group header and one for the blank line between groups (the\n * first rendered group gets a header but no blank \u2014 it mirrors the `showGroup && position > 0` rule in\n * the components). A list whose items carry no `group` never spends a header row.\n */\nconst heightOf = <T>(items: T[], start: number, end: number, groupOf: GroupOf<T>): number => {\n  let height = 0\n  let previousGroup: string | undefined\n\n  for (let index = start; index < end; index += 1) {\n    const item = items[index]\n\n    if (!item) break\n\n    const group = groupOf(item)\n    const startsGroup = group !== undefined && group !== previousGroup\n\n    height += 1 + (startsGroup ? 1 : 0) + (startsGroup && index > start ? 1 : 0)\n    previousGroup = group\n  }\n\n  return height\n}\n\n/** The last index (exclusive) that still fits `budget` rows when rendering from `start`. */\nconst endThatFits = <T>(items: T[], start: number, budget: number, groupOf: GroupOf<T>): number => {\n  let end = start\n\n  while (end < items.length && heightOf(items, start, end + 1, groupOf) <= budget) {\n    end += 1\n  }\n\n  return end\n}\n\n/**\n * The window of items to render: the largest slice starting at or after `start` that fits the terminal\n * while still containing `activeIndex`. Scrolls by the minimum needed \u2014 the caller keeps `start` in\n * state, so the list only moves when the cursor would otherwise leave the window.\n *\n * An empty `visible` is a legitimate result on a terminal too short to hold even one row. It is NOT\n * clamped up to one item: forcing a row that does not fit is exactly how the frame overflows and the\n * cursor corruption starts. A screen that gets nothing back renders its `tiny` notice instead \u2014 see\n * `listLayout`.\n *\n * @example\n * const window = paletteWindow(items, 0, 12, 24)\n * window.visible.length // => however many commands fit 18 rows\n * window.hiddenAfter    // => the rest, surfaced as '\u2026 n below'\n */\nexport const paletteWindow = <T>(\n  items: T[],\n  start: number,\n  activeIndex: number,\n  rows: number,\n  opts?: { chromeRows?: number; groupOf?: GroupOf<T> },\n): ListWindow<T> => {\n  const groupOf = opts?.groupOf ?? NO_GROUPS\n  const budget = Math.max(0, rows - (opts?.chromeRows ?? CHROME_ROWS))\n\n  // Scroll up only if the cursor moved above the window; otherwise scroll down just far enough.\n  let first = Math.min(start, activeIndex)\n\n  while (activeIndex >= endThatFits(items, first, budget, groupOf) && first < activeIndex) {\n    first += 1\n  }\n\n  const end = endThatFits(items, first, budget, groupOf)\n\n  return {\n    visible: items.slice(first, end),\n    start: first,\n    hiddenBefore: first,\n    hiddenAfter: Math.max(0, items.length - end),\n  }\n}\n", "import { Box, Text, useApp, useInput, useWindowSize } from 'ink'\nimport { useEffect, useState } from 'react'\n\nimport type { BranchPickerItem } from '../../lib/prompts/types'\nimport { useListFilter } from '../hooks/use-list-filter'\nimport { listLayout, paletteWindow } from './palette-window'\n\ninterface BranchPickerProps {\n  items: BranchPickerItem[]\n  /** Called with the chosen item's value; the app then exits. */\n  onSelect: (value: string) => void\n  /** Called when the user cancels (Esc / Ctrl-C); the app then exits. */\n  onCancel: () => void\n}\n\n/**\n * Searchable single-select branch picker rendered with Ink. Mirrors\n * `CommandPalette` minus the group headers: type-to-filter over label +\n * description, \u2191\u2193 wrap-around, Enter selects the active item's *value*.\n *\n * Like the palette, the list is WINDOWED to the terminal height. That is a safety\n * requirement, not a nicety: a repo with ~20 open releases produced a frame taller\n * than an 80x24 window, and an overflowing Ink frame corrupts the cursor and welds\n * the next frame onto the command's own output. See `palette-window.ts`.\n */\nexport const BranchPicker = (props: BranchPickerProps) => {\n  const { items, onSelect, onCancel } = props\n\n  const T = BRANCH_PICKER_TEXT\n  const labelWidth = items.reduce((max, item) => {\n    return Math.max(max, item.label.length)\n  }, 0)\n\n  const { exit } = useApp()\n  const { rows } = useWindowSize()\n  const { filtered, activeIndex, query, handleNavigation, clearQuery } = useListFilter(items, filterText)\n  // First branch in the visible window; kept in state so the list scrolls by the minimum needed.\n  const [windowStart, setWindowStart] = useState(0)\n  // When set, the component renders `null` for one frame so Ink erases the list\n  // before unmount commits its final frame.\n  const [submitted, setSubmitted] = useState(false)\n\n  // Exit only after the empty frame has committed, so the list is wiped first.\n  useEffect(() => {\n    if (submitted) {\n      exit()\n    }\n  }, [submitted, exit])\n\n  const layout = listLayout(rows)\n  // No `groupOf`: a branch list has no headers, so every branch costs exactly one row.\n  const view = paletteWindow(filtered, windowStart, activeIndex, rows, { chromeRows: layout.chromeRows })\n\n  // Commit the scroll position once the frame that used it has rendered.\n  useEffect(() => {\n    if (view.start !== windowStart) {\n      setWindowStart(view.start)\n    }\n  }, [view.start, windowStart])\n\n  const cancel = () => {\n    onCancel()\n    setSubmitted(true)\n  }\n\n  useInput((input, key) => {\n    if (submitted) {\n      return\n    }\n\n    if (key.ctrl && input === 'c') {\n      cancel()\n\n      return\n    }\n\n    // Esc pops the innermost stateful thing: a typed filter first, the picker only once\n    // there is no filter left to clear. `clearQuery` returning false IS that ladder.\n    if (key.escape) {\n      if (!clearQuery()) {\n        cancel()\n      }\n\n      return\n    }\n\n    if (key.return) {\n      const selected = filtered[activeIndex]\n\n      if (selected) {\n        onSelect(selected.value)\n        setSubmitted(true)\n      }\n\n      return\n    }\n\n    handleNavigation(input, key)\n  })\n\n  // Final frame: render nothing so Ink erases the list on its way out.\n  if (submitted) {\n    return null\n  }\n\n  // Too short for even one branch row plus a prompt. One truncated line always fits.\n  if (layout.mode === 'tiny') {\n    return (\n      <Text dimColor wrap=\"truncate\">\n        {T.tiny}\n      </Text>\n    )\n  }\n\n  return (\n    <Box flexDirection=\"column\">\n      {layout.mode === 'full' ? (\n        <Text dimColor wrap=\"truncate\">\n          {T.hint}\n        </Text>\n      ) : null}\n      <Box>\n        <Text color=\"cyan\">{T.prompt}</Text>\n        {/* truncate-START: overflow must eat the head of the filter, never the character being typed. */}\n        <Text wrap=\"truncate-start\">{query}</Text>\n      </Box>\n      <Box flexDirection=\"column\" marginTop={layout.mode === 'full' ? 1 : 0}>\n        {filtered.length === 0 ? (\n          <Text dimColor wrap=\"truncate\">\n            {T.empty}\n          </Text>\n        ) : null}\n        {view.hiddenBefore > 0 ? <Text dimColor wrap=\"truncate\">{`${T.more} ${view.hiddenBefore} above`}</Text> : null}\n        {view.visible.map((item, position) => {\n          const isActive = view.start + position === activeIndex\n\n          // `wrap=\"truncate\"` keeps one branch = one row at any width (a long branch name would\n          // otherwise wrap and make the frame taller than this component believes). Ink reads the wrap\n          // style off the OUTER <Text> only, so it must live here, not on the nested description.\n          return (\n            <Text color={labelColor(item.type, isActive)} key={item.value} wrap=\"truncate\">\n              {isActive ? '\u203A ' : '  '}\n              {item.label.padEnd(labelWidth)} <Text dimColor>{item.description ?? ''}</Text>\n            </Text>\n          )\n        })}\n        {view.hiddenAfter > 0 ? <Text dimColor wrap=\"truncate\">{`${T.more} ${view.hiddenAfter} below`}</Text> : null}\n      </Box>\n    </Box>\n  )\n}\n\n/**\n * Colour for a row's label, derived from the release type. Kept a plain lookup so\n * an unknown/absent type simply falls through to the default (green when active).\n */\nfunction labelColor(type: string | undefined, isActive: boolean): string | undefined {\n  if (type === 'hotfix') {\n    return 'red'\n  }\n\n  return isActive ? 'green' : undefined\n}\n\nfunction filterText(item: BranchPickerItem): string {\n  return `${item.label} ${item.description ?? ''}`\n}\n\n/**\n * Static screen copy. Module-scoped and exported so the hint-width guard can measure it:\n * these strings render under `wrap=\"truncate\"`, so a hint of \u226580 columns silently loses\n * its tail at the common terminal width \u2014 and the tail is where the Esc hint lives.\n */\nexport const BRANCH_PICKER_TEXT = {\n  hint: 'type to filter \u00B7 \u2191\u2193 move \u00B7 Enter select \u00B7 Esc clear/cancel',\n  prompt: '\u276F ',\n  empty: 'No matching branches',\n  tiny: 'terminal too short \u2014 resize to pick a branch',\n  more: '\u2026',\n}\n", "import { Box, Text, useApp, useInput, useWindowSize } from 'ink'\nimport { useEffect, useMemo, useState } from 'react'\n\nimport type { PaletteItem } from '../types'\nimport { listLayout, paletteWindow } from './palette-window'\n\ninterface CommandPaletteProps {\n  items: PaletteItem[]\n  /** Called with the chosen command name; the app then exits. */\n  onSelect: (name: string) => void\n  /** Called when the user cancels (Ctrl-C / Ctrl-D); the app then exits. Esc never reaches this. */\n  onCancel: () => void\n  /**\n   * Stop the foreground job (Ctrl-Z). ABSENT means suspend is impossible on this platform \u2014 the\n   * palette stays pure presentation and never inspects `process`; boot.tsx is the platform authority.\n   */\n  onSuspend?: () => void\n}\n\n/**\n * Fuzzy-ish command picker rendered with Ink. Pure presentation: it receives a\n * flat list of commands (already grouped/ordered by the catalog) and returns the\n * selected name. It never executes anything \u2014 the caller runs the command via\n * the existing Commander path.\n *\n * NOTE: this component sits at exactly the sonarjs cognitive-complexity ceiling (15). Any `if` or\n * `?:` added to its BODY breaks `pnpm run qa` \u2014 which is why the hint is picked by the module-scope\n * `hintFor` below and the control keys by `handleCtrlKey`, rather than inline.\n */\nexport const CommandPalette = (props: CommandPaletteProps) => {\n  const { items, onSelect, onCancel, onSuspend } = props\n\n  const T = {\n    hint: hintFor(Boolean(onSuspend)),\n    prompt: '\u276F ',\n    empty: 'No matching commands',\n    tiny: 'terminal too short \u2014 resize to pick a command',\n    more: '\u2026',\n  }\n  const nameWidth = 24\n\n  const { exit, suspendTerminal } = useApp()\n  const { rows } = useWindowSize()\n  const [query, setQuery] = useState('')\n  const [index, setIndex] = useState(0)\n  // First command in the visible window. Kept in state so the list scrolls by the minimum needed\n  // instead of jumping every time the cursor moves.\n  const [windowStart, setWindowStart] = useState(0)\n  // When set, the component renders `null` for one frame so Ink erases the list\n  // before unmount commits its final frame (Ink's `log.done()` would otherwise\n  // freeze the last drawn frame \u2014 the command list \u2014 into the scrollback).\n  const [submitted, setSubmitted] = useState(false)\n\n  // Exit only after the empty frame has committed, so the list is wiped first.\n  useEffect(() => {\n    if (submitted) {\n      exit()\n    }\n  }, [submitted, exit])\n\n  const filtered = useMemo(() => {\n    const q = query.trim().toLowerCase()\n\n    if (!q) {\n      return items\n    }\n\n    return items.filter((item) => {\n      return `${item.name} ${item.description}`.toLowerCase().includes(q)\n    })\n  }, [items, query])\n\n  const activeIndex = Math.min(index, Math.max(0, filtered.length - 1))\n\n  // The slice that fits this terminal, and how much chrome we may spend around it. A frame taller than\n  // the viewport corrupts the cursor (see palette-window.ts) \u2014 every row here is budgeted, and every\n  // row below is `wrap=\"truncate\"` so one command is always exactly one row.\n  const layout = listLayout(rows)\n  const view = paletteWindow(filtered, windowStart, activeIndex, rows, {\n    chromeRows: layout.chromeRows,\n    // A compact frame drops group headers, so they must not be budgeted for either.\n    groupOf: layout.groups\n      ? (item) => {\n          return item.group\n        }\n      : undefined,\n  })\n\n  // Commit the scroll position once the frame that used it has rendered.\n  useEffect(() => {\n    if (view.start !== windowStart) {\n      setWindowStart(view.start)\n    }\n  }, [view.start, windowStart])\n\n  // Back out with nothing picked (Ctrl-C / Ctrl-D). Esc is NOT a caller: it pops the filter only.\n  const quit = () => {\n    onCancel()\n    setSubmitted(true)\n  }\n\n  // Hand the terminal back to the user's shell until they `fg`.\n  //\n  // Ink does all the terminal work for us, in the right order and synchronously: `beginSuspend`\n  // settles pending frames, erases the list, restores the cursor and drops raw mode BEFORE our\n  // callback runs, and on resume `endSuspend` re-arms raw mode and force-redraws THIS SAME LIVE\n  // COMPONENT \u2014 so the typed filter survives the suspend. That is why we must NOT set `submitted`\n  // here: unmounting would throw the query away and give us a blank palette on return.\n  //\n  // The `.catch` is the PRIMARY guard, not a backstop \u2014 never simplify it to `void`. Two 0x1a bytes\n  // in one read chunk (a double-tap) are both already queued in Ink's input loop, and `pauseInput`\n  // only detaches the stdin listener, so the second one still fires \u2014 into a `beginSuspend` that is\n  // already suspended, which throws. Harmless (it throws before flipping its own state, and the first\n  // suspension still unwinds), but the rejection must be caught: `void` would make it an unhandled\n  // rejection that kills the process mid terminal-restore.\n  const suspend = () => {\n    if (!onSuspend) {\n      return\n    }\n\n    suspendTerminal(onSuspend).catch(() => {\n      // See above: a double Ctrl-Z is a no-op, not a crash.\n    })\n  }\n\n  /**\n   * Ctrl-C / Ctrl-Z, hoisted OUT of the `useInput` body. Mandatory, not tidiness: that handler sits at\n   * cognitive complexity 14, and an inline `if (key.ctrl && input === 'z' && onSuspend)` costs +2 \u2014\n   * 16, over the sonarjs ceiling of 15, and `pnpm run qa` goes red.\n   *\n   * The palette's Ctrl-Z is a BYTE (0x1a), not a signal: Ink holds stdin in raw mode, which clears\n   * termios ISIG, so the tty never generates SIGTSTP here at all. We therefore stop the process GROUP\n   * ourselves (kill(0), see ../suspend.ts). The session shell's SIGTSTP handler does the opposite \u2014\n   * it self-stops with raise('SIGSTOP') (lib/session/run-session.ts) \u2014 and that is CORRECT there,\n   * because while a child command holds the foreground the tty is cooked and has already TSTP'd the\n   * whole group, leaving only us to follow. DO NOT UNIFY THE TWO.\n   */\n  const handleCtrlKey = (input: string): boolean => {\n    if (input === 'c') {\n      quit()\n\n      return true\n    }\n\n    // Ctrl-D is the REPL/shell convention for \"end of input\", and it quits exactly like Ctrl-C above.\n    // UNCONDITIONAL, unlike anything Esc does: it ends the session with a filter typed as readily as\n    // without one. It is no longer the key the footer names \u2014 Ctrl-C is, because that is the one a\n    // hand reaches for to abandon a picker \u2014 but a shell user's fingers know this one, so it stays.\n    if (input === 'd') {\n      quit()\n\n      return true\n    }\n\n    if (input === 'z') {\n      suspend()\n\n      return true\n    }\n\n    return false\n  }\n\n  // Move the active row by `delta`, wrapping. The `+ n` sidesteps JS negative modulo\n  // (e.g. -1 % 5 === -1, not 4). No-op on an empty list.\n  const step = (delta: number) => {\n    const n = filtered.length\n\n    if (n > 0) {\n      setIndex((activeIndex + delta + n) % n)\n    }\n  }\n\n  useInput((input, key) => {\n    if (submitted) {\n      return\n    }\n\n    // Ctrl-C quits, Ctrl-Z suspends (see handleCtrlKey). Esc pops one level and this palette has\n    // exactly one \u2014 the filter \u2014 so an empty filter makes it a no-op, NOT a quit. Popping the root\n    // would leave nowhere to land: the session shell has no screen behind the palette, so an Esc that\n    // quit would be a quit wearing a back-out's clothes. Quitting is Ctrl-C / Ctrl-D, and only those.\n    // No emptiness check: clearing an already-empty query is a React no-op.\n    if (key.ctrl && handleCtrlKey(input)) {\n      return\n    }\n\n    if (key.escape) {\n      setQuery('')\n      setIndex(0)\n\n      return\n    }\n\n    if (key.return) {\n      const selected = filtered[activeIndex]\n\n      if (selected) {\n        onSelect(selected.name)\n        setSubmitted(true)\n      }\n\n      return\n    }\n\n    if (key.upArrow) {\n      step(-1)\n\n      return\n    }\n\n    if (key.downArrow) {\n      step(1)\n\n      return\n    }\n\n    if (key.backspace || key.delete) {\n      setQuery(query.slice(0, -1))\n      setIndex(0)\n\n      return\n    }\n\n    // Printable character: append to the filter.\n    if (input && !key.ctrl && !key.meta) {\n      setQuery(query + input)\n      setIndex(0)\n    }\n  })\n\n  // Final frame: render nothing so Ink erases the list on its way out.\n  if (submitted) {\n    return null\n  }\n\n  // Too short for even one command row plus a prompt. One truncated line always fits.\n  if (layout.mode === 'tiny') {\n    return (\n      <Text dimColor wrap=\"truncate\">\n        {T.tiny}\n      </Text>\n    )\n  }\n\n  let lastGroup = ''\n\n  return (\n    <Box flexDirection=\"column\">\n      {layout.mode === 'full' ? (\n        <Text dimColor wrap=\"truncate\">\n          {T.hint}\n        </Text>\n      ) : null}\n      <Box>\n        <Text color=\"cyan\">{T.prompt}</Text>\n        {/* truncate-START on the input: overflow must eat the head of the filter, never the character\n            being typed. */}\n        <Text wrap=\"truncate-start\">{query}</Text>\n      </Box>\n      <Box flexDirection=\"column\" marginTop={layout.mode === 'full' ? 1 : 0}>\n        {filtered.length === 0 ? (\n          <Text dimColor wrap=\"truncate\">\n            {T.empty}\n          </Text>\n        ) : null}\n        {view.hiddenBefore > 0 ? <Text dimColor wrap=\"truncate\">{`${T.more} ${view.hiddenBefore} above`}</Text> : null}\n        {view.visible.map((item, position) => {\n          const isActive = view.start + position === activeIndex\n          const showGroup = layout.groups && item.group !== lastGroup\n\n          lastGroup = item.group\n\n          return (\n            <Box flexDirection=\"column\" key={item.name}>\n              {/* Blank line between groups (not before the first row of the window). */}\n              {showGroup && position > 0 ? <Text> </Text> : null}\n              {showGroup ? <Text color=\"yellow\" wrap=\"truncate\">{`\u2014 ${item.group} \u2014`}</Text> : null}\n              {/* `wrap=\"truncate\"` is load-bearing, not cosmetic: it is what makes \"one command = one\n                  row\" true at any width, which is what keeps the frame shorter than the viewport. Ink\n                  reads the wrap style off the OUTER <Text> only \u2014 it squashes the nested <Text> into\n                  this one's string \u2014 so it must live here. */}\n              <Text color={isActive ? 'green' : undefined} wrap=\"truncate\">\n                {isActive ? '\u203A ' : '  '}\n                {item.name.padEnd(nameWidth)} <Text dimColor>{item.description}</Text>\n              </Text>\n            </Box>\n          )\n        })}\n        {view.hiddenAfter > 0 ? <Text dimColor wrap=\"truncate\">{`${T.more} ${view.hiddenAfter} below`}</Text> : null}\n      </Box>\n    </Box>\n  )\n}\n\n/**\n * Footer copy. Kept out of the component's `T` because picking between the two is a conditional.\n *\n * Exported so the hint-width guard can measure these strings: they render under `wrap=\"truncate\"`,\n * so a hint of \u226580 columns silently loses its TAIL \u2014 and the tail is where the newest keybinding\n * always lands. `Esc clear` is the whole truth, not an abbreviation of one: Esc pops the filter and\n * never quits, so the `quit` beside it is the only advertised way out.\n *\n * That advertised key is Ctrl-C, though Ctrl-D quits identically (see `handleCtrlKey`). Naming only\n * one is a width decision, and Ctrl-C wins it: it is what a hand reaches for to abandon a picker, and\n * it went UNADVERTISED here for as long as the palette existed.\n *\n * The slack this leaves is NOT spendable: restoring `type to filter` to the suspend variant would\n * measure 79 against the guard's `toBeLessThan(80)`, i.e. one column from silently truncating again.\n */\nexport const HINTS = {\n  suspend: 'filter \u00B7 \u2191\u2193 move \u00B7 Enter run \u00B7 Esc clear \u00B7 Ctrl-C quit \u00B7 Ctrl-Z suspend',\n  plain: 'type to filter \u00B7 \u2191\u2193 move \u00B7 Enter run \u00B7 Esc clear \u00B7 Ctrl-C quit',\n}\n\n/**\n * The footer hint, which advertises Ctrl-Z only where suspending is possible.\n *\n * Module scope for two reasons, both load-bearing. It cannot live in the component: a `?:` in\n * `CommandPalette`'s body pushes it from 15 to 16, over the sonarjs cognitive-complexity ceiling. And\n * it cannot sit above the component either: `@wl/component-file-order` pins this file to\n * imports \u2192 props interface \u2192 component with nothing in between. Below is the only legal home.\n *\n * Both strings are SHORTER than the hint they replace, on purpose \u2014 the footer renders with\n * `wrap=\"truncate\"`, so anything longer silently loses its tail on a narrow terminal, and the tail is\n * exactly where a newly-added key would land.\n *\n * @example\n * hintFor(true).includes('Ctrl-Z') // => true\n */\nconst hintFor = (canSuspend: boolean): string => {\n  return canSuspend ? HINTS.suspend : HINTS.plain\n}\n"],
-  "mappings": "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",
-  "names": ["render", "process", "Box", "Text", "useApp", "useInput", "useWindowSize", "useEffect", "useState", "useMemo", "useState", "useListFilter", "items", "toText", "query", "setQuery", "index", "setIndex", "filtered", "q", "item", "activeIndex", "input", "key", "n", "NO_GROUPS", "listLayout", "rows", "extraChromeRows", "heightOf", "items", "start", "end", "groupOf", "height", "previousGroup", "index", "item", "group", "startsGroup", "endThatFits", "budget", "paletteWindow", "activeIndex", "opts", "first", "jsx", "jsxs", "BranchMultiPicker", "props", "items", "onSubmit", "onCancel", "required", "allowSelectAll", "T", "BRANCH_MULTI_PICKER_TEXT", "labelWidth", "max", "item", "exit", "useApp", "rows", "useWindowSize", "filtered", "activeIndex", "query", "handleNavigation", "clearQuery", "useListFilter", "filterText", "selected", "setSelected", "useState", "showRequiredHint", "setShowRequiredHint", "windowStart", "setWindowStart", "submitted", "setSubmitted", "useEffect", "layout", "listLayout", "view", "paletteWindow", "toggleValue", "value", "prev", "next", "toggleSelectAll", "cancel", "submit", "useInput", "input", "key", "active", "Text", "Box", "position", "isActive", "isChecked", "Box", "Text", "useApp", "useInput", "useWindowSize", "useEffect", "useState", "jsx", "jsxs", "BranchPicker", "props", "items", "onSelect", "onCancel", "T", "BRANCH_PICKER_TEXT", "labelWidth", "max", "item", "exit", "useApp", "rows", "useWindowSize", "filtered", "activeIndex", "query", "handleNavigation", "clearQuery", "useListFilter", "filterText", "windowStart", "setWindowStart", "useState", "submitted", "setSubmitted", "useEffect", "layout", "listLayout", "view", "paletteWindow", "cancel", "useInput", "input", "key", "selected", "Text", "Box", "position", "isActive", "labelColor", "type", "Box", "Text", "useApp", "useInput", "useWindowSize", "useEffect", "useMemo", "useState", "jsx", "jsxs", "CommandPalette", "props", "items", "onSelect", "onCancel", "onSuspend", "T", "hintFor", "nameWidth", "exit", "suspendTerminal", "useApp", "rows", "useWindowSize", "query", "setQuery", "useState", "index", "setIndex", "windowStart", "setWindowStart", "submitted", "setSubmitted", "useEffect", "filtered", "useMemo", "q", "item", "activeIndex", "layout", "listLayout", "view", "paletteWindow", "quit", "suspend", "handleCtrlKey", "input", "step", "delta", "n", "useInput", "key", "selected", "Text", "lastGroup", "Box", "position", "isActive", "showGroup", "HINTS", "canSuspend", "jsx", "renderToStderr", "element", "stdout", "safeStderr", "waitUntilExit", "render", "stdinReaderCount", "process", "runCommandPalette", "items", "selected", "CommandPalette", "name", "suspendForeground", "runBranchPicker", "BranchPicker", "value", "runBranchMultiPicker", "opts", "BranchMultiPicker", "values"]
-}