letmecook 0.0.15 → 0.0.17

package/src/flows/resume-session.ts

@@ -1,17 +1,19 @@
 import type { CliRenderer } from "@opentui/core";
 import type { Session } from "../types";
 import { updateSessionSettings } from "../sessions";
-import { refreshLatestRepos } from "../git";
+import { refreshReferenceRepos } from "../git";
 import { updateSkills } from "../skills";
 import { handleSmartExit } from "../ui/exit";
 import { showSessionSettings } from "../ui/session-settings";
 import { showDeleteConfirm } from "../ui/confirm-delete";
+import { showSessionStartWarning } from "../ui/background-warning";
 import { showProgress, updateProgress, hideProgress } from "../ui/progress";
 import { showReclonePrompt } from "../ui/reclone-prompt";
 import { deleteSession } from "../sessions";
-import { recloneRepo } from "../git";
 import { writeAgentsMd } from "../agents-md";
 import { createRenderer, destroyRenderer } from "../ui/renderer";
+import { getProcessesForSession } from "../process-registry";
+import { repairReferenceLink } from "../reference-repo";
 
 export interface ResumeSessionParams {
   session: Session;
@@ -30,13 +32,27 @@ export async function resumeSession(
   let currentSession = session;
   let shouldRefresh = initialRefresh;
 
+  // Check for background processes running for this session
+  if (mode === "tui") {
+    const runningProcesses = await getProcessesForSession(session.name);
+    if (runningProcesses.length > 0) {
+      renderer = await createRenderer();
+      const choice = await showSessionStartWarning(renderer, runningProcesses);
+      destroyRenderer();
+      if (choice === "cancel") {
+        return "home";
+      }
+      // "continue" proceeds with warning acknowledged
+    }
+  }
+
   while (true) {
     if (mode === "tui" && shouldRefresh) {
       renderer = await createRenderer();
-      await refreshLatestBeforeResume(renderer, currentSession);
+      await refreshReferenceBeforeResume(renderer, currentSession);
       destroyRenderer();
     } else if (shouldRefresh) {
-      await refreshLatestBeforeResumeSimple(currentSession);
+      await refreshReferenceBeforeResumeSimple(currentSession);
     }
 
     await runOpencodeMode(mode, currentSession.path);
@@ -101,20 +117,23 @@ export async function resumeSession(
   }
 }
 
-async function refreshLatestBeforeResume(renderer: CliRenderer, session: Session): Promise<void> {
-  const latestRepos = session.repos.filter((repo) => repo.latest);
-  if (latestRepos.length === 0) return;
+async function refreshReferenceBeforeResume(
+  renderer: CliRenderer,
+  session: Session,
+): Promise<void> {
+  const referenceRepos = session.repos.filter((repo) => repo.reference);
+  if (referenceRepos.length === 0) return;
 
-  const refreshProgressState = showProgress(renderer, latestRepos, {
+  const refreshProgressState = showProgress(renderer, referenceRepos, {
     title: "Refreshing repositories",
-    label: "Refreshing latest repositories:",
+    label: "Refreshing reference repositories:",
     initialPhase: "refreshing",
   });
   refreshProgressState.sessionName = session.name;
   updateProgress(renderer, refreshProgressState);
 
-  const refreshResults = await refreshLatestRepos(
-    latestRepos,
+  const refreshResults = await refreshReferenceRepos(
+    referenceRepos,
     session.path,
     (repoIndex, status, outputLines) => {
       const repoState = refreshProgressState.repos[repoIndex];
@@ -134,59 +153,60 @@ async function refreshLatestBeforeResume(renderer: CliRenderer, session: Session
   await new Promise((resolve) => setTimeout(resolve, 700));
   hideProgress(renderer);
 
-  const recloneTargets = refreshResults.filter(
-    (result) => result.status === "error" && result.repo.readOnly,
+  // For reference repos that failed, offer to repair the link
+  const repairTargets = refreshResults.filter(
+    (result) => result.status === "error" && result.repo.reference,
   );
 
-  for (const result of recloneTargets) {
+  for (const result of repairTargets) {
     const choice = await showReclonePrompt(renderer, result.repo);
 
     if (choice === "reclone") {
-      const recloneProgressState = showProgress(renderer, [result.repo], {
-        title: "Recloning repository",
-        label: "Recloning:",
+      const repairProgressState = showProgress(renderer, [result.repo], {
+        title: "Repairing reference",
+        label: "Repairing:",
         initialPhase: "cloning",
       });
-      recloneProgressState.sessionName = session.name;
-      updateProgress(renderer, recloneProgressState);
+      repairProgressState.sessionName = session.name;
+      updateProgress(renderer, repairProgressState);
 
       try {
-        await recloneRepo(result.repo, session.path, (status, outputLines) => {
-          const repoState = recloneProgressState.repos[0];
+        await repairReferenceLink(result.repo, session.path, (status, outputLines) => {
+          const repoState = repairProgressState.repos[0];
           if (repoState) {
             repoState.status = status;
             if (outputLines) {
-              recloneProgressState.currentOutput = outputLines;
+              repairProgressState.currentOutput = outputLines;
             }
-            updateProgress(renderer, recloneProgressState);
+            updateProgress(renderer, repairProgressState);
           }
         });
       } catch (error) {
-        const repoState = recloneProgressState.repos[0];
+        const repoState = repairProgressState.repos[0];
         if (repoState) {
           repoState.status = "error";
         }
-        recloneProgressState.currentOutput = [
+        repairProgressState.currentOutput = [
           error instanceof Error ? error.message : String(error),
         ];
-        updateProgress(renderer, recloneProgressState);
+        updateProgress(renderer, repairProgressState);
       }
 
-      recloneProgressState.phase = "done";
-      updateProgress(renderer, recloneProgressState);
+      repairProgressState.phase = "done";
+      updateProgress(renderer, repairProgressState);
       await new Promise((resolve) => setTimeout(resolve, 700));
       hideProgress(renderer);
     }
   }
 }
 
-async function refreshLatestBeforeResumeSimple(session: Session): Promise<void> {
-  const latestRepos = session.repos.filter((repo) => repo.latest);
-  if (latestRepos.length === 0) return;
+async function refreshReferenceBeforeResumeSimple(session: Session): Promise<void> {
+  const referenceRepos = session.repos.filter((repo) => repo.reference);
+  if (referenceRepos.length === 0) return;
 
-  console.log("\nRefreshing latest repositories...");
+  console.log("\nRefreshing reference repositories...");
 
-  const results = await refreshLatestRepos(latestRepos, session.path);
+  const results = await refreshReferenceRepos(referenceRepos, session.path);
 
   if (results.length === 0) return;
 

package/src/git.ts

@@ -193,63 +193,101 @@ export async function sessionHasUncommittedChanges(
   return { hasChanges: reposWithChanges.length > 0, reposWithChanges };
 }
 
-export async function refreshLatestRepos(
+export async function refreshReferenceRepos(
   repos: RepoSpec[],
   sessionPath: string,
   onProgress?: (repoIndex: number, status: RefreshProgressStatus, outputLines?: string[]) => void,
 ): Promise<RefreshResult[]> {
-  const latestRepos = repos.filter((repo) => repo.latest);
-  if (latestRepos.length === 0) return [];
+  // Import reference-repo functions dynamically to avoid circular deps
+  const { refreshReferenceRepo, verifyReferenceLink, repairReferenceLink, isSymlink } =
+    await import("./reference-repo");
+
+  const referenceRepos = repos.filter((repo) => repo.reference);
+  if (referenceRepos.length === 0) return [];
 
   const results: RefreshResult[] = [];
 
-  for (const [repoIndex, repo] of latestRepos.entries()) {
+  for (const [repoIndex, repo] of referenceRepos.entries()) {
     const repoPath = join(sessionPath, repo.dir);
-    const dirty = await hasUncommittedChanges(repoPath);
 
-    if (dirty) {
-      results.push({
-        repo,
-        status: "skipped",
-        reason: "uncommitted changes",
+    // Check if this is a symlink (reference repo)
+    const isRef = await isSymlink(repoPath);
+
+    if (isRef) {
+      // Verify symlink is valid, repair if needed
+      const isValid = await verifyReferenceLink(repo, sessionPath);
+      if (!isValid) {
+        onProgress?.(repoIndex, "refreshing", [`Repairing link to ${repo.owner}/${repo.name}...`]);
+        try {
+          await repairReferenceLink(repo, sessionPath, (status, lines) => {
+            if (status === "cloning") onProgress?.(repoIndex, "refreshing", lines);
+          });
+        } catch (error) {
+          results.push({
+            repo,
+            status: "error",
+            reason: error instanceof Error ? error.message : String(error),
+          });
+          onProgress?.(repoIndex, "error", [
+            error instanceof Error ? error.message : String(error),
+          ]);
+          continue;
+        }
+      }
+
+      // Refresh the cached reference repo
+      const result = await refreshReferenceRepo(repo, (status, lines) => {
+        onProgress?.(repoIndex, status, lines);
       });
-      onProgress?.(repoIndex, "skipped", ["Skipped: uncommitted changes"]);
-      continue;
-    }
+      results.push(result);
+    } else {
+      // Non-symlink reference repo (legacy or converted) - use standard git pull
+      const dirty = await hasUncommittedChanges(repoPath);
+
+      if (dirty) {
+        results.push({
+          repo,
+          status: "skipped",
+          reason: "uncommitted changes",
+        });
+        onProgress?.(repoIndex, "skipped", ["Skipped: uncommitted changes"]);
+        continue;
+      }
 
-    onProgress?.(repoIndex, "refreshing", [`Pulling ${repo.owner}/${repo.name}...`]);
+      onProgress?.(repoIndex, "refreshing", [`Pulling ${repo.owner}/${repo.name}...`]);
 
-    const proc = Bun.spawn(["git", "-C", repoPath, "pull", "--ff-only", "--depth", "1"], {
-      stdout: "pipe",
-      stderr: "pipe",
-    });
+      const proc = Bun.spawn(["git", "-C", repoPath, "pull", "--ff-only", "--depth", "1"], {
+        stdout: "pipe",
+        stderr: "pipe",
+      });
 
-    const { success, output, fullOutput } = await readProcessOutputWithBuffer(proc, {
-      maxBufferLines: 5,
-      onBufferUpdate: (buffer) => onProgress?.(repoIndex, "refreshing", buffer),
-    });
-    const exitCode = success ? 0 : 1;
+      const { success, output, fullOutput } = await readProcessOutputWithBuffer(proc, {
+        maxBufferLines: 5,
+        onBufferUpdate: (buffer) => onProgress?.(repoIndex, "refreshing", buffer),
+      });
+      const exitCode = success ? 0 : 1;
+
+      if (exitCode !== 0) {
+        const reason = fullOutput.trim() || `git pull exited with code ${exitCode}`;
+        results.push({
+          repo,
+          status: "error",
+          reason,
+        });
+        onProgress?.(repoIndex, "error", output.length > 0 ? [...output] : [reason]);
+        continue;
+      }
+
+      const normalized = fullOutput.toLowerCase();
+      const upToDate =
+        normalized.includes("already up to date") || normalized.includes("already up-to-date");
 
-    if (exitCode !== 0) {
-      const reason = fullOutput.trim() || `git pull exited with code ${exitCode}`;
       results.push({
         repo,
-        status: "error",
-        reason,
+        status: upToDate ? "up-to-date" : "updated",
       });
-      onProgress?.(repoIndex, "error", output.length > 0 ? [...output] : [reason]);
-      continue;
+      onProgress?.(repoIndex, upToDate ? "up-to-date" : "updated", [...output]);
     }
-
-    const normalized = fullOutput.toLowerCase();
-    const upToDate =
-      normalized.includes("already up to date") || normalized.includes("already up-to-date");
-
-    results.push({
-      repo,
-      status: upToDate ? "up-to-date" : "updated",
-    });
-    onProgress?.(repoIndex, upToDate ? "up-to-date" : "updated", [...output]);
   }
 
   return results;

package/src/process-registry.ts

@@ -0,0 +1,179 @@
+import { Database } from "bun:sqlite";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { mkdir } from "node:fs/promises";
+
+const DATA_DIR = join(homedir(), ".letmecook");
+const DB_PATH = join(DATA_DIR, "history.sqlite");
+
+let db: Database | null = null;
+
+export interface BackgroundProcess {
+  pid: number;
+  command: string;
+  description: string;
+  sessionName: string;
+  startTime: string;
+}
+
+interface DbRow {
+  pid: number;
+  command: string;
+  description: string;
+  session_name: string;
+  start_time: string;
+}
+
+async function getDb(): Promise<Database> {
+  if (db) return db;
+
+  await mkdir(DATA_DIR, { recursive: true });
+  db = new Database(DB_PATH, { create: true });
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS background_processes (
+      pid INTEGER PRIMARY KEY,
+      command TEXT NOT NULL,
+      description TEXT NOT NULL,
+      session_name TEXT NOT NULL,
+      start_time TEXT NOT NULL
+    );
+  `);
+
+  return db;
+}
+
+function rowToProcess(row: DbRow): BackgroundProcess {
+  return {
+    pid: row.pid,
+    command: row.command,
+    description: row.description,
+    sessionName: row.session_name,
+    startTime: row.start_time,
+  };
+}
+
+function isProcessAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function registerBackgroundProcess(
+  pid: number,
+  command: string,
+  description: string,
+  sessionName: string,
+): Promise<void> {
+  const database = await getDb();
+  const stmt = database.prepare(`
+    INSERT OR REPLACE INTO background_processes
+    (pid, command, description, session_name, start_time)
+    VALUES (?, ?, ?, ?, ?)
+  `);
+  stmt.run(pid, command, description, sessionName, new Date().toISOString());
+}
+
+export async function getRunningProcesses(): Promise<BackgroundProcess[]> {
+  const database = await getDb();
+  const stmt = database.prepare(`SELECT * FROM background_processes`);
+  const rows = stmt.all() as DbRow[];
+
+  const aliveProcesses: BackgroundProcess[] = [];
+  const deadPids: number[] = [];
+
+  for (const row of rows) {
+    if (isProcessAlive(row.pid)) {
+      aliveProcesses.push(rowToProcess(row));
+    } else {
+      deadPids.push(row.pid);
+    }
+  }
+
+  // Clean up dead processes from the database
+  if (deadPids.length > 0) {
+    const deleteStmt = database.prepare(`DELETE FROM background_processes WHERE pid = ?`);
+    const deleteMany = database.transaction((pids: number[]) => {
+      for (const pid of pids) {
+        deleteStmt.run(pid);
+      }
+    });
+    deleteMany(deadPids);
+  }
+
+  return aliveProcesses;
+}
+
+export async function getProcessesForSession(sessionName: string): Promise<BackgroundProcess[]> {
+  const database = await getDb();
+  const stmt = database.prepare(`SELECT * FROM background_processes WHERE session_name = ?`);
+  const rows = stmt.all(sessionName) as DbRow[];
+
+  const aliveProcesses: BackgroundProcess[] = [];
+  const deadPids: number[] = [];
+
+  for (const row of rows) {
+    if (isProcessAlive(row.pid)) {
+      aliveProcesses.push(rowToProcess(row));
+    } else {
+      deadPids.push(row.pid);
+    }
+  }
+
+  // Clean up dead processes from the database
+  if (deadPids.length > 0) {
+    const deleteStmt = database.prepare(`DELETE FROM background_processes WHERE pid = ?`);
+    const deleteMany = database.transaction((pids: number[]) => {
+      for (const pid of pids) {
+        deleteStmt.run(pid);
+      }
+    });
+    deleteMany(deadPids);
+  }
+
+  return aliveProcesses;
+}
+
+export async function killProcess(pid: number): Promise<boolean> {
+  try {
+    // First try SIGTERM for graceful shutdown
+    process.kill(pid, "SIGTERM");
+
+    // Wait up to 3 seconds for process to exit
+    const startTime = Date.now();
+    while (Date.now() - startTime < 3000) {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      if (!isProcessAlive(pid)) {
+        await removeProcessFromRegistry(pid);
+        return true;
+      }
+    }
+
+    // Process didn't exit, send SIGKILL
+    process.kill(pid, "SIGKILL");
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    await removeProcessFromRegistry(pid);
+    return true;
+  } catch {
+    // Process may have already exited
+    await removeProcessFromRegistry(pid);
+    return false;
+  }
+}
+
+export async function killAllProcesses(): Promise<void> {
+  const runningProcesses = await getRunningProcesses();
+
+  for (const proc of runningProcesses) {
+    await killProcess(proc.pid);
+  }
+}
+
+async function removeProcessFromRegistry(pid: number): Promise<void> {
+  const database = await getDb();
+  const stmt = database.prepare(`DELETE FROM background_processes WHERE pid = ?`);
+  stmt.run(pid);
+}