infra-kit 0.1.128 → 0.1.130

package/src/integrations/cmux/open-workspace-with-layout.ts

@@ -1,80 +0,0 @@
-import { $ } from 'zx'
-
-import { getInfraKitConfig, resolveCmuxLayout } from 'src/lib/infra-kit-config'
-
-interface OpenCmuxWorkspaceArgs {
-  cwd: string
-  title?: string
-}
-
-/**
- * Opens a new cmux workspace rooted at `cwd`, with panes arranged per the
- * configured `worktrees.cmux.layout` (resolved via {@link resolveCmuxLayout},
- * default `two-columns`):
- *   two-columns — left | right, both full-height (two panes)
- *   three-pane  — left-top / left-bottom | full-height right (three panes)
- * All panes inherit `cwd` from the workspace.
- */
-export const openCmuxWorkspaceWithLayout = async (args: OpenCmuxWorkspaceArgs): Promise<void> => {
-  const { cwd, title } = args
-
-  const layout = resolveCmuxLayout(await getInfraKitConfig())
-
-  const newWorkspaceOutput = (await $`cmux workspace create --cwd ${cwd}`).stdout
-
-  const workspaceRef = parseWorkspaceRef(newWorkspaceOutput)
-
-  const surfacesOutput = (await $`cmux list-pane-surfaces --workspace ${workspaceRef}`).stdout
-
-  const leftTopRef = parseFirstSurfaceRef(surfacesOutput)
-
-  // Both layouts share the vertical split into left | right columns; only the
-  // legacy three-pane layout additionally splits the left column top/bottom.
-  await $`cmux new-split right --workspace ${workspaceRef} --surface ${leftTopRef}`
-
-  if (layout === 'three-pane') {
-    await $`cmux new-split down --workspace ${workspaceRef} --surface ${leftTopRef}`
-  }
-
-  if (title) {
-    await $`cmux workspace rename --workspace ${workspaceRef} --title ${title}`
-  }
-}
-
-/**
- * Extracts the first `surface:<id>` reference from the output of
- * `cmux list-pane-surfaces`. Used to locate the initial (primary) pane
- * surface so subsequent splits can be anchored relative to it.
- *
- * @example
- * const output = 'surface:12 (active)\nsurface:13\n'
- * parseFirstSurfaceRef(output) // => 'surface:12'
- */
-const parseFirstSurfaceRef = (output: string): string => {
-  const match = output.match(/surface:\d+/)
-
-  if (!match) {
-    throw new Error('cmux: could not locate initial surface in list-pane-surfaces output')
-  }
-
-  return match[0]
-}
-
-/**
- * Extracts the `workspace:<id>` reference from the output of
- * `cmux workspace create`. The returned ref is used to target the newly
- * created workspace in follow-up `cmux` commands (splits, rename, etc.).
- *
- * @example
- * const output = 'created workspace:7\n'
- * parseWorkspaceRef(output) // => 'workspace:7'
- */
-const parseWorkspaceRef = (output: string): string => {
-  const match = output.match(/workspace:\d+/)
-
-  if (!match) {
-    throw new Error('cmux: could not locate workspace ref in workspace create output')
-  }
-
-  return match[0]
-}

package/src/integrations/cmux/workspace-title.ts

@@ -1,23 +0,0 @@
-import { displayLabel, parseBranchName } from 'src/lib/release-id'
-
-interface BuildCmuxWorkspaceTitleArgs {
-  repoName: string
-  branch: string
-}
-
-/**
- * Builds the cmux workspace title used by `worktrees-add` and looked up by
- * `worktrees-remove`. Release branches are rendered via their release-id
- * display label so the title reads e.g. `"hulyo-monorepo 1.48.0"` for
- * `"release/v1.48.0"` and `"hulyo-monorepo checkout-redesign"` for
- * `"release/checkout-redesign"`. Non-release branches (cmux titles them too)
- * fall back to the raw branch string.
- */
-export const buildCmuxWorkspaceTitle = (args: BuildCmuxWorkspaceTitleArgs): string => {
-  const { repoName, branch } = args
-
-  const id = parseBranchName(branch)
-  const label = id ? displayLabel(id) : branch
-
-  return `${repoName} ${label}`
-}

