heyhank 0.1.0 → 0.3.0

package/server/cron-store.ts

@@ -2,13 +2,13 @@ import {
   mkdirSync,
   readdirSync,
   readFileSync,
-  writeFileSync,
   unlinkSync,
   existsSync,
 } from "node:fs";
 import { join } from "node:path";
 import type { CronJob, CronJobCreateInput } from "./cron-types.js";
 import { HEYHANK_HOME } from "./paths.js";
+import { atomicWriteFileSync } from "./fs-utils.js";
 
 // ─── Paths ──────────────────────────────────────────────────────────────────
 
@@ -92,7 +92,7 @@ export function createJob(data: CronJobCreateInput): CronJob {
     consecutiveFailures: 0,
     totalRuns: 0,
   };
-  writeFileSync(filePath(id), JSON.stringify(job, null, 2), "utf-8");
+  atomicWriteFileSync(filePath(id), JSON.stringify(job, null, 2));
   return job;
 }
 
@@ -132,7 +132,7 @@ export function updateJob(
     }
   }
 
-  writeFileSync(filePath(newId), JSON.stringify(job, null, 2), "utf-8");
+  atomicWriteFileSync(filePath(newId), JSON.stringify(job, null, 2));
   return job;
 }
 

package/server/embedding-service.ts

@@ -0,0 +1,49 @@
+// ─── Embedding Service ──────────────────────────────────────────────────────
+// Singleton: lazy-loads transformers.js pipeline for local embeddings.
+// Model: Xenova/multilingual-e5-small (384 dims, ~118MB quantized, 100 languages)
+
+type Pipeline = {
+  (texts: string[], options?: { pooling?: string; normalize?: boolean }): Promise<{ tolist(): number[][] }>;
+};
+
+let pipeline: Pipeline | null = null;
+let initPromise: Promise<Pipeline> | null = null;
+
+async function ensureModel(): Promise<Pipeline> {
+  if (pipeline) return pipeline;
+  if (initPromise) return initPromise;
+
+  initPromise = (async () => {
+    console.log("[embedding] Loading multilingual-e5-small model (first run downloads ~118MB)...");
+    const { pipeline: createPipeline } = await import("@huggingface/transformers");
+    const pipe = await createPipeline("feature-extraction", "Xenova/multilingual-e5-small", {
+      dtype: "q8",
+    });
+    pipeline = pipe as unknown as Pipeline;
+    console.log("[embedding] Model loaded successfully.");
+    return pipeline;
+  })();
+
+  initPromise.catch((err) => {
+    console.error("[embedding] Failed to load model:", err);
+    initPromise = null;
+  });
+
+  return initPromise;
+}
+
+/**
+ * Get embedding vector for text.
+ * @param text - The text to embed
+ * @param prefix - e5-specific prefix: "passage: " for documents, "query: " for search queries
+ */
+export async function getEmbedding(text: string, prefix = "passage: "): Promise<number[]> {
+  const pipe = await ensureModel();
+  const result = await pipe([`${prefix}${text}`], { pooling: "mean", normalize: true });
+  return result.tolist()[0];
+}
+
+/** Check if the embedding model is loaded and ready */
+export function isEmbeddingReady(): boolean {
+  return pipeline !== null;
+}

package/server/event-bus-types.ts

