@brimveyn/aimux 1.21.0 → 1.22.2

package/src/state/project-data.ts

@@ -0,0 +1,143 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+import { getProfileConfigDir } from '../profile-paths'
+
+const SETUP_HEADER = `#!/usr/bin/env bash
+set -euo pipefail
+
+`
+
+const SETUP_STUB = `#!/usr/bin/env bash
+set -euo pipefail
+
+# aimux setup script.
+#
+# Runs once per newly created workspace, with the working directory set to that
+# workspace's root. A workspace is a fresh \`git worktree\`, so it contains only
+# files tracked by git — no .env, no node_modules, no .venv, no build cache.
+#
+# Keep it idempotent and non-interactive. A non-zero exit is surfaced in the
+# setup widget and recorded on the workspace.
+
+echo "nothing to do yet — edit this script"
+`
+
+// Resolved per call, never module-cached: --profile is applied after module
+// import, so a cached path would point at the wrong profile.
+export function getProjectDataDir(projectId: string): string {
+  return join(getProfileConfigDir(), 'projects', projectId)
+}
+
+export function getSetupScriptPath(projectId: string): string {
+  return join(getProjectDataDir(projectId), 'setup.sh')
+}
+
+export function hasSetupScript(projectId: string): boolean {
+  return existsSync(getSetupScriptPath(projectId))
+}
+
+/** Returns the script path, creating an executable stub if there is none. */
+export function ensureSetupScriptStub(projectId: string): string {
+  const path = getSetupScriptPath(projectId)
+  if (existsSync(path)) return path
+  mkdirSync(getProjectDataDir(projectId), { recursive: true })
+  writeFileSync(path, SETUP_STUB)
+  chmodSync(path, 0o755)
+  return path
+}
+
+const EMPTY_LINES: readonly string[] = []
+
+/**
+ * Keyed by path, not project id: the path depends on the active profile, which is
+ * resolved per call. Holds one small array per project that has a setup script.
+ */
+const setupLinesCache = new Map<string, { mtimeMs: number; lines: string[] }>()
+
+/** A line that does something, as opposed to a shebang, an option or a comment. */
+function isWorkLine(line: string): boolean {
+  const trimmed = line.trim()
+  return (
+    trimmed !== '' &&
+    !trimmed.startsWith('#') &&
+    !/^set\s+-[a-zA-Z]/.test(trimmed) &&
+    !/^set\s+-o\s/.test(trimmed)
+  )
+}
+
+function parseSetupScript(source: string): string[] {
+  return source
+    .split('\n')
+    .filter((line) => isWorkLine(line))
+    .map((line) => line.trim())
+}
+
+/**
+ * The script's actual work, with the boilerplate stripped: the shebang, the
+ * `set -e…` line, comments and blank lines. One line left means the script is a
+ * command, and a single text field can hold all of it; more than one means it is
+ * a script, and a text field would silently truncate it.
+ *
+ * Cached against the file's mtime, because the settings screen builds its Setup
+ * rows from this: the search filter runs it for every project on every keystroke,
+ * and `getModalOptionCount` runs it from inside the reducer. A `statSync` per
+ * project is a syscall; a read-and-parse per project per keystroke is a habit
+ * that gets worse with every project the user adds. An edit made outside aimux
+ * still lands — that is what the mtime is for.
+ *
+ * `readonly` because the array it hands back is the cached one, not a copy: a
+ * caller that sorted or spliced it would be editing every later caller's answer.
+ */
+export function readSetupScriptLines(projectId: string): readonly string[] {
+  const path = getSetupScriptPath(projectId)
+  try {
+    const { mtimeMs } = statSync(path)
+    const cached = setupLinesCache.get(path)
+    if (cached?.mtimeMs === mtimeMs) return cached.lines
+    const lines = parseSetupScript(readFileSync(path, 'utf8'))
+    setupLinesCache.set(path, { lines, mtimeMs })
+    return lines
+  } catch {
+    // Missing or unreadable. Not the same thing, but the caller has nothing
+    // better to show for either, and the editor path still works.
+    setupLinesCache.delete(path)
+    return EMPTY_LINES
+  }
+}
+
+/**
+ * Put this one command in the script, replacing the work line that was there.
+ * Round-trips with `readSetupScriptLines`.
+ *
+ * Everything that is not that line survives: the shebang, the `set -e…`, and any
+ * comments. Rewriting the file from a fixed header was simpler and quietly threw
+ * away whatever the user had written around their one command — a field that
+ * deletes the notes next to what it edits is not an editor.
+ */
+export function writeSetupCommand(projectId: string, command: string): void {
+  mkdirSync(getProjectDataDir(projectId), { recursive: true })
+  const path = getSetupScriptPath(projectId)
+  writeFileSync(path, nextSetupSource(path, command.trim()))
+  chmodSync(path, 0o755)
+  // Not left to the mtime: a write and the read that follows it can land in the
+  // same millisecond, and the cache would hand back what was there before.
+  setupLinesCache.delete(path)
+}
+
+function nextSetupSource(path: string, command: string): string {
+  let existing: string
+  try {
+    existing = readFileSync(path, 'utf8')
+  } catch {
+    // No script yet (or none we can read): the template is all there is to keep.
+    return `${SETUP_HEADER}${command}\n`
+  }
+
+  const lines = existing.split('\n')
+  const first = lines.findIndex((line) => isWorkLine(line))
+  // Nothing to replace — the stub, or comments only. Append rather than drop them.
+  if (first === -1) return `${existing.replace(/\n*$/, '')}\n\n${command}\n`
+  lines[first] = command
+  return lines.join('\n')
+}

