@brimveyn/aimux 1.21.0 → 1.22.2

package/src/app-runtime/prompt-injection.ts

@@ -0,0 +1,123 @@
+// Sends the create-workspace prompt into the assistant that was just launched.
+//
+// The hard part is knowing when the assistant will accept it. Measured against
+// a real `claude` pty: it enables bracketed paste ~350ms after spawn but drops
+// anything pasted before ~1s, and that gap is not a constant — the same binary
+// in a different directory still swallowed a paste 1.5s after the flag.
+//
+// So no delay is trusted. Bracketed paste is only the coarse "the pty is in raw
+// mode" gate; after it we paste and then *check the screen* for the text,
+// retrying until it shows up. Enter is sent once, at the end, so a prompt is
+// never half-submitted.
+
+import type { SessionBackend } from '../session-backend/types'
+import type { AppState, TerminalSnapshot } from '../state/types'
+
+import { logInputDebug } from '../debug/input-log'
+import { getLineText } from '../input/terminal-text-extraction'
+import { writePasteToTab, writeToTab } from './pty-write'
+
+const POLL_INTERVAL_MS = 100
+/** Past this the command is either unusually slow or is not a TUI at all. */
+const READY_TIMEOUT_MS = 20_000
+
+/** Time for the assistant to redraw with the pasted text before we look. */
+const ECHO_WAIT_MS = 500
+const MAX_ATTEMPTS = 12
+
+/** Ctrl+U. Clears whatever a previous attempt left behind so retries cannot stack. */
+const CLEAR_INPUT = '\x15'
+const SUBMIT = '\r'
+
+/**
+ * Enough of the prompt to recognise on screen, short enough to survive the
+ * input box wrapping it onto the next row.
+ */
+const PROBE_LENGTH = 16
+const MIN_PROBE_LENGTH = 4
+
+export interface InjectPromptOptions {
+  backend: SessionBackend
+  getState: () => AppState
+  tabId: string
+  prompt: string
+  pollIntervalMs?: number
+  timeoutMs?: number
+  echoWaitMs?: number
+  maxAttempts?: number
+  sleep?: (ms: number) => Promise<void>
+}
+
+async function defaultSleep(ms: number): Promise<void> {
+  await new Promise<void>((resolve) => setTimeout(resolve, ms))
+}
+
+function screenText(viewport: TerminalSnapshot | undefined): string {
+  if (!viewport) return ''
+  return viewport.lines.map((line) => getLineText(line)).join('\n')
+}
+
+/** The needle we look for on screen, or null when the prompt cannot be matched on. */
+function echoProbe(prompt: string): string | null {
+  // A multi-line paste is folded into a "[Pasted text #1 +N lines]" placeholder
+  // by every assistant we ship, so there would be nothing on screen to find and
+  // every attempt would "fail" until the cap.
+  if (prompt.includes('\n')) return null
+  const probe = prompt.trim().slice(0, PROBE_LENGTH)
+  return probe.length >= MIN_PROBE_LENGTH ? probe : null
+}
+
+/**
+ * Paste the prompt into the tab's assistant and submit it.
+ *
+ * ponytail: a 100ms poll over state, because the pty layer exposes no "modes
+ * changed" event to await. Retries are bounded and always preceded by Ctrl+U,
+ * so the worst case is one unverified paste — never two stacked ones.
+ */
+export async function injectPromptWhenReady(options: InjectPromptOptions): Promise<void> {
+  const { backend, getState, prompt, tabId } = options
+  if (prompt.trim() === '') return
+
+  const sleep = options.sleep ?? defaultSleep
+  const interval = options.pollIntervalMs ?? POLL_INTERVAL_MS
+  const deadline = options.timeoutMs ?? READY_TIMEOUT_MS
+  const echoWait = options.echoWaitMs ?? ECHO_WAIT_MS
+  const attempts = options.maxAttempts ?? MAX_ATTEMPTS
+  const probe = echoProbe(prompt)
+
+  const currentTab = () => getState().tabs.find((entry) => entry.id === tabId)
+
+  logInputDebug('app.promptInjection.start', { promptLength: prompt.length, tabId })
+
+  for (let waited = 0; waited < deadline; waited += interval) {
+    const tab = currentTab()
+    // The tab was closed, or the command died on startup: nothing to type into.
+    if (!tab || tab.status === 'error' || tab.status === 'disconnected') {
+      logInputDebug('app.promptInjection.abandoned', { status: tab?.status ?? 'gone', tabId })
+      return
+    }
+    if (tab.terminalModes.bracketedPasteMode) break
+    await sleep(interval)
+  }
+
+  let landed = false
+  for (let attempt = 0; attempt < attempts && !landed; attempt++) {
+    const tab = currentTab()
+    if (!tab) {
+      logInputDebug('app.promptInjection.abandoned', { status: 'gone', tabId })
+      return
+    }
+    if (attempt > 0) writeToTab(backend, tabId, tab, CLEAR_INPUT)
+    writePasteToTab(backend, tabId, tab, prompt)
+    await sleep(echoWait)
+    // No usable probe (a one-word prompt, or text the assistant folds into a
+    // "pasted N lines" placeholder): take the first paste on faith.
+    landed = probe == null || screenText(currentTab()?.viewport).includes(probe)
+    logInputDebug('app.promptInjection.attempt', { attempt: attempt + 1, landed, tabId })
+  }
+
+  const tab = currentTab()
+  if (!tab) return
+  writeToTab(backend, tabId, tab, SUBMIT)
+  logInputDebug('app.promptInjection.submitted', { landed, tabId })
+}

