the-campfire 0.1.0

package/server/env-manager.ts

@@ -0,0 +1,146 @@
+import {
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  writeFileSync,
+  unlinkSync,
+  existsSync,
+} from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+// ─── Types ──────────────────────────────────────────────────────────────────
+
+export interface CampfireEnv {
+  name: string;
+  slug: string;
+  variables: Record<string, string>;
+  createdAt: number;
+  updatedAt: number;
+}
+
+// ─── Paths ──────────────────────────────────────────────────────────────────
+
+const CAMPFIRE_DIR = join(homedir(), ".campfire");
+const ENVS_DIR = join(CAMPFIRE_DIR, "envs");
+
+function ensureDir(): void {
+  mkdirSync(ENVS_DIR, { recursive: true });
+}
+
+function filePath(slug: string): string {
+  return join(ENVS_DIR, `${slug}.json`);
+}
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+function slugify(name: string): string {
+  return name
+    .toLowerCase()
+    .replace(/\s+/g, "-")
+    .replace(/[^a-z0-9-]/g, "")
+    .replace(/-+/g, "-")
+    .replace(/^-|-$/g, "");
+}
+
+// ─── CRUD ───────────────────────────────────────────────────────────────────
+
+export function listEnvs(): CampfireEnv[] {
+  ensureDir();
+  try {
+    const files = readdirSync(ENVS_DIR).filter((f) => f.endsWith(".json"));
+    const envs: CampfireEnv[] = [];
+    for (const file of files) {
+      try {
+        const raw = readFileSync(join(ENVS_DIR, file), "utf-8");
+        envs.push(JSON.parse(raw));
+      } catch {
+        // Skip corrupt files
+      }
+    }
+    envs.sort((a, b) => a.name.localeCompare(b.name));
+    return envs;
+  } catch {
+    return [];
+  }
+}
+
+export function getEnv(slug: string): CampfireEnv | null {
+  ensureDir();
+  try {
+    const raw = readFileSync(filePath(slug), "utf-8");
+    return JSON.parse(raw) as CampfireEnv;
+  } catch {
+    return null;
+  }
+}
+
+export function createEnv(
+  name: string,
+  variables: Record<string, string> = {},
+): CampfireEnv {
+  if (!name || !name.trim()) throw new Error("Environment name is required");
+  const slug = slugify(name.trim());
+  if (!slug) throw new Error("Environment name must contain alphanumeric characters");
+
+  ensureDir();
+  if (existsSync(filePath(slug))) {
+    throw new Error(`An environment with a similar name already exists ("${slug}")`);
+  }
+
+  const now = Date.now();
+  const env: CampfireEnv = {
+    name: name.trim(),
+    slug,
+    variables,
+    createdAt: now,
+    updatedAt: now,
+  };
+  writeFileSync(filePath(slug), JSON.stringify(env, null, 2), "utf-8");
+  return env;
+}
+
+export function updateEnv(
+  slug: string,
+  updates: { name?: string; variables?: Record<string, string> },
+): CampfireEnv | null {
+  ensureDir();
+  const existing = getEnv(slug);
+  if (!existing) return null;
+
+  const newName = updates.name?.trim() || existing.name;
+  const newSlug = slugify(newName);
+  if (!newSlug) throw new Error("Environment name must contain alphanumeric characters");
+
+  // If name changed, check for slug collision with a different env
+  if (newSlug !== slug && existsSync(filePath(newSlug))) {
+    throw new Error(`An environment with a similar name already exists ("${newSlug}")`);
+  }
+
+  const env: CampfireEnv = {
+    name: newName,
+    slug: newSlug,
+    variables: updates.variables ?? existing.variables,
+    createdAt: existing.createdAt,
+    updatedAt: Date.now(),
+  };
+
+  // If slug changed, delete old file
+  if (newSlug !== slug) {
+    try { unlinkSync(filePath(slug)); } catch { /* ok */ }
+  }
+
+  writeFileSync(filePath(newSlug), JSON.stringify(env, null, 2), "utf-8");
+  return env;
+}
+
+export function deleteEnv(slug: string): boolean {
+  ensureDir();
+  if (!existsSync(filePath(slug))) return false;
+  try {
+    unlinkSync(filePath(slug));
+    return true;
+  } catch {
+    return false;
+  }
+}

