heyhank 0.1.0 → 0.2.0

package/server/ceo/time-tracking-store.ts

@@ -0,0 +1,227 @@
+import { join } from "path";
+import { readFileSync, existsSync, mkdirSync } from "fs";
+import { randomUUID } from "crypto";
+import { atomicWriteFileSync } from "../fs-utils.js";
+
+export interface TimeEntry {
+  id: string;
+  task: string;
+  project?: string;
+  category?: string;
+  startTime: string;
+  endTime?: string;
+  duration?: number; // minutes
+  notes?: string;
+  source: "manual" | "timer" | "auto"; // auto = derived from calls/emails/etc
+  createdAt: string;
+}
+
+export interface ActiveTimer {
+  id: string;
+  task: string;
+  project?: string;
+  category?: string;
+  startTime: string;
+}
+
+export interface TimeReport {
+  period: string;
+  startDate: string;
+  endDate: string;
+  totalMinutes: number;
+  byProject: Record<string, number>;
+  byCategory: Record<string, number>;
+  byDay: Record<string, number>;
+  entries: TimeEntry[];
+}
+
+const DATA_DIR = join(process.env.HEYHANK_HOME || join(process.env.HOME || "/root", ".heyhank"), "time-tracking");
+const ENTRIES_FILE = join(DATA_DIR, "entries.json");
+const TIMER_FILE = join(DATA_DIR, "active-timer.json");
+
+function ensureDir() {
+  if (!existsSync(DATA_DIR)) mkdirSync(DATA_DIR, { recursive: true });
+}
+
+function loadEntries(): TimeEntry[] {
+  ensureDir();
+  if (!existsSync(ENTRIES_FILE)) return [];
+  try { return JSON.parse(readFileSync(ENTRIES_FILE, "utf-8")); }
+  catch { return []; }
+}
+
+function saveEntries(entries: TimeEntry[]) {
+  ensureDir();
+  atomicWriteFileSync(ENTRIES_FILE, JSON.stringify(entries, null, 2));
+}
+
+function loadTimer(): ActiveTimer | null {
+  ensureDir();
+  if (!existsSync(TIMER_FILE)) return null;
+  try { return JSON.parse(readFileSync(TIMER_FILE, "utf-8")); }
+  catch { return null; }
+}
+
+function saveTimer(timer: ActiveTimer | null) {
+  ensureDir();
+  if (timer) {
+    atomicWriteFileSync(TIMER_FILE, JSON.stringify(timer, null, 2));
+  } else if (existsSync(TIMER_FILE)) {
+    atomicWriteFileSync(TIMER_FILE, "null");
+  }
+}
+
+// Timer
+export function startTimer(task: string, project?: string, category?: string): ActiveTimer {
+  // Stop existing timer first
+  const existing = loadTimer();
+  if (existing) stopTimer();
+
+  const timer: ActiveTimer = {
+    id: randomUUID(),
+    task,
+    project,
+    category,
+    startTime: new Date().toISOString()
+  };
+  saveTimer(timer);
+  return timer;
+}
+
+export function getActiveTimer(): ActiveTimer | null {
+  return loadTimer();
+}
+
+export function stopTimer(notes?: string): TimeEntry | null {
+  const timer = loadTimer();
+  if (!timer) return null;
+
+  const endTime = new Date().toISOString();
+  const duration = Math.round((new Date(endTime).getTime() - new Date(timer.startTime).getTime()) / 60000);
+
+  const entry: TimeEntry = {
+    id: timer.id,
+    task: timer.task,
+    project: timer.project,
+    category: timer.category,
+    startTime: timer.startTime,
+    endTime,
+    duration,
+    notes,
+    source: "timer",
+    createdAt: new Date().toISOString()
+  };
+
+  const entries = loadEntries();
+  entries.unshift(entry);
+  saveEntries(entries);
+  saveTimer(null);
+  return entry;
+}
+
+// Manual entries
+export function logTime(task: string, duration: number, project?: string, category?: string, notes?: string, date?: string): TimeEntry {
+  const entries = loadEntries();
+  const startTime = date || new Date().toISOString();
+  const entry: TimeEntry = {
+    id: randomUUID(),
+    task,
+    project,
+    category,
+    startTime,
+    duration,
+    notes,
+    source: "manual",
+    createdAt: new Date().toISOString()
+  };
+  entries.unshift(entry);
+  saveEntries(entries);
+  return entry;
+}
+
+export function listEntries(startDate?: string, endDate?: string, project?: string): TimeEntry[] {
+  let entries = loadEntries();
+  if (startDate) entries = entries.filter(e => e.startTime >= startDate);
+  if (endDate) entries = entries.filter(e => e.startTime <= endDate);
+  if (project) entries = entries.filter(e => e.project === project);
+  return entries;
+}
+
+export function deleteEntry(id: string): boolean {
+  const entries = loadEntries();
+  const idx = entries.findIndex(e => e.id === id);
+  if (idx === -1) return false;
+  entries.splice(idx, 1);
+  saveEntries(entries);
+  return true;
+}
+
+export function updateEntry(id: string, patch: Partial<Pick<TimeEntry, "task" | "project" | "category" | "duration" | "notes">>): TimeEntry | null {
+  const entries = loadEntries();
+  const idx = entries.findIndex(e => e.id === id);
+  if (idx === -1) return null;
+  Object.assign(entries[idx], patch);
+  saveEntries(entries);
+  return entries[idx];
+}
+
+// Reports
+export function getReport(period: "today" | "week" | "month" | "custom", startDate?: string, endDate?: string): TimeReport {
+  const now = new Date();
+  let start: Date;
+  let end: Date = now;
+
+  switch (period) {
+    case "today":
+      start = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+      break;
+    case "week":
+      start = new Date(now);
+      start.setDate(start.getDate() - start.getDay() + 1); // Monday
+      start.setHours(0, 0, 0, 0);
+      break;
+    case "month":
+      start = new Date(now.getFullYear(), now.getMonth(), 1);
+      break;
+    case "custom":
+      start = startDate ? new Date(startDate) : new Date(now.getFullYear(), now.getMonth(), 1);
+      end = endDate ? new Date(endDate) : now;
+      break;
+  }
+
+  const entries = listEntries(start.toISOString(), end.toISOString());
+
+  const byProject: Record<string, number> = {};
+  const byCategory: Record<string, number> = {};
+  const byDay: Record<string, number> = {};
+  let totalMinutes = 0;
+
+  for (const entry of entries) {
+    const mins = entry.duration || 0;
+    totalMinutes += mins;
+
+    const proj = entry.project || "Uncategorized";
+    byProject[proj] = (byProject[proj] || 0) + mins;
+
+    const cat = entry.category || "General";
+    byCategory[cat] = (byCategory[cat] || 0) + mins;
+
+    const day = entry.startTime.slice(0, 10);
+    byDay[day] = (byDay[day] || 0) + mins;
+  }
+
+  return {
+    period,
+    startDate: start.toISOString(),
+    endDate: end.toISOString(),
+    totalMinutes,
+    byProject,
+    byCategory,
+    byDay,
+    entries
+  };
+}
+
+export function listProjects(): string[] {
+  return [...new Set(loadEntries().map(e => e.project).filter(Boolean) as string[])].sort();
+}