package/src/state/{session-persistence.ts → project-persistence.ts}

@@ -1,8 +1,8 @@
-import type { AppState, TabSession, TabStatus, WorkspaceSnapshotV1 } from './types'
+import type { AppState, ProjectSnapshotV1, TabSession, TabStatus } from './types'
 
 import { allLeafIds, createGroupId, type LayoutNode, pruneLayoutTree } from './layout-tree'
 
-export function createEmptyWorkspaceSnapshot(): WorkspaceSnapshotV1 {
+export function createEmptyProjectSnapshot(): ProjectSnapshotV1 {
   return {
     activeTabId: null,
     savedAt: new Date().toISOString(),
@@ -16,13 +16,13 @@ export function createEmptyWorkspaceSnapshot(): WorkspaceSnapshotV1 {
 }
 
 /**
- * The per-worktree last-tab memory is serialized into every snapshot now so the
- * data accrues across sessions, but restoring it at startup stays dormant until
+ * The per-workspace last-tab memory is serialized into every snapshot now so the
+ * data accrues across projects, but restoring it at startup stays dormant until
  * a future (non-breaking) change is ready to consume it. Flipping this to true
- * makes restart restore the last-viewed tab per worktree; until then restart
+ * makes restart restore the last-viewed tab per workspace; until then restart
  * behavior is unchanged and the live in-memory map is never clobbered on switch.
  */
-const RESTORE_LAST_ACTIVE_TAB_BY_WORKTREE: boolean = false
+const RESTORE_LAST_ACTIVE_TAB_BY_WORKSPACE: boolean = false
 
 function getDisconnectedStatus(status: TabStatus): TabStatus {
   if (status === 'running' || status === 'starting') {
@@ -32,75 +32,81 @@ function getDisconnectedStatus(status: TabStatus): TabStatus {
   return status
 }
 
-export function serializeWorkspace(state: AppState): WorkspaceSnapshotV1 {
+export function serializeProject(state: AppState): ProjectSnapshotV1 {
   return {
     activeTabId: state.activeTabId,
-    lastActiveTabByWorktree:
-      Object.keys(state.lastActiveTabByWorktree).length > 0
-        ? state.lastActiveTabByWorktree
+    lastActiveTabByWorkspace:
+      Object.keys(state.lastActiveTabByWorkspace).length > 0
+        ? state.lastActiveTabByWorkspace
         : undefined,
     layoutTree: Object.values(state.layoutTrees)[0] ?? undefined,
     layoutTrees: Object.keys(state.layoutTrees).length > 0 ? state.layoutTrees : undefined,
     savedAt: new Date().toISOString(),
-    // Mirror of the left bar. `isWorkspaceSnapshotV1` requires this key —
-    // dropping it invalidates every entry in the session catalog.
+    // Mirror of the left bar. `isProjectSnapshotV1` requires this key —
+    // dropping it invalidates every entry in the project catalog.
     sidebar: {
       visible: state.bars.left.visible,
       width: state.bars.left.width,
     },
     tabGroupMap: Object.keys(state.tabGroupMap).length > 0 ? state.tabGroupMap : undefined,
-    tabs: state.tabs.map((tab) => ({
-      assistant: tab.assistant,
-      autoRenameStatus: tab.autoRenameStatus,
-      buffer: tab.buffer,
-      command: tab.command,
-      errorMessage: tab.errorMessage,
-      exitCode: tab.exitCode,
-      id: tab.id,
-      status: tab.status === 'disconnected' ? 'running' : tab.status,
-      terminalModes: tab.terminalModes,
-      title: tab.title,
-      viewport: tab.viewport,
-      workerName: tab.workerName,
-      worktreeId: tab.worktreeId,
-    })),
+    // Hidden tabs (the setup runner's PTY) are session-scoped on purpose: the
+    // durable record of a setup run is `WorkspaceRecord.setupRanAt`, and keeping
+    // them out here is what lets `hidden` stay off the ipc/daemon wire.
+    tabs: state.tabs
+      .filter((tab) => tab.hidden !== true)
+      .map((tab) => ({
+        assistant: tab.assistant,
+        autoRenameStatus: tab.autoRenameStatus,
+        buffer: tab.buffer,
+        command: tab.command,
+        errorMessage: tab.errorMessage,
+        exitCode: tab.exitCode,
+        id: tab.id,
+        status: tab.status === 'disconnected' ? 'running' : tab.status,
+        terminalModes: tab.terminalModes,
+        title: tab.title,
+        viewport: tab.viewport,
+        workerName: tab.workerName,
+        workspaceId: tab.workspaceId,
+      })),
     version: 1,
   }
 }
 
 export interface RestoreOptions {
   // Force any running/starting tab to 'disconnected' on restore. True for
-  // cold-start (daemon may not own the sessions yet) and the daemon's own
-  // catalog hydration. False for live in-app workspace switches where an
-  // attach() is guaranteed to follow within a frame and hydrate-workspace
+  // cold-start (daemon may not own the projects yet) and the daemon's own
+  // catalog hydration. False for live in-app project switches where an
+  // attach() is guaranteed to follow within a frame and hydrate-project
   // will overwrite the status with daemon truth — leaving the flag on would
   // briefly flash the "Restored snapshot" hint on every j/k cycle.
   forceDisconnected?: boolean
-  // When provided, drop tabs pinned to a worktree id that the session no
-  // longer owns. Some delete paths (notably the sidebar's "Remove worktree")
-  // historically removed the worktree record without closing its tabs, leaving
+  // When provided, drop tabs pinned to a workspace id that the project no
+  // longer owns. Some delete paths (notably the sidebar's "Remove workspace")
+  // historically removed the workspace record without closing its tabs, leaving
   // orphans bound to a vanished id. Those orphans are invisible (filtered out
-  // by the active-worktree filter) yet keep a worktree id that a *future*
-  // delete can collide with — exactly what closes "another worktree's" tabs.
+  // by the active-workspace filter) yet keep a workspace id that a *future*
+  // delete can collide with — exactly what closes "another workspace's" tabs.
   // Pruning them on restore both repairs corrupted catalogs and prevents the
-  // collision. Tabs with no worktree id (legacy/unbound) are always kept.
-  validWorktreeIds?: ReadonlySet<string>
+  // collision. Tabs with no workspace id (legacy/unbound) are always kept.
+  validWorkspaceIds?: ReadonlySet<string>
 }
 
-// Drop tabs bound to a worktree id the session no longer owns. Unbound tabs
-// (no worktreeId) are kept — they surface under the primary worktree.
+// Drop tabs bound to a workspace id the project no longer owns. Unbound tabs
+// (no workspaceId) are kept — they surface under the primary workspace.
 function pruneOrphanedTabs(
   tabs: TabSession[],
-  validWorktreeIds: ReadonlySet<string> | undefined
+  validWorkspaceIds: ReadonlySet<string> | undefined
 ): TabSession[] {
-  if (!validWorktreeIds) return tabs
+  if (!validWorkspaceIds) return tabs
   return tabs.filter(
-    (tab) => tab.worktreeId == null || tab.worktreeId === '' || validWorktreeIds.has(tab.worktreeId)
+    (tab) =>
+      tab.workspaceId == null || tab.workspaceId === '' || validWorkspaceIds.has(tab.workspaceId)
   )
 }
 
-export function restoreTabsFromWorkspace(
-  snapshot: WorkspaceSnapshotV1 | undefined,
+export function restoreTabsFromProject(
+  snapshot: ProjectSnapshotV1 | undefined,
   options: RestoreOptions = {}
 ): TabSession[] {
   if (!snapshot || snapshot.version !== 1) {
@@ -128,13 +134,13 @@ export function restoreTabsFromWorkspace(
       title: tab.title,
       viewport: tab.viewport,
       workerName: tab.workerName,
-      worktreeId: tab.worktreeId,
+      workspaceId: tab.workspaceId,
     }))
-  return pruneOrphanedTabs(restored, options.validWorktreeIds)
+  return pruneOrphanedTabs(restored, options.validWorkspaceIds)
 }
 
 export function restoreLayoutTrees(
-  snapshot: WorkspaceSnapshotV1 | undefined,
+  snapshot: ProjectSnapshotV1 | undefined,
   tabs: TabSession[]
 ): { layoutTrees: Record<string, LayoutNode>; tabGroupMap: Record<string, string> } {
   const validTabIds = new Set(tabs.map((t) => t.id))
@@ -167,16 +173,16 @@ export function restoreLayoutTrees(
   return { layoutTrees, tabGroupMap }
 }
 
-// When a worktree is removed, its tabs are killed live via disposeWorktreeTabs
-// — but the session's persisted workspaceSnapshot still references them by
-// worktreeId. Without this pruning, a subsequent load-session (session switch
+// When a workspace is removed, its tabs are killed live via disposeWorkspaceTabs
+// — but the project's persisted projectSnapshot still references them by
+// workspaceId. Without this pruning, a subsequent load-project (project switch
 // or restart) resurrects the dead tabs and they reappear in h-l navigation.
-export function pruneSnapshotOfWorktree(
-  snapshot: WorkspaceSnapshotV1 | undefined,
-  worktreeId: string
-): WorkspaceSnapshotV1 | undefined {
+export function pruneSnapshotOfWorkspace(
+  snapshot: ProjectSnapshotV1 | undefined,
+  workspaceId: string
+): ProjectSnapshotV1 | undefined {
   if (!snapshot) return snapshot
-  const keptTabs = snapshot.tabs.filter((tab) => tab.worktreeId !== worktreeId)
+  const keptTabs = snapshot.tabs.filter((tab) => tab.workspaceId !== workspaceId)
   if (keptTabs.length === snapshot.tabs.length) return snapshot
   const validTabIds = new Set(keptTabs.map((tab) => tab.id))
 
@@ -275,29 +281,29 @@ export function normalizeGroupedTabOrder(
   return orderedTabs
 }
 
-export function restoreWorkspaceState(
+export function restoreProjectState(
   state: AppState,
-  workspaceSnapshot: WorkspaceSnapshotV1 | undefined,
+  projectSnapshot: ProjectSnapshotV1 | undefined,
   options: RestoreOptions = {}
 ): Pick<AppState, 'tabs' | 'activeTabId' | 'focusMode' | 'layoutTrees' | 'tabGroupMap'> &
-  Partial<Pick<AppState, 'lastActiveTabByWorktree'>> {
-  const tabs = restoreTabsFromWorkspace(workspaceSnapshot, options)
+  Partial<Pick<AppState, 'lastActiveTabByWorkspace'>> {
+  const tabs = restoreTabsFromProject(projectSnapshot, options)
   const activeTabId =
-    workspaceSnapshot?.activeTabId != null &&
-    workspaceSnapshot?.activeTabId !== '' &&
-    tabs.some((tab) => tab.id === workspaceSnapshot.activeTabId)
-      ? workspaceSnapshot.activeTabId
+    projectSnapshot?.activeTabId != null &&
+    projectSnapshot?.activeTabId !== '' &&
+    tabs.some((tab) => tab.id === projectSnapshot.activeTabId)
+      ? projectSnapshot.activeTabId
       : (tabs[0]?.id ?? null)
 
-  const { layoutTrees, tabGroupMap } = restoreLayoutTrees(workspaceSnapshot, tabs)
+  const { layoutTrees, tabGroupMap } = restoreLayoutTrees(projectSnapshot, tabs)
   const orderedTabs = normalizeGroupedTabOrder(tabs, layoutTrees, tabGroupMap)
 
-  // Dormant until the gate flips: merge the persisted per-worktree memory over
+  // Dormant until the gate flips: merge the persisted per-workspace memory over
   // the live in-memory map. While off, the key is omitted entirely so callers
   // that spread the result never overwrite their existing map on a switch.
   const persistedLastActiveTab =
-    RESTORE_LAST_ACTIVE_TAB_BY_WORKTREE && workspaceSnapshot?.lastActiveTabByWorktree
-      ? { ...state.lastActiveTabByWorktree, ...workspaceSnapshot.lastActiveTabByWorktree }
+    RESTORE_LAST_ACTIVE_TAB_BY_WORKSPACE && projectSnapshot?.lastActiveTabByWorkspace
+      ? { ...state.lastActiveTabByWorkspace, ...projectSnapshot.lastActiveTabByWorkspace }
       : undefined
 
   return {
@@ -306,6 +312,6 @@ export function restoreWorkspaceState(
     layoutTrees,
     tabGroupMap,
     tabs: orderedTabs,
-    ...(persistedLastActiveTab ? { lastActiveTabByWorktree: persistedLastActiveTab } : {}),
+    ...(persistedLastActiveTab ? { lastActiveTabByWorkspace: persistedLastActiveTab } : {}),
   }
 }

package/src/state/project-save.ts

@@ -0,0 +1,46 @@
+import type { AppState, ProjectRecord } from './types'
+
+import { loadConfig, saveConfig } from '../config'
+import { saveProjectCatalog } from './project-catalog'
+import { serializeProject } from './project-persistence'
+
+export function buildProjectsWithCurrentSnapshot(
+  projects: ProjectRecord[],
+  currentProjectId: string | null,
+  state: AppState
+): ProjectRecord[] {
+  return projects.map((project) =>
+    project.id === currentProjectId
+      ? {
+          ...project,
+          projectSnapshot: serializeProject(state),
+          updatedAt: new Date().toISOString(),
+        }
+      : project
+  )
+}
+
+export function saveCurrentProject(state: AppState): void {
+  saveConfig({
+    ...loadConfig(),
+    bars: state.bars,
+    customCommands: state.customCommands,
+    gitPane: {
+      diffModeRatio: state.gitPane.diffModeRatio,
+      fileListMode: state.gitPane.fileListMode,
+      // Was missing, so every autosave dropped it and `t`/`T` in git mode never
+      // survived a restart — this write replaces the whole `gitPane` block.
+      treeCompaction: state.gitPane.treeCompaction,
+    },
+    projectBarVisible: state.projectBar.visible,
+    // Legacy mirror of the left bar: lets an older build (and the project
+    // snapshot schema) still find a sidebar after a downgrade.
+    sidebar: {
+      visible: state.bars.left.visible,
+      width: state.bars.left.width,
+    },
+  })
+  saveProjectCatalog(
+    buildProjectsWithCurrentSnapshot(state.projects, state.currentProjectId, state)
+  )
+}