package/server/environment-detector.ts

@@ -0,0 +1,106 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import type { DetectedEnvironment, McpServerConfig } from "./session-types.js";
+import { ENVIRONMENT_RULES, toDetectedRule, type PackageJsonLike, type ProjectContext } from "./environment-rules.js";
+
+const ENV_FILES = [".env", ".env.local", ".env.development"];
+const MAX_ENV_BYTES = 256 * 1024;
+
+function readPackageJson(cwd: string): PackageJsonLike | undefined {
+  try {
+    const raw = readFileSync(join(cwd, "package.json"), "utf-8");
+    return JSON.parse(raw) as PackageJsonLike;
+  } catch {
+    return undefined;
+  }
+}
+
+function parseEnvContent(content: string): Record<string, string> {
+  const vars: Record<string, string> = {};
+  for (const line of content.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const match = /^([\w.-]+)\s*=\s*(.*)$/.exec(trimmed);
+    if (!match) continue;
+    let value = match[2].trim();
+    if ((value.startsWith("\"") && value.endsWith("\"")) || (value.startsWith("'") && value.endsWith("'"))) {
+      value = value.slice(1, -1);
+    }
+    vars[match[1]] = value;
+  }
+  return vars;
+}
+
+function readEnvVars(cwd: string): Record<string, string> {
+  const envVars: Record<string, string> = {};
+  for (const file of ENV_FILES) {
+    const path = join(cwd, file);
+    try {
+      if (!existsSync(path)) continue;
+      const stat = statSync(path);
+      if (!stat.isFile() || stat.size > MAX_ENV_BYTES) continue;
+      Object.assign(envVars, parseEnvContent(readFileSync(path, "utf-8")));
+    } catch {
+      // Ignore unreadable env files. Detection is best effort.
+    }
+  }
+  return envVars;
+}
+
+function addIfExists(cwd: string, relPath: string, files: Set<string>, dirs: Set<string>): void {
+  const path = join(cwd, relPath);
+  try {
+    if (!existsSync(path)) return;
+    const stat = statSync(path);
+    if (stat.isDirectory()) dirs.add(relPath);
+    if (stat.isFile()) files.add(relPath);
+  } catch {
+    // Ignore transient filesystem errors.
+  }
+}
+
+function collectProjectContext(cwd: string): ProjectContext {
+  const files = new Set<string>();
+  const dirs = new Set<string>();
+
+  try {
+    for (const entry of readdirSync(cwd, { withFileTypes: true })) {
+      if (entry.isFile()) files.add(entry.name);
+      if (entry.isDirectory()) dirs.add(entry.name);
+    }
+  } catch {
+    // Leave sets empty; downstream rules will simply not match.
+  }
+
+  addIfExists(cwd, "prisma/schema.prisma", files, dirs);
+  addIfExists(cwd, ".github/workflows", files, dirs);
+
+  return {
+    cwd,
+    files,
+    dirs,
+    packageJson: readPackageJson(cwd),
+    envVars: readEnvVars(cwd),
+  };
+}
+
+export function detectEnvironment(cwd: string): DetectedEnvironment {
+  const ctx = collectProjectContext(cwd);
+  const rules = [];
+  const mcpServers: Record<string, McpServerConfig> = {};
+
+  for (const rule of ENVIRONMENT_RULES) {
+    if (!rule.detect(ctx)) continue;
+    rules.push(toDetectedRule(rule, ctx.envVars));
+    if (rule.mcpServer) {
+      mcpServers[rule.id] = rule.mcpServer;
+    }
+  }
+
+  return {
+    cwd,
+    scannedAt: Date.now(),
+    rules,
+    mcpServers,
+  };
+}

package/server/environment-rules.ts