package/server/claude-auth-monitor.ts

@@ -0,0 +1,128 @@
+// ─── Claude Auth Monitor ────────────────────────────────────────────────────
+// Monitors Claude sessions for auth failures and attempts automatic re-auth.
+
+import { getSettings, updateSettings } from "./settings-manager.js";
+import { EventEmitter } from "node:events";
+
+export const authEvents = new EventEmitter();
+
+export type AuthStatus = "ok" | "warning" | "expired" | "unknown";
+
+interface AuthState {
+  status: AuthStatus;
+  lastCheck: number;
+  lastError?: string;
+  refreshAttempts: number;
+}
+
+let currentState: AuthState = {
+  status: "unknown",
+  lastCheck: 0,
+  refreshAttempts: 0,
+};
+
+// Patterns that indicate auth failure in CLI stderr
+const AUTH_FAILURE_PATTERNS = [
+  /401/i,
+  /unauthorized/i,
+  /token expired/i,
+  /invalid.*bearer.*token/i,
+  /authentication.*failed/i,
+  /oauth.*error/i,
+  /EAUTH/i,
+];
+
+/** Check if a stderr line indicates an auth failure */
+export function isAuthFailure(line: string): boolean {
+  return AUTH_FAILURE_PATTERNS.some(p => p.test(line));
+}
+
+/** Called when an auth failure is detected in CLI output */
+export function reportAuthFailure(error: string, sessionId?: string): void {
+  currentState = {
+    status: "expired",
+    lastCheck: Date.now(),
+    lastError: error,
+    refreshAttempts: currentState.refreshAttempts,
+  };
+  authEvents.emit("auth:failure", { error, sessionId });
+  console.log(`[auth-monitor] Auth failure detected: ${error}`);
+
+  // Auto-attempt refresh if we haven't tried too many times
+  if (currentState.refreshAttempts < 3) {
+    attemptRefresh().catch(() => {});
+  }
+}
+
+/** Attempt to refresh the OAuth token */
+export async function attemptRefresh(): Promise<boolean> {
+  currentState.refreshAttempts++;
+  console.log(`[auth-monitor] Attempting token refresh (attempt ${currentState.refreshAttempts})`);
+
+  try {
+    const settings = getSettings();
+    const token = settings.claudeCodeOAuthToken;
+
+    if (!token) {
+      console.log("[auth-monitor] No OAuth token configured, cannot refresh");
+      currentState.status = "expired";
+      authEvents.emit("auth:refresh-failed", { reason: "no_token" });
+      return false;
+    }
+
+    // Try to validate the current token by making a test request
+    const testRes = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": settings.anthropicApiKey || "",
+        "anthropic-version": "2023-06-01",
+      },
+      body: JSON.stringify({
+        model: "claude-sonnet-4-20250514",
+        max_tokens: 1,
+        messages: [{ role: "user", content: "test" }],
+      }),
+    });
+
+    if (testRes.ok || testRes.status === 400) {
+      // Token works (400 = bad request but auth is fine)
+      currentState = { status: "ok", lastCheck: Date.now(), refreshAttempts: 0 };
+      authEvents.emit("auth:refreshed");
+      console.log("[auth-monitor] Token validated successfully");
+      return true;
+    }
+
+    if (testRes.status === 401) {
+      currentState.status = "expired";
+      authEvents.emit("auth:refresh-failed", { reason: "token_invalid" });
+      console.log("[auth-monitor] Token is invalid (401)");
+      return false;
+    }
+
+    // Other errors — mark as warning
+    currentState.status = "warning";
+    authEvents.emit("auth:refresh-failed", { reason: `http_${testRes.status}` });
+    return false;
+  } catch (err) {
+    console.log(`[auth-monitor] Refresh error: ${err instanceof Error ? err.message : err}`);
+    currentState.status = "warning";
+    authEvents.emit("auth:refresh-failed", { reason: "network_error" });
+    return false;
+  }
+}
+
+/** Get current auth status */
+export function getAuthStatus(): AuthState {
+  return { ...currentState };
+}
+
+/** Mark auth as OK (e.g., after successful session start) */
+export function markAuthOk(): void {
+  currentState = { status: "ok", lastCheck: Date.now(), refreshAttempts: 0 };
+}
+
+/** Reset auth state */
+export function resetAuthState(): void {
+  currentState = { status: "unknown", lastCheck: 0, refreshAttempts: 0 };
+}

