heyhank 0.1.0

package/server/agent-types.ts

@@ -0,0 +1,122 @@
+// ─── Agent Types ─────────────────────────────────────────────────────────────
+
+export interface McpServerConfigAgent {
+  type: "stdio" | "sse" | "http";
+  command?: string;
+  args?: string[];
+  url?: string;
+  env?: Record<string, string>;
+}
+
+export interface AgentConfig {
+  /** Unique slug-based ID (derived from name) */
+  id: string;
+  /** Schema version for forward compat */
+  version: 1;
+  /** Human-readable name */
+  name: string;
+  /** Short description of what this agent does */
+  description: string;
+  /** Emoji or icon identifier */
+  icon?: string;
+
+  // ── Session Config ──
+  /** "claude", "codex", "ollama", "openrouter", or "gemini" */
+  backendType: "claude" | "codex" | "ollama" | "openrouter" | "gemini";
+  /** Model to use (e.g. "claude-sonnet-4-6") */
+  model: string;
+  /** Permission mode — "bypassPermissions" for Claude auto mode */
+  permissionMode: string;
+  /** Working directory path, or "temp" for an auto-created temp dir */
+  cwd: string;
+  /** Optional environment slug (references ~/.heyhank/envs/) */
+  envSlug?: string;
+  /** Extra environment variables */
+  env?: Record<string, string>;
+  /** Tool allowlist (empty = all tools) */
+  allowedTools?: string[];
+  /** Codex-specific: internet access */
+  codexInternetAccess?: boolean;
+
+  // ── Prompt ──
+  /** Prompt template. Use {{input}} as placeholder for trigger-provided input */
+  prompt: string;
+
+  // ── MCP Servers ──
+  /** MCP server configs to set on the session after CLI connects */
+  mcpServers?: Record<string, McpServerConfigAgent>;
+
+  // ── Skills ──
+  /** Skill slugs to attach (from ~/.claude/skills/) */
+  skills?: string[];
+
+  // ── Docker ──
+  /** Optional Docker container configuration */
+  container?: {
+    image?: string;
+    ports?: number[];
+    volumes?: string[];
+    initScript?: string;
+  };
+
+  // ── Git ──
+  branch?: string;
+  createBranch?: boolean;
+  useWorktree?: boolean;
+
+  // ── Triggers ──
+  triggers?: {
+    /** Webhook trigger config */
+    webhook?: {
+      enabled: boolean;
+      /** Auto-generated secret token for URL auth */
+      secret: string;
+    };
+    /** Cron/schedule trigger config */
+    schedule?: {
+      enabled: boolean;
+      /** Cron expression or ISO datetime */
+      expression: string;
+      /** true = recurring cron, false = one-shot */
+      recurring: boolean;
+    };
+  };
+
+  // ── Tracking ──
+  enabled: boolean;
+  createdAt: number;
+  updatedAt: number;
+  lastRunAt?: number;
+  lastSessionId?: string;
+  totalRuns: number;
+  consecutiveFailures: number;
+}
+
+/** Input for creating an agent (without auto-generated fields) */
+export type AgentConfigCreateInput = Omit<
+  AgentConfig,
+  "id" | "createdAt" | "updatedAt" | "totalRuns" | "consecutiveFailures" | "lastRunAt" | "lastSessionId"
+>;
+
+/** The portable/shareable JSON format (no internal tracking fields) */
+export type AgentConfigExport = Omit<
+  AgentConfig,
+  "id" | "createdAt" | "updatedAt" | "totalRuns" | "consecutiveFailures" | "lastRunAt" | "lastSessionId" | "enabled"
+>;
+
+export interface AgentExecution {
+  /** The session ID created for this execution */
+  sessionId: string;
+  /** The agent ID that triggered this */
+  agentId: string;
+  /** Trigger type that initiated this execution */
+  triggerType: "manual" | "webhook" | "schedule";
+  /** When the execution started */
+  startedAt: number;
+  /** When the execution completed */
+  completedAt?: number;
+  /** Whether the execution succeeded */
+  success?: boolean;
+  /** Error message if it failed */
+  error?: string;
+}

package/server/ai-validation-settings.ts

