heyhank 0.1.0

package/server/agent-executor.ts

@@ -0,0 +1,357 @@
+import { Cron } from "croner";
+import { mkdtempSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import type { AgentConfig, AgentExecution } from "./agent-types.js";
+import type { CliLauncher, SdkSessionInfo } from "./cli-launcher.js";
+import type { WsBridge } from "./ws-bridge.js";
+import * as agentStore from "./agent-store.js";
+import * as envManager from "./env-manager.js";
+import * as sessionNames from "./session-names.js";
+import { ExecutionStore } from "./execution-store.js";
+import { notifyAgentAlert } from "./push-notifications.js";
+
+/** Max consecutive failures before auto-disabling an agent */
+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 interface ExecuteAgentOptions {
+  force?: boolean;
+  triggerType?: "manual" | "webhook" | "schedule";
+  additionalEnv?: Record<string, string>;
+  systemPrompt?: string;
+}
+
+export class AgentExecutor {
+  private timers = new Map<string, Cron>();
+  private launcher: CliLauncher;
+  private wsBridge: WsBridge;
+  /** In-memory execution history (last N per agent) */
+  private executions = new Map<string, AgentExecution[]>();
+  private static readonly MAX_EXECUTIONS_PER_AGENT = 50;
+  /** Persistent execution store (JSONL on disk) */
+  private executionStore = new ExecutionStore();
+
+  constructor(launcher: CliLauncher, wsBridge: WsBridge) {
+    this.launcher = launcher;
+    this.wsBridge = wsBridge;
+  }
+
+  /** Start all enabled agents with schedule triggers from disk. Called once at server startup. */
+  startAll(): void {
+    const agents = agentStore.listAgents();
+    let started = 0;
+    for (const agent of agents) {
+      if (agent.enabled && agent.triggers?.schedule?.enabled) {
+        this.scheduleAgent(agent);
+        started++;
+      }
+    }
+    if (started > 0) {
+      console.log(`[agent-executor] Started ${started} scheduled agent(s)`);
+    }
+  }
+
+  /** Schedule (or reschedule) an agent's cron trigger. */
+  scheduleAgent(agent: AgentConfig): void {
+    this.stopAgent(agent.id);
+
+    const schedule = agent.triggers?.schedule;
+    if (!agent.enabled || !schedule?.enabled || !schedule.expression) return;
+
+    try {
+      if (schedule.recurring) {
+        const cronTask = new Cron(schedule.expression, {}, () => {
+          this.executeAgent(agent.id, undefined, { triggerType: "schedule" }).catch((err) => {
+            console.error(`[agent-executor] Unhandled error in agent "${agent.name}":`, err);
+          });
+        });
+        this.timers.set(agent.id, cronTask);
+        console.log(`[agent-executor] Scheduled "${agent.name}" with cron "${schedule.expression}"`);
+      } else {
+        // One-shot: schedule for the specified datetime
+        const targetTime = new Date(schedule.expression);
+        if (targetTime.getTime() > Date.now()) {
+          const cronTask = new Cron(targetTime, () => {
+            this.executeAgent(agent.id, undefined, { triggerType: "schedule" })
+              .then(() => {
+                // Auto-disable schedule after one-shot execution
+                const current = agentStore.getAgent(agent.id);
+                if (current?.triggers?.schedule) {
+                  agentStore.updateAgent(agent.id, {
+                    triggers: {
+                      ...current.triggers,
+                      schedule: { ...current.triggers.schedule, enabled: false },
+                    },
+                  });
+                }
+                this.timers.delete(agent.id);
+              })
+              .catch((err) => {
+                console.error(`[agent-executor] Unhandled error in one-shot agent "${agent.name}":`, err);
+              });
+          });
+          this.timers.set(agent.id, cronTask);
+          console.log(`[agent-executor] Scheduled one-shot "${agent.name}" at ${targetTime.toISOString()}`);
+        } else {
+          console.log(`[agent-executor] Skipping one-shot "${agent.name}" — target time is in the past`);
+        }
+      }
+    } catch (err) {
+      console.error(`[agent-executor] Failed to schedule "${agent.name}":`, err);
+    }
+  }
+
+  /** Stop an agent's cron timer. */
+  stopAgent(agentId: string): void {
+    const timer = this.timers.get(agentId);
+    if (timer) {
+      timer.stop();
+      this.timers.delete(agentId);
+    }
+  }
+
+  /** Execute an agent: create a session, configure MCP, send the prompt, track the result. */
+  async executeAgent(
+    agentId: string,
+    input?: string,
+    opts?: ExecuteAgentOptions,
+  ): Promise<SdkSessionInfo | undefined> {
+    const agent = agentStore.getAgent(agentId);
+    if (!agent) return;
+    if (!agent.enabled && !opts?.force) return;
+
+    // Overlap prevention: skip if previous execution is still running (unless forced)
+    if (!opts?.force && agent.lastSessionId && this.launcher.isAlive(agent.lastSessionId)) {
+      console.log(`[agent-executor] Skipping "${agent.name}" — previous execution still running (${agent.lastSessionId})`);
+      return;
+    }
+
+    const triggerType = opts?.triggerType || "manual";
+    console.log(`[agent-executor] Executing agent "${agent.name}" (${agentId}) via ${triggerType}`);
+
+    const execution: AgentExecution = {
+      sessionId: "",
+      agentId,
+      triggerType,
+      startedAt: Date.now(),
+    };
+
+    try {
+      // Resolve environment variables
+      let envVars: Record<string, string> | undefined;
+      if (agent.envSlug) {
+        const env = envManager.getEnv(agent.envSlug);
+        if (env) envVars = { ...env.variables };
+      }
+      if (agent.env) {
+        envVars = { ...envVars, ...agent.env };
+      }
+      if (opts?.additionalEnv) {
+        envVars = { ...envVars, ...opts.additionalEnv };
+      }
+
+      // Resolve working directory
+      let cwd = agent.cwd;
+      if (cwd === "temp" || !cwd) {
+        cwd = mkdtempSync(join(tmpdir(), `heyhank-agent-${agent.id}-`));
+      }
+
+      // Launch the session via CliLauncher.
+      // Agents always run with full permissions — no interactive prompts.
+      // For Claude Code this sets --permission-mode bypassPermissions;
+      // for Codex, approvalPolicy is already hardcoded to "never".
+      if (agent.permissionMode && agent.permissionMode !== "bypassPermissions") {
+        console.warn(
+          `[agent-executor] Agent "${agent.name}" has permissionMode="${agent.permissionMode}" ` +
+          `but agent sessions always run with bypassPermissions`,
+        );
+      }
+      const sessionInfo = this.launcher.launch({
+        model: agent.model,
+        permissionMode: "bypassPermissions",
+        cwd,
+        env: envVars,
+        allowedTools: agent.allowedTools,
+        backendType: agent.backendType,
+        codexInternetAccess: agent.backendType === "codex" ? (agent.codexInternetAccess ?? true) : undefined,
+        codexSandbox: agent.backendType === "codex"
+          ? (agent.permissionMode === "bypassPermissions" ? "danger-full-access" : "workspace-write")
+          : undefined,
+        systemPrompt: agent.backendType === "codex" ? opts?.systemPrompt : undefined,
+      });
+
+      execution.sessionId = sessionInfo.sessionId;
+
+      // Tag the session as agent-originated
+      sessionInfo.agentId = agentId;
+      sessionInfo.agentName = agent.name;
+
+      // Set the session name
+      const runLabel = `🤖 ${agent.name}`;
+      sessionNames.setName(sessionInfo.sessionId, runLabel);
+
+      // Wait for CLI to connect
+      await this.waitForCLIConnection(sessionInfo.sessionId);
+
+      // Configure MCP servers if specified
+      if (agent.mcpServers && Object.keys(agent.mcpServers).length > 0) {
+        this.wsBridge.injectMcpSetServers(sessionInfo.sessionId, agent.mcpServers);
+        // MCP servers need time to initialize before the CLI processes the prompt.
+        // The CLI handles MCP setup asynchronously; this delay ensures servers are
+        // ready. A proper health-check mechanism would be better long-term, but the
+        // CLI doesn't expose an MCP-ready signal yet.
+        const MCP_INIT_DELAY_MS = 2000;
+        await new Promise((r) => setTimeout(r, MCP_INIT_DELAY_MS));
+      }
+
+      if (opts?.systemPrompt && agent.backendType === "claude") {
+        this.wsBridge.injectSystemPrompt(sessionInfo.sessionId, opts.systemPrompt);
+      }
+
+      // Resolve prompt: replace {{input}} placeholder with trigger input
+      let resolvedPrompt = agent.prompt;
+      if (input !== undefined) {
+        resolvedPrompt = resolvedPrompt.replace(/\{\{input\}\}/g, input);
+      } else {
+        resolvedPrompt = resolvedPrompt.replace(/\{\{input\}\}/g, "");
+      }
+
+      // Send the prompt with agent prefix for traceability
+      const fullPrompt = `[agent:${agent.id} ${agent.name}]\n\n${resolvedPrompt}`;
+      this.wsBridge.injectUserMessage(sessionInfo.sessionId, fullPrompt);
+
+      // Update agent tracking
+      agentStore.updateAgent(agentId, {
+        lastRunAt: Date.now(),
+        lastSessionId: sessionInfo.sessionId,
+        totalRuns: agent.totalRuns + 1,
+        consecutiveFailures: 0,
+      });
+
+      // Execution is now "running" — completedAt/success will be set
+      // when the CLI process exits via handleSessionExited().
+      this.addExecution(agentId, execution);
+
+      return sessionInfo;
+    } catch (err) {
+      console.error(`[agent-executor] Agent "${agent.name}" failed:`, err);
+      execution.error = err instanceof Error ? err.message : String(err);
+      execution.completedAt = Date.now();
+      this.addExecution(agentId, execution);
+
+      const failures = agent.consecutiveFailures + 1;
+      const updates: Partial<AgentConfig> = {
+        consecutiveFailures: failures,
+        lastRunAt: Date.now(),
+      };
+
+      // Auto-disable after too many failures
+      if (failures >= MAX_CONSECUTIVE_FAILURES) {
+        updates.enabled = false;
+        this.stopAgent(agentId);
+        console.warn(`[agent-executor] Agent "${agent.name}" disabled after ${failures} consecutive failures`);
+      }
+
+      agentStore.updateAgent(agentId, updates);
+      return undefined;
+    }
+  }
+
+  /** Manual trigger (run now regardless of schedule, bypasses enabled check). */
+  executeAgentManually(agentId: string, input?: string): void {
+    this.executeAgent(agentId, input, { force: true, triggerType: "manual" }).catch((err) => {
+      console.error(`[agent-executor] Manual execution of agent "${agentId}" 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 an agent. */
+  getNextRunTime(agentId: string): Date | null {
+    const timer = this.timers.get(agentId);
+    if (!timer) return null;
+    return timer.nextRun() || null;
+  }
+
+  /** Get recent executions for an agent. */
+  getExecutions(agentId: string): AgentExecution[] {
+    return this.executions.get(agentId) || [];
+  }
+
+  private addExecution(agentId: string, execution: AgentExecution): void {
+    if (!this.executions.has(agentId)) {
+      this.executions.set(agentId, []);
+    }
+    const list = this.executions.get(agentId)!;
+    list.push(execution);
+    if (list.length > AgentExecutor.MAX_EXECUTIONS_PER_AGENT) {
+      list.splice(0, list.length - AgentExecutor.MAX_EXECUTIONS_PER_AGENT);
+    }
+    // Persist to disk
+    this.executionStore.append(execution);
+  }
+
+  /** Query executions across all agents (for Runs view). */
+  listAllExecutions(opts?: { agentId?: string; triggerType?: string; status?: "running" | "success" | "error"; limit?: number; offset?: number }) {
+    return this.executionStore.list(opts);
+  }
+
+  /** Handle session exit: mark the corresponding execution as completed. */
+  handleSessionExited(sessionId: string, exitCode: number | null): void {
+    for (const [, execs] of this.executions) {
+      const exec = execs.find((e) => e.sessionId === sessionId && !e.completedAt);
+      if (exec) {
+        exec.completedAt = Date.now();
+        exec.success = exitCode === 0 || exitCode === null;
+        if (exitCode && exitCode !== 0) {
+          exec.error = exec.error || `Process exited with code ${exitCode}`;
+        }
+        this.executionStore.update(sessionId, {
+          completedAt: exec.completedAt,
+          success: exec.success,
+          error: exec.error,
+        });
+
+        // Send push notification for agent completion
+        const agent = agentStore.getAgent(exec.agentId);
+        const agentName = agent?.name || exec.agentId;
+        if (exec.success) {
+          notifyAgentAlert(agentName, `Aufgabe erfolgreich abgeschlossen.`, "info").catch(() => {});
+        } else {
+          notifyAgentAlert(agentName, `Aufgabe fehlgeschlagen: ${exec.error || "Unbekannter Fehler"}`, "error").catch(() => {});
+        }
+
+        break;
+      }
+    }
+  }
+
+  /** 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/agent-store.ts

@@ -0,0 +1,185 @@
+import {
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  writeFileSync,
+  unlinkSync,
+  existsSync,
+} from "node:fs";
+import { join } from "node:path";
+import { HEYHANK_HOME } from "./paths.js";
+import { randomBytes } from "node:crypto";
+import type { AgentConfig, AgentConfigCreateInput } from "./agent-types.js";
+
+// ─── Paths ──────────────────────────────────────────────────────────────────
+
+const AGENTS_DIR = join(HEYHANK_HOME, "agents");
+
+function ensureDir(): void {
+  mkdirSync(AGENTS_DIR, { recursive: true });
+}
+
+function filePath(id: string): string {
+  return join(AGENTS_DIR, `${id}.json`);
+}
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+function slugify(name: string): string {
+  return name
+    .toLowerCase()
+    .replace(/\s+/g, "-")
+    .replace(/[^a-z0-9-]/g, "")
+    .replace(/-+/g, "-")
+    .replace(/^-|-$/g, "");
+}
+
+function generateWebhookSecret(): string {
+  return randomBytes(24).toString("hex");
+}
+
+/**
+ * Strip the legacy `triggers.chat` block from agents loaded from disk.
+ * The Chat SDK was removed but agents saved with the old schema may still
+ * have chat platform credentials on disk. Stripping on load prevents
+ * leaking those secrets via the API.
+ */
+function stripLegacyChatTrigger(agent: AgentConfig): AgentConfig {
+  if (!agent.triggers || !("chat" in agent.triggers)) return agent;
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const { chat: _chat, ...rest } = agent.triggers as Record<string, unknown>;
+  return { ...agent, triggers: rest as AgentConfig["triggers"] };
+}
+
+// ─── CRUD ───────────────────────────────────────────────────────────────────
+
+export function listAgents(): AgentConfig[] {
+  ensureDir();
+  try {
+    const files = readdirSync(AGENTS_DIR).filter((f) => f.endsWith(".json"));
+    const agents: AgentConfig[] = [];
+    for (const file of files) {
+      try {
+        const raw = readFileSync(join(AGENTS_DIR, file), "utf-8");
+        agents.push(stripLegacyChatTrigger(JSON.parse(raw)));
+      } catch {
+        // Skip corrupt files
+      }
+    }
+    agents.sort((a, b) => a.name.localeCompare(b.name));
+    return agents;
+  } catch {
+    return [];
+  }
+}
+
+export function getAgent(id: string): AgentConfig | null {
+  ensureDir();
+  try {
+    const raw = readFileSync(filePath(id), "utf-8");
+    return stripLegacyChatTrigger(JSON.parse(raw) as AgentConfig);
+  } catch {
+    return null;
+  }
+}
+
+export function createAgent(data: AgentConfigCreateInput): AgentConfig {
+  if (!data.name || !data.name.trim()) throw new Error("Agent name is required");
+  if (!data.prompt || !data.prompt.trim()) throw new Error("Agent prompt is required");
+
+  const id = slugify(data.name.trim());
+  if (!id) throw new Error("Agent name must contain alphanumeric characters");
+
+  ensureDir();
+  if (existsSync(filePath(id))) {
+    throw new Error(`An agent with a similar name already exists ("${id}")`);
+  }
+
+  // Auto-generate webhook secret if webhook trigger is enabled but has no secret
+  const triggers = data.triggers ? { ...data.triggers } : undefined;
+  if (triggers?.webhook && !triggers.webhook.secret) {
+    triggers.webhook = { ...triggers.webhook, secret: generateWebhookSecret() };
+  }
+
+  const now = Date.now();
+  const agent: AgentConfig = {
+    ...data,
+    triggers,
+    id,
+    name: data.name.trim(),
+    prompt: data.prompt.trim(),
+    description: data.description?.trim() || "",
+    cwd: data.cwd?.trim() || "",
+    createdAt: now,
+    updatedAt: now,
+    totalRuns: 0,
+    consecutiveFailures: 0,
+  };
+  writeFileSync(filePath(id), JSON.stringify(agent, null, 2), "utf-8");
+  return agent;
+}
+
+export function updateAgent(
+  id: string,
+  updates: Partial<AgentConfig>,
+): AgentConfig | null {
+  ensureDir();
+  const existing = getAgent(id);
+  if (!existing) return null;
+
+  const newName = updates.name?.trim() || existing.name;
+  const newId = slugify(newName);
+  if (!newId) throw new Error("Agent name must contain alphanumeric characters");
+
+  // If name changed, check for slug collision with a different agent
+  if (newId !== id && existsSync(filePath(newId))) {
+    throw new Error(`An agent with a similar name already exists ("${newId}")`);
+  }
+
+  const agent: AgentConfig = {
+    ...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(agent, null, 2), "utf-8");
+  return agent;
+}
+
+export function deleteAgent(id: string): boolean {
+  ensureDir();
+  if (!existsSync(filePath(id))) return false;
+  try {
+    unlinkSync(filePath(id));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** Generate a new webhook secret for an agent */
+export function regenerateWebhookSecret(id: string): AgentConfig | null {
+  const agent = getAgent(id);
+  if (!agent) return null;
+
+  const triggers = agent.triggers || {};
+  triggers.webhook = {
+    enabled: triggers.webhook?.enabled ?? false,
+    secret: generateWebhookSecret(),
+  };
+
+  return updateAgent(id, { triggers });
+}

package/server/agent-timeout.ts

@@ -0,0 +1,107 @@
+// ─── Agent Timeout Management ────────────────────────────────────────────────
+// Monitors agent sessions and kills those that exceed time limits
+
+import type { CliLauncher, SdkSessionInfo } from "./cli-launcher.js";
+import type { WsBridge } from "./ws-bridge.js";
+import { isKilled } from "./kill-switch.js";
+import { notifyAgentAlert } from "./push-notifications.js";
+
+// ─── Constants ───────────────────────────────────────────────────────────────
+
+/** Default timeout per agent session (30 minutes) */
+const DEFAULT_TIMEOUT_MS = 30 * 60 * 1000;
+
+/** Check interval (every 60 seconds) */
+const CHECK_INTERVAL_MS = 60 * 1000;
+
+/** Agent-specific timeouts (in ms) */
+const AGENT_TIMEOUTS: Record<string, number> = {
+  "monitoring-agent": 5 * 60 * 1000,    // 5 min (should be quick)
+  "personal-agent": 10 * 60 * 1000,     // 10 min
+  "coding-agent": 60 * 60 * 1000,       // 60 min (complex tasks)
+  "marketing-agent": 30 * 60 * 1000,    // 30 min
+  "content-agent": 30 * 60 * 1000,      // 30 min
+  "agent-max": 60 * 60 * 1000,          // 60 min (meta-agent)
+};
+
+// ─── Timeout Manager ─────────────────────────────────────────────────────────
+
+let intervalId: ReturnType<typeof setInterval> | null = null;
+
+export function startTimeoutMonitor(
+  launcher: CliLauncher,
+  wsBridge: WsBridge,
+): void {
+  if (intervalId) return; // Already running
+
+  intervalId = setInterval(() => {
+    checkTimeouts(launcher, wsBridge);
+  }, CHECK_INTERVAL_MS);
+
+  // Don't keep process alive just for this timer
+  if (intervalId && typeof intervalId === "object" && "unref" in intervalId) {
+    intervalId.unref();
+  }
+
+  console.log("[agent-timeout] Timeout monitor started");
+}
+
+export function stopTimeoutMonitor(): void {
+  if (intervalId) {
+    clearInterval(intervalId);
+    intervalId = null;
+  }
+}
+
+function checkTimeouts(launcher: CliLauncher, wsBridge: WsBridge): void {
+  // If kill switch is active, kill everything
+  if (isKilled()) {
+    const sessions = launcher.listSessions();
+    for (const session of sessions) {
+      if (session.state === "running" || session.state === "connected") {
+        try {
+          launcher.kill(session.sessionId);
+          console.log(`[agent-timeout] Kill switch: killed session ${session.sessionId.slice(0, 8)}`);
+        } catch {
+          // ignore
+        }
+      }
+    }
+    return;
+  }
+
+  const now = Date.now();
+  const sessions = launcher.listSessions();
+
+  for (const session of sessions) {
+    if (session.state !== "running" && session.state !== "connected") continue;
+
+    const agentId = (session as SdkSessionInfo & { agentId?: string }).agentId;
+    if (!agentId) continue; // Only timeout agent sessions
+
+    const timeout = AGENT_TIMEOUTS[agentId] ?? DEFAULT_TIMEOUT_MS;
+    const elapsed = now - session.createdAt;
+
+    if (elapsed > timeout) {
+      console.warn(
+        `[agent-timeout] Session ${session.sessionId.slice(0, 8)} for agent "${agentId}" ` +
+        `exceeded timeout (${Math.round(elapsed / 60000)}m > ${Math.round(timeout / 60000)}m). Killing.`,
+      );
+      try {
+        launcher.kill(session.sessionId);
+        notifyAgentAlert(
+          agentId,
+          `Session timed out after ${Math.round(elapsed / 60000)} minutes`,
+          "warning",
+        ).catch(() => {});
+      } catch {
+        // ignore
+      }
+    }
+  }
+}
+
+/** Get timeout config for an agent (for API). */
+export function getTimeoutConfig(): Record<string, number> {
+  return { ...AGENT_TIMEOUTS, _default: DEFAULT_TIMEOUT_MS };
+}