package/src/app-runtime/selection.ts

@@ -0,0 +1,29 @@
+import type { AppState, ProjectRecord, SnippetRecord } from '../state/types'
+
+// eslint-disable-next-line no-duplicate-imports
+import { type AssistantOption, getAssistantOption } from '../pty/command-registry'
+import { filterProjects, filterSnippets, getNewTabAssistantOptions } from '../state/selectors'
+
+/**
+ * The row a picker modal currently highlights. Each reads the same filtered
+ * list the modal renders, so the effect acts on the row the user is looking at.
+ */
+export function getSelectedProject(state: AppState): ProjectRecord | undefined {
+  const filter = state.modal.type === 'project-picker' ? state.modal.editBuffer : null
+  return filterProjects(state.projects, filter)[state.modal.selectedIndex]
+}
+
+export function getSelectedSnippet(state: AppState): SnippetRecord | undefined {
+  const filter = state.modal.type === 'snippet-picker' ? state.modal.editBuffer : null
+  return filterSnippets(state.snippets, filter)[state.modal.selectedIndex]
+}
+
+export function getSelectedAssistantOption(state: AppState): AssistantOption {
+  const newTab = state.modal.type === 'new-tab' ? state.modal : null
+  const list = getNewTabAssistantOptions(
+    state.customCommands,
+    newTab?.editBuffer ?? null,
+    newTab?.pendingWorkspace != null
+  )
+  return list[state.modal.selectedIndex] ?? list[0] ?? getAssistantOption(0)
+}

package/src/app-runtime/settings-actions.ts

