the-campfire 0.1.0

package/server/session-folders.ts

@@ -0,0 +1,107 @@
+/**
+ * Session Folders — user-defined groups for organizing sessions.
+ * Stored in ~/.campfire/session-folders.json
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+const FOLDERS_FILE = join(homedir(), ".campfire", "session-folders.json");
+
+export interface SessionFolder {
+  id: string;
+  name: string;
+  color?: string;
+  sessionIds: string[];
+  createdAt: number;
+}
+
+interface FoldersData {
+  folders: SessionFolder[];
+}
+
+function ensureDir(): void {
+  const dir = join(homedir(), ".campfire");
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+}
+
+function load(): FoldersData {
+  try {
+    if (!existsSync(FOLDERS_FILE)) return { folders: [] };
+    return JSON.parse(readFileSync(FOLDERS_FILE, "utf-8"));
+  } catch {
+    return { folders: [] };
+  }
+}
+
+function save(data: FoldersData): void {
+  ensureDir();
+  writeFileSync(FOLDERS_FILE, JSON.stringify(data, null, 2), "utf-8");
+}
+
+export function listFolders(): SessionFolder[] {
+  return load().folders;
+}
+
+export function createFolder(name: string, color?: string): SessionFolder {
+  const data = load();
+  const folder: SessionFolder = {
+    id: `folder-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+    name,
+    color,
+    sessionIds: [],
+    createdAt: Date.now(),
+  };
+  data.folders.push(folder);
+  save(data);
+  return folder;
+}
+
+export function updateFolder(id: string, updates: { name?: string; color?: string }): SessionFolder | null {
+  const data = load();
+  const folder = data.folders.find((f) => f.id === id);
+  if (!folder) return null;
+  if (updates.name !== undefined) folder.name = updates.name;
+  if (updates.color !== undefined) folder.color = updates.color;
+  save(data);
+  return folder;
+}
+
+export function deleteFolder(id: string): boolean {
+  const data = load();
+  const index = data.folders.findIndex((f) => f.id === id);
+  if (index === -1) return false;
+  data.folders.splice(index, 1);
+  save(data);
+  return true;
+}
+
+export function addSessionToFolder(folderId: string, sessionId: string): boolean {
+  const data = load();
+  // Remove from any other folder first
+  for (const folder of data.folders) {
+    folder.sessionIds = folder.sessionIds.filter((s) => s !== sessionId);
+  }
+  const folder = data.folders.find((f) => f.id === folderId);
+  if (!folder) return false;
+  folder.sessionIds.push(sessionId);
+  save(data);
+  return true;
+}
+
+export function removeSessionFromFolder(sessionId: string): boolean {
+  const data = load();
+  let removed = false;
+  for (const folder of data.folders) {
+    const len = folder.sessionIds.length;
+    folder.sessionIds = folder.sessionIds.filter((s) => s !== sessionId);
+    if (folder.sessionIds.length < len) removed = true;
+  }
+  if (removed) save(data);
+  return removed;
+}
+
+export function getSessionFolder(sessionId: string): SessionFolder | null {
+  const data = load();
+  return data.folders.find((f) => f.sessionIds.includes(sessionId)) ?? null;
+}

package/server/session-git-info.ts

@@ -0,0 +1,89 @@
+/**
+ * Git info resolution for Docker containers.
+ * Runs git commands inside containers via `docker exec`.
+ */
+
+import { execSync } from "node:child_process";
+
+export interface ContainerGitInfo {
+  branch: string;
+  isWorktree: boolean;
+  repoRoot: string;
+  ahead: number;
+  behind: number;
+}
+
+/**
+ * Resolve git information from inside a Docker container.
+ * @param containerId Docker container ID or name
+ * @param containerCwd Working directory inside the container
+ * @returns Git info or null if not a git repo
+ */
+export function containerGitInfo(
+  containerId: string,
+  containerCwd: string,
+): ContainerGitInfo | null {
+  try {
+    const branch = dockerExec(containerId, containerCwd,
+      "git rev-parse --abbrev-ref HEAD").trim();
+
+    if (!branch) return null;
+
+    let isWorktree = false;
+    try {
+      const gitDir = dockerExec(containerId, containerCwd,
+        "git rev-parse --git-dir").trim();
+      isWorktree = gitDir.includes("/worktrees/");
+    } catch { /* ignore */ }
+
+    let repoRoot = "";
+    try {
+      repoRoot = dockerExec(containerId, containerCwd,
+        "git rev-parse --show-toplevel").trim();
+    } catch { /* ignore */ }
+
+    let ahead = 0;
+    let behind = 0;
+    try {
+      const counts = dockerExec(containerId, containerCwd,
+        "git rev-list --left-right --count @{upstream}...HEAD").trim();
+      const [b, a] = counts.split(/\s+/).map(Number);
+      ahead = a || 0;
+      behind = b || 0;
+    } catch { /* no upstream */ }
+
+    return { branch, isWorktree, repoRoot, ahead, behind };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Map a path inside a container to the corresponding host path.
+ * @param containerPath Path inside the container
+ * @param containerInfo Container metadata (mount points)
+ * @returns Host path or the original container path if no mapping found
+ */
+export function mapContainerPath(
+  containerPath: string,
+  mountMappings: Array<{ hostPath: string; containerPath: string }>,
+): string {
+  for (const mount of mountMappings) {
+    if (containerPath.startsWith(mount.containerPath)) {
+      return containerPath.replace(mount.containerPath, mount.hostPath);
+    }
+  }
+  return containerPath;
+}
+
+/** Run a command inside a Docker container and return stdout. */
+function dockerExec(
+  containerId: string,
+  cwd: string,
+  command: string,
+): string {
+  return execSync(`docker exec -w "${cwd}" ${containerId} ${command}`, {
+    encoding: "utf-8",
+    timeout: 5000,
+  });
+}

package/server/session-linear-issues.ts

@@ -0,0 +1,94 @@
+/**
+ * Associates Linear issues with Campfire sessions.
+ * Persisted to ~/.campfire/linear-session-issues.json
+ */
+
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+
+export interface LinkedIssue {
+  issueId: string;
+  identifier: string;
+  title: string;
+  url: string;
+  state: string;
+  teamKey: string;
+  linkedAt: number;
+}
+
+interface IssueMap {
+  [sessionId: string]: LinkedIssue;
+}
+
+const STORE_DIR = join(homedir(), ".campfire");
+const STORE_PATH = join(STORE_DIR, "linear-session-issues.json");
+
+function loadIssues(): IssueMap {
+  if (!existsSync(STORE_PATH)) return {};
+  try {
+    return JSON.parse(readFileSync(STORE_PATH, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+function saveIssues(data: IssueMap): void {
+  mkdirSync(STORE_DIR, { recursive: true });
+  writeFileSync(STORE_PATH, JSON.stringify(data, null, 2), "utf-8");
+}
+
+/** Link a Linear issue to a session. */
+export function linkIssueToSession(sessionId: string, issue: Omit<LinkedIssue, "linkedAt">): LinkedIssue {
+  const data = loadIssues();
+  const entry: LinkedIssue = { ...issue, linkedAt: Date.now() };
+  data[sessionId] = entry;
+  saveIssues(data);
+  return entry;
+}
+
+/** Get the linked Linear issue for a session. */
+export function getLinkedIssue(sessionId: string): LinkedIssue | null {
+  const data = loadIssues();
+  return data[sessionId] ?? null;
+}
+
+/** Remove the linked issue for a session. */
+export function unlinkIssue(sessionId: string): boolean {
+  const data = loadIssues();
+  if (!(sessionId in data)) return false;
+  delete data[sessionId];
+  saveIssues(data);
+  return true;
+}
+
+/** Transition a Linear issue to a new state via the API. */
+export async function transitionIssue(
+  issueId: string,
+  stateId: string,
+  apiKey: string,
+): Promise<boolean> {
+  try {
+    const res = await fetch("https://api.linear.app/graphql", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": apiKey,
+      },
+      body: JSON.stringify({
+        query: `
+          mutation TransitionIssue($issueId: String!, $stateId: String!) {
+            issueUpdate(id: $issueId, input: { stateId: $stateId }) {
+              success
+            }
+          }
+        `,
+        variables: { issueId, stateId },
+      }),
+    });
+    const data = await res.json() as { data?: { issueUpdate?: { success: boolean } } };
+    return data.data?.issueUpdate?.success ?? false;
+  } catch {
+    return false;
+  }
+}

package/server/session-names.ts

@@ -0,0 +1,67 @@
+import {
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  existsSync,
+} from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+
+// ─── Paths ──────────────────────────────────────────────────────────────────
+
+const DEFAULT_PATH = join(homedir(), ".campfire", "session-names.json");
+
+// ─── Store ──────────────────────────────────────────────────────────────────
+
+let names: Record<string, string> = {};
+let loaded = false;
+let filePath = DEFAULT_PATH;
+
+function ensureLoaded(): void {
+  if (loaded) return;
+  try {
+    if (existsSync(filePath)) {
+      const raw = readFileSync(filePath, "utf-8");
+      names = JSON.parse(raw) as Record<string, string>;
+    }
+  } catch {
+    names = {};
+  }
+  loaded = true;
+}
+
+function persist(): void {
+  mkdirSync(dirname(filePath), { recursive: true });
+  writeFileSync(filePath, JSON.stringify(names, null, 2), "utf-8");
+}
+
+// ─── Public API ─────────────────────────────────────────────────────────────
+
+export function getName(sessionId: string): string | undefined {
+  ensureLoaded();
+  return names[sessionId];
+}
+
+export function setName(sessionId: string, name: string): void {
+  ensureLoaded();
+  names[sessionId] = name;
+  persist();
+}
+
+export function getAllNames(): Record<string, string> {
+  ensureLoaded();
+  return { ...names };
+}
+
+export function removeName(sessionId: string): void {
+  ensureLoaded();
+  delete names[sessionId];
+  persist();
+}
+
+/** Reset internal state and optionally set a custom file path (for testing). */
+export function _resetForTest(customPath?: string): void {
+  names = {};
+  loaded = false;
+  filePath = customPath || DEFAULT_PATH;
+}

package/server/session-store.ts

@@ -0,0 +1,169 @@
+import { mkdirSync, readdirSync, readFileSync, writeFileSync, unlinkSync, existsSync, cpSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir, homedir } from "node:os";
+import type {
+  SessionState,
+  BrowserIncomingMessage,
+  PermissionRequest,
+  BufferedBrowserEvent,
+} from "./session-types.js";
+
+// ─── Serializable session shape ─────────────────────────────────────────────
+
+export interface PersistedSession {
+  id: string;
+  state: SessionState;
+  messageHistory: BrowserIncomingMessage[];
+  pendingMessages: string[];
+  pendingPermissions: [string, PermissionRequest][];
+  eventBuffer?: BufferedBrowserEvent[];
+  nextEventSeq?: number;
+  lastAckSeq?: number;
+  processedClientMessageIds?: string[];
+  archived?: boolean;
+}
+
+// ─── Store ──────────────────────────────────────────────────────────────────
+
+// Persistent storage: ~/.campfire/sessions/ (survives reboots, unlike /tmp/)
+const PERSISTENT_DIR = join(homedir(), ".campfire", "sessions");
+// Legacy location (may contain data from older installs or pre-migration)
+const LEGACY_DIR = join(tmpdir(), "vibe-sessions");
+const DEFAULT_DIR = process.env.CAMPFIRE_SESSION_DIR || PERSISTENT_DIR;
+
+export class SessionStore {
+  private readonly dir: string;
+  private readonly debounceTimers = new Map<string, ReturnType<typeof setTimeout>>();
+
+  constructor(dir?: string) {
+    this.dir = dir || DEFAULT_DIR;
+    mkdirSync(this.dir, { recursive: true });
+    // Migrate data from legacy /tmp/ location if it exists and persistent dir is empty
+    this.migrateFromLegacy();
+  }
+
+  /** One-time migration: copy session files from /tmp/vibe-sessions/ to ~/.campfire/sessions/ */
+  private migrateFromLegacy(): void {
+    // Skip if using custom dir or legacy dir doesn't exist
+    if (this.dir !== PERSISTENT_DIR) return;
+    if (!existsSync(LEGACY_DIR)) return;
+
+    try {
+      const legacyFiles = readdirSync(LEGACY_DIR).filter((f) => f.endsWith(".json"));
+      const currentFiles = new Set(readdirSync(this.dir).filter((f) => f.endsWith(".json")));
+      let migrated = 0;
+
+      for (const file of legacyFiles) {
+        if (currentFiles.has(file)) continue; // don't overwrite existing
+        try {
+          cpSync(join(LEGACY_DIR, file), join(this.dir, file));
+          migrated++;
+        } catch { /* skip individual file errors */ }
+      }
+
+      if (migrated > 0) {
+        console.log(`[session-store] Migrated ${migrated} session(s) from ${LEGACY_DIR} to ${this.dir}`);
+      }
+    } catch { /* legacy dir not readable, skip */ }
+  }
+
+  private filePath(sessionId: string): string {
+    return join(this.dir, `${sessionId}.json`);
+  }
+
+  /** Debounced write — batches rapid changes (e.g. multiple stream events). */
+  save(session: PersistedSession): void {
+    const existing = this.debounceTimers.get(session.id);
+    if (existing) clearTimeout(existing);
+
+    const timer = setTimeout(() => {
+      this.debounceTimers.delete(session.id);
+      this.saveSync(session);
+    }, 150);
+    this.debounceTimers.set(session.id, timer);
+  }
+
+  /** Immediate write — use for critical state changes. */
+  saveSync(session: PersistedSession): void {
+    try {
+      writeFileSync(this.filePath(session.id), JSON.stringify(session), "utf-8");
+    } catch (err) {
+      console.error(`[session-store] Failed to save session ${session.id}:`, err);
+    }
+  }
+
+  /** Load a single session from disk. */
+  load(sessionId: string): PersistedSession | null {
+    try {
+      const raw = readFileSync(this.filePath(sessionId), "utf-8");
+      return JSON.parse(raw) as PersistedSession;
+    } catch {
+      return null;
+    }
+  }
+
+  /** Load all sessions from disk. */
+  loadAll(): PersistedSession[] {
+    const sessions: PersistedSession[] = [];
+    try {
+      const files = readdirSync(this.dir).filter((f) => f.endsWith(".json") && f !== "launcher.json");
+      for (const file of files) {
+        try {
+          const raw = readFileSync(join(this.dir, file), "utf-8");
+          sessions.push(JSON.parse(raw));
+        } catch {
+          // Skip corrupt files
+        }
+      }
+    } catch {
+      // Dir doesn't exist yet
+    }
+    return sessions;
+  }
+
+  /** Set the archived flag on a persisted session. */
+  setArchived(sessionId: string, archived: boolean): boolean {
+    const session = this.load(sessionId);
+    if (!session) return false;
+    session.archived = archived;
+    this.saveSync(session);
+    return true;
+  }
+
+  /** Remove a session file from disk. */
+  remove(sessionId: string): void {
+    const timer = this.debounceTimers.get(sessionId);
+    if (timer) {
+      clearTimeout(timer);
+      this.debounceTimers.delete(sessionId);
+    }
+    try {
+      unlinkSync(this.filePath(sessionId));
+    } catch {
+      // File may not exist
+    }
+  }
+
+  /** Persist launcher state (separate file). */
+  saveLauncher(data: unknown): void {
+    try {
+      writeFileSync(join(this.dir, "launcher.json"), JSON.stringify(data), "utf-8");
+    } catch (err) {
+      console.error("[session-store] Failed to save launcher state:", err);
+    }
+  }
+
+  /** Load launcher state. */
+  loadLauncher<T>(): T | null {
+    try {
+      const raw = readFileSync(join(this.dir, "launcher.json"), "utf-8");
+      return JSON.parse(raw) as T;
+    } catch {
+      return null;
+    }
+  }
+
+  get directory(): string {
+    return this.dir;
+  }
+}