talon-agent 1.0.0

package/src/backend/opencode/index.ts

@@ -0,0 +1,252 @@
+/**
+ * OpenCode backend — uses the OpenCode SDK as an alternative to Claude Agent SDK.
+ *
+ * Implements the same QueryBackend interface so it's a drop-in replacement.
+ * Manages an OpenCode server process and routes queries through it.
+ */
+
+import { createOpencode, type OpencodeClient } from "@opencode-ai/sdk";
+import type { TalonConfig } from "../../util/config.js";
+import type { QueryParams, QueryResult } from "../../core/types.js";
+import {
+  getSession,
+  incrementTurns,
+  recordUsage,
+  setSessionId,
+  setSessionName,
+  resetSession,
+} from "../../storage/sessions.js";
+import { getChatSettings } from "../../storage/chat-settings.js";
+import { getRecentHistory } from "../../storage/history.js";
+import { classify } from "../../core/errors.js";
+import { log, logError, logWarn } from "../../util/log.js";
+import { traceMessage } from "../../util/trace.js";
+
+// ── State ───────────────────────────────────────────────────────────────────
+
+let config: TalonConfig;
+let client: OpencodeClient | null = null;
+let serverHandle: { url: string; close(): void } | null = null;
+let gatewayPortFn: () => number = () => 19876;
+
+export function initOpenCodeAgent(
+  cfg: TalonConfig,
+  getGatewayPort?: () => number,
+): void {
+  config = cfg;
+  if (getGatewayPort) gatewayPortFn = getGatewayPort;
+}
+
+// ── Server lifecycle ────────────────────────────────────────────────────────
+
+async function ensureServer(): Promise<OpencodeClient> {
+  if (client) return client;
+
+  log("agent", "Starting OpenCode server...");
+  const result = await createOpencode({
+    port: 4096,
+    timeout: 10_000,
+  });
+  client = result.client;
+  serverHandle = result.server;
+  log("agent", `OpenCode server running at ${result.server.url}`);
+
+  // Register our MCP tools server with OpenCode
+  try {
+    const toolsPath = new URL("../claude-sdk/tools.ts", import.meta.url)
+      .pathname;
+    await client.mcp.add({
+      body: {
+        name: "talon-tools",
+        config: {
+          type: "local" as const,
+          command: ["node", "--import", "tsx", toolsPath],
+          environment: {
+            TALON_BRIDGE_URL: `http://127.0.0.1:${gatewayPortFn()}`,
+          },
+        },
+      },
+    });
+    log("agent", "Registered talon-tools MCP server with OpenCode");
+  } catch (err) {
+    logWarn(
+      "agent",
+      `MCP registration failed (tools may not be available): ${err instanceof Error ? err.message : err}`,
+    );
+  }
+
+  return client;
+}
+
+export function stopOpenCodeServer(): void {
+  if (serverHandle) {
+    serverHandle.close();
+    serverHandle = null;
+    client = null;
+    log("agent", "OpenCode server stopped");
+  }
+}
+
+// ── Session management ──────────────────────────────────────────────────────
+
+async function ensureSession(
+  oc: OpencodeClient,
+  chatId: string,
+): Promise<string> {
+  const session = getSession(chatId);
+
+  if (session.sessionId) {
+    // Verify session still exists
+    try {
+      await oc.session.get({ path: { id: session.sessionId } });
+      return session.sessionId;
+    } catch {
+      logWarn(
+        "agent",
+        `[${chatId}] Session ${session.sessionId} expired, creating new`,
+      );
+      resetSession(chatId);
+    }
+  }
+
+  // Create new session
+  const resp = await oc.session.create({
+    body: { title: `Chat ${chatId}` },
+  });
+
+  // Extract session ID from response
+  const data = resp.data as Record<string, unknown> | undefined;
+  const newId = (data?.id as string) ?? String(Date.now());
+  setSessionId(chatId, newId);
+  log("agent", `[${chatId}] Created OpenCode session: ${newId}`);
+  return newId;
+}
+
+// ── Main handler ────────────────────────────────────────────────────────────
+
+export async function handleMessage(
+  params: QueryParams,
+  _retried = false,
+): Promise<QueryResult> {
+  if (!config) throw new Error("OpenCode agent not initialized");
+
+  const { chatId, text, senderName, isGroup, onTextBlock } = params;
+  const t0 = Date.now();
+
+  const chatSettings = getChatSettings(chatId);
+  const activeModel = chatSettings.model ?? config.model;
+
+  // Resolve provider and model ID
+  const providerID = activeModel.includes("gpt")
+    ? "openai"
+    : activeModel.includes("gemini")
+      ? "google"
+      : "anthropic";
+  const modelID = activeModel;
+
+  const oc = await ensureServer();
+  const sessionId = await ensureSession(oc, chatId);
+
+  // Build prompt with group context
+  const msgIdHint = params.messageId ? ` [msg_id:${params.messageId}]` : "";
+  let continuityPrefix = "";
+  const session = getSession(chatId);
+  if (!session.sessionId && session.turns > 0) {
+    const recent = getRecentHistory(chatId, 3);
+    if (recent.length > 0) {
+      const ctx = recent
+        .map(
+          (m) =>
+            `[${new Date(m.timestamp).toISOString().slice(11, 16)}] ${m.senderName}: ${m.text.slice(0, 300)}`,
+        )
+        .join("\n");
+      continuityPrefix = `[Session resumed — recent context:\n${ctx}]\n\n`;
+    }
+  }
+
+  const prompt = isGroup
+    ? `${continuityPrefix}[${senderName}]${msgIdHint}: ${text}`
+    : `${continuityPrefix}${text}${msgIdHint}`;
+
+  log("agent", `[${chatId}] <- (${text.length} chars)`);
+  traceMessage(chatId, "in", text, { senderName, isGroup });
+
+  try {
+    const resp = await oc.session.prompt({
+      body: {
+        parts: [{ type: "text" as const, text: prompt }],
+        model: { providerID, modelID },
+        system: config.systemPrompt,
+      },
+      path: { id: sessionId },
+    });
+
+    // Extract text from response parts
+    const data = resp.data as Record<string, unknown> | undefined;
+    const parts = (data?.parts as Array<Record<string, unknown>>) ?? [];
+    let responseText = "";
+    let toolCalls = 0;
+
+    for (const part of parts) {
+      if (part.type === "text" && typeof part.text === "string") {
+        if (responseText && onTextBlock) {
+          await onTextBlock(responseText);
+        }
+        responseText = part.text;
+      } else if (part.type === "tool") {
+        toolCalls++;
+      }
+    }
+
+    const durationMs = Date.now() - t0;
+
+    // Persist session state
+    incrementTurns(chatId);
+    recordUsage(chatId, {
+      inputTokens: 0, // OpenCode doesn't expose token counts in the same way
+      outputTokens: 0,
+      cacheRead: 0,
+      cacheWrite: 0,
+      durationMs,
+      model: activeModel,
+    });
+
+    if (session.turns === 0 && text) {
+      const cleanText = text
+        .replace(/^\[.*?\]\s*/g, "")
+        .replace(/\[msg_id:\d+\]\s*/g, "")
+        .trim();
+      if (cleanText) {
+        setSessionName(
+          chatId,
+          cleanText.length > 30 ? cleanText.slice(0, 30) + "..." : cleanText,
+        );
+      }
+    }
+
+    log(
+      "agent",
+      `[${chatId}] -> (${durationMs}ms${toolCalls > 0 ? ` tools=${toolCalls}` : ""})`,
+    );
+    traceMessage(chatId, "out", responseText, { durationMs, toolCalls });
+
+    return {
+      text: responseText.trim(),
+      durationMs,
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheRead: 0,
+      cacheWrite: 0,
+    };
+  } catch (err) {
+    const classified = classify(err);
+    // Session expired — reset and retry once
+    if (classified.reason === "session_expired" && !_retried) {
+      logWarn("agent", `[${chatId}] OpenCode session expired, retrying`);
+      resetSession(chatId);
+      return handleMessage(params, true);
+    }
+    logError("agent", `[${chatId}] OpenCode error: ${classified.message}`);
+    throw classified;
+  }
+}