@@ -0,0 +1,156 @@
+import type { SettingCtx, SettingRow, SettingValue } from '../settings/types'
+import type { AppState } from '../state/types'
+import type { SideEffectContext } from './side-effect-context'
+
+import { filterSettingRows } from '../settings/search'
+import { findSettingRow, getSectionRows } from '../settings/sections'
+import { readRow, resetRow, settingsStore, writeRow } from '../settings/settings-store'
+import { dispatchGlobal } from '../state/dispatch-ref'
+import { toast } from '../state/toast-store'
+
+type SettingsContext = Pick<SideEffectContext, 'getState'>
+
+/** Steps like 0.05 otherwise accumulate binary noise into the persisted value. */
+function round(value: number): number {
+  return Math.round(value * 10_000) / 10_000
+}
+
+function nextOptionValue(
+  options: readonly { value: SettingValue }[],
+  current: SettingValue,
+  delta: 1 | -1
+): SettingValue | undefined {
+  // -1 when the current value isn't one of the options. Hydration keeps that from
+  // happening to a row this screen stores, so what is left is a row reading a
+  // value that lives elsewhere; stepping forward from -1 lands on the first
+  // option, which is how it heals.
+  const index = options.findIndex((option) => option.value === current)
+  const size = options.length
+  if (size === 0) return undefined
+  return options[(index + delta + size) % size]?.value
+}
+
+function nextNumberValue(
+  row: Extract<SettingRow, { kind: 'number' }>,
+  current: SettingValue,
+  delta: 1 | -1
+): number {
+  const base = typeof current === 'number' ? current : row.min
+  // Clamped, never wrapped: `-`/`+` name a direction, and holding + on a width
+  // until it snaps to the narrowest is not what anyone meant.
+  return Math.min(row.max, Math.max(row.min, round(base + delta * row.step)))
+}
+
+/** Asks for a field, seeded with what the row holds. */
+function openField(row: SettingRow, current: SettingValue): void {
+  dispatchGlobal({
+    label: row.label,
+    settingId: row.id,
+    type: 'open-setting-text-modal',
+    value: String(current),
+  })
+}
+
+function readCtx(state: AppState): SettingCtx {
+  return { state, values: settingsStore.getState().values }
+}
+
+/**
+ * One entry point for every kind of row. `delta` is the direction asked for
+ * (`-`/`+`); without it the row advances the way activating it should — a toggle
+ * flips, an enum steps forward, a number steps up, a text field opens.
+ */
+export function changeSelectedSetting(runtime: SettingsContext, delta?: 1 | -1): void {
+  const state = runtime.getState()
+  if (state.focusMode !== 'settings' || state.settings.pane !== 'rows') return
+
+  const row = getSectionRows(state.settings.sectionId, state.projects)[state.settings.rowIndex]
+  if (!row || row.kind === 'info') return
+
+  const ctx = readCtx(state)
+  const current = readRow(row, ctx)
+
+  switch (row.kind) {
+    case 'toggle':
+      // `-`/`+` set the value rather than flipping it: holding + on a checkbox
+      // should settle on "on", not blink.
+      writeRow(row, delta === undefined ? current !== true : delta === 1, ctx)
+      return
+    case 'select': {
+      const next = nextOptionValue(row.options, current, delta ?? 1)
+      if (next !== undefined) writeRow(row, next, ctx)
+      return
+    }
+    case 'number':
+      // `-`/`+` step it; <CR> asks for the number. Stepping alone meant 59
+      // presses to cross the AI usage refresh interval.
+      if (delta === undefined) openField(row, current)
+      else writeRow(row, nextNumberValue(row, current, delta), ctx)
+      return
+    case 'text':
+      // Nothing a keystroke can advance, so activating hands over to a field.
+      // `-`/`+` have nothing to do on one.
+      if (delta === undefined) openField(row, current)
+      return
+    case 'action':
+      // Not a value, so a direction means nothing to it either.
+      if (delta === undefined) row.run()
+      return
+    default:
+      row satisfies never
+  }
+}
+
+/**
+ * Move the screen's cursor onto the setting the search had highlighted, wherever
+ * it turned out to live. The list is recomputed from the same filter the picker
+ * drew, so the index still means what it meant.
+ */
+export function confirmSettingsSearch(runtime: SettingsContext): void {
+  const state = runtime.getState()
+  if (state.modal.type !== 'settings-search') return
+  const hit = filterSettingRows(state.projects, state.modal.editBuffer)[state.modal.selectedIndex]
+  dispatchGlobal({ type: 'close-modal' })
+  if (!hit) return
+  dispatchGlobal({ sectionId: hit.sectionId, type: 'settings-select-section' })
+  dispatchGlobal({ rowIndex: hit.rowIndex, type: 'settings-select-row' })
+}
+
+/** Puts the selected row back to what it would be if this screen had never run. */
+export function resetSelectedSetting(runtime: SettingsContext): void {
+  const state = runtime.getState()
+  if (state.focusMode !== 'settings' || state.settings.pane !== 'rows') return
+  const row = getSectionRows(state.settings.sectionId, state.projects)[state.settings.rowIndex]
+  if (row) resetRow(row)
+}
+
+/** Applies what the text field was holding when it was confirmed. */
+export function commitSettingText(
+  runtime: SettingsContext,
+  settingId: string,
+  value: string
+): void {
+  const state = runtime.getState()
+  // Dynamic rows included: a per-project setup command is a text row that exists
+  // only while its project does.
+  const row = findSettingRow(settingId, state.projects)
+  if (!row) return
+  const ctx = readCtx(state)
+
+  if (row.kind === 'number') {
+    const parsed = Number(value.trim())
+    if (!Number.isFinite(parsed)) {
+      toast.error(`${row.label} takes a number`)
+      return
+    }
+    // Clamped rather than refused: someone typing 10 into a field whose floor is
+    // 60 meant "as low as it goes", and saying so beats doing nothing.
+    const clamped = Math.min(row.max, Math.max(row.min, parsed))
+    if (clamped !== parsed) toast.info(`${row.label} clamped to ${String(clamped)}`)
+    writeRow(row, clamped, ctx)
+    return
+  }
+
+  if (row.kind !== 'text') return
+  writeRow(row, value.trim(), ctx)
+}