package/server/claude-code-worker.ts

@@ -0,0 +1,86 @@
+// ─── Claude Code Headless Worker ─────────────────────────────────────────────
+// One-shot LLM call via the locally-installed Claude Code CLI in --print mode.
+// Uses the Claude Code Subscription (no Anthropic API charges) instead of
+// `callInternalAI`. Tools are disabled (`--tools ""`) so the call behaves as a
+// pure completion endpoint. Session persistence is off so we don't pollute the
+// user's local Claude Code history.
+
+import { spawn } from "node:child_process";
+
+interface HeadlessOpts {
+  systemPrompt: string;
+  userPrompt: string;
+  /** "sonnet" | "opus" | "haiku" | full model id. Defaults to "sonnet". */
+  model?: string;
+  /** Total wall-clock timeout. Defaults to 120s. */
+  timeoutMs?: number;
+}
+
+type HeadlessResult =
+  | { ok: true; text: string }
+  | { ok: false; error: string };
+
+/** Spawn `claude -p` and return its stdout. */
+export function callClaudeCodeHeadless(opts: HeadlessOpts): Promise<HeadlessResult> {
+  return new Promise((resolve) => {
+    const args = [
+      "-p",
+      "--tools", "",
+      "--no-session-persistence",
+      "--model", opts.model ?? "sonnet",
+      "--system-prompt", opts.systemPrompt,
+      opts.userPrompt,
+    ];
+
+    let child;
+    try {
+      // Unset CLAUDECODE so the headless invocation isn't refused as a "nested
+      // session" if our own process happens to be running inside Claude Code.
+      // PM2-managed prod doesn't have it; dev under Claude Code does.
+      const childEnv: Record<string, string | undefined> = { ...process.env, NO_COLOR: "1" };
+      delete childEnv.CLAUDECODE;
+      delete childEnv.CLAUDE_CODE_ENTRYPOINT;
+
+      child = spawn("claude", args, {
+        stdio: ["ignore", "pipe", "pipe"],
+        env: childEnv,
+      });
+    } catch (e) {
+      resolve({ ok: false, error: `spawn failed: ${e instanceof Error ? e.message : String(e)}` });
+      return;
+    }
+
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+
+    child.stdout.on("data", (d) => { stdout += d.toString(); });
+    child.stderr.on("data", (d) => { stderr += d.toString(); });
+
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      child.kill("SIGKILL");
+      resolve({ ok: false, error: `claude headless timeout after ${opts.timeoutMs ?? 120_000}ms` });
+    }, opts.timeoutMs ?? 120_000);
+
+    child.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve({ ok: false, error: `claude spawn error: ${err.message}` });
+    });
+
+    child.on("close", (code) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (code === 0) {
+        resolve({ ok: true, text: stdout.trim() });
+      } else {
+        const tail = stderr.trim().slice(-500) || stdout.trim().slice(-500);
+        resolve({ ok: false, error: `claude exit ${code}: ${tail || "no output"}` });
+      }
+    });
+  });
+}