@@ -0,0 +1,106 @@
+import type { DetectedEnvironmentRule, McpServerConfig } from "./session-types.js";
+
+export interface PackageJsonLike {
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+  scripts?: Record<string, string>;
+}
+
+export interface ProjectContext {
+  cwd: string;
+  files: Set<string>;
+  dirs: Set<string>;
+  packageJson?: PackageJsonLike;
+  envVars: Record<string, string>;
+}
+
+export interface DetectionRule {
+  id: string;
+  name: string;
+  description: string;
+  envRequired?: string[];
+  detect(ctx: ProjectContext): boolean;
+  mcpServer?: McpServerConfig;
+}
+
+function hasDependency(ctx: ProjectContext, dep: string): boolean {
+  return Boolean(ctx.packageJson?.dependencies?.[dep] || ctx.packageJson?.devDependencies?.[dep]);
+}
+
+function hasAnyDependency(ctx: ProjectContext, deps: string[]): boolean {
+  return deps.some((dep) => hasDependency(ctx, dep));
+}
+
+function envServer(command: string, args: string[] = []): McpServerConfig {
+  return { type: "stdio", command, args };
+}
+
+export const ENVIRONMENT_RULES: DetectionRule[] = [
+  {
+    id: "supabase",
+    name: "Supabase",
+    description: "Supabase project or SDK detected.",
+    envRequired: ["SUPABASE_URL"],
+    detect: (ctx) => Boolean(ctx.envVars.SUPABASE_URL) || hasAnyDependency(ctx, ["@supabase/supabase-js", "supabase"]),
+    mcpServer: envServer("npx", ["-y", "@supabase/mcp-server-supabase"]),
+  },
+  {
+    id: "stripe",
+    name: "Stripe",
+    description: "Stripe SDK or secret key detected.",
+    envRequired: ["STRIPE_SECRET_KEY"],
+    detect: (ctx) => Boolean(ctx.envVars.STRIPE_SECRET_KEY) || hasDependency(ctx, "stripe"),
+    mcpServer: envServer("npx", ["-y", "@stripe/mcp"]),
+  },
+  {
+    id: "vercel",
+    name: "Vercel",
+    description: "Vercel or Next.js deployment target detected.",
+    detect: (ctx) => ctx.files.has("vercel.json") || hasDependency(ctx, "next"),
+    mcpServer: envServer("npx", ["-y", "@vercel/mcp-server"]),
+  },
+  {
+    id: "prisma",
+    name: "Prisma",
+    description: "Prisma schema or dependency detected.",
+    envRequired: ["DATABASE_URL"],
+    detect: (ctx) => ctx.files.has("prisma/schema.prisma") || hasAnyDependency(ctx, ["prisma", "@prisma/client"]),
+  },
+  {
+    id: "docker",
+    name: "Docker",
+    description: "Dockerfile or compose configuration detected.",
+    detect: (ctx) => ctx.files.has("Dockerfile") || ctx.files.has("docker-compose.yml") || ctx.files.has("docker-compose.yaml"),
+  },
+  {
+    id: "flyio",
+    name: "Fly.io",
+    description: "Fly.io deployment configuration detected.",
+    detect: (ctx) => ctx.files.has("fly.toml"),
+  },
+  {
+    id: "github-actions",
+    name: "GitHub Actions",
+    description: "GitHub Actions workflow directory detected.",
+    detect: (ctx) => ctx.dirs.has(".github/workflows"),
+  },
+  {
+    id: "database",
+    name: "Database",
+    description: "Database connection configuration detected.",
+    envRequired: ["DATABASE_URL"],
+    detect: (ctx) => Boolean(ctx.envVars.DATABASE_URL),
+  },
+];
+
+export function toDetectedRule(rule: DetectionRule, envVars: Record<string, string>): DetectedEnvironmentRule {
+  const envRequired = rule.envRequired ?? [];
+  return {
+    id: rule.id,
+    name: rule.name,
+    description: rule.description,
+    envRequired: envRequired.length ? envRequired : undefined,
+    envPresent: envRequired.filter((name) => Boolean(envVars[name])),
+    envMissing: envRequired.filter((name) => !envVars[name]),
+  };
+}

package/server/gallery-store.ts