package/src/integrations/cursor/.omc/state/agent-replay-f99d8dad-81d1-4987-8183-62edf0843d0c.jsonl

@@ -1,2 +0,0 @@
-{"t":0,"agent":"system","event":"skill_invoked","skill_name":"oh-my-claudecode:cancel"}
-{"t":0,"agent":"a56b8e3","agent_type":"unknown","event":"agent_stop","success":true,"duration_ms":0}

package/src/integrations/cursor/.omc/state/idle-notif-cooldown.json

@@ -1,3 +0,0 @@
-{
-  "lastSentAt": "2026-06-22T07:10:20.378Z"
-}

package/src/integrations/cursor/.omc/state/sessions/f99d8dad-81d1-4987-8183-62edf0843d0c/pre-tool-advisory-throttle.json

@@ -1,18 +0,0 @@
-{
-  "version": 1,
-  "entries": {
-    "79a93d4a2f8f50b95f852280616242fee1855dc99a3c75211917f55e72e95fae": {
-      "last_emitted_at_ms": 1782112155382,
-      "message": "Use parallel execution for independent tasks. Use run_in_background for long operations (npm install, builds, tests)."
-    },
-    "466399dafa2d20f60587180bad0a07358eb7f2bce724df0ff682f038ad33f5ad": {
-      "last_emitted_at_ms": 1782112102061,
-      "message": "Read multiple files in parallel when possible for faster analysis."
-    },
-    "445ed27a3872b681d98190bae61ccb84954e1bc4e140df5370be958dee776b3a": {
-      "last_emitted_at_ms": 1782112093035,
-      "message": "Verify changes work after editing. Test functionality before marking complete."
-    }
-  },
-  "updated_at": "2026-06-22T07:09:15.382Z"
-}

package/src/integrations/cursor/.omc/state/sessions/f99d8dad-81d1-4987-8183-62edf0843d0c/subagent-tracking-state.json

@@ -1,17 +0,0 @@
-{
-  "agents": [
-    {
-      "agent_id": "a56b8e33689099584",
-      "agent_type": "unknown",
-      "started_at": "2026-06-22T07:13:23.151Z",
-      "parent_mode": "none",
-      "status": "completed",
-      "completed_at": "2026-06-22T07:13:23.151Z",
-      "duration_ms": 0
-    }
-  ],
-  "total_spawned": 0,
-  "total_completed": 1,
-  "total_failed": 0,
-  "last_updated": "2026-06-22T07:13:23.253Z"
-}

package/src/integrations/cursor/add-folders-to-workspace.ts

@@ -1,84 +0,0 @@
-import fs from 'node:fs/promises'
-import path from 'node:path'
-
-interface AddFoldersToCursorWorkspaceArgs {
-  workspacePath: string
-  folderPaths: string[]
-}
-
-interface AddFoldersToCursorWorkspaceResult {
-  added: string[]
-  skipped: string[]
-}
-
-interface WorkspaceFolderEntry {
-  path: string
-  name?: string
-}
-
-interface WorkspaceFile {
-  folders?: WorkspaceFolderEntry[]
-  [key: string]: unknown
-}
-
-/**
- * Adds folders to a Cursor (`.code-workspace`) file's `folders` array, skipping
- * entries that already point to the same absolute path. Folder paths are written
- * as relative to the workspace file's directory to match Cursor's default style.
- */
-export const addFoldersToCursorWorkspace = async (
-  args: AddFoldersToCursorWorkspaceArgs,
-): Promise<AddFoldersToCursorWorkspaceResult> => {
-  const { workspacePath, folderPaths } = args
-
-  const workspaceDir = path.dirname(workspacePath)
-
-  let raw: string
-
-  try {
-    raw = await fs.readFile(workspacePath, 'utf-8')
-  } catch (error) {
-    throw new Error(`Cursor workspace file not found at ${workspacePath}: ${(error as Error).message}`)
-  }
-
-  let parsed: WorkspaceFile
-
-  try {
-    parsed = JSON.parse(raw) as WorkspaceFile
-  } catch (error) {
-    throw new Error(
-      `Failed to parse ${workspacePath} as JSON. Comments (JSONC) are not supported. ${(error as Error).message}`,
-    )
-  }
-
-  const existingFolders = parsed.folders ?? []
-  const existingAbsolutePaths = new Set(
-    existingFolders.map((entry) => {
-      return path.resolve(workspaceDir, entry.path)
-    }),
-  )
-
-  const added: string[] = []
-  const skipped: string[] = []
-
-  for (const folderPath of folderPaths) {
-    const absolutePath = path.resolve(folderPath)
-
-    if (existingAbsolutePaths.has(absolutePath)) {
-      skipped.push(folderPath)
-      continue
-    }
-
-    const relativePath = path.relative(workspaceDir, absolutePath)
-
-    existingFolders.push({ path: relativePath })
-    existingAbsolutePaths.add(absolutePath)
-    added.push(folderPath)
-  }
-
-  parsed.folders = existingFolders
-
-  await fs.writeFile(workspacePath, `${JSON.stringify(parsed, null, 2)}\n`, 'utf-8')
-
-  return { added, skipped }
-}