package/server/claude-session-discovery.ts

@@ -1,4 +1,4 @@
-import { closeSync, existsSync, openSync, readSync, readdirSync, statSync } from "node:fs";
+import { closeSync, existsSync, openSync, readSync, readdirSync, rmSync, statSync, unlinkSync } from "node:fs";
 import { basename, join } from "node:path";
 import { homedir } from "node:os";
 
@@ -155,3 +155,76 @@ export function discoverClaudeSessions(
       sessionId: session.sessionId || basename(session.sourceFile, ".jsonl"),
     }));
 }
+
+export interface DeleteClaudeSessionTranscriptOptions {
+  projectsRoot?: string;
+}
+
+export interface DeleteClaudeSessionTranscriptResult {
+  deleted: string[];
+}
+
+/**
+ * Delete the Claude Code transcript file (and any sidecar directory) for a
+ * given CLI session ID. Claude Code stores transcripts under
+ * `~/.claude/projects/<encoded-cwd>/<sessionId>.jsonl` and may also create a
+ * `<sessionId>/` directory next to it. We walk all project subdirs because
+ * the same session can occasionally appear under multiple encoded-cwd dirs
+ * (e.g. when the working directory was renamed mid-session).
+ *
+ * Safe to call with a session that has no transcript on disk — returns an
+ * empty `deleted` list in that case.
+ */
+export function deleteClaudeSessionTranscript(
+  sessionId: string,
+  options: DeleteClaudeSessionTranscriptOptions = {},
+): DeleteClaudeSessionTranscriptResult {
+  const deleted: string[] = [];
+  if (!sessionId || typeof sessionId !== "string") return { deleted };
+
+  const projectsRoot = options.projectsRoot
+    || process.env.CLAUDE_PROJECTS_DIR
+    || join(homedir(), ".claude", "projects");
+
+  if (!existsSync(projectsRoot)) return { deleted };
+
+  let projectDirs: string[] = [];
+  try {
+    projectDirs = readdirSync(projectsRoot);
+  } catch {
+    return { deleted };
+  }
+
+  for (const projectDir of projectDirs) {
+    const projectPath = join(projectsRoot, projectDir);
+    try {
+      if (!statSync(projectPath).isDirectory()) continue;
+    } catch {
+      continue;
+    }
+
+    const filePath = join(projectPath, `${sessionId}.jsonl`);
+    if (existsSync(filePath)) {
+      try {
+        unlinkSync(filePath);
+        deleted.push(filePath);
+      } catch {
+        // Skip; another process may have removed it concurrently.
+      }
+    }
+
+    const sidecarPath = join(projectPath, sessionId);
+    if (existsSync(sidecarPath)) {
+      try {
+        if (statSync(sidecarPath).isDirectory()) {
+          rmSync(sidecarPath, { recursive: true, force: true });
+          deleted.push(sidecarPath);
+        }
+      } catch {
+        // no-op
+      }
+    }
+  }
+
+  return { deleted };
+}