@@ -0,0 +1,216 @@
+import {
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  writeFileSync,
+  unlinkSync,
+  existsSync,
+} from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import type {
+  GalleryEntry,
+  GalleryEntryCreateInput,
+  GallerySessionSnapshot,
+  GalleryFilter,
+} from "./gallery-types.js";
+
+// ─── Paths ──────────────────────────────────────────────────────────────────
+
+const CAMPFIRE_DIR = join(homedir(), ".campfire");
+const GALLERY_DIR = join(CAMPFIRE_DIR, "gallery");
+
+function ensureDir(): void {
+  mkdirSync(GALLERY_DIR, { recursive: true });
+}
+
+function filePath(id: string): string {
+  return join(GALLERY_DIR, `${id}.json`);
+}
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+function slugify(name: string): string {
+  return name
+    .toLowerCase()
+    .replace(/\s+/g, "-")
+    .replace(/[^a-z0-9-]/g, "")
+    .replace(/-+/g, "-")
+    .replace(/^-|-$/g, "");
+}
+
+// ─── CRUD ───────────────────────────────────────────────────────────────────
+
+export function listEntries(filter?: GalleryFilter): GalleryEntry[] {
+  ensureDir();
+  try {
+    const files = readdirSync(GALLERY_DIR).filter(
+      (f) => f.endsWith(".json") && f !== "votes.json",
+    );
+    let entries: GalleryEntry[] = [];
+    for (const file of files) {
+      try {
+        const raw = readFileSync(join(GALLERY_DIR, file), "utf-8");
+        entries.push(JSON.parse(raw));
+      } catch {
+        // Skip corrupt files
+      }
+    }
+
+    if (filter) {
+      entries = applyFilter(entries, filter);
+    } else {
+      // Default sort: votes descending
+      entries.sort((a, b) => b.votes - a.votes);
+    }
+
+    return entries;
+  } catch {
+    return [];
+  }
+}
+
+export function getEntry(id: string): GalleryEntry | null {
+  ensureDir();
+  try {
+    const raw = readFileSync(filePath(id), "utf-8");
+    return JSON.parse(raw) as GalleryEntry;
+  } catch {
+    return null;
+  }
+}
+
+export function createEntry(
+  input: GalleryEntryCreateInput,
+  snapshot: GallerySessionSnapshot,
+): GalleryEntry {
+  if (!input.name || !input.name.trim()) throw new Error("Entry name is required");
+  if (!input.sessionId || !input.sessionId.trim())
+    throw new Error("Session ID is required");
+
+  const id = slugify(input.name.trim());
+  if (!id) throw new Error("Entry name must contain alphanumeric characters");
+
+  ensureDir();
+  if (existsSync(filePath(id))) {
+    throw new Error(`A gallery entry with a similar name already exists ("${id}")`);
+  }
+
+  const now = Date.now();
+  const entry: GalleryEntry = {
+    id,
+    sessionId: input.sessionId.trim(),
+    name: input.name.trim(),
+    description: (input.description || "").trim(),
+    tags: (input.tags || []).map((t) => t.trim().toLowerCase()).filter(Boolean),
+    featured: false,
+    votes: 0,
+    createdAt: now,
+    updatedAt: now,
+    backendType: snapshot.backendType || "claude",
+    model: snapshot.model || "unknown",
+    totalCostUsd: snapshot.totalCostUsd || 0,
+    durationMs: snapshot.durationMs || 0,
+    totalLinesAdded: snapshot.totalLinesAdded || 0,
+    totalLinesRemoved: snapshot.totalLinesRemoved || 0,
+    numTurns: snapshot.numTurns || 0,
+    repoRoot: snapshot.repoRoot,
+  };
+
+  writeFileSync(filePath(id), JSON.stringify(entry, null, 2), "utf-8");
+  return entry;
+}
+
+export function updateEntry(
+  id: string,
+  updates: Partial<GalleryEntry>,
+): GalleryEntry | null {
+  ensureDir();
+  const existing = getEntry(id);
+  if (!existing) return null;
+
+  const newName = updates.name?.trim() || existing.name;
+  const newId = slugify(newName);
+  if (!newId) throw new Error("Entry name must contain alphanumeric characters");
+
+  // If name changed, check for slug collision
+  if (newId !== id && existsSync(filePath(newId))) {
+    throw new Error(`A gallery entry with a similar name already exists ("${newId}")`);
+  }
+
+  const entry: GalleryEntry = {
+    ...existing,
+    ...updates,
+    id: newId,
+    name: newName,
+    updatedAt: Date.now(),
+    createdAt: existing.createdAt,
+  };
+
+  // If id changed, delete old file
+  if (newId !== id) {
+    try {
+      unlinkSync(filePath(id));
+    } catch {
+      /* ok */
+    }
+  }
+
+  writeFileSync(filePath(newId), JSON.stringify(entry, null, 2), "utf-8");
+  return entry;
+}
+
+export function deleteEntry(id: string): boolean {
+  ensureDir();
+  if (!existsSync(filePath(id))) return false;
+  try {
+    unlinkSync(filePath(id));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// ─── Filtering & Sorting ────────────────────────────────────────────────────
+
+function applyFilter(entries: GalleryEntry[], filter: GalleryFilter): GalleryEntry[] {
+  let result = entries;
+
+  if (filter.backend) {
+    result = result.filter((e) => e.backendType === filter.backend);
+  }
+  if (filter.minCost !== undefined) {
+    result = result.filter((e) => e.totalCostUsd >= filter.minCost!);
+  }
+  if (filter.maxCost !== undefined) {
+    result = result.filter((e) => e.totalCostUsd <= filter.maxCost!);
+  }
+  if (filter.tags && filter.tags.length > 0) {
+    const filterTags = new Set(filter.tags.map((t) => t.toLowerCase()));
+    result = result.filter((e) => e.tags.some((t) => filterTags.has(t)));
+  }
+  if (filter.featuredOnly) {
+    result = result.filter((e) => e.featured);
+  }
+
+  const sortBy = filter.sortBy || "votes";
+  const sortOrder = filter.sortOrder || "desc";
+  const multiplier = sortOrder === "asc" ? 1 : -1;
+
+  result.sort((a, b) => {
+    switch (sortBy) {
+      case "votes":
+        return (a.votes - b.votes) * multiplier;
+      case "cost":
+        return (a.totalCostUsd - b.totalCostUsd) * multiplier;
+      case "recent":
+        return (a.createdAt - b.createdAt) * multiplier;
+      case "duration":
+        return (a.durationMs - b.durationMs) * multiplier;
+      default:
+        return (a.votes - b.votes) * multiplier;
+    }
+  });
+
+  return result;
+}

package/server/gallery-types.ts

@@ -0,0 +1,52 @@
+import type { BackendType } from "./session-types.js";
+
+// ─── Gallery Entry ─────────────────────────────────────────────────────────
+
+export interface GalleryEntry {
+  id: string;
+  sessionId: string;
+  name: string;
+  description: string;
+  tags: string[];
+  featured: boolean;
+  votes: number;
+  createdAt: number;
+  updatedAt: number;
+  // Denormalized session snapshot for fast listing
+  backendType: BackendType;
+  model: string;
+  totalCostUsd: number;
+  durationMs: number;
+  totalLinesAdded: number;
+  totalLinesRemoved: number;
+  numTurns: number;
+  repoRoot?: string;
+}
+
+export interface GalleryEntryCreateInput {
+  sessionId: string;
+  name: string;
+  description: string;
+  tags?: string[];
+}
+
+export interface GallerySessionSnapshot {
+  backendType?: BackendType;
+  model?: string;
+  totalCostUsd?: number;
+  durationMs?: number;
+  totalLinesAdded?: number;
+  totalLinesRemoved?: number;
+  numTurns?: number;
+  repoRoot?: string;
+}
+
+export interface GalleryFilter {
+  backend?: BackendType;
+  minCost?: number;
+  maxCost?: number;
+  tags?: string[];
+  featuredOnly?: boolean;
+  sortBy?: "votes" | "cost" | "recent" | "duration";
+  sortOrder?: "asc" | "desc";
+}