sootsim 0.1.83 → 0.1.84

package/src/attached-projects.ts

@@ -0,0 +1,536 @@
+// durable data model for attached projects, preview attachments, and agent
+// sessions. pure main-process state — no UI, no pty, no agent lifecycle.
+//
+// persistence: a single JSON file at userData/attached-projects.json holding
+// all three collections. RMW goes through mutateStore() which re-reads from
+// disk, applies the mutation, and writes via a tmp file + rename for crash
+// safety. main.ts is single-threaded so there is no lock — "atomic" means
+// no await between load and save.
+
+import { randomBytes, createHash } from 'node:crypto'
+import fs from 'node:fs'
+import path from 'node:path'
+import { electronUserDataDir } from './home-paths'
+
+// plan → attached-projects-and-agents.md §data model
+export interface AttachedProject {
+  id: string
+  name: string
+  cwd: string
+  repoRoot?: string
+  sourceRoots: string[]
+  framework: 'expo' | 'one' | 'rock' | 'unknown'
+  bundleId?: string
+  knownBundleUrls: string[]
+  preferredProvider: 'codex' | 'claude'
+  preferredTransport: 'tmux' | 'pty'
+  editorOpenCommand?: string
+  moshiWebhookToken?: string
+  pinnedSourceResolutions: Record<string, string>
+  isolateDiscovery?: boolean
+  git?: { remote?: string; branch?: string }
+  telemetry: {
+    lastOpened: number
+    runsCompleted: number
+    /** rolling log of (timestamp, cost in USD) per completed turn. trimmed to
+     *  the last 14 days on write so the file doesn't grow unboundedly. a
+     *  7-day window is the reporting default (see `costThisWeek`). */
+    costHistory?: Array<{ ts: number; usd: number }>
+  }
+  createdAt: number
+  updatedAt: number
+}
+
+export interface PreviewAttachment {
+  id: string
+  projectId: string | null
+  bundleUrl: string
+  simId: string
+  deviceModel: string
+  status: 'connecting' | 'live' | 'stale'
+  lastSeenAt: number
+}
+
+export interface AgentSession {
+  id: string
+  projectId: string
+  provider: 'codex' | 'claude'
+  transport: 'tmux' | 'pty'
+  cwd: string
+  /** stable uuid passed to `claude --session-id`. persisted so the file at
+   *  `~/.claude/projects/<encoded-cwd>/<uuid>.jsonl` is reused across
+   *  wrapper restarts, preserving conversational memory. generated once at
+   *  session creation for provider=claude; unused for codex. */
+  claudeSessionUuid?: string
+  tmuxSessionName?: string
+  wrapperPid?: number
+  status: 'idle' | 'working' | 'needs-attention' | 'ended'
+  needsAttention: boolean
+  lastPrompt?: string
+  lastSummary?: string
+  lastTurnFiles?: string[]
+  currentlyEditing?: string
+  lastSeenAt: number
+  createdAt: number
+}
+
+interface StoreShape {
+  version: 1
+  attachedProjects: AttachedProject[]
+  previewAttachments: PreviewAttachment[]
+  agentSessions: AgentSession[]
+}
+
+const EMPTY_STORE: StoreShape = {
+  version: 1,
+  attachedProjects: [],
+  previewAttachments: [],
+  agentSessions: [],
+}
+
+let overrideDir: string | null = null
+
+/** override the user-data directory. set by tests (to a tmp dir) and by the
+ *  standalone CLI when it wants to read/write the same state electron uses.
+ *  pass null to restore default resolution. */
+export function setUserDataDir(dir: string | null): void {
+  overrideDir = dir
+}
+
+/** back-compat alias retained for existing test imports. */
+export const __setUserDataDirForTests = setUserDataDir
+
+/** resolve the user-data directory where attached-projects.json lives.
+ *  precedence:
+ *    1. explicit override from setUserDataDir() (tests, CLI bootstrap)
+ *    2. SOOTSIM_USER_DATA_DIR env var (electron → wrapper handoff)
+ *    3. electronUserDataDir() — the canonical sootsim home, used by both
+ *       electron (`app.setPath('userData', …)`) and the standalone CLI.
+ */
+function userDataDir(): string {
+  if (overrideDir) return overrideDir
+  const fromEnv = process.env.SOOTSIM_USER_DATA_DIR
+  if (fromEnv) return fromEnv
+  return electronUserDataDir()
+}
+
+/** exposed for CLI status printing so `sootsim agent projects` can show the
+ *  user which file it's reading from. */
+export function getUserDataDir(): string {
+  return userDataDir()
+}
+
+function storeFile(): string {
+  return path.join(userDataDir(), 'attached-projects.json')
+}
+
+function cloneEmpty(): StoreShape {
+  return {
+    version: 1,
+    attachedProjects: [],
+    previewAttachments: [],
+    agentSessions: [],
+  }
+}
+
+export function loadStore(): StoreShape {
+  const file = storeFile()
+  let raw: string
+  try {
+    raw = fs.readFileSync(file, 'utf8')
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code === 'ENOENT') return cloneEmpty()
+    throw err
+  }
+  try {
+    const parsed = JSON.parse(raw) as Partial<StoreShape>
+    if (!parsed || typeof parsed !== 'object') throw new Error('not an object')
+    return {
+      version: 1,
+      attachedProjects: Array.isArray(parsed.attachedProjects)
+        ? parsed.attachedProjects
+        : [],
+      previewAttachments: Array.isArray(parsed.previewAttachments)
+        ? parsed.previewAttachments
+        : [],
+      agentSessions: Array.isArray(parsed.agentSessions) ? parsed.agentSessions : [],
+    }
+  } catch (err) {
+    // quarantine the corrupt file instead of silently returning empty — that
+    // path turns a partial-write into permanent data loss.
+    const quarantine = `${file}.corrupt-${Date.now()}`
+    try {
+      fs.renameSync(file, quarantine)
+      console.warn(
+        `[sootsim] attached-projects.json was unparseable; quarantined to ${quarantine}. ` +
+          `original error: ${(err as Error).message}`,
+      )
+    } catch {}
+    return cloneEmpty()
+  }
+}
+
+function writeStore(store: StoreShape): void {
+  const file = storeFile()
+  fs.mkdirSync(path.dirname(file), { recursive: true })
+  const tmp = `${file}.tmp-${process.pid}-${Date.now()}`
+  // explicit open + fsync so a crash between write and rename leaves the old
+  // file intact, not a zero-length scrap. without fsync, renameSync's
+  // atomicity only guarantees the directory entry swap — the data could still
+  // be pending in the page cache when the power drops.
+  const fd = fs.openSync(tmp, 'w', 0o600)
+  try {
+    fs.writeFileSync(fd, JSON.stringify(store, null, 2))
+    fs.fsyncSync(fd)
+  } finally {
+    fs.closeSync(fd)
+  }
+  fs.renameSync(tmp, file)
+}
+
+export function mutateStore(fn: (store: StoreShape) => void): StoreShape {
+  const store = loadStore()
+  fn(store)
+  writeStore(store)
+  return store
+}
+
+// --- ID helpers ---
+
+export function projectIdForCwd(cwd: string): string {
+  return createHash('sha256').update(path.resolve(cwd)).digest('hex').slice(0, 16)
+}
+
+function newSessionId(): string {
+  return `s_${randomBytes(10).toString('hex')}`
+}
+
+function newPreviewId(): string {
+  return `pa_${randomBytes(10).toString('hex')}`
+}
+
+// --- project CRUD ---
+
+/** upsert by canonicalized cwd — cwd is the unique index. `input.id` is
+ *  ignored; the id is always derived from cwd so re-attaches merge cleanly. */
+export function upsertProject(
+  input: Partial<AttachedProject> & { cwd: string },
+): AttachedProject {
+  const cwd = path.resolve(input.cwd)
+  const id = projectIdForCwd(cwd)
+  let result!: AttachedProject
+  mutateStore((store) => {
+    const existing = store.attachedProjects.find((p) => p.id === id)
+    if (existing) {
+      const merged: AttachedProject = {
+        ...existing,
+        ...input,
+        id,
+        cwd,
+        sourceRoots: input.sourceRoots ?? existing.sourceRoots,
+        knownBundleUrls: input.knownBundleUrls ?? existing.knownBundleUrls,
+        pinnedSourceResolutions:
+          input.pinnedSourceResolutions ?? existing.pinnedSourceResolutions,
+        telemetry: input.telemetry ?? existing.telemetry,
+        updatedAt: Date.now(),
+        createdAt: existing.createdAt,
+      }
+      const idx = store.attachedProjects.indexOf(existing)
+      store.attachedProjects[idx] = merged
+      result = merged
+      return
+    }
+    const now = Date.now()
+    const created: AttachedProject = {
+      id,
+      name: input.name ?? path.basename(cwd),
+      cwd,
+      repoRoot: input.repoRoot,
+      sourceRoots: input.sourceRoots ?? [cwd],
+      framework: input.framework ?? 'unknown',
+      bundleId: input.bundleId,
+      knownBundleUrls: input.knownBundleUrls ?? [],
+      preferredProvider: input.preferredProvider ?? 'codex',
+      preferredTransport: input.preferredTransport ?? 'tmux',
+      editorOpenCommand: input.editorOpenCommand,
+      moshiWebhookToken: input.moshiWebhookToken,
+      pinnedSourceResolutions: input.pinnedSourceResolutions ?? {},
+      isolateDiscovery: input.isolateDiscovery,
+      git: input.git,
+      telemetry: input.telemetry ?? { lastOpened: 0, runsCompleted: 0 },
+      createdAt: now,
+      updatedAt: now,
+    }
+    store.attachedProjects.push(created)
+    result = created
+  })
+  return result
+}
+
+export function findProjectById(id: string): AttachedProject | null {
+  return loadStore().attachedProjects.find((p) => p.id === id) ?? null
+}
+
+export function findProjectByCwd(cwd: string): AttachedProject | null {
+  const resolved = path.resolve(cwd)
+  return loadStore().attachedProjects.find((p) => p.cwd === resolved) ?? null
+}
+
+export function findProjectByBundleUrl(bundleUrl: string): AttachedProject | null {
+  // first exact match, then prefix match. the prefix path handles metro query
+  // param drift (?platform=ios&dev=true) so the same base URL binds.
+  const store = loadStore()
+  const exact = store.attachedProjects.find((p) => p.knownBundleUrls.includes(bundleUrl))
+  if (exact) return exact
+  const base = stripQuery(bundleUrl)
+  return (
+    store.attachedProjects.find((p) =>
+      p.knownBundleUrls.some((u) => stripQuery(u) === base),
+    ) ?? null
+  )
+}
+
+function stripQuery(url: string): string {
+  const q = url.indexOf('?')
+  return q >= 0 ? url.slice(0, q) : url
+}
+
+export function listProjects(): AttachedProject[] {
+  return loadStore().attachedProjects
+}
+
+const COST_HISTORY_MAX_AGE_MS = 14 * 24 * 60 * 60 * 1000
+
+/** record a completed turn's cost into the project's rolling history. trims
+ *  entries older than 14 days on write. `usd` is optional — turns without cost
+ *  metadata (e.g. claude early result with cost omitted) still bump the
+ *  runsCompleted counter but don't add a history entry. */
+export function recordTurnTelemetry(
+  projectId: string,
+  input: { usd?: number; ts?: number } = {},
+): void {
+  mutateStore((store) => {
+    const project = store.attachedProjects.find((p) => p.id === projectId)
+    if (!project) return
+    const ts = input.ts ?? Date.now()
+    project.telemetry.runsCompleted = (project.telemetry.runsCompleted ?? 0) + 1
+    if (typeof input.usd === 'number' && Number.isFinite(input.usd) && input.usd >= 0) {
+      const history = project.telemetry.costHistory ?? []
+      const cutoff = ts - COST_HISTORY_MAX_AGE_MS
+      const trimmed = history.filter((e) => e.ts >= cutoff)
+      trimmed.push({ ts, usd: input.usd })
+      project.telemetry.costHistory = trimmed
+    }
+    project.updatedAt = ts
+  })
+}
+
+/** rolling 7-day cost for a project, or 0 if none recorded. */
+export function costThisWeek(project: AttachedProject, now: number = Date.now()): number {
+  const cutoff = now - 7 * 24 * 60 * 60 * 1000
+  const history = project.telemetry.costHistory ?? []
+  let total = 0
+  for (const e of history) {
+    if (e.ts >= cutoff) total += e.usd
+  }
+  return total
+}
+
+export function deleteProject(id: string): void {
+  mutateStore((store) => {
+    store.attachedProjects = store.attachedProjects.filter((p) => p.id !== id)
+    // cascade: drop sessions + preview attachments tied to the project
+    store.agentSessions = store.agentSessions.filter((s) => s.projectId !== id)
+    store.previewAttachments = store.previewAttachments.filter(
+      (pa) => pa.projectId !== id,
+    )
+  })
+}
+
+// --- session CRUD ---
+
+export function upsertSession(
+  input: Partial<AgentSession> & { projectId: string; provider: 'codex' | 'claude' },
+): AgentSession {
+  let result!: AgentSession
+  mutateStore((store) => {
+    if (input.id) {
+      const existing = store.agentSessions.find((s) => s.id === input.id)
+      if (existing) {
+        const merged: AgentSession = {
+          ...existing,
+          ...input,
+          lastSeenAt: Date.now(),
+        }
+        const idx = store.agentSessions.indexOf(existing)
+        store.agentSessions[idx] = merged
+        result = merged
+        return
+      }
+    }
+    const project = store.attachedProjects.find((p) => p.id === input.projectId)
+    if (!project) {
+      throw new Error(`upsertSession: no AttachedProject with id=${input.projectId}`)
+    }
+    const now = Date.now()
+    const created: AgentSession = {
+      id: input.id ?? newSessionId(),
+      projectId: input.projectId,
+      provider: input.provider,
+      transport: input.transport ?? project.preferredTransport,
+      cwd: input.cwd ?? project.cwd,
+      claudeSessionUuid: input.claudeSessionUuid,
+      tmuxSessionName: input.tmuxSessionName,
+      wrapperPid: input.wrapperPid,
+      status: input.status ?? 'idle',
+      needsAttention: input.needsAttention ?? false,
+      lastPrompt: input.lastPrompt,
+      lastSummary: input.lastSummary,
+      lastTurnFiles: input.lastTurnFiles,
+      currentlyEditing: input.currentlyEditing,
+      lastSeenAt: now,
+      createdAt: now,
+    }
+    store.agentSessions.push(created)
+    result = created
+  })
+  return result
+}
+
+export function findSessionById(id: string): AgentSession | null {
+  return loadStore().agentSessions.find((s) => s.id === id) ?? null
+}
+
+export function listSessions(projectId?: string): AgentSession[] {
+  const all = loadStore().agentSessions
+  return projectId ? all.filter((s) => s.projectId === projectId) : all
+}
+
+export function updateSessionStatus(id: string, patch: Partial<AgentSession>): void {
+  mutateStore((store) => {
+    const existing = store.agentSessions.find((s) => s.id === id)
+    if (!existing) return
+    const idx = store.agentSessions.indexOf(existing)
+    store.agentSessions[idx] = {
+      ...existing,
+      ...patch,
+      id: existing.id,
+      projectId: existing.projectId,
+      createdAt: existing.createdAt,
+      lastSeenAt: Date.now(),
+    }
+  })
+}
+
+export function deleteSession(id: string): void {
+  mutateStore((store) => {
+    store.agentSessions = store.agentSessions.filter((s) => s.id !== id)
+  })
+}
+
+// --- preview attachment CRUD ---
+
+export function upsertPreviewAttachment(
+  input: Partial<PreviewAttachment> & { bundleUrl: string; simId: string },
+): PreviewAttachment {
+  let result!: PreviewAttachment
+  mutateStore((store) => {
+    const existing = store.previewAttachments.find(
+      (pa) => pa.bundleUrl === input.bundleUrl && pa.simId === input.simId,
+    )
+    if (existing) {
+      const merged: PreviewAttachment = {
+        ...existing,
+        ...input,
+        lastSeenAt: Date.now(),
+      }
+      const idx = store.previewAttachments.indexOf(existing)
+      store.previewAttachments[idx] = merged
+      result = merged
+      return
+    }
+    const created: PreviewAttachment = {
+      id: input.id ?? newPreviewId(),
+      projectId: input.projectId ?? null,
+      bundleUrl: input.bundleUrl,
+      simId: input.simId,
+      deviceModel: input.deviceModel ?? 'unknown',
+      status: input.status ?? 'connecting',
+      lastSeenAt: Date.now(),
+    }
+    store.previewAttachments.push(created)
+    result = created
+  })
+  return result
+}
+
+export function listPreviewAttachments(projectId?: string): PreviewAttachment[] {
+  const all = loadStore().previewAttachments
+  return projectId ? all.filter((pa) => pa.projectId === projectId) : all
+}
+
+export function deletePreviewAttachment(id: string): void {
+  mutateStore((store) => {
+    store.previewAttachments = store.previewAttachments.filter((pa) => pa.id !== id)
+  })
+}
+
+// --- seed from demo registry ---
+
+/** seed the store from packages/sootsim/scripts/demo-app-registry. only runs
+ *  when the store is completely empty (never re-seeds) and only adds apps
+ *  whose `dir` exists on disk (concern 6.4 — demo dirs vary per machine). */
+export async function seedFromDemoAppRegistry(): Promise<void> {
+  const existing = loadStore().attachedProjects
+  if (existing.length > 0) return
+  let APPS: unknown
+  try {
+    const mod = (await import('sootsim/scripts/demo-app-registry')) as {
+      APPS: Array<{
+        name: string
+        label: string
+        dir: string
+        preferredPort: number
+        framework: 'expo' | 'one' | 'rock'
+      }>
+    }
+    APPS = mod.APPS
+  } catch (err) {
+    console.warn(
+      '[sootsim] seedFromDemoAppRegistry: could not load demo registry:',
+      (err as Error).message,
+    )
+    return
+  }
+  if (!Array.isArray(APPS)) return
+  const apps = APPS as Array<{
+    name: string
+    label: string
+    dir: string
+    preferredPort: number
+    framework: 'expo' | 'one' | 'rock'
+  }>
+  mutateStore((store) => {
+    for (const app of apps) {
+      if (!fs.existsSync(app.dir)) continue
+      const cwd = path.resolve(app.dir)
+      const id = projectIdForCwd(cwd)
+      if (store.attachedProjects.some((p) => p.id === id)) continue
+      const now = Date.now()
+      store.attachedProjects.push({
+        id,
+        name: app.label,
+        cwd,
+        sourceRoots: [cwd],
+        framework: app.framework,
+        knownBundleUrls: [`http://localhost:${app.preferredPort}/index.bundle`],
+        preferredProvider: 'codex',
+        preferredTransport: 'tmux',
+        pinnedSourceResolutions: {},
+        telemetry: { lastOpened: 0, runsCompleted: 0 },
+        createdAt: now,
+        updatedAt: now,
+      })
+    }
+  })
+}