@@ -62,6 +62,19 @@ export interface HeyHankEventMap {
   /** A result (turn completion) was processed and broadcast to browsers. */
   "message:result": { sessionId: string; message: BrowserIncomingMessage };
 
+  // ── Telephony ──────────────────────────────────────────────────────
+
+  /** A phone call has just ended; a notification has been persisted for HankChat. */
+  "telephony:call-ended": {
+    notificationId: string;
+    callId: string;
+    phone: string;
+    contactName: string | null;
+    direction: "inbound" | "outbound";
+    durationSeconds: number;
+    summary: string | null;
+  };
+
   // ── Federation ──────────────────────────────────────────────────────
 
   /** A remote federation node connected. */

package/server/execution-store.ts

@@ -2,7 +2,7 @@
 // Persists AgentExecution records to disk as JSONL (one file per day).
 // Used by the Runs view to display execution history across server restarts.
 
-import { mkdirSync, appendFileSync, readdirSync, readFileSync } from "node:fs";
+import { mkdirSync, appendFileSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
 import type { AgentExecution } from "./agent-types.js";
@@ -72,6 +72,59 @@ export class ExecutionStore {
     }
   }
 
+  /**
+   * Permanently delete executions by sessionId. Rewrites any daily JSONL file
+   * that contained matching records and removes them from the in-memory cache.
+   * Returns the number of records that were removed (counts cache hits — the
+   * on-disk file may contain extra historical lines for the same sessionId
+   * which are all stripped too).
+   */
+  deleteBySessionIds(sessionIds: string[]): number {
+    if (sessionIds.length === 0) return 0;
+    const toDelete = new Set(sessionIds);
+
+    // Rewrite each daily JSONL file, stripping any line whose sessionId matches.
+    try {
+      const files = readdirSync(this.dir)
+        .filter((f) => f.startsWith("executions-") && f.endsWith(".jsonl"));
+      for (const file of files) {
+        const filepath = join(this.dir, file);
+        const content = readFileSync(filepath, "utf-8");
+        const lines = content.split("\n").filter(Boolean);
+        const kept: string[] = [];
+        let touched = false;
+        for (const line of lines) {
+          try {
+            const exec = JSON.parse(line) as AgentExecution;
+            if (toDelete.has(exec.sessionId)) {
+              touched = true;
+              continue;
+            }
+          } catch {
+            // Keep malformed lines as-is rather than risk data loss.
+          }
+          kept.push(line);
+        }
+        if (touched) {
+          writeFileSync(filepath, kept.length ? kept.join("\n") + "\n" : "", "utf-8");
+        }
+      }
+    } catch (err) {
+      console.error("[execution-store] Failed to delete executions from disk:", err);
+    }
+
+    // Remove from in-memory cache and count.
+    let removed = 0;
+    this.recentCache = this.recentCache.filter((e) => {
+      if (toDelete.has(e.sessionId)) {
+        removed++;
+        return false;
+      }
+      return true;
+    });
+    return removed;
+  }
+
   /** Query executions with pagination and filtering. */
   list(opts?: ExecutionQuery): ExecutionListResult {
     const limit = opts?.limit ?? 50;

package/server/federation/node-store.ts

@@ -1,10 +1,11 @@
 // ─── Node Store ───────────────────────────────────────────────────────────────
 // File-based CRUD for node configs. Stores identity + peer list in HEYHANK_HOME.
 
-import { mkdirSync, readFileSync, writeFileSync, existsSync } from "node:fs";
+import { mkdirSync, readFileSync, existsSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { randomUUID, randomBytes } from "node:crypto";
 import { HEYHANK_HOME } from "../paths.js";
+import { atomicWriteFileSync } from "../fs-utils.js";
 import type { NodeIdentity, NodeConfig } from "./node-types.js";
 
 const IDENTITY_FILE = join(HEYHANK_HOME, "node-identity.json");
@@ -32,14 +33,14 @@ export function getNodeIdentity(): NodeIdentity {
     createdAt: new Date().toISOString(),
   };
   mkdirSync(dirname(IDENTITY_FILE), { recursive: true });
-  writeFileSync(IDENTITY_FILE, JSON.stringify(_identity, null, 2));
+  atomicWriteFileSync(IDENTITY_FILE, JSON.stringify(_identity, null, 2));
   return _identity;
 }
 
 export function updateNodeName(name: string): NodeIdentity {
   const id = getNodeIdentity();
   id.name = name;
-  writeFileSync(IDENTITY_FILE, JSON.stringify(id, null, 2));
+  atomicWriteFileSync(IDENTITY_FILE, JSON.stringify(id, null, 2));
   return id;
 }
 
@@ -56,7 +57,7 @@ function readNodes(): NodeConfig[] {
 
 function writeNodes(nodes: NodeConfig[]): void {
   mkdirSync(dirname(NODES_FILE), { recursive: true });
-  writeFileSync(NODES_FILE, JSON.stringify(nodes, null, 2));
+  atomicWriteFileSync(NODES_FILE, JSON.stringify(nodes, null, 2));
 }
 
 export function listNodes(): NodeConfig[] {

package/server/fs-utils.ts

@@ -1,4 +1,4 @@
-import { readFileSync } from "node:fs";
+import { readFileSync, writeFileSync, renameSync, unlinkSync } from "node:fs";
 
 /** Count newlines in a file. Fast: reads raw buffer, counts 0x0A bytes. */
 export function countFileLines(path: string): number {
@@ -13,3 +13,30 @@ export function countFileLines(path: string): number {
     return 0;
   }
 }
+
+/**
+ * Atomic write: write to `path.tmp` then rename over the destination.
+ *
+ * Prevents corrupted/half-written files if the process crashes or two writers
+ * race each other — rename is atomic on POSIX & NTFS within the same filesystem.
+ * If the rename fails, the tmp file is removed so no `.tmp` junk is left behind.
+ */
+export function atomicWriteFileSync(
+  path: string,
+  content: string | Buffer | Uint8Array,
+  encoding: BufferEncoding = "utf-8",
+): void {
+  const tmp = `${path}.tmp`;
+  try {
+    if (typeof content === "string") {
+      writeFileSync(tmp, content, encoding);
+    } else {
+      writeFileSync(tmp, content);
+    }
+    renameSync(tmp, path);
+  } catch (err) {
+    // Best-effort cleanup of the temp file so we don't leave turds behind
+    try { unlinkSync(tmp); } catch { /* ignore */ }
+    throw err;
+  }
+}

package/server/hank-notifications-store.ts

@@ -0,0 +1,91 @@
+// ─── Hank Notifications Store ───────────────────────────────────────────────
+// Persistent queue of events that should be delivered to HankChat asynchronously
+// (e.g. "call ended, please summarise"). Survives server restarts and HankChat
+// being closed.
+
+import { mkdirSync, readFileSync, writeFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { randomUUID } from "node:crypto";
+import type { TranscriptEntry } from "./telephony/call-types.js";
+
+export interface CallEndedNotification {
+  id: string;
+  type: "call-ended";
+  createdAt: number;
+  consumed: boolean;
+  callId: string;
+  phone: string;
+  contactName: string | null;
+  direction: "inbound" | "outbound";
+  durationSeconds: number;
+  summary: string | null;
+  transcript: TranscriptEntry[];
+}
+
+export type HankNotification = CallEndedNotification;
+
+const DATA_DIR = join(homedir(), ".heyhank");
+const FILE = join(DATA_DIR, "hank-notifications.json");
+const MAX_KEEP = 100; // keep last N (consumed + unconsumed) to avoid unbounded growth
+
+let cache: HankNotification[] | null = null;
+
+function load(): HankNotification[] {
+  if (cache) return cache;
+  try {
+    if (!existsSync(FILE)) return (cache = []);
+    const raw = readFileSync(FILE, "utf-8");
+    cache = JSON.parse(raw) as HankNotification[];
+    if (!Array.isArray(cache)) cache = [];
+    return cache;
+  } catch (err) {
+    console.error("[hank-notifications] Failed to load store:", err);
+    return (cache = []);
+  }
+}
+
+function persist(): void {
+  try {
+    mkdirSync(DATA_DIR, { recursive: true });
+    const list = load();
+    // Trim to most recent MAX_KEEP
+    const trimmed = list.slice(-MAX_KEEP);
+    writeFileSync(FILE, JSON.stringify(trimmed, null, 2), "utf-8");
+    cache = trimmed;
+  } catch (err) {
+    console.error("[hank-notifications] Failed to persist store:", err);
+  }
+}
+
+export function addNotification(
+  n: Omit<HankNotification, "id" | "createdAt" | "consumed">,
+): HankNotification {
+  const list = load();
+  const full: HankNotification = {
+    id: randomUUID(),
+    createdAt: Date.now(),
+    consumed: false,
+    ...n,
+  };
+  list.push(full);
+  persist();
+  return full;
+}
+
+export function listPending(): HankNotification[] {
+  return load().filter((n) => !n.consumed);
+}
+
+export function markConsumed(id: string): boolean {
+  const list = load();
+  const n = list.find((x) => x.id === id);
+  if (!n) return false;
+  n.consumed = true;
+  persist();
+  return true;
+}
+
+export function getById(id: string): HankNotification | null {
+  return load().find((n) => n.id === id) ?? null;
+}