talon-agent 1.0.0

package/src/login.ts

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+/**
+ * One-time login script for the GramJS user session.
+ * Run: npx tsx src/login.ts
+ *
+ * You'll need:
+ * - TALON_API_ID and TALON_API_HASH from https://my.telegram.org
+ * - Your phone number (will receive a login code via Telegram)
+ */
+
+import { TelegramClient } from "telegram";
+import { StringSession } from "telegram/sessions/index.js";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+import { createInterface } from "node:readline";
+import { files } from "./util/paths.js";
+
+// Load .env
+const envPath = resolve(process.cwd(), ".env");
+if (existsSync(envPath)) {
+  for (const line of readFileSync(envPath, "utf-8").split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eq = trimmed.indexOf("=");
+    if (eq <= 0) continue;
+    const key = trimmed.slice(0, eq).trim();
+    let value = trimmed.slice(eq + 1).trim();
+    if (
+      (value.startsWith('"') && value.endsWith('"')) ||
+      (value.startsWith("'") && value.endsWith("'"))
+    ) {
+      value = value.slice(1, -1);
+    }
+    if (!process.env[key]) process.env[key] = value;
+  }
+}
+
+const SESSION_FILE = files.userSession;
+
+const apiId = parseInt(process.env.TALON_API_ID || "", 10);
+const apiHash = process.env.TALON_API_HASH || "";
+
+if (!apiId || !apiHash) {
+  console.error("Set TALON_API_ID and TALON_API_HASH in .env");
+  console.error(
+    "Get them from https://my.telegram.org → API development tools",
+  );
+  process.exit(1);
+}
+
+const rl = createInterface({ input: process.stdin, output: process.stdout });
+const ask = (q: string): Promise<string> =>
+  new Promise((resolve) => rl.question(q, resolve));
+
+async function main() {
+  let sessionString = "";
+  if (existsSync(SESSION_FILE)) {
+    sessionString = readFileSync(SESSION_FILE, "utf-8").trim();
+  }
+
+  const session = new StringSession(sessionString);
+  const client = new TelegramClient(session, apiId, apiHash, {
+    connectionRetries: 5,
+  });
+
+  await client.start({
+    phoneNumber: async () => await ask("Phone number (with country code): "),
+    password: async () => await ask("2FA password (if enabled): "),
+    phoneCode: async () => await ask("Login code from Telegram: "),
+    onError: (err) => console.error("Login error:", err),
+  });
+
+  console.log("\nLogged in successfully!");
+
+  // Save session
+  const newSession = client.session.save() as unknown as string;
+  const dir = dirname(SESSION_FILE);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(SESSION_FILE, newSession);
+  console.log(`Session saved to ${SESSION_FILE}`);
+
+  await client.disconnect();
+  rl.close();
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/src/storage/chat-settings.ts

@@ -0,0 +1,218 @@
+/**
+ * Per-chat runtime settings. Overrides global config on a per-chat basis.
+ * Persisted alongside sessions.
+ */
+
+import { existsSync, readFileSync, mkdirSync } from "node:fs";
+import writeFileAtomic from "write-file-atomic";
+import { dirname } from "node:path";
+import { log } from "../util/log.js";
+import { files } from "../util/paths.js";
+
+export type EffortLevel = "off" | "low" | "medium" | "high" | "max";
+
+export type ChatSettings = {
+  /** Model override for this chat. */
+  model?: string;
+  /** Effort level override (maps to SDK thinking + effort options). */
+  effort?: EffortLevel;
+  /** Whether pulse is enabled for this chat. */
+  pulse?: boolean;
+  /** Per-chat pulse check interval in milliseconds. */
+  pulseIntervalMs?: number;
+  /** Last message ID checked by pulse (persisted to avoid reprocessing on restart). */
+  pulseLastCheckMsgId?: number;
+};
+
+const STORE_FILE = files.chatSettings;
+let store: Record<string, ChatSettings> = {};
+let dirty = false;
+
+export function loadChatSettings(): void {
+  try {
+    if (existsSync(STORE_FILE)) {
+      store = JSON.parse(readFileSync(STORE_FILE, "utf-8"));
+    }
+  } catch {
+    // Primary corrupt — try backup
+    const bakFile = STORE_FILE + ".bak";
+    try {
+      if (existsSync(bakFile)) {
+        store = JSON.parse(readFileSync(bakFile, "utf-8"));
+        log("settings", "Loaded from backup (primary was corrupt)");
+      }
+    } catch { /* backup also corrupt */ }
+  }
+  // Migrate legacy maxThinkingTokens → effort
+  let migrated = 0;
+  for (const [chatId, settings] of Object.entries(store)) {
+    const raw = settings as Record<string, unknown>;
+    if ("maxThinkingTokens" in raw && !settings.effort) {
+      const tokens = Number(raw.maxThinkingTokens);
+      let effort: EffortLevel;
+      if (tokens === 0) effort = "off";
+      else if (tokens <= 2000) effort = "low";
+      else if (tokens <= 8000) effort = "medium";
+      else if (tokens <= 16000) effort = "high";
+      else effort = "max";
+      settings.effort = effort;
+      delete raw.maxThinkingTokens;
+      migrated++;
+      log(
+        "settings",
+        `Migrated chat ${chatId}: maxThinkingTokens=${tokens} to effort=${effort}`,
+      );
+    } else if ("maxThinkingTokens" in raw) {
+      // Has effort already, just clean up the old field
+      delete raw.maxThinkingTokens;
+      migrated++;
+    }
+  }
+  if (migrated > 0) {
+    dirty = true;
+    save();
+    log(
+      "settings",
+      `Migrated ${migrated} chat(s) from maxThinkingTokens to effort`,
+    );
+  }
+}
+
+function save(): void {
+  if (!dirty) return;
+  try {
+    const dir = dirname(STORE_FILE);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    const data = JSON.stringify(store, null, 2) + "\n";
+    if (existsSync(STORE_FILE)) {
+      try { writeFileAtomic.sync(STORE_FILE + ".bak", readFileSync(STORE_FILE)); } catch { /* best effort */ }
+    }
+    writeFileAtomic.sync(STORE_FILE, data);
+    dirty = false;
+  } catch {
+    // Non-fatal
+  }
+}
+
+const autoSaveTimer = setInterval(save, 10_000);
+process.on("exit", save);
+
+/** Flush settings to disk and stop the auto-save timer. */
+export function flushChatSettings(): void {
+  clearInterval(autoSaveTimer);
+  save();
+}
+
+export function getChatSettings(chatId: string): ChatSettings {
+  return store[chatId] ?? {};
+}
+
+function cleanupEmpty(chatId: string): void {
+  const s = store[chatId];
+  if (s && !s.model && !s.effort && s.pulse === undefined && s.pulseIntervalMs === undefined && s.pulseLastCheckMsgId === undefined) {
+    delete store[chatId];
+  }
+}
+
+export function setPulseLastCheckMsgId(chatId: string, msgId: number | undefined): void {
+  if (!store[chatId]) store[chatId] = {};
+  if (msgId !== undefined) {
+    store[chatId].pulseLastCheckMsgId = msgId;
+  } else {
+    delete store[chatId].pulseLastCheckMsgId;
+    cleanupEmpty(chatId);
+  }
+  dirty = true;
+  // Don't force-save on every pulse check — let the auto-save interval handle it
+}
+
+export function setChatModel(chatId: string, model: string | undefined): void {
+  if (!store[chatId]) store[chatId] = {};
+  if (model) {
+    store[chatId].model = model;
+  } else {
+    delete store[chatId].model;
+    cleanupEmpty(chatId);
+  }
+  dirty = true;
+  save();
+}
+
+export function setChatEffort(
+  chatId: string,
+  effort: EffortLevel | undefined,
+): void {
+  if (!store[chatId]) store[chatId] = {};
+  if (effort) {
+    store[chatId].effort = effort;
+  } else {
+    delete store[chatId].effort;
+    cleanupEmpty(chatId);
+  }
+  dirty = true;
+  save();
+}
+
+export function setChatPulse(
+  chatId: string,
+  enabled: boolean | undefined,
+): void {
+  if (!store[chatId]) store[chatId] = {};
+  if (enabled !== undefined) {
+    store[chatId].pulse = enabled;
+  } else {
+    delete store[chatId].pulse;
+    cleanupEmpty(chatId);
+  }
+  dirty = true;
+  save();
+}
+
+export function setChatPulseInterval(
+  chatId: string,
+  intervalMs: number | undefined,
+): void {
+  if (!store[chatId]) store[chatId] = {};
+  if (intervalMs !== undefined) {
+    store[chatId].pulseIntervalMs = intervalMs;
+  } else {
+    delete store[chatId].pulseIntervalMs;
+    cleanupEmpty(chatId);
+  }
+  dirty = true;
+  save();
+}
+
+/** Get all chat IDs that have pulse enabled in settings. */
+export function getRegisteredPulseChats(): string[] {
+  return Object.entries(store)
+    .filter(([, s]) => s.pulse === true)
+    .map(([id]) => id);
+}
+
+/** Valid effort levels. */
+export const EFFORT_LEVELS: EffortLevel[] = [
+  "off",
+  "low",
+  "medium",
+  "high",
+  "max",
+];
+
+/** Known model aliases. */
+export const MODEL_ALIASES: Record<string, string> = {
+  sonnet: "claude-sonnet-4-6",
+  opus: "claude-opus-4-6",
+  haiku: "claude-haiku-4-5",
+  "sonnet-4.6": "claude-sonnet-4-6",
+  "opus-4.6": "claude-opus-4-6",
+  "haiku-4.5": "claude-haiku-4-5",
+  "sonnet-4-6": "claude-sonnet-4-6",
+  "opus-4-6": "claude-opus-4-6",
+  "haiku-4-5": "claude-haiku-4-5",
+};
+
+export function resolveModelName(input: string): string {
+  const lower = input.trim().toLowerCase();
+  return Object.hasOwn(MODEL_ALIASES, lower) ? MODEL_ALIASES[lower] : input.trim();
+}

package/src/storage/cron-store.ts

@@ -0,0 +1,165 @@
+/**
+ * Persistent cron job store. In-memory Map with dirty-flag auto-save to workspace/cron.json.
+ * Same pattern as chat-settings.ts.
+ */
+
+import { existsSync, readFileSync, mkdirSync } from "node:fs";
+import writeFileAtomic from "write-file-atomic";
+import { dirname } from "node:path";
+import { Cron } from "croner";
+import { log } from "../util/log.js";
+import { files } from "../util/paths.js";
+
+export type CronJobType = "message" | "query";
+
+export type CronJob = {
+  id: string;
+  chatId: string;
+  /** Cron expression (5-field: minute hour day month weekday) */
+  schedule: string;
+  /** "message" sends content as text; "query" runs content as a Claude prompt with tools */
+  type: CronJobType;
+  /** The message text or query prompt */
+  content: string;
+  /** Human-readable name for the job */
+  name: string;
+  enabled: boolean;
+  createdAt: number;
+  lastRunAt?: number;
+  runCount: number;
+  /** IANA timezone (e.g. "America/New_York"). Defaults to system timezone. */
+  timezone?: string;
+};
+
+const STORE_FILE = files.cron;
+let store: Record<string, CronJob> = {};
+let dirty = false;
+
+export function loadCronJobs(): void {
+  try {
+    if (existsSync(STORE_FILE)) {
+      const raw = JSON.parse(readFileSync(STORE_FILE, "utf-8"));
+      // Support both array (legacy) and object formats
+      if (Array.isArray(raw)) {
+        for (const job of raw) store[job.id] = job;
+      } else {
+        store = raw;
+      }
+    }
+  } catch {
+    // Primary corrupt — try backup
+    const bakFile = STORE_FILE + ".bak";
+    try {
+      if (existsSync(bakFile)) {
+        const raw = JSON.parse(readFileSync(bakFile, "utf-8"));
+        store = Array.isArray(raw) ? Object.fromEntries(raw.map((j: CronJob) => [j.id, j])) : raw;
+        log("cron", "Loaded from backup (primary was corrupt)");
+      }
+    } catch { /* backup also corrupt */ }
+  }
+  const count = Object.keys(store).length;
+  if (count > 0) {
+    log("cron", `Loaded ${count} cron job(s)`);
+  }
+}
+
+function save(): void {
+  if (!dirty) return;
+  try {
+    const dir = dirname(STORE_FILE);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    const data = JSON.stringify(store, null, 2) + "\n";
+    if (existsSync(STORE_FILE)) {
+      try { writeFileAtomic.sync(STORE_FILE + ".bak", readFileSync(STORE_FILE)); } catch { /* best effort */ }
+    }
+    writeFileAtomic.sync(STORE_FILE, data);
+    dirty = false;
+  } catch {
+    // Non-fatal
+  }
+}
+
+const autoSaveTimer = setInterval(save, 10_000);
+process.on("exit", save);
+
+/** Flush cron jobs to disk and stop the auto-save timer. */
+export function flushCronJobs(): void {
+  clearInterval(autoSaveTimer);
+  save();
+}
+
+// ── ID generation ───────────────────────────────────────────────────────────
+
+export function generateCronId(): string {
+  return `cron_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+}
+
+// ── Validation ──────────────────────────────────────────────────────────────
+
+export function validateCronExpression(
+  expr: string,
+  timezone?: string,
+): { valid: boolean; error?: string; next?: string } {
+  try {
+    const cron = new Cron(expr, { timezone: timezone ?? undefined });
+    const nextDate = cron.nextRun();
+    return {
+      valid: true,
+      next: nextDate ? nextDate.toISOString() : undefined,
+    };
+  } catch (err) {
+    return {
+      valid: false,
+      error: err instanceof Error ? err.message : String(err),
+    };
+  }
+}
+
+// ── CRUD ────────────────────────────────────────────────────────────────────
+
+export function addCronJob(job: CronJob): void {
+  store[job.id] = job;
+  dirty = true;
+  save();
+}
+
+export function getCronJob(id: string): CronJob | undefined {
+  return store[id];
+}
+
+export function getCronJobsForChat(chatId: string): CronJob[] {
+  return Object.values(store).filter((j) => j.chatId === chatId);
+}
+
+export function getAllCronJobs(): CronJob[] {
+  return Object.values(store);
+}
+
+export function updateCronJob(
+  id: string,
+  updates: Partial<Omit<CronJob, "id" | "chatId" | "createdAt">>,
+): CronJob | undefined {
+  const job = store[id];
+  if (!job) return undefined;
+  Object.assign(job, updates);
+  dirty = true;
+  save();
+  return job;
+}
+
+export function deleteCronJob(id: string): boolean {
+  if (!store[id]) return false;
+  delete store[id];
+  dirty = true;
+  save();
+  return true;
+}
+
+export function recordCronRun(id: string): void {
+  const job = store[id];
+  if (!job) return;
+  job.lastRunAt = Date.now();
+  job.runCount = (job.runCount || 0) + 1;
+  dirty = true;
+  // Don't force-save on every run; let the interval handle it
+}

package/src/storage/daily-log.ts

@@ -0,0 +1,97 @@
+/**
+ * Daily log system — appends brief interaction summaries to workspace/logs/YYYY-MM-DD.md.
+ * Claude can reference these via the Read tool for continuity across sessions.
+ */
+
+import { existsSync, mkdirSync, appendFileSync, readdirSync, unlinkSync } from "node:fs";
+import { resolve } from "node:path";
+import { log as logInfo, logError } from "../util/log.js";
+import { dirs } from "../util/paths.js";
+
+const LOGS_DIR = dirs.logs;
+const MAX_LOG_DAYS = 30; // Keep last 30 days of logs
+
+function ensureLogsDir(): void {
+  if (!existsSync(LOGS_DIR)) {
+    mkdirSync(LOGS_DIR, { recursive: true });
+  }
+}
+
+/**
+ * Append a user message entry to today's daily log.
+ * Format: ## HH:MM -- [chatTitle/userName]\nmessage text\n
+ * @param chatName - Display name of the sender (or "System")
+ * @param text - Message content
+ * @param chatContext - Optional chat context (group title, username, etc.)
+ */
+export function appendDailyLog(chatName: string, text: string, chatContext?: { chatTitle?: string; username?: string }): void {
+  try {
+    ensureLogsDir();
+    const now = new Date();
+    const dateStr = now.toISOString().slice(0, 10); // YYYY-MM-DD
+    const timeStr = now.toTimeString().slice(0, 5); // HH:MM
+    const logFile = resolve(LOGS_DIR, `${dateStr}.md`);
+
+    const label = formatLabel(chatName, chatContext);
+    const entry = `## ${timeStr} -- [${label}]\n${text}\n\n`;
+    appendFileSync(logFile, entry);
+  } catch (err) {
+    logError("bot", "Daily log write failed", err);
+  }
+}
+
+/**
+ * Append a bot response entry to today's daily log.
+ * Format: ## HH:MM -- [botName] in chatTitle\nresponse text\n
+ */
+export function appendDailyLogResponse(botName: string, text: string, chatContext?: { chatTitle?: string }): void {
+  try {
+    ensureLogsDir();
+    const now = new Date();
+    const dateStr = now.toISOString().slice(0, 10); // YYYY-MM-DD
+    const timeStr = now.toTimeString().slice(0, 5); // HH:MM
+    const logFile = resolve(LOGS_DIR, `${dateStr}.md`);
+
+    const label = chatContext?.chatTitle ? `${botName} in ${chatContext.chatTitle}` : botName;
+    const entry = `## ${timeStr} -- [${label}]\n${text}\n\n`;
+    appendFileSync(logFile, entry);
+  } catch (err) {
+    logError("bot", "Daily log response write failed", err);
+  }
+}
+
+/** Format a log label with optional chat title and username. */
+function formatLabel(name: string, ctx?: { chatTitle?: string; username?: string }): string {
+  const userPart = ctx?.username ? `${name} (@${ctx.username})` : name;
+  if (ctx?.chatTitle) return `${userPart} in ${ctx.chatTitle}`;
+  return userPart;
+}
+
+/** Get the path to the logs directory (for system prompt reference). */
+export function getLogsDir(): string {
+  return LOGS_DIR;
+}
+
+/** Remove daily logs older than MAX_LOG_DAYS. Called on startup. */
+export function cleanupOldLogs(): void {
+  try {
+    if (!existsSync(LOGS_DIR)) return;
+    const cutoff = new Date();
+    cutoff.setDate(cutoff.getDate() - MAX_LOG_DAYS);
+    const cutoffStr = cutoff.toISOString().slice(0, 10);
+
+    let deleted = 0;
+    for (const file of readdirSync(LOGS_DIR)) {
+      // Log files are named YYYY-MM-DD.md
+      if (file.endsWith(".md") && file < cutoffStr) {
+        try {
+          unlinkSync(resolve(LOGS_DIR, file));
+          deleted++;
+        } catch { /* skip */ }
+      }
+    }
+    if (deleted > 0) {
+      logInfo("workspace", `Cleaned up ${deleted} old daily log(s)`);
+    }
+  } catch { /* skip */ }
+}