heyhank 0.1.0

package/server/cost-tracker.ts

@@ -0,0 +1,222 @@
+// ─── Cost Tracker ────────────────────────────────────────────────────────────
+// Ported from AgentManager/src/cost-tracker.ts — uses Bun's native SQLite
+
+import { Database } from "bun:sqlite";
+import { mkdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { HEYHANK_HOME } from "./paths.js";
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export interface CostRecord {
+  agentId: string;
+  agentName: string;
+  model: string;
+  tokensIn: number;
+  tokensOut: number;
+  estimatedCost: number;
+  createdAt: string;
+  closedAt: string | null;
+}
+
+export interface CostHistorySummary {
+  allTimeCost: number;
+  allTimeTokensIn: number;
+  allTimeTokensOut: number;
+  totalRecords: number;
+}
+
+// ─── Constants ───────────────────────────────────────────────────────────────
+
+const DB_PATH = join(HEYHANK_HOME, "costs.db");
+
+// ─── CostTracker ─────────────────────────────────────────────────────────────
+
+export class CostTracker {
+  private db: Database;
+
+  constructor() {
+    mkdirSync(dirname(DB_PATH), { recursive: true });
+    this.db = new Database(DB_PATH);
+    this.db.exec("PRAGMA journal_mode=WAL");
+    this.db.exec("PRAGMA synchronous=NORMAL");
+    this.initSchema();
+  }
+
+  private initSchema(): void {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS cost_records (
+        agent_id TEXT PRIMARY KEY,
+        agent_name TEXT NOT NULL,
+        model TEXT NOT NULL,
+        tokens_in INTEGER DEFAULT 0,
+        tokens_out INTEGER DEFAULT 0,
+        estimated_cost REAL DEFAULT 0,
+        created_at TEXT NOT NULL,
+        closed_at TEXT
+      );
+      CREATE TABLE IF NOT EXISTS settings (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+    `);
+  }
+
+  /** Insert or update a cost record. */
+  upsert(record: CostRecord): void {
+    try {
+      const stmt = this.db.prepare(`
+        INSERT INTO cost_records (agent_id, agent_name, model, tokens_in, tokens_out, estimated_cost, created_at, closed_at)
+        VALUES ($agentId, $agentName, $model, $tokensIn, $tokensOut, $estimatedCost, $createdAt, $closedAt)
+        ON CONFLICT(agent_id) DO UPDATE SET
+          agent_name = $agentName,
+          model = $model,
+          tokens_in = $tokensIn,
+          tokens_out = $tokensOut,
+          estimated_cost = $estimatedCost,
+          closed_at = $closedAt
+      `);
+      stmt.run({
+        $agentId: record.agentId,
+        $agentName: record.agentName,
+        $model: record.model,
+        $tokensIn: record.tokensIn,
+        $tokensOut: record.tokensOut,
+        $estimatedCost: record.estimatedCost,
+        $createdAt: record.createdAt,
+        $closedAt: record.closedAt,
+      });
+    } catch (err) {
+      console.warn("[cost-tracker] upsert failed:", err);
+    }
+  }
+
+  /** Mark a record as closed (agent destroyed). */
+  finalize(agentId: string): void {
+    try {
+      this.db
+        .prepare("UPDATE cost_records SET closed_at = $closedAt WHERE agent_id = $agentId")
+        .run({
+          $closedAt: new Date().toISOString(),
+          $agentId: agentId,
+        });
+    } catch (err) {
+      console.warn("[cost-tracker] finalize failed:", err);
+    }
+  }
+
+  /** Get all records, newest first. */
+  getAll(limit = 500): CostRecord[] {
+    try {
+      const rows = this.db
+        .prepare(
+          "SELECT agent_id, agent_name, model, tokens_in, tokens_out, estimated_cost, created_at, closed_at FROM cost_records ORDER BY created_at DESC LIMIT ?",
+        )
+        .all(limit) as Array<{
+        agent_id: string;
+        agent_name: string;
+        model: string;
+        tokens_in: number;
+        tokens_out: number;
+        estimated_cost: number;
+        created_at: string;
+        closed_at: string | null;
+      }>;
+      return rows.map((r) => ({
+        agentId: r.agent_id,
+        agentName: r.agent_name,
+        model: r.model,
+        tokensIn: r.tokens_in,
+        tokensOut: r.tokens_out,
+        estimatedCost: r.estimated_cost,
+        createdAt: r.created_at,
+        closedAt: r.closed_at,
+      }));
+    } catch (err) {
+      console.warn("[cost-tracker] getAll failed:", err);
+      return [];
+    }
+  }
+
+  /** Get aggregate summary. */
+  getSummary(): CostHistorySummary {
+    try {
+      const row = this.db
+        .prepare(
+          "SELECT COALESCE(SUM(estimated_cost),0) as total_cost, COALESCE(SUM(tokens_in),0) as total_in, COALESCE(SUM(tokens_out),0) as total_out, COUNT(*) as cnt FROM cost_records",
+        )
+        .get() as {
+        total_cost: number;
+        total_in: number;
+        total_out: number;
+        cnt: number;
+      };
+      return {
+        allTimeCost: row.total_cost,
+        allTimeTokensIn: row.total_in,
+        allTimeTokensOut: row.total_out,
+        totalRecords: row.cnt,
+      };
+    } catch (err) {
+      console.warn("[cost-tracker] getSummary failed:", err);
+      return {
+        allTimeCost: 0,
+        allTimeTokensIn: 0,
+        allTimeTokensOut: 0,
+        totalRecords: 0,
+      };
+    }
+  }
+
+  /** Delete all cost records. Returns number deleted. */
+  reset(): number {
+    try {
+      const result = this.db.prepare("DELETE FROM cost_records").run();
+      return result.changes;
+    } catch (err) {
+      console.warn("[cost-tracker] reset failed:", err);
+      return 0;
+    }
+  }
+
+  /** Get spend limit. */
+  getSpendLimit(): number | null {
+    try {
+      const row = this.db
+        .prepare("SELECT value FROM settings WHERE key = 'spend_limit'")
+        .get() as { value: string } | undefined;
+      return row ? parseFloat(row.value) : null;
+    } catch {
+      return null;
+    }
+  }
+
+  /** Set or clear spend limit. */
+  setSpendLimit(limit: number | null): void {
+    try {
+      if (limit === null) {
+        this.db.prepare("DELETE FROM settings WHERE key = 'spend_limit'").run();
+      } else {
+        this.db
+          .prepare(
+            "INSERT INTO settings (key, value) VALUES ('spend_limit', $val) ON CONFLICT(key) DO UPDATE SET value = $val",
+          )
+          .run({ $val: String(limit) });
+      }
+    } catch (err) {
+      console.warn("[cost-tracker] setSpendLimit failed:", err);
+    }
+  }
+
+  /** Close the database connection. */
+  close(): void {
+    try {
+      this.db.close();
+    } catch {
+      // Ignore
+    }
+  }
+}
+
+/** Singleton instance */
+export const costTracker = new CostTracker();

package/server/cron-scheduler.ts

@@ -0,0 +1,243 @@
+import { Cron } from "croner";
+import type { CronJob, CronJobExecution } from "./cron-types.js";
+import type { CliLauncher } from "./cli-launcher.js";
+import type { WsBridge } from "./ws-bridge.js";
+import * as cronStore from "./cron-store.js";
+import * as envManager from "./env-manager.js";
+import * as sessionNames from "./session-names.js";
+
+/** Max consecutive failures before auto-disabling a job */
+const MAX_CONSECUTIVE_FAILURES = 5;
+/** Max time to wait for CLI to connect (ms) */
+const CLI_CONNECT_TIMEOUT_MS = 30_000;
+/** Poll interval when waiting for CLI connection */
+const CLI_CONNECT_POLL_MS = 500;
+
+export class CronScheduler {
+  private timers = new Map<string, Cron>();
+  private launcher: CliLauncher;
+  private wsBridge: WsBridge;
+  /** In-memory execution history (last N per job) */
+  private executions = new Map<string, CronJobExecution[]>();
+  private static readonly MAX_EXECUTIONS_PER_JOB = 50;
+
+  constructor(launcher: CliLauncher, wsBridge: WsBridge) {
+    this.launcher = launcher;
+    this.wsBridge = wsBridge;
+  }
+
+  /** Start all enabled jobs from disk. Called once at server startup. */
+  startAll(): void {
+    const jobs = cronStore.listJobs();
+    let started = 0;
+    for (const job of jobs) {
+      if (job.enabled) {
+        this.scheduleJob(job);
+        started++;
+      }
+    }
+    if (started > 0) {
+      console.log(`[cron-scheduler] Started ${started} cron job(s)`);
+    }
+  }
+
+  /** Schedule (or reschedule) a single job. */
+  scheduleJob(job: CronJob): void {
+    this.stopJob(job.id);
+
+    if (!job.enabled) return;
+
+    try {
+      if (job.recurring) {
+        const cronTask = new Cron(job.schedule, {}, () => {
+          this.executeJob(job.id).catch((err) => {
+            console.error(`[cron-scheduler] Unhandled error in job "${job.name}":`, err);
+          });
+        });
+        this.timers.set(job.id, cronTask);
+        console.log(`[cron-scheduler] Scheduled "${job.name}" with cron "${job.schedule}"`);
+      } else {
+        // One-shot: schedule for the specified datetime
+        const targetTime = new Date(job.schedule);
+        if (targetTime.getTime() > Date.now()) {
+          const cronTask = new Cron(targetTime, () => {
+            this.executeJob(job.id)
+              .then(() => {
+                // Auto-disable after one-shot execution
+                cronStore.updateJob(job.id, { enabled: false });
+                this.timers.delete(job.id);
+              })
+              .catch((err) => {
+                console.error(`[cron-scheduler] Unhandled error in one-shot job "${job.name}":`, err);
+              });
+          });
+          this.timers.set(job.id, cronTask);
+          console.log(`[cron-scheduler] Scheduled one-shot "${job.name}" at ${targetTime.toISOString()}`);
+        } else {
+          console.log(`[cron-scheduler] Skipping one-shot "${job.name}" — target time is in the past`);
+        }
+      }
+    } catch (err) {
+      console.error(`[cron-scheduler] Failed to schedule "${job.name}":`, err);
+    }
+  }
+
+  /** Stop a job's timer. */
+  stopJob(jobId: string): void {
+    const timer = this.timers.get(jobId);
+    if (timer) {
+      timer.stop();
+      this.timers.delete(jobId);
+    }
+  }
+
+  /** Execute a job: create a session, send the prompt, track the result. */
+  async executeJob(jobId: string, opts?: { force?: boolean }): Promise<void> {
+    const job = cronStore.getJob(jobId);
+    if (!job) return;
+    if (!job.enabled && !opts?.force) return;
+
+    // Overlap prevention: skip if previous execution is still running
+    if (job.lastSessionId && this.launcher.isAlive(job.lastSessionId)) {
+      console.log(`[cron-scheduler] Skipping "${job.name}" — previous execution still running (${job.lastSessionId})`);
+      return;
+    }
+
+    console.log(`[cron-scheduler] Executing job "${job.name}" (${jobId})`);
+
+    const execution: CronJobExecution = {
+      sessionId: "",
+      jobId,
+      startedAt: Date.now(),
+    };
+
+    try {
+      // Resolve environment variables
+      let envVars: Record<string, string> | undefined;
+      if (job.envSlug) {
+        const env = envManager.getEnv(job.envSlug);
+        if (env) envVars = env.variables;
+      }
+
+      // Launch the session via CliLauncher
+      // For Codex, explicitly set sandbox and internet access for full autonomy
+      const sessionInfo = this.launcher.launch({
+        model: job.model,
+        permissionMode: job.permissionMode,
+        cwd: job.cwd,
+        env: envVars,
+        backendType: job.backendType,
+        codexInternetAccess: job.backendType === "codex" ? (job.codexInternetAccess ?? true) : undefined,
+        codexSandbox: job.backendType === "codex"
+          ? (job.permissionMode === "bypassPermissions" ? "danger-full-access" : "workspace-write")
+          : undefined,
+      });
+
+      execution.sessionId = sessionInfo.sessionId;
+
+      // Tag the session as cron-originated
+      sessionInfo.cronJobId = jobId;
+      sessionInfo.cronJobName = job.name;
+
+      // Set the session name
+      const runLabel = `⏰ ${job.name}`;
+      sessionNames.setName(sessionInfo.sessionId, runLabel);
+
+      // Wait for CLI to connect, then send the prompt
+      await this.waitForCLIConnection(sessionInfo.sessionId);
+
+      // Send the prompt with cron prefix for traceability
+      const fullPrompt = `[cron:${job.id} ${job.name}]\n\n${job.prompt}`;
+      this.wsBridge.injectUserMessage(sessionInfo.sessionId, fullPrompt);
+
+      // Update job tracking
+      cronStore.updateJob(jobId, {
+        lastRunAt: Date.now(),
+        lastSessionId: sessionInfo.sessionId,
+        totalRuns: job.totalRuns + 1,
+        consecutiveFailures: 0,
+      });
+
+      execution.success = true;
+      this.addExecution(jobId, execution);
+
+    } catch (err) {
+      console.error(`[cron-scheduler] Job "${job.name}" failed:`, err);
+      execution.error = err instanceof Error ? err.message : String(err);
+      execution.completedAt = Date.now();
+      this.addExecution(jobId, execution);
+
+      const failures = job.consecutiveFailures + 1;
+      const updates: Partial<CronJob> = {
+        consecutiveFailures: failures,
+        lastRunAt: Date.now(),
+      };
+
+      // Auto-disable after too many failures
+      if (failures >= MAX_CONSECUTIVE_FAILURES) {
+        updates.enabled = false;
+        this.stopJob(jobId);
+        console.warn(`[cron-scheduler] Job "${job.name}" disabled after ${failures} consecutive failures`);
+      }
+
+      cronStore.updateJob(jobId, updates);
+    }
+  }
+
+  /** Manual trigger (run now regardless of schedule, bypasses enabled check). */
+  executeJobManually(jobId: string): void {
+    this.executeJob(jobId, { force: true }).catch((err) => {
+      console.error(`[cron-scheduler] Manual execution of job "${jobId}" failed:`, err);
+    });
+  }
+
+  /** Wait for CLI to be connected (poll up to timeout). */
+  private async waitForCLIConnection(sessionId: string): Promise<void> {
+    const start = Date.now();
+
+    while (Date.now() - start < CLI_CONNECT_TIMEOUT_MS) {
+      const info = this.launcher.getSession(sessionId);
+      if (info && (info.state === "connected" || info.state === "running")) {
+        return;
+      }
+      if (info?.state === "exited") {
+        throw new Error(`CLI process exited before connecting (exit code: ${info.exitCode})`);
+      }
+      await new Promise((r) => setTimeout(r, CLI_CONNECT_POLL_MS));
+    }
+
+    throw new Error(`CLI process did not connect within ${CLI_CONNECT_TIMEOUT_MS / 1000}s`);
+  }
+
+  /** Get next run time for a job. */
+  getNextRunTime(jobId: string): Date | null {
+    const timer = this.timers.get(jobId);
+    if (!timer) return null;
+    return timer.nextRun() || null;
+  }
+
+  /** Get recent executions for a job. */
+  getExecutions(jobId: string): CronJobExecution[] {
+    return this.executions.get(jobId) || [];
+  }
+
+  private addExecution(jobId: string, execution: CronJobExecution): void {
+    if (!this.executions.has(jobId)) {
+      this.executions.set(jobId, []);
+    }
+    const list = this.executions.get(jobId)!;
+    list.push(execution);
+    if (list.length > CronScheduler.MAX_EXECUTIONS_PER_JOB) {
+      list.splice(0, list.length - CronScheduler.MAX_EXECUTIONS_PER_JOB);
+    }
+  }
+
+  /** Stop all timers (for graceful shutdown). */
+  destroy(): void {
+    for (const timer of this.timers.values()) {
+      timer.stop();
+    }
+    this.timers.clear();
+    this.executions.clear();
+  }
+}

package/server/cron-store.ts

@@ -0,0 +1,148 @@
+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";
+
+// ─── Paths ──────────────────────────────────────────────────────────────────
+
+const CRON_DIR = join(HEYHANK_HOME, "cron");
+
+function ensureDir(): void {
+  mkdirSync(CRON_DIR, { recursive: true });
+}
+
+function filePath(id: string): string {
+  return join(CRON_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 listJobs(): CronJob[] {
+  ensureDir();
+  try {
+    const files = readdirSync(CRON_DIR).filter((f) => f.endsWith(".json"));
+    const jobs: CronJob[] = [];
+    for (const file of files) {
+      try {
+        const raw = readFileSync(join(CRON_DIR, file), "utf-8");
+        jobs.push(JSON.parse(raw));
+      } catch {
+        // Skip corrupt files
+      }
+    }
+    jobs.sort((a, b) => a.name.localeCompare(b.name));
+    return jobs;
+  } catch {
+    return [];
+  }
+}
+
+export function getJob(id: string): CronJob | null {
+  ensureDir();
+  try {
+    const raw = readFileSync(filePath(id), "utf-8");
+    return JSON.parse(raw) as CronJob;
+  } catch {
+    return null;
+  }
+}
+
+export function createJob(data: CronJobCreateInput): CronJob {
+  if (!data.name || !data.name.trim()) throw new Error("Job name is required");
+  if (!data.prompt || !data.prompt.trim()) throw new Error("Job prompt is required");
+  if (!data.schedule || !data.schedule.trim()) throw new Error("Job schedule is required");
+  if (!data.cwd || !data.cwd.trim()) throw new Error("Job working directory is required");
+
+  const id = slugify(data.name.trim());
+  if (!id) throw new Error("Job name must contain alphanumeric characters");
+
+  ensureDir();
+  if (existsSync(filePath(id))) {
+    throw new Error(`A job with a similar name already exists ("${id}")`);
+  }
+
+  const now = Date.now();
+  const job: CronJob = {
+    ...data,
+    id,
+    name: data.name.trim(),
+    prompt: data.prompt.trim(),
+    schedule: data.schedule.trim(),
+    cwd: data.cwd.trim(),
+    createdAt: now,
+    updatedAt: now,
+    consecutiveFailures: 0,
+    totalRuns: 0,
+  };
+  writeFileSync(filePath(id), JSON.stringify(job, null, 2), "utf-8");
+  return job;
+}
+
+export function updateJob(
+  id: string,
+  updates: Partial<CronJob>,
+): CronJob | null {
+  ensureDir();
+  const existing = getJob(id);
+  if (!existing) return null;
+
+  const newName = updates.name?.trim() || existing.name;
+  const newId = slugify(newName);
+  if (!newId) throw new Error("Job name must contain alphanumeric characters");
+
+  // If name changed, check for slug collision with a different job
+  if (newId !== id && existsSync(filePath(newId))) {
+    throw new Error(`A job with a similar name already exists ("${newId}")`);
+  }
+
+  const job: CronJob = {
+    ...existing,
+    ...updates,
+    id: newId,
+    name: newName,
+    updatedAt: Date.now(),
+    // Preserve immutable fields
+    createdAt: existing.createdAt,
+  };
+
+  // If id changed, delete old file
+  if (newId !== id) {
+    try {
+      unlinkSync(filePath(id));
+    } catch {
+      /* ok */
+    }
+  }
+
+  writeFileSync(filePath(newId), JSON.stringify(job, null, 2), "utf-8");
+  return job;
+}
+
+export function deleteJob(id: string): boolean {
+  ensureDir();
+  if (!existsSync(filePath(id))) return false;
+  try {
+    unlinkSync(filePath(id));
+    return true;
+  } catch {
+    return false;
+  }
+}

package/server/cron-types.ts

@@ -0,0 +1,63 @@
+// ─── Cron Job Types ────────────────────────────────────────────────────────
+
+export interface CronJob {
+  /** Unique slug-based ID (derived from name) */
+  id: string;
+  /** Human-readable job name */
+  name: string;
+  /** The prompt to send when the job fires */
+  prompt: string;
+  /** Cron expression (e.g. "0 8 * * *") or ISO datetime string for one-shot */
+  schedule: string;
+  /** true = recurring cron, false = one-shot at a specific time */
+  recurring: boolean;
+  /** Backend to use */
+  backendType: "claude" | "codex";
+  /** Model to use (e.g. "claude-sonnet-4-6") */
+  model: string;
+  /** Working directory for the session */
+  cwd: string;
+  /** Optional environment slug (references ~/.heyhank/envs/) */
+  envSlug?: string;
+  /** Whether the job is currently enabled */
+  enabled: boolean;
+  /** Permission mode — defaults to "bypassPermissions" for autonomy */
+  permissionMode: string;
+  /** Codex-only: enable internet access */
+  codexInternetAccess?: boolean;
+
+  // ── Tracking ──
+  createdAt: number;
+  updatedAt: number;
+  /** Last time this job was triggered */
+  lastRunAt?: number;
+  /** Session ID of the last execution */
+  lastSessionId?: string;
+  /** Number of consecutive failures */
+  consecutiveFailures: number;
+  /** Total number of runs */
+  totalRuns: number;
+}
+
+export interface CronJobExecution {
+  /** The session ID created for this execution */
+  sessionId: string;
+  /** The job ID that triggered this */
+  jobId: string;
+  /** When the execution started */
+  startedAt: number;
+  /** When the execution completed (result received) */
+  completedAt?: number;
+  /** Whether the execution succeeded */
+  success?: boolean;
+  /** Error message if it failed */
+  error?: string;
+  /** Cost in USD */
+  costUsd?: number;
+}
+
+/** Input for creating a cron job (without auto-generated fields) */
+export type CronJobCreateInput = Omit<
+  CronJob,
+  "id" | "createdAt" | "updatedAt" | "consecutiveFailures" | "totalRuns" | "lastRunAt" | "lastSessionId"
+>;