@@ -0,0 +1,37 @@
+import { getSettings } from "./settings-manager.js";
+import { hasInternalAI } from "./internal-ai.js";
+import type { SessionState } from "./session-types.js";
+
+export interface EffectiveAiValidationSettings {
+  enabled: boolean;
+  autoApprove: boolean;
+  autoDeny: boolean;
+  /** @deprecated Use hasInternalAI() instead. Kept for backward compat in ws-bridge checks. */
+  anthropicApiKey: string;
+}
+
+/**
+ * Resolve effective AI validation settings for a session.
+ * Session-level overrides take priority; falls back to global settings.
+ */
+export function getEffectiveAiValidation(
+  sessionState: SessionState,
+): EffectiveAiValidationSettings {
+  const global = getSettings();
+  return {
+    enabled:
+      sessionState.aiValidationEnabled != null
+        ? sessionState.aiValidationEnabled
+        : global.aiValidationEnabled,
+    autoApprove:
+      sessionState.aiValidationAutoApprove != null
+        ? sessionState.aiValidationAutoApprove
+        : global.aiValidationAutoApprove,
+    autoDeny:
+      sessionState.aiValidationAutoDeny != null
+        ? sessionState.aiValidationAutoDeny
+        : global.aiValidationAutoDeny,
+    // For backward compat: return a truthy string if any AI provider is available
+    anthropicApiKey: hasInternalAI() ? "configured" : "",
+  };
+}

package/server/ai-validator.ts