package/src/integrations/cursor/index.ts

@@ -1,6 +0,0 @@
-export { addFoldersToCursorWorkspace } from './add-folders-to-workspace'
-export { launchCursor } from './launch-cursor'
-export { openCursorWorkspace } from './open-cursor-workspace'
-export { reconcileCursorWorkspaceFolders } from './reconcile-workspace-folders'
-export { removeFoldersFromCursorWorkspace } from './remove-folders-from-workspace'
-export { resolveCursorWorkspacePath } from './resolve-workspace-path'

package/src/integrations/cursor/launch-cursor.ts

@@ -1,12 +0,0 @@
-import { $ } from 'zx'
-
-/**
- * Spawns Cursor against a `.code-workspace` file (or any path). Centralised here
- * — rather than inlined at each call site — so the editor spawn lives inside the
- * cursor provider module and is covered by a single `vi.mock('src/integrations/cursor')`.
- * Keeping it out of the IDE-orchestration layer is what stops tests that mock the
- * provider (but not `zx`) from shelling out to a real editor.
- */
-export const launchCursor = async (workspacePath: string): Promise<void> => {
-  await $`cursor ${workspacePath}`
-}

package/src/integrations/cursor/open-cursor-workspace.ts

@@ -1,64 +0,0 @@
-import { logger } from 'src/lib/logger'
-
-import { launchCursor } from './launch-cursor'
-import { reconcileCursorWorkspaceFolders } from './reconcile-workspace-folders'
-import { resolveCursorWorkspacePath } from './resolve-workspace-path'
-
-interface OpenCursorWorkspaceArgs {
-  projectRoot: string
-  worktreeDir: string
-  currentBranches: string[]
-  /**
-   * The Cursor entry's config, selected by the facade from the (possibly
-   * multi-IDE) infra-kit config. Passed in rather than re-read here so this
-   * opener acts on the exact entry the caller chose — essential once `ide` can
-   * be an array of providers.
-   */
-  cursorConfig: { workspaceConfigPath: string }
-}
-
-interface OpenCursorWorkspaceOutcome {
-  ran: boolean
-  added: number
-  removed: number
-}
-
-/**
- * Reconciles the configured Cursor `.code-workspace` `folders` array against the
- * set of release worktrees on disk, then launches Cursor against it (the folder
- * reconcile still runs when there are no worktrees, but the relaunch is skipped
- * so `worktrees-reload` never pops an empty Cursor window). Used by
- * `worktrees-reload`.
- *
- * No-ops (returns `ran: false`) when the Cursor entry has no `workspaceConfigPath`.
- * All failures are swallowed into a warning — opening Cursor is best-effort.
- */
-export const openCursorWorkspace = async (args: OpenCursorWorkspaceArgs): Promise<OpenCursorWorkspaceOutcome> => {
-  const { projectRoot, worktreeDir, currentBranches, cursorConfig } = args
-
-  if (!cursorConfig.workspaceConfigPath) {
-    logger.warn('⚠️ Skipping Cursor: workspaceConfigPath is not set.')
-
-    return { ran: false, added: 0, removed: 0 }
-  }
-
-  const workspacePath = resolveCursorWorkspacePath(cursorConfig.workspaceConfigPath, projectRoot)
-
-  try {
-    const { added, removed } = await reconcileCursorWorkspaceFolders({
-      workspacePath,
-      worktreeDir,
-      currentBranches,
-    })
-
-    if (currentBranches.length > 0) {
-      await launchCursor(workspacePath)
-    }
-
-    return { ran: true, added: added.length, removed: removed.length }
-  } catch (error) {
-    logger.warn({ error }, `⚠️ Failed to reconcile/open Cursor workspace at ${workspacePath}`)
-
-    return { ran: false, added: 0, removed: 0 }
-  }
-}