package/src/bootstrap.ts

@@ -0,0 +1,134 @@
+/**
+ * Shared bootstrap logic used by both the main entry point (index.ts)
+ * and the CLI chat command (cli.ts).
+ *
+ * Handles: config loading, env vars, plugin loading, workspace init,
+ * storage loading, backend + dispatcher initialization.
+ *
+ * Frontend creation and lifecycle remain with the callers since they
+ * differ (index.ts selects dynamically, cli.ts always uses terminal).
+ */
+
+import { loadConfig, rebuildSystemPrompt } from "./util/config.js";
+import { initWorkspace } from "./util/workspace.js";
+import { loadSessions } from "./storage/sessions.js";
+import { loadChatSettings } from "./storage/chat-settings.js";
+import { loadCronJobs } from "./storage/cron-store.js";
+import { loadHistory } from "./storage/history.js";
+import { loadMediaIndex } from "./storage/media-index.js";
+import { cleanupOldLogs } from "./storage/daily-log.js";
+import { initDispatcher } from "./core/dispatcher.js";
+import { initPulse, resetPulseTimer } from "./core/pulse.js";
+import { initCron } from "./core/cron.js";
+import { initDream } from "./core/dream.js";
+import { log } from "./util/log.js";
+import type { TalonConfig } from "./util/config.js";
+import type { QueryBackend, ContextManager } from "./core/types.js";
+
+// ── Types ────────────────────────────────────────────────────────────────────
+
+export type Frontend = {
+  context: ContextManager;
+  sendTyping: (chatId: number) => Promise<void>;
+  sendMessage: (chatId: number, text: string) => Promise<void>;
+  getBridgePort: () => number;
+  init: () => Promise<void>;
+  start: () => Promise<void>;
+  stop: () => Promise<void>;
+};
+
+export type BootstrapOptions = {
+  /** Override frontend names for plugin loading (e.g. ["terminal"]). */
+  frontendNames?: string[];
+};
+
+export type BootstrapResult = {
+  config: TalonConfig;
+};
+
+// ── Bootstrap: config, env, plugins, workspace, storage ──────────────────────
+
+/**
+ * Load config, set env vars, load plugins, init workspace, load all storage.
+ * Returns the loaded config for further use by the caller.
+ */
+export async function bootstrap(
+  options: BootstrapOptions = {},
+): Promise<BootstrapResult> {
+  const config = loadConfig();
+
+  // Expose search config as env vars for gateway-actions
+  if (config.braveApiKey) process.env.TALON_BRAVE_API_KEY = config.braveApiKey;
+  if (config.searxngUrl) process.env.TALON_SEARXNG_URL = config.searxngUrl;
+
+  // Load plugins (external tool packages)
+  if (config.plugins.length > 0) {
+    const { loadPlugins, getPluginPromptAdditions } = await import(
+      "./core/plugin.js"
+    );
+    const frontends =
+      options.frontendNames ??
+      (Array.isArray(config.frontend)
+        ? config.frontend
+        : [config.frontend]);
+    await loadPlugins(config.plugins, frontends);
+    rebuildSystemPrompt(config, getPluginPromptAdditions());
+  }
+
+  initWorkspace(config.workspace);
+  loadSessions();
+  loadChatSettings();
+  loadCronJobs();
+  loadHistory();
+  loadMediaIndex();
+  cleanupOldLogs();
+
+  return { config };
+}
+
+// ── Backend + dispatcher wiring ──────────────────────────────────────────────
+
+/**
+ * Create the AI backend and wire the dispatcher.
+ * Call this after creating the frontend.
+ */
+export async function initBackendAndDispatcher(
+  config: TalonConfig,
+  frontend: Frontend,
+): Promise<void> {
+  let backend: QueryBackend;
+
+  if (config.backend === "opencode") {
+    const {
+      initOpenCodeAgent,
+      handleMessage: opencodeHandleMessage,
+    } = await import("./backend/opencode/index.js");
+    initOpenCodeAgent(config, frontend.getBridgePort);
+    backend = { query: (params) => opencodeHandleMessage(params) };
+    log("bot", "Backend: OpenCode");
+  } else {
+    const {
+      initAgent: initClaudeAgent,
+      handleMessage: claudeHandleMessage,
+    } = await import("./backend/claude-sdk/index.js");
+    initClaudeAgent(config, frontend.getBridgePort);
+    backend = { query: (params) => claudeHandleMessage(params) };
+    log("bot", "Backend: Claude SDK");
+  }
+
+  initDispatcher({
+    backend,
+    context: frontend.context,
+    sendTyping: frontend.sendTyping,
+    onActivity: () => resetPulseTimer(),
+  });
+
+  initPulse();
+  initCron({ sendMessage: frontend.sendMessage });
+  initDream({
+    model: config.model,
+    dreamModel: config.dreamModel,
+    claudeBinary: config.claudeBinary,
+    workspace: config.workspace,
+  });
+}