heyhank 0.1.0 → 0.2.0

package/server/telephony/telephony-store.ts

@@ -1,7 +1,8 @@
 // ─── Telephony Store ──────────────────────────────────────────────────────────
 // File-based persistence for telephony settings and call history.
 
-import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, readdirSync } from "node:fs";
+import { atomicWriteFileSync } from "../fs-utils.js";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import type { TelephonySettings, CallState, TelephonyContact } from "./call-types.js";
@@ -31,7 +32,7 @@ export function getSettings(): TelephonySettings {
 
 export function saveSettings(settings: TelephonySettings): void {
   ensureDirs();
-  writeFileSync(SETTINGS_FILE, JSON.stringify(settings, null, 2), "utf-8");
+  atomicWriteFileSync(SETTINGS_FILE, JSON.stringify(settings, null, 2));
 }
 
 // ─── Contacts ───────────────────────────────────────────────────────────────
@@ -85,7 +86,7 @@ export function resolveContactByName(nameQuery: string): TelephonyContact | null
 export function saveCall(call: CallState): void {
   ensureDirs();
   const file = join(CALLS_DIR, `${call.id}.json`);
-  writeFileSync(file, JSON.stringify(call, null, 2), "utf-8");
+  atomicWriteFileSync(file, JSON.stringify(call, null, 2));
 }
 
 export function getCall(callId: string): CallState | null {
@@ -102,17 +103,17 @@ export function listCalls(limit = 50): CallState[] {
   ensureDirs();
   try {
     const files = readdirSync(CALLS_DIR)
-      .filter((f) => f.endsWith(".json"))
-      .sort()
-      .reverse()
-      .slice(0, limit);
-    return files.map((f) => {
+      .filter((f) => f.endsWith(".json"));
+    // Parse all calls, sort by startedAt descending (newest first), then apply limit
+    const calls = files.map((f) => {
       try {
         return JSON.parse(readFileSync(join(CALLS_DIR, f), "utf-8")) as CallState;
       } catch {
         return null;
       }
     }).filter(Boolean) as CallState[];
+    calls.sort((a, b) => (b.startedAt || 0) - (a.startedAt || 0));
+    return calls.slice(0, limit);
   } catch {
     return [];
   }

package/server/url-validator.ts

@@ -0,0 +1,82 @@
+// ─── URL Validation ──────────────────────────────────────────────────────────
+// SSRF protection: reject baseUrl values that point to internal/private networks
+// unless they are known safe provider domains.
+
+const KNOWN_PROVIDER_HOSTS = new Set([
+  "api.openai.com",
+  "generativelanguage.googleapis.com",
+  "openrouter.ai",
+  "api.anthropic.com",
+  "api.together.xyz",
+  "api.groq.com",
+  "api.mistral.ai",
+  "api.deepseek.com",
+  "api.fireworks.ai",
+  "api.perplexity.ai",
+  "api.cohere.com",
+]);
+
+/**
+ * Check if a base URL is safe to make requests to.
+ * Rejects URLs pointing to internal/private IP ranges unless the host
+ * is a known LLM provider domain or localhost (for Ollama).
+ */
+export function isAllowedBaseUrl(url: string): boolean {
+  let parsed: URL;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return false;
+  }
+
+  const hostname = parsed.hostname.toLowerCase();
+
+  // Allow known provider domains
+  if (KNOWN_PROVIDER_HOSTS.has(hostname)) return true;
+
+  // Allow localhost / 127.0.0.1 (for Ollama and local services)
+  if (hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1") return true;
+
+  // Allow Tailscale domains (.ts.net)
+  if (hostname.endsWith(".ts.net")) return true;
+
+  // Block internal/private IP ranges
+  if (isPrivateHostname(hostname)) return false;
+
+  // Allow all other public hostnames
+  return true;
+}
+
+function isPrivateHostname(hostname: string): boolean {
+  // IPv6 loopback
+  if (hostname === "[::1]" || hostname === "::1") return true;
+
+  // Check if it looks like an IP address
+  const ipv4Match = hostname.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
+  if (ipv4Match) {
+    const [, a, b] = ipv4Match.map(Number);
+    // 127.x.x.x (loopback — already allowed above for localhost, but block raw IPs other than 127.0.0.1)
+    if (a === 127) return true;
+    // 10.x.x.x (private)
+    if (a === 10) return true;
+    // 172.16.0.0 - 172.31.255.255 (private)
+    if (a === 172 && b >= 16 && b <= 31) return true;
+    // 192.168.x.x (private)
+    if (a === 192 && b === 168) return true;
+    // 169.254.x.x (link-local)
+    if (a === 169 && b === 254) return true;
+    // 0.0.0.0
+    if (a === 0) return true;
+  }
+
+  // IPv6 private ranges (simplified check for common patterns)
+  if (hostname.startsWith("[")) {
+    const inner = hostname.slice(1, -1).toLowerCase();
+    if (inner.startsWith("fc") || inner.startsWith("fd")) return true; // ULA
+    if (inner.startsWith("fe80")) return true; // link-local
+    if (inner === "::1") return true;
+    if (inner === "::") return true;
+  }
+
+  return false;
+}

package/server/vault-markdown.ts

@@ -0,0 +1,317 @@
+// ─── Vault Markdown Serialization ────────────────────────────────────────────
+// Pure functions to convert HeyHank data models to/from Markdown with YAML frontmatter.
+// Used by vault-store.ts for Obsidian-as-primary-store architecture.
+
+import type { Todo, Note, Reminder, GeminiConversation, Contact, ContactInteraction, Decision } from "./assistant-store.js";
+
+// ─── Frontmatter Parser ─────────────────────────────────────────────────────
+
+export function parseFrontmatter(md: string): { frontmatter: Record<string, string>; body: string } {
+  const match = md.match(/^---\n([\s\S]*?)\n---\n\n?([\s\S]*)$/);
+  if (!match) return { frontmatter: {}, body: md.trim() };
+  const fm: Record<string, string> = {};
+  for (const line of match[1].split("\n")) {
+    const idx = line.indexOf(": ");
+    if (idx > 0) fm[line.slice(0, idx).trim()] = line.slice(idx + 2).trim();
+  }
+  return { frontmatter: fm, body: match[2].trim() };
+}
+
+function buildFrontmatter(fields: Array<[string, string | undefined]>): string {
+  const lines: string[] = ["---"];
+  for (const [key, value] of fields) {
+    if (value !== undefined) lines.push(`${key}: ${value}`);
+  }
+  lines.push("---");
+  return lines.join("\n");
+}
+
+// ─── Todos ───────────────────────────────────────────────────────────────────
+
+export function todoToMarkdown(todo: Todo): string {
+  const fm = buildFrontmatter([
+    ["id", todo.id],
+    ["priority", todo.priority],
+    ["done", String(todo.done)],
+    ["category", todo.category],
+    ["delegatedTo", todo.delegatedTo],
+    ["dueDate", todo.dueDate],
+    ["followUpDate", todo.followUpDate],
+    ["project", todo.project],
+    ["createdAt", todo.createdAt],
+    ["doneAt", todo.doneAt],
+  ]);
+  return `${fm}\n\n${todo.text}\n`;
+}
+
+export function markdownToTodo(md: string): Todo {
+  const { frontmatter: fm, body } = parseFrontmatter(md);
+  return {
+    id: fm.id || "",
+    text: body,
+    priority: (["high", "medium", "low"].includes(fm.priority) ? fm.priority : "medium") as Todo["priority"],
+    done: fm.done === "true",
+    createdAt: fm.createdAt || "",
+    doneAt: fm.doneAt || undefined,
+    category: fm.category || undefined,
+    delegatedTo: fm.delegatedTo || undefined,
+    dueDate: fm.dueDate || undefined,
+    followUpDate: fm.followUpDate || undefined,
+    project: fm.project || undefined,
+  };
+}
+
+// ─── Notes ───────────────────────────────────────────────────────────────────
+
+export function noteToMarkdown(note: Note): string {
+  const fm = buildFrontmatter([
+    ["id", note.id],
+    ["createdAt", note.createdAt],
+    ["updatedAt", note.updatedAt],
+    ["tags", note.tags.length > 0 ? note.tags.join(", ") : undefined],
+  ]);
+  return `${fm}\n\n# ${note.title}\n\n${note.content}\n`;
+}
+
+export function markdownToNote(md: string): Note {
+  const { frontmatter: fm, body } = parseFrontmatter(md);
+  // Parse title from first heading, rest is content
+  const titleMatch = body.match(/^# (.+)\n\n?([\s\S]*)$/);
+  const title = titleMatch ? titleMatch[1].trim() : body.split("\n")[0];
+  const content = titleMatch ? titleMatch[2].trim() : "";
+  const tags = fm.tags ? fm.tags.split(",").map((t) => t.trim()).filter(Boolean) : [];
+  return {
+    id: fm.id || "",
+    title,
+    content,
+    tags,
+    createdAt: fm.createdAt || "",
+    updatedAt: fm.updatedAt || "",
+  };
+}
+
+// ─── Reminders ───────────────────────────────────────────────────────────────
+
+export function reminderToMarkdown(reminder: Reminder): string {
+  const fm = buildFrontmatter([
+    ["id", reminder.id],
+    ["triggerAt", reminder.triggerAt],
+    ["fired", String(reminder.fired)],
+    ["createdAt", reminder.createdAt],
+    ["calendarEventUid", reminder.calendarEventUid],
+  ]);
+  return `${fm}\n\n${reminder.text}\n`;
+}
+
+export function markdownToReminder(md: string): Reminder {
+  const { frontmatter: fm, body } = parseFrontmatter(md);
+  const reminder: Reminder = {
+    id: fm.id || "",
+    text: body,
+    triggerAt: fm.triggerAt || "",
+    fired: fm.fired === "true",
+    createdAt: fm.createdAt || "",
+  };
+  if (fm.calendarEventUid) reminder.calendarEventUid = fm.calendarEventUid;
+  return reminder;
+}
+
+// ─── Conversations ───────────────────────────────────────────────────────────
+
+const ROLE_LABELS: Record<string, string> = {
+  user: "You",
+  gemini: "Hank",
+  system: "System",
+};
+
+export function conversationToMarkdown(convo: GeminiConversation): string {
+  const fm = buildFrontmatter([
+    ["id", convo.id],
+    ["title", convo.title],
+    ["createdAt", convo.createdAt],
+    ["duration", convo.duration !== undefined ? String(convo.duration) : undefined],
+  ]);
+  const msgLines = convo.messages.map((m) => {
+    const label = ROLE_LABELS[m.role] || m.role;
+    return `**${label}**: ${m.text}`;
+  });
+  return `${fm}\n\n${msgLines.join("\n\n")}\n`;
+}
+
+export function markdownToConversation(md: string): GeminiConversation {
+  const { frontmatter: fm, body } = parseFrontmatter(md);
+  // Parse messages from body: **Label**: text
+  const messages: Array<{ role: "user" | "gemini" | "system"; text: string; ts: number }> = [];
+  const labelToRole: Record<string, "user" | "gemini" | "system"> = {
+    You: "user",
+    Hank: "gemini",
+    System: "system",
+  };
+  // Split on message boundaries: lines starting with **Label**:
+  const parts = body.split(/\n\n(?=\*\*(?:You|Hank|System)\*\*:)/);
+  for (const part of parts) {
+    const msgMatch = part.match(/^\*\*(\w+)\*\*:\s*([\s\S]*)$/);
+    if (msgMatch) {
+      const role = labelToRole[msgMatch[1]] || "user";
+      messages.push({ role, text: msgMatch[2].trim(), ts: 0 });
+    }
+  }
+  return {
+    id: fm.id || "",
+    title: fm.title || "",
+    messages,
+    createdAt: fm.createdAt || "",
+    duration: fm.duration ? Number(fm.duration) : undefined,
+  };
+}
+
+// ─── Memories ────────────────────────────────────────────────────────────────
+
+export interface Memory {
+  id: string;
+  content: string;
+  createdAt: string;
+  updatedAt: string;
+  category?: string;
+  source?: string;
+}
+
+export function memoryToMarkdown(memory: Memory): string {
+  const fm = buildFrontmatter([
+    ["id", memory.id],
+    ["createdAt", memory.createdAt],
+    ["updatedAt", memory.updatedAt],
+    ["category", memory.category],
+    ["source", memory.source],
+  ]);
+  return `${fm}\n\n${memory.content}\n`;
+}
+
+export function markdownToMemory(md: string): Memory {
+  const { frontmatter: fm, body } = parseFrontmatter(md);
+  return {
+    id: fm.id || "",
+    content: body,
+    createdAt: fm.createdAt || "",
+    updatedAt: fm.updatedAt || "",
+    category: fm.category || undefined,
+    source: fm.source || undefined,
+  };
+}
+
+// ─── Contacts ───────────────────────────────────────────────────────────────
+
+export function contactToMarkdown(c: Contact): string {
+  const fm = buildFrontmatter([
+    ["id", c.id],
+    ["name", c.name],
+    ["company", c.company],
+    ["email", c.email],
+    ["phone", c.phone],
+    ["tags", c.tags.length > 0 ? c.tags.join(", ") : undefined],
+    ["lastContactDate", c.lastContactDate],
+    ["createdAt", c.createdAt],
+    ["updatedAt", c.updatedAt],
+  ]);
+  const bodyParts: string[] = [];
+  bodyParts.push(`## Notes\n${c.notes || ""}`);
+  bodyParts.push("\n## Interactions");
+  for (const i of c.interactions) {
+    bodyParts.push(`- ${i.date.slice(0, 10)} [${i.type}] ${i.summary}`);
+  }
+  return `${fm}\n\n${bodyParts.join("\n")}\n`;
+}
+
+export function markdownToContact(md: string): Contact {
+  const { frontmatter: fm, body } = parseFrontmatter(md);
+  const tags = fm.tags ? fm.tags.split(",").map((t) => t.trim()).filter(Boolean) : [];
+  // Parse notes: between ## Notes and ## Interactions
+  const notesMatch = body.match(/## Notes\n([\s\S]*?)(?=\n## Interactions|$)/);
+  const notes = notesMatch ? notesMatch[1].trim() : "";
+  // Parse interactions
+  const interactions: ContactInteraction[] = [];
+  const interSection = body.match(/## Interactions\n([\s\S]*)$/);
+  if (interSection) {
+    const lines = interSection[1].trim().split("\n");
+    for (const line of lines) {
+      const m = line.match(/^- (\S+) \[(\w+)\] (.+)$/);
+      if (m) {
+        interactions.push({ date: m[1], type: m[2] as ContactInteraction["type"], summary: m[3] });
+      }
+    }
+  }
+  return {
+    id: fm.id || "",
+    name: fm.name || "",
+    company: fm.company || undefined,
+    email: fm.email || undefined,
+    phone: fm.phone || undefined,
+    notes: notes || undefined,
+    tags,
+    lastContactDate: fm.lastContactDate || undefined,
+    interactions,
+    createdAt: fm.createdAt || "",
+    updatedAt: fm.updatedAt || "",
+  };
+}
+
+// ─── Decisions ──────────────────────────────────────────────────────────────
+
+export function decisionToMarkdown(d: Decision): string {
+  const fm = buildFrontmatter([
+    ["id", d.id],
+    ["tags", d.tags.length > 0 ? d.tags.join(", ") : undefined],
+    ["alternatives", d.alternatives.length > 0 ? d.alternatives.join(", ") : undefined],
+    ["createdAt", d.createdAt],
+  ]);
+  return `${fm}\n\n# ${d.title}\n\n## Context\n${d.context}\n\n## Decision\n${d.decision}\n\n## Reasoning\n${d.reasoning}\n`;
+}
+
+export function markdownToDecision(md: string): Decision {
+  const { frontmatter: fm, body } = parseFrontmatter(md);
+  const tags = fm.tags ? fm.tags.split(",").map((t) => t.trim()).filter(Boolean) : [];
+  const alternatives = fm.alternatives ? fm.alternatives.split(",").map((a) => a.trim()).filter(Boolean) : [];
+  const titleMatch = body.match(/^# (.+)/);
+  const title = titleMatch ? titleMatch[1].trim() : "";
+  const contextMatch = body.match(/## Context\n([\s\S]*?)(?=\n## Decision)/);
+  const context = contextMatch ? contextMatch[1].trim() : "";
+  const decisionMatch = body.match(/## Decision\n([\s\S]*?)(?=\n## Reasoning)/);
+  const decision = decisionMatch ? decisionMatch[1].trim() : "";
+  const reasoningMatch = body.match(/## Reasoning\n([\s\S]*)$/);
+  const reasoning = reasoningMatch ? reasoningMatch[1].trim() : "";
+  return { id: fm.id || "", title, context, decision, alternatives, reasoning, tags, createdAt: fm.createdAt || "" };
+}
+
+// ─── Calls (export only) ────────────────────────────────────────────────────
+
+export interface CallData {
+  id: string;
+  phone: string;
+  status: string;
+  durationSeconds: number;
+  startedAt: number;
+  transcript?: Array<{ speaker: string; text: string; ts: number }>;
+  summary?: string | null;
+}
+
+export function callToMarkdown(call: CallData): string {
+  const fm = buildFrontmatter([
+    ["id", call.id],
+    ["phone", call.phone],
+    ["status", call.status],
+    ["durationSeconds", String(call.durationSeconds)],
+    ["startedAt", new Date(call.startedAt).toISOString()],
+  ]);
+  const bodyParts: string[] = [];
+  if (call.transcript && call.transcript.length > 0) {
+    bodyParts.push("## Transcript\n");
+    for (const entry of call.transcript) {
+      bodyParts.push(`**${entry.speaker}**: ${entry.text}`);
+    }
+  }
+  if (call.summary) {
+    bodyParts.push("\n## Summary\n");
+    bodyParts.push(call.summary);
+  }
+  return `${fm}\n\n${bodyParts.join("\n")}\n`;
+}

package/server/vault-migration.ts

@@ -0,0 +1,121 @@
+// ─── Vault Migration ─────────────────────────────────────────────────────────
+// One-time migration of JSON-based assistant data to Obsidian vault (.md files).
+// Reads directly from ~/.heyhank/assistant/*.json (bypassing assistant-store to
+// avoid vault delegation) and writes .md files using vault-markdown serializers.
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { HEYHANK_HOME } from "./paths.js";
+import { getSettings } from "./settings-manager.js";
+import * as md from "./vault-markdown.js";
+import type { Todo, Note, Reminder, GeminiConversation } from "./assistant-store.js";
+
+const ASSISTANT_DIR = join(HEYHANK_HOME, "assistant");
+const MIGRATION_MARKER = join(ASSISTANT_DIR, ".migrated-to-vault");
+
+/** Read a JSON file directly from the assistant directory (bypasses vault delegation). */
+function readJsonFile<T>(filename: string, fallback: T): T {
+  const filepath = join(ASSISTANT_DIR, filename);
+  try {
+    if (!existsSync(filepath)) return fallback;
+    return JSON.parse(readFileSync(filepath, "utf-8")) as T;
+  } catch {
+    return fallback;
+  }
+}
+
+function ensureDir(dir: string): void {
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+}
+
+/** Write a file only if it doesn't already exist (idempotent migration). */
+function writeIfNotExists(filepath: string, content: string): void {
+  if (!existsSync(filepath)) writeFileSync(filepath, content, "utf-8");
+}
+
+/**
+ * Migrate all JSON-based assistant data to the Obsidian vault.
+ * This is idempotent: it writes a marker file after completion and
+ * skips if the marker already exists. Individual files are also
+ * written only if they don't already exist.
+ */
+export function migrateToVault(): void {
+  const vaultPath = getSettings().obsidianVaultPath;
+  if (!vaultPath) return;
+  if (existsSync(MIGRATION_MARKER)) return;
+
+  console.log("[vault-migration] Starting migration to Obsidian vault...");
+
+  const vaultBase = join(vaultPath, "HeyHank");
+
+  // ─── Todos ──────────────────────────────────────────────────────────────────
+  try {
+    const todos = readJsonFile<Todo[]>("todos.json", []);
+    if (todos.length > 0) {
+      const todosDir = join(vaultBase, "Todos");
+      ensureDir(todosDir);
+      for (const todo of todos) {
+        writeIfNotExists(join(todosDir, `todo-${todo.id}.md`), md.todoToMarkdown(todo));
+      }
+      console.log(`[vault-migration] Migrated ${todos.length} todos`);
+    }
+  } catch (e) {
+    console.warn("[vault-migration] Todos:", e);
+  }
+
+  // ─── Notes ──────────────────────────────────────────────────────────────────
+  try {
+    const notes = readJsonFile<Note[]>("notes.json", []);
+    if (notes.length > 0) {
+      const notesDir = join(vaultBase, "Notes");
+      ensureDir(notesDir);
+      for (const note of notes) {
+        writeIfNotExists(join(notesDir, `note-${note.id}.md`), md.noteToMarkdown(note));
+      }
+      console.log(`[vault-migration] Migrated ${notes.length} notes`);
+    }
+  } catch (e) {
+    console.warn("[vault-migration] Notes:", e);
+  }
+
+  // ─── Reminders ──────────────────────────────────────────────────────────────
+  try {
+    const reminders = readJsonFile<Reminder[]>("reminders.json", []);
+    if (reminders.length > 0) {
+      const remindersDir = join(vaultBase, "Reminders");
+      ensureDir(remindersDir);
+      for (const reminder of reminders) {
+        writeIfNotExists(
+          join(remindersDir, `reminder-${reminder.id}.md`),
+          md.reminderToMarkdown(reminder),
+        );
+      }
+      console.log(`[vault-migration] Migrated ${reminders.length} reminders`);
+    }
+  } catch (e) {
+    console.warn("[vault-migration] Reminders:", e);
+  }
+
+  // ─── Conversations ──────────────────────────────────────────────────────────
+  try {
+    const convos = readJsonFile<GeminiConversation[]>("gemini-conversations.json", []);
+    if (convos.length > 0) {
+      const convosDir = join(vaultBase, "Conversations");
+      ensureDir(convosDir);
+      for (const convo of convos) {
+        writeIfNotExists(
+          join(convosDir, `convo-${convo.id}.md`),
+          md.conversationToMarkdown(convo),
+        );
+      }
+      console.log(`[vault-migration] Migrated ${convos.length} conversations`);
+    }
+  } catch (e) {
+    console.warn("[vault-migration] Conversations:", e);
+  }
+
+  // ─── Mark complete ──────────────────────────────────────────────────────────
+  ensureDir(ASSISTANT_DIR);
+  writeFileSync(MIGRATION_MARKER, new Date().toISOString(), "utf-8");
+  console.log("[vault-migration] Migration complete!");
+}