package/src/integrations/cursor/reconcile-workspace-folders.ts

@@ -1,90 +0,0 @@
-import fs from 'node:fs/promises'
-import path from 'node:path'
-
-import { addFoldersToCursorWorkspace } from './add-folders-to-workspace'
-import { removeFoldersFromCursorWorkspace } from './remove-folders-from-workspace'
-
-interface ReconcileCursorWorkspaceFoldersArgs {
-  workspacePath: string
-  worktreeDir: string
-  currentBranches: string[]
-}
-
-interface ReconcileCursorWorkspaceFoldersResult {
-  added: string[]
-  removed: string[]
-}
-
-interface WorkspaceFolderEntry {
-  path: string
-  name?: string
-}
-
-interface WorkspaceFile {
-  folders?: WorkspaceFolderEntry[]
-  [key: string]: unknown
-}
-
-/**
- * Reconciles the configured Cursor workspace's `folders` array against the
- * actual set of release worktrees on disk:
- *   - Adds any worktree folders that aren't already listed.
- *   - Removes entries whose absolute path lives under `${worktreeDir}/release/`
- *     but no longer corresponds to a current branch (drift from manual
- *     `git worktree remove`, deleted branches, etc.).
- *
- * Non-worktree folder entries are left untouched.
- */
-export const reconcileCursorWorkspaceFolders = async (
-  args: ReconcileCursorWorkspaceFoldersArgs,
-): Promise<ReconcileCursorWorkspaceFoldersResult> => {
-  const { workspacePath, worktreeDir, currentBranches } = args
-
-  const workspaceDir = path.dirname(workspacePath)
-  const releaseRoot = path.resolve(`${worktreeDir}/release`)
-
-  const raw = await fs.readFile(workspacePath, 'utf-8')
-  const parsed = JSON.parse(raw) as WorkspaceFile
-
-  const existingFolders = parsed.folders ?? []
-
-  const desiredAbsolutePaths = new Set(
-    currentBranches.map((branch) => {
-      return path.resolve(`${worktreeDir}/${branch}`)
-    }),
-  )
-
-  const danglingFolderPaths: string[] = []
-
-  for (const entry of existingFolders) {
-    const entryAbsolutePath = path.resolve(workspaceDir, entry.path)
-
-    const isReleaseShaped = entryAbsolutePath === releaseRoot || entryAbsolutePath.startsWith(`${releaseRoot}/`)
-
-    if (isReleaseShaped && !desiredAbsolutePaths.has(entryAbsolutePath)) {
-      danglingFolderPaths.push(entryAbsolutePath)
-    }
-  }
-
-  let removed: string[] = []
-
-  if (danglingFolderPaths.length > 0) {
-    const result = await removeFoldersFromCursorWorkspace({
-      workspacePath,
-      folderPaths: danglingFolderPaths,
-    })
-
-    removed = result.removed
-  }
-
-  const desiredFolderPaths = currentBranches.map((branch) => {
-    return `${worktreeDir}/${branch}`
-  })
-
-  const { added } =
-    desiredFolderPaths.length > 0
-      ? await addFoldersToCursorWorkspace({ workspacePath, folderPaths: desiredFolderPaths })
-      : { added: [] as string[] }
-
-  return { added, removed }
-}

package/src/integrations/cursor/remove-folders-from-workspace.ts