package/src/app-runtime/setup-actions.ts

@@ -0,0 +1,237 @@
+import type { AppAction } from '../state/actions'
+import type { ProjectRecord, TabSession, WorkspaceRecord } from '../state/types'
+import type { SideEffectContext } from './side-effect-context'
+
+import { logInputDebug } from '../debug/input-log'
+import { shellQuote } from '../pty/command-registry'
+import { appStore } from '../state/app-store'
+import { saveProjectCatalog } from '../state/project-catalog'
+import { ensureSetupScriptStub, getProjectDataDir, getSetupScriptPath } from '../state/project-data'
+import {
+  findWorkspace,
+  getActiveWorkspace,
+  getActiveWorkspacePath,
+  getCurrentProject,
+} from '../state/project-workspaces'
+import { toast } from '../state/toast-store'
+import { launchEditorOnFile } from './editor-actions'
+import { createTabSession, startTabSession } from './tab-actions'
+
+/**
+ * The setup tab starts before its host is on screen (or without a host at all —
+ * the widget is opt-in), so it has no measured box yet. This bootstrap size also
+ * has to lift the backend's paneReady gate: while that gate is closed every
+ * render is buffered, and a setup running behind a hidden widget would produce
+ * no viewport ever. The widget's own measurement corrects the size later.
+ */
+const BOOTSTRAP_COLS = 80
+const BOOTSTRAP_ROWS = 24
+
+/**
+ * The setup tab the widget owns for this workspace. Hidden is part of the
+ * predicate: a promoted tab is a normal tab in the main pane, so the widget must
+ * stop rendering and sizing it — two hosts reporting a measurement for one PTY
+ * never settle on a size.
+ */
+export function findSetupTab(
+  tabs: TabSession[],
+  workspaceId: string | undefined
+): TabSession | undefined {
+  if (workspaceId == null || workspaceId === '') return undefined
+  return tabs.find(
+    (tab) => tab.role === 'setup' && tab.hidden === true && tab.workspaceId === workspaceId
+  )
+}
+
+/**
+ * Stamp a finished setup run onto its workspace record. Returns whether the tab
+ * was a setup tab, which is the caller's signal to leave it open.
+ *
+ * The workspace record — not the tab — is what tells the widget a run finished,
+ * so no new TabStatus is needed for "exited but still on screen".
+ */
+export function recordSetupExit(
+  tabId: string,
+  exitCode: number,
+  dispatch: (action: AppAction) => void
+): boolean {
+  const { projects, tabs } = appStore.getState()
+  const tab = tabs.find((entry) => entry.id === tabId)
+  if (tab?.role !== 'setup') return false
+
+  // A promoted tab is no longer the one the widget owns, but its exit is still
+  // the latest thing that happened to this workspace — unless a newer run has
+  // started since, which is the only case where this result is stale news.
+  // Reporting is not optional: without it, promoting a setup to watch it fail
+  // means watching it fail in silence.
+  const superseded = tab.hidden !== true && findSetupTab(tabs, tab.workspaceId) !== undefined
+  const found = findWorkspace(projects, tab.workspaceId)
+  if (superseded || !found) return true
+  const { project, workspace } = found
+
+  dispatch({
+    patch: { setupExitCode: exitCode, setupRanAt: new Date().toISOString() },
+    projectId: project.id,
+    type: 'update-workspace-record',
+    workspaceId: workspace.id,
+  })
+  saveProjectCatalog(appStore.getState().projects)
+  logInputDebug('setup.exit', {
+    exitCode,
+    projectId: project.id,
+    tabId,
+    workspaceId: workspace.id,
+  })
+
+  // The widget is opt-in, so a failure has to reach a user who never added it.
+  // Success stays quiet.
+  if (exitCode !== 0) {
+    toast.error(`Setup failed in ${workspace.name} — exit ${exitCode}`)
+  }
+  return true
+}
+
+function resolveTarget(
+  ctx: SideEffectContext
+): { project: ProjectRecord; workspace: WorkspaceRecord } | undefined {
+  const project = getCurrentProject(ctx.getState())
+  const workspace = getActiveWorkspace(project)
+  if (!project || !workspace) return undefined
+  return { project, workspace }
+}
+
+/**
+ * Spawn the hidden PTY that runs a project's setup script in one workspace.
+ * Replaces any existing setup tab for that workspace, so Run and Re-run are the
+ * same path.
+ */
+export function runSetup(ctx: SideEffectContext, projectId: string, workspace: WorkspaceRecord) {
+  const existing = findSetupTab(ctx.getState().tabs, workspace.id)
+  if (existing) {
+    ctx.backend.disposeSession(existing.id)
+    ctx.dispatch({ tabId: existing.id, type: 'close-tab' })
+  }
+
+  const scriptPath = getSetupScriptPath(projectId)
+  const tab: TabSession = {
+    // Quoted, not interpolated bare: the path sits under $HOME, which can hold a
+    // space or an apostrophe.
+    ...createTabSession('terminal', `bash ${shellQuote(scriptPath)}`, {}, workspace.id),
+    hidden: true,
+    role: 'setup',
+    title: 'Setup',
+  }
+
+  ctx.dispatch({
+    patch: { setupExitCode: undefined, setupRanAt: undefined },
+    projectId,
+    type: 'update-workspace-record',
+    workspaceId: workspace.id,
+  })
+  ctx.dispatch({ tab, type: 'add-tab' })
+  startTabSession(ctx, tab, {
+    autoRenameCandidate: false,
+    cols: BOOTSTRAP_COLS,
+    cwd: workspace.path,
+    rows: BOOTSTRAP_ROWS,
+  })
+  // Lifts the render gate immediately — see BOOTSTRAP_COLS.
+  ctx.backend.resizeTab(tab.id, BOOTSTRAP_COLS, BOOTSTRAP_ROWS, {
+    confirmedFromMeasurement: true,
+  })
+  logInputDebug('setup.run', { projectId, scriptPath, tabId: tab.id, workspaceId: workspace.id })
+  return tab.id
+}
+
+export function handleRunSetupEffect(ctx: SideEffectContext): void {
+  const target = resolveTarget(ctx)
+  if (!target) {
+    toast.error('Open a workspace first')
+    return
+  }
+  runSetup(ctx, target.project.id, target.workspace)
+}
+
+export function handleStopSetupEffect(ctx: SideEffectContext): void {
+  const target = resolveTarget(ctx)
+  if (!target) return
+  const tab = findSetupTab(ctx.getState().tabs, target.workspace.id)
+  if (!tab) return
+  ctx.backend.disposeSession(tab.id)
+  ctx.dispatch({ tabId: tab.id, type: 'close-tab' })
+}
+
+/**
+ * `projectId` names a project other than the current one — the settings screen
+ * lists every project, and a script too long for one field hands over to here.
+ * Without it, the current project's active workspace is the target.
+ */
+export function handleConfigureSetupScriptEffect(ctx: SideEffectContext, projectId?: string): void {
+  const state = ctx.getState()
+  const project =
+    projectId != null && projectId !== ''
+      ? state.projects.find((entry) => entry.id === projectId)
+      : getCurrentProject(state)
+  if (!project) {
+    toast.error('Open a project first')
+    return
+  }
+  // The editor's working directory: this project's active workspace if it has
+  // one, else wherever the project itself lives, else the script's own home —
+  // a GUI editor ignores it, a TUI one needs somewhere to be.
+  const cwd =
+    getActiveWorkspacePath(project) ?? project.projectPath ?? getProjectDataDir(project.id)
+  launchEditorOnFile(ctx, ensureSetupScriptStub(project.id), cwd, (message) =>
+    toast.error(`editor: ${message}`)
+  )
+}
+
+/**
+ * Promote the setup tab to a normal focusable tab. A failing setup means reading
+ * a stack trace, which a bar 30 columns wide cannot do.
+ */
+export function handlePromoteSetupTabEffect(ctx: SideEffectContext): void {
+  const target = resolveTarget(ctx)
+  if (!target) return
+  const tab = findSetupTab(ctx.getState().tabs, target.workspace.id)
+  if (!tab) return
+  ctx.dispatch({ hidden: false, tabId: tab.id, type: 'update-tab-metadata' })
+  ctx.dispatch({ tabId: tab.id, type: 'set-active-tab' })
+}
+
+export function buildSetupAgentPrompt(scriptPath: string): string {
+  return `Write the setup script for this project.
+
+aimux creates each workspace as a fresh \`git worktree\`. That checkout contains only files tracked by git — no .env, no node_modules, no .venv, no build cache, no local database. The setup script's job is to take that bare checkout to a state where the project builds, tests, and runs.
+
+Inspect this repository and work out what that takes: package manifests and their lockfiles, the package manager actually in use, .env.example or equivalent templates, database migrations, code generation steps, native builds, and whatever the README or CONTRIBUTING tells a new contributor to do.
+
+A stub already exists at exactly this absolute path. Read it, then replace its contents:
+
+    ${scriptPath}
+
+It lives outside the repository on purpose, so every workspace of this project shares one script. Do not move it into the repo.
+
+Requirements:
+- \`#!/usr/bin/env bash\` and \`set -euo pipefail\`.
+- Runs with the working directory set to the workspace root. Use relative paths; never hardcode a worktree path, they differ per workspace.
+- Idempotent: safe to run twice in a row.
+- Non-interactive: no prompts, no sudo, no password reads, no browser logins. If a step needs a human, print a clear instruction and keep going.
+- Never write a secret into the script. Copy .env.example to .env and print which values the user still has to fill in.
+- Exit non-zero if a required step fails; aimux surfaces the exit code.
+- Echo a short line before each step so the output is readable in a narrow pane.
+
+When you are done, print the script's path and a one-line summary of what it does. Do not run it.`
+}
+
+export function handleAskAgentForSetupScriptEffect(ctx: SideEffectContext): void {
+  const target = resolveTarget(ctx)
+  if (!target) {
+    toast.error('Open a project first')
+    return
+  }
+  // Create the stub first: the agent then edits a file it can read, rather than
+  // creating one at an absolute path outside its working directory.
+  const path = ensureSetupScriptStub(target.project.id)
+  ctx.dispatch({ pendingPrompt: buildSetupAgentPrompt(path), type: 'open-new-tab-modal' })
+}