package/server/cli-launcher.ts

@@ -20,6 +20,7 @@ import {
   getLegacyCodexHome,
   resolveHeyHankCodexSessionHome,
 } from "./codex-home.js";
+import { isAuthFailure, reportAuthFailure } from "./claude-auth-monitor.js";
 
 /** Whether WebSocket transport is enabled for Codex sessions. */
 function isCodexWsTransportEnabled(): boolean {
@@ -443,11 +444,20 @@ export class CliLauncher {
         env: runtimeEnv,
       });
     } else {
+      // Prefer the CLI's reported internal session id (populated after the
+      // first system/init). Fall back to the user-chosen branch-from-session
+      // target, so that a Reconnect after an initial-spawn crash still
+      // resumes the intended session instead of starting a fresh one.
+      const resumeSessionId = info.cliSessionId || info.resumeSessionAt;
       this.spawnCLI(sessionId, info, {
         model: info.model,
         permissionMode: info.permissionMode,
         cwd: info.cwd,
-        resumeSessionId: info.cliSessionId,
+        resumeSessionId,
+        // Preserve fork intent only while we don't yet have a post-fork
+        // cliSessionId. Once cliSessionId is known, we resume into the fork
+        // directly and must not re-fork.
+        forkSession: !info.cliSessionId && info.forkSession ? true : false,
         containerId: info.containerId,
         containerName: info.containerName,
         containerImage: info.containerImage,
@@ -543,19 +553,28 @@ export class CliLauncher {
         args.push("--allowedTools", tool);
       }
     }
-    if (options.resumeSessionAt) {
-      args.push("--resume-session-at", options.resumeSessionAt);
+    // The "Branch from session" UI passes the parent CLI session UUID via
+    // `resumeSessionAt`. Despite the field name, this is a *session* UUID,
+    // not the message UUID that the CLI's `--resume-session-at` flag
+    // expects — and that flag also requires `--resume <sessionId>` to be
+    // present, so emitting it alone makes the CLI exit immediately with
+    // "Error: --resume-session-at requires --resume". Map this to
+    // `--resume <id>` instead, plus `--fork-session` for the Fork case.
+    //
+    // `resumeSessionId` (set by the relaunch path with the CLI's reported
+    // internal session id) takes precedence when both are present, since
+    // the post-init id is the authoritative resume target.
+    const resumeTarget = options.resumeSessionId || options.resumeSessionAt;
+    if (resumeTarget) {
+      args.push("--resume", resumeTarget);
     }
-    if (options.forkSession) {
+    if (options.forkSession && !options.resumeSessionId) {
+      // Only emit `--fork-session` on the *initial* spawn after the user
+      // chose Fork. Subsequent relaunches use the post-fork CLI session id
+      // via `resumeSessionId` and must not fork again.
       args.push("--fork-session");
     }
 
-    // Always pass -p "" for headless mode. When relaunching, also pass --resume
-    // to restore the CLI's conversation context.
-    if (options.resumeSessionId) {
-      args.push("--resume", options.resumeSessionId);
-    }
-
     args.push("-p", "");
 
     let spawnCmd: string[];
@@ -1283,6 +1302,9 @@ export class CliLauncher {
         const text = decoder.decode(value);
         if (text.trim()) {
           log(`[session:${sessionId}:${label}] ${text.trimEnd()}`);
+          if (label === "stderr" && isAuthFailure(text)) {
+            reportAuthFailure(text.trimEnd());
+          }
         }
       }
     } catch {

package/server/codex-adapter.ts

@@ -314,7 +314,7 @@ export class StdioTransport implements ICodexTransport {
       // When the WS proxy reconnects to Codex, all pending RPC calls are
       // orphaned (Codex sees a fresh connection and won't respond to them).
       // Reject them immediately so callers don't hang until timeout.
-      if ((msg as JsonRpcNotification).method === "companion/wsReconnected") {
+      if ((msg as JsonRpcNotification).method === "heyhank/wsReconnected") {
         const pendingCount = this.pending.size;
         if (pendingCount > 0) {
           console.warn(
@@ -1659,7 +1659,7 @@ export class CodexAdapter implements IBackendAdapter {
         }
         break;
       }
-      case "companion/wsReconnected":
+      case "heyhank/wsReconnected":
         this.handleWsReconnected();
         break;
       default:

package/server/codex-ws-proxy.cjs

@@ -140,7 +140,7 @@ function connect() {
     // rejects all pending calls and cleans up.
     if (wasReconnect) {
       const reconnectNotification = JSON.stringify({
-        method: "companion/wsReconnected",
+        method: "heyhank/wsReconnected",
         params: {},
       });
       process.stdout.write(reconnectNotification + "\n");

package/server/container-manager.ts

@@ -20,7 +20,7 @@ export interface ContainerPortSpec {
 }
 
 export interface ContainerConfig {
-  /** Docker image to use (e.g. "the-companion:latest", "node:22-slim") */
+  /** Docker image to use (e.g. "heyhank:latest", "node:22-slim") */
   image: string;
   /** Container ports to expose (e.g. [3000, 8080] or [{ port: 6080, hostIp: "127.0.0.1" }]) */
   ports: (number | ContainerPortSpec)[];
@@ -832,7 +832,7 @@ export class ContainerManager {
    * Build a Docker image from a provided Dockerfile path.
    * Returns the build output log. Throws on failure.
    */
-  buildImage(dockerfilePath: string, tag: string = "the-companion:latest"): string {
+  buildImage(dockerfilePath: string, tag: string = "heyhank:latest"): string {
     const contextDir = dockerfilePath.replace(/\/[^/]+$/, "") || ".";
     try {
       const output = exec(
@@ -941,8 +941,8 @@ export class ContainerManager {
    * Return the Docker Hub remote path for a default image, or null for non-default images.
    */
   static getRegistryImage(localTag: string): string | null {
-    if (localTag === "the-companion:latest") {
-      return `${DOCKER_REGISTRY}/the-companion:latest`;
+    if (localTag === "heyhank:latest") {
+      return `${DOCKER_REGISTRY}/heyhank:latest`;
     }
     return null;
   }