@@ -1,93 +0,0 @@
-import fs from 'node:fs/promises'
-import path from 'node:path'
-
-interface RemoveFoldersFromCursorWorkspaceArgs {
-  workspacePath: string
-  folderPaths: string[]
-}
-
-interface RemoveFoldersFromCursorWorkspaceResult {
-  removed: string[]
-  notFound: string[]
-}
-
-interface WorkspaceFolderEntry {
-  path: string
-  name?: string
-}
-
-interface WorkspaceFile {
-  folders?: WorkspaceFolderEntry[]
-  [key: string]: unknown
-}
-
-/**
- * Removes folders from a Cursor (`.code-workspace`) file's `folders` array. Entries
- * are matched by resolved absolute path, so relative and absolute entries pointing
- * at the same folder are both removed.
- */
-export const removeFoldersFromCursorWorkspace = async (
-  args: RemoveFoldersFromCursorWorkspaceArgs,
-): Promise<RemoveFoldersFromCursorWorkspaceResult> => {
-  const { workspacePath, folderPaths } = args
-
-  const workspaceDir = path.dirname(workspacePath)
-
-  let raw: string
-
-  try {
-    raw = await fs.readFile(workspacePath, 'utf-8')
-  } catch (error) {
-    throw new Error(`Cursor workspace file not found at ${workspacePath}: ${(error as Error).message}`)
-  }
-
-  let parsed: WorkspaceFile
-
-  try {
-    parsed = JSON.parse(raw) as WorkspaceFile
-  } catch (error) {
-    throw new Error(
-      `Failed to parse ${workspacePath} as JSON. Comments (JSONC) are not supported. ${(error as Error).message}`,
-    )
-  }
-
-  const existingFolders = parsed.folders ?? []
-  const targetAbsolutePaths = new Set(
-    folderPaths.map((folderPath) => {
-      return path.resolve(folderPath)
-    }),
-  )
-
-  const removedAbsolutePaths = new Set<string>()
-
-  const filteredFolders = existingFolders.filter((entry) => {
-    const entryAbsolutePath = path.resolve(workspaceDir, entry.path)
-
-    if (targetAbsolutePaths.has(entryAbsolutePath)) {
-      removedAbsolutePaths.add(entryAbsolutePath)
-
-      return false
-    }
-
-    return true
-  })
-
-  parsed.folders = filteredFolders
-
-  await fs.writeFile(workspacePath, `${JSON.stringify(parsed, null, 2)}\n`, 'utf-8')
-
-  const removed: string[] = []
-  const notFound: string[] = []
-
-  for (const folderPath of folderPaths) {
-    const absolutePath = path.resolve(folderPath)
-
-    if (removedAbsolutePaths.has(absolutePath)) {
-      removed.push(folderPath)
-    } else {
-      notFound.push(folderPath)
-    }
-  }
-
-  return { removed, notFound }
-}

package/src/integrations/cursor/resolve-workspace-path.ts

@@ -1,13 +0,0 @@
-import path from 'node:path'
-
-/**
- * Resolves the configured Cursor workspace path against the project root.
- * Absolute paths are returned unchanged.
- */
-export const resolveCursorWorkspacePath = (configValue: string, projectRoot: string): string => {
-  if (path.isAbsolute(configValue)) {
-    return configValue
-  }
-
-  return path.resolve(projectRoot, configValue)
-}

package/src/integrations/doppler/__tests__/doppler-errors.test.ts

