peachsim 0.1.527

package/src/agent-sessions.ts

@@ -0,0 +1,580 @@
+// session lifecycle shared between the CLI (`sootsim agent ...`) and electron
+// main (IPC handlers). both contexts spawn the same `sootsim agent-wrapper`
+// subcommand, mutate the same AttachedProjects store, and subscribe to the
+// same events.out FIFO.
+//
+// this file is the canonical implementation; thin wrappers in the CLI and
+// electron layers call these functions for their UX needs.
+
+import { spawn, spawnSync } from 'node:child_process'
+import { randomUUID } from 'node:crypto'
+import fs, { constants as fsConstants } from 'node:fs'
+import path from 'node:path'
+import readline from 'node:readline'
+import { rnxSelfInvocation, type RnxSelfInvocation } from '../cli/self-invocation.ts'
+import { IS_STANDALONE } from '../cli/standalone.ts'
+import { parseAgentEventLine, type AgentEvent } from './agent-events.ts'
+import { encodeAgentPromptEnvelope, type AgentPromptEnvelope } from './agent-prompt.ts'
+import {
+  findProjectById,
+  findSessionById,
+  getUserDataDir,
+  listSessions,
+  updateSessionStatus,
+  upsertSession,
+  type AgentSession,
+} from './attached-projects.ts'
+import { rnxPublicBrand } from './public-brand.ts'
+
+export type Provider = 'codex' | 'claude'
+
+// --- fs layout ---
+
+export function sessionDir(sessionId: string): string {
+  return path.join(getUserDataDir(), 'sessions', sessionId)
+}
+export function promptFifoPath(sessionId: string): string {
+  return path.join(sessionDir(sessionId), 'prompt.in')
+}
+export function eventsFifoPath(sessionId: string): string {
+  return path.join(sessionDir(sessionId), 'events.out')
+}
+export function transcriptPath(sessionId: string): string {
+  return path.join(getUserDataDir(), 'transcripts', `${sessionId}.log`)
+}
+
+// --- pid helpers ---
+
+/** returns true iff a process with this pid is alive AND owned by us. pid
+ *  recycling means kill(0) can return true for an unrelated process that
+ *  happened to take the same number — we also require the sentinel file
+ *  written by the wrapper at startup to still exist. */
+export function pidIsAlive(pid: number | undefined, sessionId?: string): boolean {
+  if (!pid) return false
+  try {
+    process.kill(pid, 0)
+  } catch {
+    return false
+  }
+  if (sessionId) {
+    // sentinel: the events.out fifo's session dir. if the session was ended
+    // via cmdEnd, the dir was removed; kill(0) returning true on that pid
+    // would be a recycled pid from an unrelated process.
+    if (!fs.existsSync(sessionDir(sessionId))) return false
+  }
+  return true
+}
+
+// --- invocation resolution ---
+
+/** locate the rnx CLI so this process can run a subcommand of it. callers
+ *  range from the CLI itself to electron main and the vite-plugin daemon.
+ *  priority:
+ *    1. RNX_BIN env var (explicit override)
+ *    2. this process already IS the CLI — `rnxSelfInvocation` owns that answer
+ *    3. electron prod: bundled binary under process.resourcesPath/bin/
+ *    4. workspace build artifacts (dist-bin/<binary> or dist-cli/bin.js)
+ *       — shared between electron dev, the vite-plugin-hosted daemon, and
+ *       any other node process that isn't launched with the CLI entry
+ *       script directly (e.g. argv[1] = .../node_modules/.bin/vite).
+ *    5. CLI dev (argv[1] points at the entry script): re-use argv[0] + argv[1]
+ */
+export function resolveSootsimInvocation(): RnxSelfInvocation {
+  if (process.env.RNX_BIN) {
+    return { executable: process.env.RNX_BIN, prefixArgs: [] }
+  }
+  // the compiled standalone binary cannot be found through argv: bun reports
+  // argv[0] as the literal string "bun" and argv[1] as a path inside its
+  // virtual filesystem, so both fall through to spawning a `bun` that a
+  // shell-installed user does not have.
+  if (IS_STANDALONE) return rnxSelfInvocation()
+  // electron prod: packaged binary lives under Resources/bin/.
+  if (process.versions.electron) {
+    const resourcesPath = (process as NodeJS.Process & { resourcesPath?: string })
+      .resourcesPath
+    if (resourcesPath) {
+      const candidates = [
+        path.join(resourcesPath, 'bin', 'sootsim'),
+        path.join(resourcesPath, 'bin', `sootsim-${process.platform}-${process.arch}`),
+      ]
+      for (const c of candidates) {
+        if (fs.existsSync(c)) return { executable: c, prefixArgs: [] }
+      }
+    }
+  }
+
+  // workspace build artifacts — tried for every non-CLI-entry node context
+  // (electron dev, vite-plugin-hosted daemon, random script) before falling
+  // back to argv. prefers the compiled bun binary because `bun dev` runs
+  // `watch:cli:binary`; the same dev graph runs `watch:cli` to keep the node
+  // fallback and browser-facing dist-lib exports fresh. still warn when a
+  // caller starts outside that graph with stale artifacts.
+  const workspace = tryWorkspaceSootsim()
+  if (workspace) return workspace
+
+  // argv fallback. only trust it when argv[1] looks like a real entry
+  // script — `.js`/`.ts`/`.mjs` etc. launching vite gives us argv[1] =
+  // `…/node_modules/.bin/vite` (no extension), which would make us try
+  // to run agent-wrapper under the vite shim and silently fail.
+  const argv1 = process.argv[1]
+  if (argv1 && /\.(ts|tsx|mjs|cjs|js)$/.test(argv1)) {
+    return { executable: process.argv[0], prefixArgs: [argv1] }
+  }
+  // anything else — a bin shim such as `…/node_modules/.bin/vite`, or no
+  // argv[1] at all — names no rnx entry script, so say so instead of
+  // spawning the host runtime with no arguments.
+  throw new Error(
+    'rnx CLI not found. set RNX_BIN to the path of the rnx binary, ' +
+      'or build the workspace CLI via `bun run --cwd packages/sootsim build:cli`.',
+  )
+}
+
+function tryWorkspaceSootsim(): RnxSelfInvocation | null {
+  try {
+    const sootsimDir = resolveSootsimPackageDir()
+    if (!sootsimDir) return null
+    const binaryName = `rnx-${
+      process.platform === 'win32' ? 'windows' : process.platform
+    }-${process.arch}${process.platform === 'win32' ? '.exe' : ''}`
+    const distBinary = path.join(sootsimDir, 'dist-bin', binaryName)
+    if (fs.existsSync(distBinary)) return { executable: distBinary, prefixArgs: [] }
+    const distBin = path.join(sootsimDir, 'dist-cli', 'bin.js')
+    if (fs.existsSync(distBin)) {
+      try {
+        const src = path.join(sootsimDir, 'cli', 'commands', 'agent-wrapper.ts')
+        if (fs.existsSync(src)) {
+          const srcMtime = fs.statSync(src).mtimeMs
+          const buildMtime = fs.statSync(distBin).mtimeMs
+          if (buildMtime < srcMtime) {
+            console.warn(
+              `[rnx] dist-cli/bin.js is older than agent-wrapper.ts — ` +
+                `rebuild with \`bun run --cwd packages/sootsim build:cli\`.`,
+            )
+          }
+        }
+      } catch {}
+      return { executable: process.execPath, prefixArgs: [distBin] }
+    }
+    return null
+  } catch {
+    return null
+  }
+}
+
+/** locate the workspace sootsim package directory. tries `require.resolve`
+ *  first (works in most contexts), then walks up from this module file
+ *  looking for `packages/sootsim/package.json` (works when sootsim is
+ *  loaded via vite's native TS resolution, where require.resolve doesn't
+ *  know about the workspace). */
+function resolveSootsimPackageDir(): string | null {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const resolved = require.resolve(`${rnxPublicBrand.packageName}/package.json`)
+    return path.dirname(resolved)
+  } catch {}
+  // walk up from this file: .../packages/sootsim/src/agent-sessions.ts
+  // → .../packages/sootsim/. the module path is whatever the runtime
+  // gave us; when bundled by esbuild this will be the bundle path, not
+  // the source path, which is why we try require.resolve first.
+  const here = fileFromImportMeta()
+  if (!here) return null
+  let cur = path.dirname(here)
+  for (let i = 0; i < 8; i++) {
+    const pkg = path.join(cur, 'package.json')
+    try {
+      if (fs.existsSync(pkg)) {
+        const parsed = JSON.parse(fs.readFileSync(pkg, 'utf8')) as { name?: string }
+        if (parsed.name === rnxPublicBrand.packageName) return cur
+      }
+    } catch {}
+    const parent = path.dirname(cur)
+    if (parent === cur) break
+    cur = parent
+  }
+  return null
+}
+
+function fileFromImportMeta(): string | null {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const url = (import.meta as unknown as { url?: string }).url
+    if (!url || !url.startsWith('file://')) return null
+    return decodeURIComponent(url.slice('file://'.length))
+  } catch {
+    return null
+  }
+}
+
+// --- lockfile for start races ---
+
+async function withStartLock<T>(
+  projectId: string,
+  provider: Provider,
+  fn: () => Promise<T>,
+): Promise<T> {
+  const lockDir = path.join(getUserDataDir(), 'locks')
+  fs.mkdirSync(lockDir, { recursive: true })
+  try {
+    fs.chmodSync(lockDir, 0o700)
+  } catch {}
+  const lockPath = path.join(lockDir, `start-${projectId}-${provider}.lock`)
+  const deadline = Date.now() + 4000
+  let fd: number | null = null
+  while (fd === null) {
+    try {
+      fd = fs.openSync(
+        lockPath,
+        fsConstants.O_WRONLY | fsConstants.O_CREAT | fsConstants.O_EXCL,
+        0o600,
+      )
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code !== 'EEXIST') throw err
+      // staleness check: if the pid in the lockfile is dead, steal it
+      try {
+        const stale = Number(fs.readFileSync(lockPath, 'utf8').trim())
+        if (stale && !isProcessAlive(stale)) {
+          fs.unlinkSync(lockPath)
+          continue
+        }
+      } catch {}
+      if (Date.now() > deadline) {
+        throw new Error(
+          `another start is in progress for project=${projectId} provider=${provider} ` +
+            `(lock: ${lockPath})`,
+        )
+      }
+      await new Promise((r) => setTimeout(r, 50))
+    }
+  }
+  try {
+    fs.writeFileSync(fd, String(process.pid))
+    return await fn()
+  } finally {
+    try {
+      fs.closeSync(fd)
+    } catch {}
+    try {
+      fs.unlinkSync(lockPath)
+    } catch {}
+  }
+}
+
+function isProcessAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch {
+    return false
+  }
+}
+
+// --- FIFO helpers ---
+
+export function mkfifoSync(p: string): void {
+  const parent = path.dirname(p)
+  fs.mkdirSync(parent, { recursive: true })
+  try {
+    fs.chmodSync(parent, 0o700)
+  } catch {}
+  if (fs.existsSync(p)) {
+    try {
+      const stat = fs.statSync(p)
+      if (stat.isFIFO()) {
+        try {
+          fs.chmodSync(p, 0o600)
+        } catch {}
+        return
+      }
+      fs.unlinkSync(p)
+    } catch {
+      fs.unlinkSync(p)
+    }
+  }
+  const result = spawnSync('mkfifo', ['-m', '600', p])
+  if (result.status !== 0) {
+    throw new Error(
+      `mkfifo(${p}) failed: ${result.stderr?.toString().trim() || 'unknown error'}`,
+    )
+  }
+}
+
+// --- session lifecycle ---
+
+export interface StartSessionOpts {
+  projectId: string
+  provider?: Provider
+  codexBin?: string
+  claudeBin?: string
+  freshThread?: boolean
+  readyTimeoutMs?: number
+}
+
+export interface StartSessionResult {
+  session: AgentSession
+  /** child pid — the same value stored on session.wrapperPid */
+  wrapperPid: number
+}
+
+export class AgentSessionError extends Error {
+  code: string
+  constructor(code: string, message: string) {
+    super(message)
+    this.code = code
+  }
+}
+
+export async function startSession(opts: StartSessionOpts): Promise<StartSessionResult> {
+  const project = findProjectById(opts.projectId)
+  if (!project) {
+    throw new AgentSessionError('NO_PROJECT', `no project with id=${opts.projectId}`)
+  }
+  const provider: Provider = opts.provider || project.preferredProvider || 'codex'
+
+  return withStartLock(project.id, provider, async () => {
+    // re-check inside the lock. a concurrent start that slipped through the
+    // pre-check can't slip through both the check AND the lock.
+    const existingLive = listSessions(project.id).find(
+      (s) =>
+        s.provider === provider && s.status !== 'ended' && pidIsAlive(s.wrapperPid, s.id),
+    )
+    if (existingLive) {
+      throw new AgentSessionError(
+        'ALREADY_RUNNING',
+        `session already running for project=${project.id} provider=${provider} ` +
+          `(session ${existingLive.id}, pid ${existingLive.wrapperPid}). ` +
+          'end it first with `rnx agent end <sessionId>`.',
+      )
+    }
+
+    // generate the claude session uuid once and persist it so successive
+    // wrapper restarts resume the same `~/.claude/projects/<cwd>/<uuid>.jsonl`
+    // file. codex has its own thread-id persistence via `thread/list`, so we
+    // only need this for claude.
+    const claudeSessionUuid = provider === 'claude' ? randomUUID() : undefined
+
+    const session = upsertSession({
+      projectId: project.id,
+      provider,
+      transport: 'pty',
+      cwd: project.cwd,
+      status: 'idle',
+      claudeSessionUuid,
+    })
+
+    const promptIn = promptFifoPath(session.id)
+    const eventsOut = eventsFifoPath(session.id)
+    const transcript = transcriptPath(session.id)
+    mkfifoSync(promptIn)
+    mkfifoSync(eventsOut)
+    // transcripts dir locked too
+    const transcriptDir = path.dirname(transcript)
+    fs.mkdirSync(transcriptDir, { recursive: true })
+    try {
+      fs.chmodSync(transcriptDir, 0o700)
+    } catch {}
+
+    const { executable, prefixArgs } = resolveSootsimInvocation()
+    const wrapperArgs = [
+      ...prefixArgs,
+      'agent-wrapper',
+      '--session-id',
+      session.id,
+      '--project-id',
+      project.id,
+      '--provider',
+      provider,
+      '--cwd',
+      project.cwd,
+      '--prompt-in',
+      promptIn,
+      '--events-out',
+      eventsOut,
+      '--transcript',
+      transcript,
+    ]
+    if (opts.codexBin) wrapperArgs.push('--codex-bin', opts.codexBin)
+    if (opts.claudeBin) wrapperArgs.push('--claude-bin', opts.claudeBin)
+    if (opts.freshThread) wrapperArgs.push('--fresh-thread')
+    if (claudeSessionUuid) {
+      wrapperArgs.push('--claude-session-uuid', claudeSessionUuid)
+    }
+
+    const child = spawn(executable, wrapperArgs, {
+      detached: true,
+      stdio: 'ignore',
+      env: {
+        ...process.env,
+        SOOTSIM_USER_DATA_DIR: getUserDataDir(),
+      },
+    })
+    child.unref()
+
+    const readyTimeout = opts.readyTimeoutMs ?? 6000
+    const boot = await waitForFirstEvent(
+      eventsOut,
+      (e) => e.type === 'ready' || e.type === 'error',
+      readyTimeout,
+    )
+    if (!boot || boot.type === 'error') {
+      if (child.pid) {
+        try {
+          process.kill(child.pid, 'SIGTERM')
+        } catch {}
+      }
+      try {
+        fs.rmSync(sessionDir(session.id), { recursive: true, force: true })
+      } catch {}
+      updateSessionStatus(session.id, { status: 'ended' })
+      const reason =
+        boot && boot.type === 'error'
+          ? boot.message
+          : `no ready event within ${readyTimeout}ms`
+      throw new AgentSessionError('WRAPPER_FAILED', reason)
+    }
+
+    updateSessionStatus(session.id, {
+      wrapperPid: child.pid,
+      status: 'idle',
+    })
+    const updated = findSessionById(session.id)!
+    return { session: updated, wrapperPid: child.pid! }
+  })
+}
+
+export async function sendPrompt(
+  sessionId: string,
+  prompt: AgentPromptEnvelope,
+): Promise<void> {
+  const session = findSessionById(sessionId)
+  if (!session) {
+    throw new AgentSessionError('NO_SESSION', `no session with id=${sessionId}`)
+  }
+  if (!pidIsAlive(session.wrapperPid, sessionId)) {
+    updateSessionStatus(sessionId, { status: 'ended' })
+    throw new AgentSessionError(
+      'NOT_ALIVE',
+      `session wrapper is not alive (pid=${session.wrapperPid}). start a new session.`,
+    )
+  }
+  const fifo = promptFifoPath(sessionId)
+  if (!fs.existsSync(fifo)) {
+    throw new AgentSessionError('NO_FIFO', `prompt FIFO missing: ${fifo}`)
+  }
+  const fd = fs.openSync(fifo, fsConstants.O_WRONLY)
+  try {
+    const wireText = encodeAgentPromptEnvelope(prompt)
+    if (!wireText) {
+      throw new AgentSessionError('EMPTY_PROMPT', 'prompt text is empty')
+    }
+    fs.writeSync(fd, wireText + '\n')
+  } finally {
+    fs.closeSync(fd)
+  }
+  updateSessionStatus(sessionId, {
+    lastPrompt: prompt.displayText ?? prompt.text,
+    status: 'working',
+  })
+}
+
+export async function endSession(sessionId: string): Promise<void> {
+  const session = findSessionById(sessionId)
+  if (!session) {
+    throw new AgentSessionError('NO_SESSION', `no session with id=${sessionId}`)
+  }
+  if (pidIsAlive(session.wrapperPid, sessionId)) {
+    try {
+      process.kill(session.wrapperPid!, 'SIGTERM')
+    } catch {}
+  }
+  // guard rm: only delete paths we fully own, derived from getUserDataDir()
+  const dir = sessionDir(sessionId)
+  const base = getUserDataDir()
+  if (dir.startsWith(base)) {
+    try {
+      fs.rmSync(dir, { recursive: true, force: true })
+    } catch {}
+  }
+  updateSessionStatus(sessionId, { status: 'ended', wrapperPid: undefined })
+}
+
+// --- event subscription ---
+
+/** open events.out and stream events to onEvent. returns an unsubscribe fn.
+ *  this is a single-reader channel — only ONE caller (the bridge daemon's
+ *  AgentHost) should hold a live subscription at a time. every other
+ *  consumer (electron, cli watch, browser shell) routes through the daemon
+ *  via the agent:* ws protocol, where the daemon fans events out to N
+ *  subscribers without re-reading the FIFO. */
+export function subscribeEvents(
+  sessionId: string,
+  onEvent: (event: AgentEvent) => void,
+): () => void {
+  const fifo = eventsFifoPath(sessionId)
+  if (!fs.existsSync(fifo)) {
+    throw new AgentSessionError('NO_FIFO', `events FIFO missing: ${fifo}`)
+  }
+  // O_RDWR keeps the FIFO open even if every writer closes. the empty line in
+  // unsubscribe wakes any blocking read before destroy closes the fd; without
+  // that wake, repeated daemon teardown leaves reads occupying libuv workers
+  // and later sessions stop receiving events.
+  const fd = fs.openSync(fifo, fsConstants.O_RDWR)
+  const stream = fs.createReadStream('', { fd, autoClose: true })
+  const rl = readline.createInterface({ input: stream, crlfDelay: Infinity })
+  rl.on('line', (line) => {
+    const event = parseAgentEventLine(line)
+    if (event) onEvent(event)
+  })
+  let closed = false
+  return () => {
+    if (closed) return
+    closed = true
+    try {
+      fs.writeSync(fd, '\n')
+    } catch {}
+    try {
+      rl.close()
+    } catch {}
+    try {
+      stream.destroy()
+    } catch {}
+  }
+}
+
+// --- wait for a specific event (used by startSession + watch tools) ---
+
+async function waitForFirstEvent(
+  fifo: string,
+  predicate: (e: AgentEvent) => boolean,
+  timeoutMs: number,
+): Promise<AgentEvent | null> {
+  const fd = fs.openSync(fifo, fsConstants.O_RDWR | fsConstants.O_NONBLOCK)
+  const buf = Buffer.alloc(8192)
+  let leftover = ''
+  const deadline = Date.now() + timeoutMs
+  try {
+    while (Date.now() < deadline) {
+      let n = 0
+      try {
+        n = fs.readSync(fd, buf, 0, buf.length, null)
+      } catch (err) {
+        if ((err as NodeJS.ErrnoException).code !== 'EAGAIN') throw err
+        n = 0
+      }
+      if (n > 0) {
+        leftover += buf.subarray(0, n).toString('utf8')
+        let idx: number
+        while ((idx = leftover.indexOf('\n')) >= 0) {
+          const line = leftover.slice(0, idx)
+          leftover = leftover.slice(idx + 1)
+          const event = parseAgentEventLine(line)
+          if (event && predicate(event)) return event
+        }
+      } else {
+        await new Promise((r) => setTimeout(r, 30))
+      }
+    }
+    return null
+  } finally {
+    fs.closeSync(fd)
+  }
+}