@@ -0,0 +1,181 @@
+import { callInternalAI } from "./internal-ai.js";
+
+const AI_TIMEOUT_MS = 5_000;
+
+export type AiVerdict = "safe" | "dangerous" | "uncertain";
+
+export interface AiValidationResult {
+  verdict: AiVerdict;
+  reason: string;
+  ruleBasedOnly: boolean;
+}
+
+// Tools that are always safe (read-only, no side effects)
+const SAFE_TOOLS = new Set(["Read", "Glob", "Grep", "Task"]);
+
+// Tools that should always be shown to the user (interactive)
+const ALWAYS_MANUAL_TOOLS = new Set(["AskUserQuestion", "ExitPlanMode"]);
+
+// Dangerous patterns for Bash commands
+const DANGEROUS_BASH_PATTERNS: Array<{ pattern: RegExp; reason: string }> = [
+  { pattern: /\brm\s+(-\w*r\w*\s+(-\w*f\w*\s+)?|(-\w*f\w*\s+)?-\w*r\w*\s+)[/~.]/, reason: "Recursive delete of root, home, or current directory" },
+  { pattern: /\|\s*(ba)?sh\b/, reason: "Piping content to shell execution" },
+  { pattern: /\|\s*bash\b/, reason: "Piping content to bash" },
+  { pattern: /\bcurl\b.*\|\s*(ba)?sh/, reason: "Piping remote content to shell" },
+  { pattern: /\bwget\b.*\|\s*(ba)?sh/, reason: "Piping remote download to shell" },
+  { pattern: /^\s*sudo\b/, reason: "Privilege escalation with sudo" },
+  { pattern: /\bgit\s+push\s+.*(-f|--force)\b/, reason: "Force pushing to remote" },
+  { pattern: /\bgit\s+push\s+(-f|--force)\b/, reason: "Force pushing to remote" },
+  { pattern: /\bDROP\s+(DATABASE|TABLE)\b/i, reason: "Dropping database or table" },
+  { pattern: /\bTRUNCATE\s+TABLE\b/i, reason: "Truncating table" },
+  { pattern: /\bmkfs\b/, reason: "Formatting filesystem" },
+  { pattern: /\bdd\s+if=/, reason: "Direct disk write with dd" },
+  { pattern: /:\(\)\s*\{\s*:\|:&\s*\}\s*;?\s*:/, reason: "Fork bomb" },
+  { pattern: /\b(shutdown|reboot|init\s+0)\b/, reason: "System shutdown or reboot" },
+  { pattern: />\s*\/dev\/[hs]d[a-z]/, reason: "Writing to block device" },
+  { pattern: /\bchmod\s+777\b/, reason: "Setting overly permissive file permissions" },
+];
+
+// Sensitive file paths for Write/Edit tools
+const SENSITIVE_PATH_PATTERNS: Array<{ pattern: RegExp; reason: string }> = [
+  { pattern: /\/etc\/passwd\b/, reason: "Modifying system password file" },
+  { pattern: /\/etc\/shadow\b/, reason: "Modifying system shadow file" },
+  { pattern: /\/etc\/sudoers\b/, reason: "Modifying sudoers file" },
+  { pattern: /\.ssh\/authorized_keys\b/, reason: "Modifying SSH authorized keys" },
+  { pattern: /\.ssh\/id_[a-z]+\b/, reason: "Modifying SSH private keys" },
+];
+
+/**
+ * Rule-based pre-filter: returns a verdict without making any API call,
+ * or null if the tool call needs AI evaluation.
+ */
+export function ruleBasedFilter(
+  toolName: string,
+  input: Record<string, unknown>,
+): AiValidationResult | null {
+  // Always-safe read-only tools
+  if (SAFE_TOOLS.has(toolName)) {
+    return { verdict: "safe", reason: `${toolName} is a read-only tool`, ruleBasedOnly: true };
+  }
+
+  // Always-manual interactive tools
+  if (ALWAYS_MANUAL_TOOLS.has(toolName)) {
+    return { verdict: "uncertain", reason: "Interactive tool requires user input", ruleBasedOnly: true };
+  }
+
+  // Bash command analysis
+  if (toolName === "Bash" || toolName === "bash") {
+    const command = typeof input.command === "string" ? input.command : "";
+    for (const { pattern, reason } of DANGEROUS_BASH_PATTERNS) {
+      if (pattern.test(command)) {
+        return { verdict: "dangerous", reason, ruleBasedOnly: true };
+      }
+    }
+  }
+
+  // Write/Edit sensitive path analysis
+  if (toolName === "Write" || toolName === "Edit") {
+    const filePath = typeof input.file_path === "string"
+      ? input.file_path
+      : typeof input.path === "string"
+        ? input.path
+        : "";
+    for (const { pattern, reason } of SENSITIVE_PATH_PATTERNS) {
+      if (pattern.test(filePath)) {
+        return { verdict: "dangerous", reason, ruleBasedOnly: true };
+      }
+    }
+  }
+
+  // No rule matched — needs AI evaluation
+  return null;
+}
+
+const SYSTEM_PROMPT = `You are a security validator for a coding assistant. You evaluate tool calls and classify them as "safe", "dangerous", or "uncertain".
+
+Respond with exactly one JSON object on a single line:
+{"verdict": "safe"|"dangerous"|"uncertain", "reason": "brief explanation"}
+
+Rules:
+- "safe": The operation is clearly non-destructive (reading files, creating new files in project dirs, standard dev commands like npm install/test, git commit, running tests, writing code)
+- "dangerous": The operation could cause data loss, security issues, or system damage (deleting files recursively, modifying system files, running untrusted scripts, force-pushing, dropping databases, privilege escalation)
+- "uncertain": You cannot confidently determine safety (complex bash pipelines, unfamiliar tools, ambiguous file operations)
+
+Be conservative: when in doubt, say "uncertain" rather than "safe".`;
+
+/**
+ * Call the configured internal AI provider to evaluate a tool call.
+ */
+export async function aiEvaluate(
+  toolName: string,
+  input: Record<string, unknown>,
+  description?: string,
+): Promise<AiValidationResult> {
+  const inputStr = JSON.stringify(input, null, 0);
+  const truncatedInput = inputStr.length > 1000 ? inputStr.slice(0, 1000) + "..." : inputStr;
+  let userPrompt = `Tool: ${toolName}\nInput: ${truncatedInput}`;
+  if (description) {
+    userPrompt += `\nDescription: ${description}`;
+  }
+
+  const result = await callInternalAI({
+    systemPrompt: SYSTEM_PROMPT,
+    userPrompt,
+    maxTokens: 256,
+    temperature: 0,
+    timeoutMs: AI_TIMEOUT_MS,
+  });
+
+  if (!result.ok) {
+    console.warn(`[ai-validator] AI evaluation failed: ${result.error}`);
+    return { verdict: "uncertain", reason: result.error || "AI evaluation failed", ruleBasedOnly: false };
+  }
+
+  return parseAiResponse(result.text);
+}
+
+/**
+ * Parse the AI model's JSON response into a structured result.
+ */
+export function parseAiResponse(raw: string): AiValidationResult {
+  try {
+    // Try to extract JSON from the response (the model may include extra text)
+    const jsonMatch = raw.match(/\{[^}]*"verdict"\s*:\s*"[^"]*"[^}]*\}/);
+    if (!jsonMatch) {
+      return { verdict: "uncertain", reason: "Could not parse AI response", ruleBasedOnly: false };
+    }
+
+    const parsed = JSON.parse(jsonMatch[0]) as { verdict?: string; reason?: string };
+
+    if (parsed.verdict === "safe" || parsed.verdict === "dangerous" || parsed.verdict === "uncertain") {
+      return {
+        verdict: parsed.verdict,
+        reason: typeof parsed.reason === "string" ? parsed.reason : "No reason provided",
+        ruleBasedOnly: false,
+      };
+    }
+
+    return { verdict: "uncertain", reason: "Invalid AI verdict value", ruleBasedOnly: false };
+  } catch {
+    return { verdict: "uncertain", reason: "Failed to parse AI response JSON", ruleBasedOnly: false };
+  }
+}
+
+/**
+ * Main entry point: validate a permission request using rule-based filter first,
+ * then AI if needed.
+ */
+export async function validatePermission(
+  toolName: string,
+  input: Record<string, unknown>,
+  description?: string,
+): Promise<AiValidationResult> {
+  // Step 1: Try rule-based filter (instant, no API call)
+  const ruleResult = ruleBasedFilter(toolName, input);
+  if (ruleResult) {
+    return ruleResult;
+  }
+
+  // Step 2: Call AI for evaluation
+  return aiEvaluate(toolName, input, description);
+}