@@ -1,76 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { buildDopplerNotFoundMessage, classifyDopplerDownloadError } from '../doppler-errors'
-
-// Verbatim Doppler stderr observed on a not-found download (doppler v3.76.0,
-// 2026-06-27). The "" prefix is the real ANSI color on "Doppler Error:".
-const PROJECT_NOT_FOUND_STDERR =
-  "Unable to download secrets\nDoppler Error: Could not find requested project 'infra-kit'\n"
-const CONFIG_NOT_FOUND_STDERR =
-  "Unable to download secrets\nDoppler Error: Could not find requested config 'bogus-cfg'\n"
-
-describe('classifyDopplerDownloadError', () => {
-  it('classifies a project-not-found stderr as "project"', () => {
-    expect(classifyDopplerDownloadError(PROJECT_NOT_FOUND_STDERR)).toBe('project')
-  })
-
-  it('classifies a config-not-found stderr as "config"', () => {
-    expect(classifyDopplerDownloadError(CONFIG_NOT_FOUND_STDERR)).toBe('config')
-  })
-
-  it('is color-safe — the markers are matched despite ANSI codes', () => {
-    expect(classifyDopplerDownloadError('Doppler Error: Could not find requested project')).toBe('project')
-  })
-
-  it('returns "unknown" for unrelated failures (auth, network, timeout)', () => {
-    expect(classifyDopplerDownloadError('Doppler Error: you must be logged in')).toBe('unknown')
-    expect(classifyDopplerDownloadError('connect ETIMEDOUT')).toBe('unknown')
-    expect(classifyDopplerDownloadError('')).toBe('unknown')
-  })
-})
-
-describe('buildDopplerNotFoundMessage', () => {
-  it('names the missing project and points at envManagement.config.name', () => {
-    const msg = buildDopplerNotFoundMessage({ kind: 'project', project: 'infra-kit', config: 'dev', available: null })
-
-    expect(msg).toContain('Doppler project "infra-kit" not found')
-    expect(msg).toContain('envManagement.config.name')
-    expect(msg).toContain('Fix:')
-  })
-
-  it('lists available projects when the enrichment list is non-empty', () => {
-    const msg = buildDopplerNotFoundMessage({
-      kind: 'project',
-      project: 'infra-kit',
-      config: 'dev',
-      available: ['example-project', 'nomadream'],
-    })
-
-    expect(msg).toContain('Available projects: example-project, nomadream.')
-  })
-
-  it('omits the available line when the list is empty (told: none exist)', () => {
-    const msg = buildDopplerNotFoundMessage({ kind: 'project', project: 'infra-kit', config: 'dev', available: [] })
-
-    expect(msg).not.toContain('Available projects')
-  })
-
-  it('omits the available line when the list is null (lookup failed)', () => {
-    const msg = buildDopplerNotFoundMessage({ kind: 'project', project: 'infra-kit', config: 'dev', available: null })
-
-    expect(msg).not.toContain('Available projects')
-  })
-
-  it('names the missing config, its project, and points at environments', () => {
-    const msg = buildDopplerNotFoundMessage({
-      kind: 'config',
-      project: 'nomadream',
-      config: 'staging',
-      available: ['dev', 'arthur'],
-    })
-
-    expect(msg).toContain('Doppler config "staging" not found in project "nomadream"')
-    expect(msg).toContain('infra-kit.json → environments')
-    expect(msg).toContain('Available configs in "nomadream": dev, arthur.')
-  })
-})

package/src/integrations/doppler/doppler-cli-auth.ts

@@ -1,31 +0,0 @@
-import { $ } from 'zx'
-
-/**
- * Hard upper bound for the Doppler auth probes. `doppler me` is a network call;
- * without a timeout a hung VPN/connection would stall every caller indefinitely
- * (notably the env auto-load preAction hook, which runs before each CLI command).
- */
-const DOPPLER_AUTH_TIMEOUT_MS = 5_000
-
-/**
- * Validate Doppler CLI installation and authentication status. Throws on failure
- * so callers (CLI entry, MCP tool handler) can translate to the right surface —
- * CLI exits non-zero; MCP returns a structured tool error instead of tearing
- * down the server. Both probes are time-bounded so a hung Doppler/network never
- * blocks the caller (a timeout surfaces as the same "not authenticated" path).
- */
-export const validateDopplerCliAndAuth = async (): Promise<void> => {
-  try {
-    await $`doppler --version`.timeout(DOPPLER_AUTH_TIMEOUT_MS)
-  } catch (error: unknown) {
-    throw new Error('Doppler CLI is not installed. Install it from: https://docs.doppler.com/docs/install-cli', {
-      cause: error,
-    })
-  }
-
-  try {
-    await $`doppler me`.timeout(DOPPLER_AUTH_TIMEOUT_MS)
-  } catch (error: unknown) {
-    throw new Error('Doppler CLI is not authenticated (or timed out). Run: doppler login', { cause: error })
-  }
-}