package/src/app-runtime/side-effect-context.ts

@@ -0,0 +1,33 @@
+import type { CliRenderer } from '@opentui/core'
+
+import type { SessionBackend } from '../session-backend/types'
+import type { AppAction } from '../state/actions'
+import type { AppState, TabSession } from '../state/types'
+import type { ThemeId } from '../ui/themes'
+
+/**
+ * Everything a side effect is allowed to reach: the store, the pty backend, the
+ * renderer, and the few timers the tab lifecycle owns.
+ *
+ * Lives apart from `side-effects.ts` so the per-domain effect modules can take
+ * it without importing the dispatcher that calls them.
+ */
+export interface SideEffectContext {
+  /**
+   * The render snapshot. Fine for anything read and used in the same turn;
+   * anything that awaits — git, a spawn, a model call — must read `getState()`
+   * instead, because by then this is stale.
+   */
+  state: AppState
+  dispatch: (action: AppAction) => void
+  backend: SessionBackend
+  renderer: CliRenderer
+  themeId: ThemeId
+  setThemeId: (id: ThemeId) => void
+  activeTab: TabSession | undefined
+  clearIdleTimer: (tabId: string) => void
+  clearStartupGrace: (tabId: string) => void
+  startStartupGrace: (tabId: string, timeoutMs: number) => void
+  getState: () => AppState
+  getCurrentProjectProjectPath: () => string | undefined
+}