package/server/anthropic-provider-migration.ts

@@ -0,0 +1,48 @@
+// Anthropic API Key Provider Migration
+// One-time migration: moves the legacy anthropicApiKey from settings.json
+// into the provider system (providers.json) under the "anthropic" provider.
+// This runs on server startup to handle the transition from legacy settings
+// to the unified provider management system.
+
+import { getSettings, updateSettings } from "./settings-manager.js";
+import { getProviderConfig, upsertProviderConfig } from "./provider-manager.js";
+
+/** Migrate legacy Anthropic API key from settings to the provider system.
+ *  This is a one-time operation: once the key is moved, the legacy field is cleared. */
+export function migrateAnthropicApiKeyToProvider(): void {
+  const settings = getSettings();
+
+  // Nothing to migrate if no legacy key
+  const legacyKey = settings.anthropicApiKey?.trim();
+  if (!legacyKey) return;
+
+  // Check if anthropic provider already has a key configured
+  const existing = getProviderConfig("anthropic");
+  if (existing && existing.envValues.ANTHROPIC_API_KEY?.trim()) {
+    // Provider already configured — just clear the legacy field
+    console.log(
+      "[anthropic-migration] Provider already configured, clearing legacy settings field.",
+    );
+    updateSettings({ anthropicApiKey: "" });
+    return;
+  }
+
+  // Migrate key into provider system
+  const model = settings.anthropicModel?.trim() || "";
+  upsertProviderConfig("anthropic", {
+    enabled: true,
+    envValues: { ANTHROPIC_API_KEY: legacyKey },
+    ...(model ? { customModel: model } : {}),
+  });
+
+  // Also set as internalAiProvider if not already set
+  if (!settings.internalAiProvider?.trim()) {
+    updateSettings({ anthropicApiKey: "", internalAiProvider: "anthropic" });
+  } else {
+    updateSettings({ anthropicApiKey: "" });
+  }
+
+  console.log(
+    "[anthropic-migration] Migrated legacy Anthropic API key to provider system.",
+  );
+}

package/server/assistant-store.ts