package/src/app-url.ts

@@ -0,0 +1,39 @@
+import type { InspectBridge } from '../cli/commands/inspect/core'
+
+const APP_URL_SCHEME_RE = /^[A-Za-z][A-Za-z0-9+.-]*:/
+
+export function normalizeAppUrlTarget(target: string): string {
+  const trimmed = target.trim()
+  if (!trimmed) {
+    throw new Error('expected <url-or-route>')
+  }
+  if (APP_URL_SCHEME_RE.test(trimmed) || trimmed.startsWith('/')) {
+    return trimmed
+  }
+  return `/${trimmed}`
+}
+
+export function isAppDeepLinkTarget(target: string): boolean {
+  const trimmed = target.trim()
+  if (!trimmed) return false
+  if (trimmed.startsWith('/')) return true
+  if (!APP_URL_SCHEME_RE.test(trimmed)) return false
+  return !/^https?:\/\//i.test(trimmed)
+}
+
+export async function openAppUrl(bridge: InspectBridge, target: string): Promise<string> {
+  const normalized = normalizeAppUrlTarget(target)
+  const result: unknown = await bridge.send({
+    type: 'openUrl',
+    url: normalized,
+  })
+  if (
+    result !== null &&
+    typeof result === 'object' &&
+    Reflect.get(result, 'ok') === false
+  ) {
+    const error = Reflect.get(result, 'error')
+    throw new Error(typeof error === 'string' ? error : 'deep-link dispatch failed')
+  }
+  return normalized
+}