talon-agent 1.0.0

package/src/storage/sessions.ts

@@ -0,0 +1,328 @@
+import { existsSync, readFileSync, mkdirSync } from "node:fs";
+import writeFileAtomic from "write-file-atomic";
+import { log, logError } from "../util/log.js";
+import { recordError } from "../util/watchdog.js";
+import { dirs, files } from "../util/paths.js";
+
+/**
+ * Session manager — maps Telegram chat IDs to Claude SDK session IDs.
+ * The SDK handles actual conversation storage (JSONL); we just track
+ * the mapping so conversations persist across messages.
+ *
+ * Sessions are persisted to disk so they survive restarts.
+ */
+
+type SessionUsage = {
+  totalInputTokens: number;
+  totalOutputTokens: number;
+  totalCacheRead: number;
+  totalCacheWrite: number;
+  /** Last turn's prompt tokens (context size snapshot). */
+  lastPromptTokens: number;
+  /** Estimated cost in USD. */
+  estimatedCostUsd: number;
+  /** Total response time in ms (for averaging). */
+  totalResponseMs: number;
+  /** Last response time in ms. */
+  lastResponseMs: number;
+  /** Fastest response time in ms. */
+  fastestResponseMs: number;
+};
+
+type SessionState = {
+  /** Claude SDK server-side session ID. */
+  sessionId: string | undefined;
+  /** Turn count. */
+  turns: number;
+  /** Last activity timestamp. */
+  lastActive: number;
+  /** Created timestamp. */
+  createdAt: number;
+  /** Cumulative usage stats. */
+  usage: SessionUsage;
+  /** ID of the last message sent by the bot in this chat. */
+  lastBotMessageId?: number;
+  /** Descriptive session name derived from first message. */
+  sessionName?: string;
+  /** Model used for this session's cost tracking. */
+  lastModel?: string;
+};
+
+type SessionStore = Record<string, SessionState>;
+
+const STORE_FILE = files.sessions;
+let store: SessionStore = {};
+let dirty = false;
+
+function ensureDir(): void {
+  if (!existsSync(dirs.data)) mkdirSync(dirs.data, { recursive: true });
+}
+
+export function loadSessions(): void {
+  try {
+    if (existsSync(STORE_FILE)) {
+      store = JSON.parse(readFileSync(STORE_FILE, "utf-8"));
+    }
+  } catch {
+    // Primary file corrupt — try backup
+    const bakFile = STORE_FILE + ".bak";
+    try {
+      if (existsSync(bakFile)) {
+        store = JSON.parse(readFileSync(bakFile, "utf-8"));
+        logError("sessions", "Loaded from backup (primary was corrupt)");
+        return;
+      }
+    } catch {
+      /* backup also corrupt */
+    }
+    logError(
+      "sessions",
+      "Session data corrupt and no valid backup — starting fresh",
+    );
+    store = {};
+  }
+  // SDK sessions don't survive process restarts — the embedded Claude Code
+  // subprocess is gone.  Clear stale session IDs so we don't try to resume
+  // a dead session (which causes the SDK to hang silently on Windows).
+  // Keep turns/usage intact — they're historical data used by /resume.
+  for (const session of Object.values(store)) {
+    if (session.sessionId) {
+      session.sessionId = undefined;
+      dirty = true;
+    }
+  }
+}
+
+function saveSessions(): void {
+  if (!dirty) return;
+  try {
+    ensureDir();
+    const data = JSON.stringify(store, null, 2) + "\n";
+    // Write backup of current file before overwriting
+    if (existsSync(STORE_FILE)) {
+      try {
+        writeFileAtomic.sync(STORE_FILE + ".bak", readFileSync(STORE_FILE));
+      } catch {
+        /* best effort */
+      }
+    }
+    // Atomic write: writes to temp file then renames — prevents corruption on crash
+    writeFileAtomic.sync(STORE_FILE, data);
+    dirty = false;
+  } catch (err) {
+    logError("sessions", "Failed to persist sessions", err);
+    recordError(
+      `Session save failed: ${err instanceof Error ? err.message : err}`,
+    );
+  }
+}
+
+// Auto-save every 10 seconds if dirty
+const autoSaveTimer = setInterval(saveSessions, 10_000);
+
+// Periodic stale session pruning (every hour)
+
+const emptyUsage = (): SessionUsage => ({
+  totalInputTokens: 0,
+  totalOutputTokens: 0,
+  totalCacheRead: 0,
+  totalCacheWrite: 0,
+  lastPromptTokens: 0,
+  estimatedCostUsd: 0,
+  totalResponseMs: 0,
+  lastResponseMs: 0,
+  fastestResponseMs: Infinity,
+});
+
+export function getSession(chatId: string): SessionState {
+  let session = store[chatId];
+  if (!session) {
+    const now = Date.now();
+    session = {
+      sessionId: undefined,
+      turns: 0,
+      lastActive: now,
+      createdAt: now,
+      usage: emptyUsage(),
+    };
+    store[chatId] = session;
+  }
+  // Migrate old sessions without usage or missing fields
+  if (!session.usage) session.usage = emptyUsage();
+  if (!session.createdAt) session.createdAt = session.lastActive;
+  if (session.usage.totalResponseMs === undefined)
+    session.usage.totalResponseMs = 0;
+  if (session.usage.lastResponseMs === undefined)
+    session.usage.lastResponseMs = 0;
+  if (
+    session.usage.fastestResponseMs === undefined ||
+    session.usage.fastestResponseMs === 0
+  )
+    session.usage.fastestResponseMs = Infinity;
+  return session;
+}
+
+export function setSessionId(chatId: string, sessionId: string): void {
+  const session = getSession(chatId);
+  session.sessionId = sessionId;
+  dirty = true;
+}
+
+export function incrementTurns(chatId: string): void {
+  const session = getSession(chatId);
+  session.turns += 1;
+  session.lastActive = Date.now();
+  dirty = true;
+}
+
+/** Model-specific pricing ($ per million tokens). */
+const MODEL_PRICING: Record<
+  string,
+  { input: number; output: number; cacheRead: number; cacheWrite: number }
+> = {
+  haiku: { input: 0.8, output: 4, cacheRead: 0.08, cacheWrite: 1 },
+  sonnet: { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+  opus: { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 },
+};
+
+function getPricing(model?: string): (typeof MODEL_PRICING)["sonnet"] {
+  if (!model) return MODEL_PRICING.sonnet;
+  const lower = model.toLowerCase();
+  if (lower.includes("haiku")) return MODEL_PRICING.haiku;
+  if (lower.includes("opus")) return MODEL_PRICING.opus;
+  return MODEL_PRICING.sonnet;
+}
+
+export function recordUsage(
+  chatId: string,
+  turn: {
+    inputTokens: number;
+    outputTokens: number;
+    cacheRead: number;
+    cacheWrite: number;
+    durationMs?: number;
+    model?: string;
+  },
+): void {
+  const session = getSession(chatId);
+  session.usage.totalInputTokens += turn.inputTokens;
+  session.usage.totalOutputTokens += turn.outputTokens;
+  session.usage.totalCacheRead += turn.cacheRead;
+  session.usage.totalCacheWrite += turn.cacheWrite;
+  // Snapshot: prompt tokens = input + cache_read + cache_write for this turn
+  session.usage.lastPromptTokens =
+    turn.inputTokens + turn.cacheRead + turn.cacheWrite;
+  // Model-aware cost estimate
+  const pricing = getPricing(turn.model);
+  session.usage.estimatedCostUsd +=
+    (turn.inputTokens * pricing.input +
+      turn.cacheWrite * pricing.cacheWrite +
+      turn.cacheRead * pricing.cacheRead +
+      turn.outputTokens * pricing.output) /
+    1_000_000;
+  // Track which model was last used
+  if (turn.model) session.lastModel = turn.model;
+  // Response time tracking
+  if (turn.durationMs && turn.durationMs > 0) {
+    session.usage.totalResponseMs =
+      (session.usage.totalResponseMs || 0) + turn.durationMs;
+    session.usage.lastResponseMs = turn.durationMs;
+    const current = session.usage.fastestResponseMs || Infinity;
+    if (turn.durationMs < current) {
+      session.usage.fastestResponseMs = turn.durationMs;
+    }
+  }
+  dirty = true;
+}
+
+export function setSessionName(chatId: string, name: string): void {
+  const session = getSession(chatId);
+  session.sessionName = name;
+  dirty = true;
+}
+
+export function setLastBotMessageId(chatId: string, messageId: number): void {
+  const session = getSession(chatId);
+  session.lastBotMessageId = messageId;
+  dirty = true;
+}
+
+export function getLastBotMessageId(chatId: string): number | undefined {
+  return store[chatId]?.lastBotMessageId;
+}
+
+export function resetSession(chatId: string): void {
+  const session = store[chatId];
+  const turns = session?.turns ?? 0;
+  const name = session?.sessionName;
+  delete store[chatId];
+  dirty = true;
+  saveSessions();
+  log(
+    "sessions",
+    `[${chatId}] Reset${name ? ` "${name}"` : ""} (${turns} turns)`,
+  );
+}
+
+export type SessionInfo = {
+  sessionId: string | undefined;
+  turns: number;
+  lastActive: number;
+  createdAt: number;
+  usage: SessionUsage;
+  sessionName?: string;
+  lastModel?: string;
+};
+
+export function getSessionInfo(chatId: string): SessionInfo {
+  const session = store[chatId];
+  return {
+    sessionId: session?.sessionId,
+    turns: session?.turns ?? 0,
+    lastActive: session?.lastActive ?? 0,
+    createdAt: session?.createdAt ?? 0,
+    usage: session?.usage ?? emptyUsage(),
+    sessionName: session?.sessionName,
+    lastModel: session?.lastModel,
+  };
+}
+
+export function getActiveSessionCount(): number {
+  return Object.keys(store).length;
+}
+
+/** Get all chat IDs with active sessions and their info. */
+export function getAllSessions(): Array<{ chatId: string; info: SessionInfo }> {
+  return Object.entries(store).map(([chatId, session]) => ({
+    chatId,
+    info: {
+      sessionId: session.sessionId,
+      turns: session.turns,
+      lastActive: session.lastActive,
+      createdAt: session.createdAt,
+      usage: session.usage ?? {
+        totalInputTokens: 0,
+        totalOutputTokens: 0,
+        totalCacheRead: 0,
+        totalCacheWrite: 0,
+        lastPromptTokens: 0,
+        estimatedCostUsd: 0,
+        totalResponseMs: 0,
+        lastResponseMs: 0,
+        fastestResponseMs: Infinity,
+      },
+      sessionName: session.sessionName,
+      lastModel: session.lastModel,
+    },
+  }));
+}
+
+// Flush on exit (signal handlers are in index.ts for graceful shutdown)
+process.on("exit", saveSessions);
+
+/** Force-save sessions to disk and stop the auto-save timer. */
+export function flushSessions(): void {
+  clearInterval(autoSaveTimer);
+  dirty = true;
+  saveSessions();
+}

package/src/util/chat-id.ts

@@ -0,0 +1,21 @@
+/**
+ * Shared chat-ID utilities used by terminal and Teams frontends.
+ */
+
+import { createHash } from "node:crypto";
+
+/** Derive a stable 32-bit numeric chat ID from a string chat ID. */
+export function deriveNumericChatId(chatId: string): number {
+  const hash = createHash("sha256").update(chatId).digest();
+  return hash.readUInt32BE(0);
+}
+
+/** Generate a unique terminal chat ID. */
+export function generateTerminalChatId(): string {
+  return `t_${Date.now()}`;
+}
+
+/** Check if a chat ID belongs to a terminal session. */
+export function isTerminalChatId(chatId: string): boolean {
+  return chatId.startsWith("t_") || chatId === "1";
+}

package/src/util/config.ts

@@ -0,0 +1,244 @@
+import { existsSync, readFileSync, mkdirSync, readdirSync, statSync } from "node:fs";
+import { resolve } from "node:path";
+import writeFileAtomic from "write-file-atomic";
+import { z } from "zod";
+import { dirs, files as pathFiles } from "./paths.js";
+import { setTimezone, formatFullDatetime } from "./time.js";
+import { log } from "./log.js";
+
+
+// ── Config schema ───────────────────────────────────────────────────────────
+
+const pluginEntrySchema = z.object({
+  path: z.string(),
+  config: z.record(z.string(), z.unknown()).optional(),
+});
+
+const frontendEnum = z.enum(["telegram", "terminal", "teams"]);
+
+const configSchema = z.object({
+  frontend: z.union([frontendEnum, z.array(frontendEnum)]).default("telegram"),
+  botToken: z.string().optional(),
+  backend: z.enum(["claude", "opencode"]).default("claude"),
+  claudeBinary: z.string().optional(),
+  model: z.string().default("claude-sonnet-4-6"),
+  dreamModel: z.string().optional(), // Model used for background memory consolidation (defaults to main model)
+  maxMessageLength: z.number().int().min(100).default(4000),
+  concurrency: z.number().int().min(1).max(20).default(1),
+  apiId: z.number().int().optional(),
+  apiHash: z.string().optional(),
+  adminUserId: z.number().int().optional(),
+  pulse: z.boolean().default(true),
+  pulseIntervalMs: z.number().int().min(60000).default(300000),
+  braveApiKey: z.string().optional(),
+  searxngUrl: z.string().default("http://localhost:8080"),
+  timezone: z.string().optional(),
+  plugins: z.array(pluginEntrySchema).default([]),
+
+  // Display name shown in terminal UI (defaults to "Talon")
+  botDisplayName: z.string().default("Talon"),
+
+  // Teams frontend (Power Automate webhooks)
+  teamsWebhookUrl: z.string().url().optional(),
+  teamsWebhookSecret: z.string().optional(),
+  teamsWebhookPort: z.number().int().min(1024).max(65535).default(19878),
+  teamsBotDisplayName: z.string().optional(),
+  teamsTeamName: z.string().optional(),
+  teamsChannelName: z.string().optional(),
+  teamsChatTopic: z.string().optional(),
+  teamsGraphPollMs: z.number().int().min(5000).default(10000),
+});
+
+export type TalonConfig = z.infer<typeof configSchema> & {
+  systemPrompt: string;
+  workspace: string;
+};
+
+/** Normalize frontend config to always be an array. */
+export function getFrontends(config: TalonConfig): string[] {
+  return Array.isArray(config.frontend) ? config.frontend : [config.frontend];
+}
+
+// ── Config file ─────────────────────────────────────────────────────────────
+
+const CONFIG_FILE = pathFiles.config;
+
+const DEFAULT_CONFIG = {
+  botToken: "",
+  model: "claude-sonnet-4-6",
+  maxMessageLength: 4000,
+  concurrency: 1,
+  pulse: true,
+  pulseIntervalMs: 300000,
+};
+
+function loadConfigFile(): Record<string, unknown> {
+  try {
+    if (existsSync(CONFIG_FILE)) {
+      return JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+    }
+  } catch { /* corrupt — will be recreated */ }
+  return {};
+}
+
+/**
+ * First-run onboarding: creates workspace/talon.json with defaults.
+ * Returns true if this is a fresh install.
+ */
+function ensureConfigFile(): boolean {
+  if (!existsSync(dirs.root)) mkdirSync(dirs.root, { recursive: true });
+  if (!existsSync(dirs.data)) mkdirSync(dirs.data, { recursive: true });
+  if (!existsSync(CONFIG_FILE)) {
+    writeFileAtomic.sync(CONFIG_FILE, JSON.stringify(DEFAULT_CONFIG, null, 2) + "\n");
+    return true;
+  }
+  return false;
+}
+
+// ── System prompt assembly ──────────────────────────────────────────────────
+
+function readOptionalFile(path: string): string {
+  try {
+    if (existsSync(path)) return readFileSync(path, "utf-8").trim();
+  } catch { /* ignore */ }
+  return "";
+}
+
+let lastLoggedPromptKey = "";
+
+function loadSystemPrompt(frontend?: string, pluginPromptAdditions?: string[]): string {
+  const promptDir = dirs.prompts;
+  const parts: string[] = [];
+
+  const loaded: string[] = [];
+
+  // Identity — static personality from prompts/identity.md + dynamic config from ~/.talon/workspace/identity.md
+  const identityPrompt = readOptionalFile(resolve(promptDir, "identity.md"));
+  const identityUser = readOptionalFile(pathFiles.identity);
+  if (identityPrompt || identityUser) {
+    const identityParts = [identityPrompt, identityUser].filter(Boolean);
+    parts.push(`## Identity\n\n${identityParts.join("\n\n")}`);
+    loaded.push("identity");
+  }
+
+  // Load base prompt (shared across all frontends)
+  const custom = readOptionalFile(resolve(promptDir, "custom.md"));
+  const basePrompt = readOptionalFile(resolve(promptDir, "base.md"));
+  if (custom) { parts.push(custom); loaded.push("custom"); }
+  else if (basePrompt) { parts.push(basePrompt); loaded.push("base"); }
+  else parts.push("You are a sharp and helpful AI assistant.");
+
+  // Load frontend-specific prompt
+  const frontendFile = `${frontend ?? "telegram"}.md`;
+  const frontendPrompt = readOptionalFile(resolve(promptDir, frontendFile));
+  if (frontendPrompt) { parts.push(frontendPrompt); loaded.push(frontendFile.replace(".md", "")); }
+
+  const memory = readOptionalFile(pathFiles.memory);
+  if (memory) {
+    parts.push(
+      `## Persistent Memory\n\nThe following is your memory file. Reference it naturally. Update it via the Write tool when you learn important new information.\nFile: ~/.talon/workspace/memory/memory.md\n\n${memory}`,
+    );
+    loaded.push("memory");
+  }
+
+  const loadedKey = loaded.join(" + ");
+  if (loadedKey && loadedKey !== lastLoggedPromptKey) {
+    log("config", `System prompt: ${loadedKey}`);
+    lastLoggedPromptKey = loadedKey;
+  }
+
+  // Workspace file listing for context
+  const workspaceDir = dirs.workspace;
+  let workspaceFiles = "";
+  try {
+    const listDir = (dir: string, prefix = ""): string[] => {
+      const entries: string[] = [];
+      try {
+        for (const e of readdirSync(dir, { withFileTypes: true })) {
+          if (e.name.startsWith(".") || e.name === "node_modules" || e.name === "talon.log") continue;
+          const full = resolve(dir, e.name);
+          if (e.isDirectory()) {
+            const sub = listDir(full, `${prefix}${e.name}/`);
+            if (sub.length > 0 && sub.length <= 8) entries.push(...sub);
+            else if (sub.length > 8) entries.push(`${prefix}${e.name}/ (${sub.length} files)`);
+          } else {
+            const sz = statSync(full).size;
+            entries.push(`${prefix}${e.name} (${sz < 1024 ? sz + "B" : (sz / 1024).toFixed(0) + "KB"})`);
+          }
+        }
+      } catch { /* skip */ }
+      return entries;
+    };
+    const files = listDir(workspaceDir);
+    if (files.length > 0) workspaceFiles = "\n\nCurrent workspace contents:\n" + files.map((f) => `  ${f}`).join("\n");
+  } catch { /* no workspace yet */ }
+
+  parts.push(`## Workspace
+
+You have a workspace directory at \`~/.talon/workspace/\`. This is your home — organize it however you want.
+- \`~/.talon/workspace/memory/memory.md\` is your persistent memory file. Update it when you learn important things.
+- Daily interaction logs are saved to \`~/.talon/workspace/logs/\` automatically.
+- Files users send you (photos, docs, voice) are saved to \`~/.talon/workspace/uploads/\`.
+- Persistent cron jobs are managed via the cron tools.
+- Everything else is yours to create and organize as you see fit.${workspaceFiles}
+
+## Cron Jobs
+
+You can create persistent recurring scheduled tasks using cron tools. Jobs survive restarts.
+- \`create_cron_job\` — create a new recurring job with a cron schedule
+- \`list_cron_jobs\` — list all jobs in the current chat
+- \`edit_cron_job\` — modify an existing job (schedule, content, enable/disable)
+- \`delete_cron_job\` — remove a job permanently
+Two job types: "message" sends text directly, "query" runs a Claude prompt with full tool access.`);
+
+  parts.push(`## Current Date & Time\n${formatFullDatetime()}`);
+
+  // Plugin system prompt contributions (injected by caller)
+  if (pluginPromptAdditions) {
+    for (const addition of pluginPromptAdditions) {
+      parts.push(addition);
+    }
+  }
+
+  return parts.join("\n\n---\n\n");
+}
+
+// ── Main loader ─────────────────────────────────────────────────────────────
+
+export function loadConfig(): TalonConfig {
+  ensureConfigFile();
+  const fileConfig = loadConfigFile();
+
+  const parsed = configSchema.parse(fileConfig);
+
+  // Apply timezone globally before building the system prompt
+  setTimezone(parsed.timezone);
+
+  // Validate per-frontend requirements
+  const frontends = Array.isArray(parsed.frontend) ? parsed.frontend : [parsed.frontend];
+  for (const fe of frontends) {
+    if (fe === "telegram" && !parsed.botToken) {
+      throw new Error(`Telegram frontend requires "botToken" in ${CONFIG_FILE}. Run "talon setup" to configure.`);
+    }
+    if (fe === "teams" && !parsed.teamsWebhookUrl) {
+      throw new Error(`Teams frontend requires "teamsWebhookUrl" in ${CONFIG_FILE}. Run "talon setup" to configure.`);
+    }
+  }
+
+  const activeFrontend = frontends[0];
+
+  return {
+    ...parsed,
+    workspace: dirs.workspace,
+    systemPrompt: loadSystemPrompt(activeFrontend),
+  };
+}
+
+/**
+ * Rebuild the system prompt with plugin additions.
+ * Called after plugins are loaded to inject their prompt contributions.
+ */
+export function rebuildSystemPrompt(config: TalonConfig, pluginAdditions: string[]): void {
+  const frontends = Array.isArray(config.frontend) ? config.frontend : [config.frontend];
+  config.systemPrompt = loadSystemPrompt(frontends[0], pluginAdditions.length > 0 ? pluginAdditions : undefined);
+}