@@ -0,0 +1,272 @@
+// ─── Assistant Store ──────────────────────────────────────────────────────────
+// Persistent storage for personal assistant features: todos, notes, reminders.
+// All data stored as JSON in ~/.heyhank/assistant/
+
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { HEYHANK_HOME } from "./paths.js";
+
+const ASSISTANT_DIR = join(HEYHANK_HOME, "assistant");
+
+function ensureDir(): void {
+  if (!existsSync(ASSISTANT_DIR)) {
+    mkdirSync(ASSISTANT_DIR, { recursive: true });
+  }
+}
+
+function readJson<T>(filename: string, fallback: T): T {
+  ensureDir();
+  const path = join(ASSISTANT_DIR, filename);
+  try {
+    if (existsSync(path)) {
+      return JSON.parse(readFileSync(path, "utf-8")) as T;
+    }
+  } catch {}
+  return fallback;
+}
+
+function writeJson(filename: string, data: unknown): void {
+  ensureDir();
+  writeFileSync(join(ASSISTANT_DIR, filename), JSON.stringify(data, null, 2), "utf-8");
+}
+
+// ─── Todos ────────────────────────────────────────────────────────────────────
+
+export interface Todo {
+  id: string;
+  text: string;
+  priority: "high" | "medium" | "low";
+  done: boolean;
+  createdAt: string;
+  doneAt?: string;
+  category?: string;
+}
+
+function genId(): string {
+  return Date.now().toString(36) + Math.random().toString(36).slice(2, 6);
+}
+
+export function listTodos(filter?: { done?: boolean; priority?: string; category?: string }): Todo[] {
+  const todos = readJson<Todo[]>("todos.json", []);
+  return todos.filter((t) => {
+    if (filter?.done !== undefined && t.done !== filter.done) return false;
+    if (filter?.priority && t.priority !== filter.priority) return false;
+    if (filter?.category && t.category !== filter.category) return false;
+    return true;
+  });
+}
+
+export function addTodo(text: string, priority: string = "medium", category?: string): Todo {
+  const todos = readJson<Todo[]>("todos.json", []);
+  const todo: Todo = {
+    id: genId(),
+    text,
+    priority: (["high", "medium", "low"].includes(priority) ? priority : "medium") as Todo["priority"],
+    done: false,
+    createdAt: new Date().toISOString(),
+    category,
+  };
+  todos.push(todo);
+  writeJson("todos.json", todos);
+  return todo;
+}
+
+export function completeTodo(id: string): Todo | null {
+  const todos = readJson<Todo[]>("todos.json", []);
+  const todo = todos.find((t) => t.id === id);
+  if (!todo) return null;
+  todo.done = true;
+  todo.doneAt = new Date().toISOString();
+  writeJson("todos.json", todos);
+  return todo;
+}
+
+export function deleteTodo(id: string): boolean {
+  const todos = readJson<Todo[]>("todos.json", []);
+  const idx = todos.findIndex((t) => t.id === id);
+  if (idx === -1) return false;
+  todos.splice(idx, 1);
+  writeJson("todos.json", todos);
+  return true;
+}
+
+export function updateTodo(id: string, patch: { text?: string; priority?: string; category?: string }): Todo | null {
+  const todos = readJson<Todo[]>("todos.json", []);
+  const todo = todos.find((t) => t.id === id);
+  if (!todo) return null;
+  if (patch.text) todo.text = patch.text;
+  if (patch.priority && ["high", "medium", "low"].includes(patch.priority)) {
+    todo.priority = patch.priority as Todo["priority"];
+  }
+  if (patch.category !== undefined) todo.category = patch.category;
+  writeJson("todos.json", todos);
+  return todo;
+}
+
+// ─── Notes ────────────────────────────────────────────────────────────────────
+
+export interface Note {
+  id: string;
+  title: string;
+  content: string;
+  tags: string[];
+  createdAt: string;
+  updatedAt: string;
+}
+
+export function listNotes(search?: string): Note[] {
+  const notes = readJson<Note[]>("notes.json", []);
+  if (!search) return notes;
+  const q = search.toLowerCase();
+  return notes.filter((n) =>
+    n.title.toLowerCase().includes(q) ||
+    n.content.toLowerCase().includes(q) ||
+    n.tags.some((t) => t.toLowerCase().includes(q))
+  );
+}
+
+export function addNote(title: string, content: string, tags: string[] = []): Note {
+  const notes = readJson<Note[]>("notes.json", []);
+  const note: Note = {
+    id: genId(),
+    title,
+    content,
+    tags,
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+  };
+  notes.push(note);
+  writeJson("notes.json", notes);
+  return note;
+}
+
+export function getNote(id: string): Note | null {
+  const notes = readJson<Note[]>("notes.json", []);
+  return notes.find((n) => n.id === id) || null;
+}
+
+export function updateNote(id: string, patch: { title?: string; content?: string; tags?: string[] }): Note | null {
+  const notes = readJson<Note[]>("notes.json", []);
+  const note = notes.find((n) => n.id === id);
+  if (!note) return null;
+  if (patch.title) note.title = patch.title;
+  if (patch.content) note.content = patch.content;
+  if (patch.tags) note.tags = patch.tags;
+  note.updatedAt = new Date().toISOString();
+  writeJson("notes.json", notes);
+  return note;
+}
+
+export function deleteNote(id: string): boolean {
+  const notes = readJson<Note[]>("notes.json", []);
+  const idx = notes.findIndex((n) => n.id === id);
+  if (idx === -1) return false;
+  notes.splice(idx, 1);
+  writeJson("notes.json", notes);
+  return true;
+}
+
+// ─── Reminders ────────────────────────────────────────────────────────────────
+
+export interface Reminder {
+  id: string;
+  text: string;
+  triggerAt: string; // ISO datetime
+  fired: boolean;
+  createdAt: string;
+}
+
+export function listReminders(includeFired = false): Reminder[] {
+  const reminders = readJson<Reminder[]>("reminders.json", []);
+  return includeFired ? reminders : reminders.filter((r) => !r.fired);
+}
+
+export function addReminder(text: string, triggerAt: string): Reminder {
+  const reminders = readJson<Reminder[]>("reminders.json", []);
+  const reminder: Reminder = {
+    id: genId(),
+    text,
+    triggerAt,
+    fired: false,
+    createdAt: new Date().toISOString(),
+  };
+  reminders.push(reminder);
+  writeJson("reminders.json", reminders);
+  return reminder;
+}
+
+export function fireReminder(id: string): Reminder | null {
+  const reminders = readJson<Reminder[]>("reminders.json", []);
+  const r = reminders.find((rem) => rem.id === id);
+  if (!r) return null;
+  r.fired = true;
+  writeJson("reminders.json", reminders);
+  return r;
+}
+
+export function deleteReminder(id: string): boolean {
+  const reminders = readJson<Reminder[]>("reminders.json", []);
+  const idx = reminders.findIndex((r) => r.id === id);
+  if (idx === -1) return false;
+  reminders.splice(idx, 1);
+  writeJson("reminders.json", reminders);
+  return true;
+}
+
+/** Get all reminders that should have fired by now */
+export function getDueReminders(): Reminder[] {
+  const now = new Date().toISOString();
+  const reminders = readJson<Reminder[]>("reminders.json", []);
+  return reminders.filter((r) => !r.fired && r.triggerAt <= now);
+}
+
+// ─── Gemini Conversations ──────��─────────────────────────────────────────────
+
+export interface GeminiConversation {
+  id: string;
+  title: string;
+  messages: Array<{ role: "user" | "gemini" | "system"; text: string; ts: number }>;
+  createdAt: string;
+  duration?: number; // seconds
+}
+
+export function listGeminiConversations(): GeminiConversation[] {
+  return readJson<GeminiConversation[]>("gemini-conversations.json", [])
+    .sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+}
+
+export function saveGeminiConversation(
+  messages: Array<{ role: "user" | "gemini" | "system"; text: string; ts: number }>,
+  duration?: number,
+): GeminiConversation {
+  const convos = readJson<GeminiConversation[]>("gemini-conversations.json", []);
+  // Generate title from first user message
+  const firstUser = messages.find((m) => m.role === "user");
+  const title = firstUser ? firstUser.text.slice(0, 80) : "Gemini conversation";
+  const convo: GeminiConversation = {
+    id: genId(),
+    title,
+    messages: messages.filter((m) => m.role !== "system"),
+    createdAt: new Date().toISOString(),
+    duration,
+  };
+  convos.push(convo);
+  // Keep last 100 conversations
+  if (convos.length > 100) convos.splice(0, convos.length - 100);
+  writeJson("gemini-conversations.json", convos);
+  return convo;
+}
+
+export function getGeminiConversation(id: string): GeminiConversation | null {
+  const convos = readJson<GeminiConversation[]>("gemini-conversations.json", []);
+  return convos.find((c) => c.id === id) || null;
+}
+
+export function deleteGeminiConversation(id: string): boolean {
+  const convos = readJson<GeminiConversation[]>("gemini-conversations.json", []);
+  const idx = convos.findIndex((c) => c.id === id);
+  if (idx === -1) return false;
+  convos.splice(idx, 1);
+  writeJson("gemini-conversations.json", convos);
+  return true;
+}