opencandle 0.2.0 → 0.4.0

package/gui/server/tool-metadata.ts

@@ -0,0 +1,88 @@
+import { getOpenCandleToolDefinitions } from "../../src/index.js";
+import { PROVIDERS, getCredential } from "../../src/onboarding/providers.js";
+import { getAllDefaults, setDefault } from "../../src/memory/tool-defaults.js";
+
+const WORKFLOWS = [
+  {
+    id: "comprehensive_analysis",
+    name: "Comprehensive Analysis",
+    description: "Run the multi-analyst stock analysis workflow.",
+    prompt: "/analyze {symbol}",
+    slots: [{ name: "symbol", label: "Symbol", type: "text" }],
+  },
+  {
+    id: "portfolio_builder",
+    name: "Portfolio Builder",
+    description: "Build a diversified portfolio from goals and constraints.",
+    prompt: "Build me a portfolio for {objective}",
+    slots: [{ name: "objective", label: "Objective", type: "text" }],
+  },
+  {
+    id: "options_screener",
+    name: "Options Screener",
+    description: "Screen option chains for a target symbol.",
+    prompt: "Screen options for {symbol}",
+    slots: [{ name: "symbol", label: "Symbol", type: "text" }],
+  },
+  {
+    id: "compare_assets",
+    name: "Compare Assets",
+    description: "Compare two or more assets side by side.",
+    prompt: "Compare {symbols}",
+    slots: [{ name: "symbols", label: "Symbols", type: "text" }],
+  },
+];
+
+export function buildCatalog() {
+  const defaults = getAllDefaults();
+  const tools = getOpenCandleToolDefinitions().map((tool) => ({
+    name: tool.name,
+    label: tool.label,
+    description: tool.description,
+    parameters: tool.parameters,
+    domain: inferDomain(tool.name),
+    enabled: defaults.get(tool.name)?.__enabled !== false,
+    defaults: defaults.get(tool.name) ?? {},
+  }));
+
+  return {
+    tools,
+    workflows: WORKFLOWS,
+    providers: PROVIDERS.map((provider) => {
+      const credential = getCredential(provider.id);
+      const source = credential.source;
+      return {
+        id: provider.id,
+        displayName: provider.displayName,
+        source,
+        apiKey: credential.value,
+        status:
+          source === "env"
+            ? "From env"
+            : source === "file"
+              ? "Configured"
+              : "Not configured",
+        unlocks: provider.unlocks,
+        fallbackDescription: provider.fallbackDescription,
+        signupUrl: provider.signupUrl,
+        envVar: provider.envVar,
+        instructionsHint: provider.instructionsHint,
+      };
+    }),
+  };
+}
+
+export function setToolEnabled(toolName: string, enabled: boolean): void {
+  setDefault(toolName, "__enabled", enabled);
+}
+
+function inferDomain(toolName: string): string {
+  if (toolName.includes("option")) return "options";
+  if (toolName.includes("portfolio") || toolName.includes("risk") || toolName.includes("correlation")) return "portfolio";
+  if (toolName.includes("sentiment") || toolName.includes("reddit") || toolName.includes("twitter") || toolName.includes("web")) return "sentiment";
+  if (toolName.includes("economic") || toolName.includes("fear")) return "macro";
+  if (toolName.includes("technical") || toolName.includes("backtest")) return "technical";
+  if (toolName.includes("company") || toolName.includes("financial") || toolName.includes("earnings") || toolName.includes("dcf") || toolName.includes("sec")) return "fundamentals";
+  if (toolName.includes("ask_user") || toolName.includes("login")) return "interaction";
+  return "market";
+}

package/gui/server/websocket.ts

@@ -0,0 +1,128 @@
+import { createHash } from "node:crypto";
+import type { IncomingMessage } from "node:http";
+import type { Duplex } from "node:stream";
+
+export interface WsClient {
+  send(data: unknown): void;
+  close(): void;
+  onMessage(handler: (data: unknown) => void): void;
+  onClose(handler: () => void): void;
+}
+
+export function acceptWebSocket(req: IncomingMessage, socket: Duplex): WsClient {
+  const key = req.headers["sec-websocket-key"];
+  if (typeof key !== "string") {
+    socket.destroy();
+    throw new Error("Missing Sec-WebSocket-Key");
+  }
+
+  const accept = createHash("sha1")
+    .update(`${key}258EAFA5-E914-47DA-95CA-C5AB0DC85B11`)
+    .digest("base64");
+
+  socket.write(
+    [
+      "HTTP/1.1 101 Switching Protocols",
+      "Upgrade: websocket",
+      "Connection: Upgrade",
+      `Sec-WebSocket-Accept: ${accept}`,
+      "",
+      "",
+    ].join("\r\n"),
+  );
+
+  const messageHandlers: Array<(data: unknown) => void> = [];
+  const closeHandlers: Array<() => void> = [];
+  let buffer = Buffer.alloc(0);
+
+  socket.on("data", (chunk: Buffer) => {
+    buffer = Buffer.concat([buffer, chunk]);
+    while (true) {
+      const frame = readFrame(buffer);
+      if (!frame) break;
+      buffer = buffer.subarray(frame.bytesRead);
+      if (frame.opcode === 8) {
+        socket.end();
+        break;
+      }
+      if (frame.opcode !== 1) continue;
+      try {
+        const parsed = JSON.parse(frame.payload.toString("utf8"));
+        messageHandlers.forEach((handler) => handler(parsed));
+      } catch {
+        // Ignore malformed client frames; the GUI reconnects on protocol errors.
+      }
+    }
+  });
+
+  socket.on("close", () => closeHandlers.forEach((handler) => handler()));
+  socket.on("error", () => closeHandlers.forEach((handler) => handler()));
+
+  return {
+    send(data) {
+      if (socket.destroyed) return;
+      socket.write(writeFrame(Buffer.from(JSON.stringify(data), "utf8")));
+    },
+    close() {
+      socket.end();
+    },
+    onMessage(handler) {
+      messageHandlers.push(handler);
+    },
+    onClose(handler) {
+      closeHandlers.push(handler);
+    },
+  };
+}
+
+function readFrame(buffer: Buffer): { opcode: number; payload: Buffer; bytesRead: number } | null {
+  if (buffer.length < 2) return null;
+
+  const opcode = buffer[0] & 0x0f;
+  let length = buffer[1] & 0x7f;
+  let offset = 2;
+
+  if (length === 126) {
+    if (buffer.length < offset + 2) return null;
+    length = buffer.readUInt16BE(offset);
+    offset += 2;
+  } else if (length === 127) {
+    if (buffer.length < offset + 8) return null;
+    const big = buffer.readBigUInt64BE(offset);
+    if (big > BigInt(Number.MAX_SAFE_INTEGER)) throw new Error("Frame too large");
+    length = Number(big);
+    offset += 8;
+  }
+
+  const masked = (buffer[1] & 0x80) !== 0;
+  const mask = masked ? buffer.subarray(offset, offset + 4) : null;
+  if (masked) offset += 4;
+  if (buffer.length < offset + length) return null;
+
+  const payload = Buffer.from(buffer.subarray(offset, offset + length));
+  if (mask) {
+    for (let i = 0; i < payload.length; i++) {
+      payload[i] ^= mask[i % 4];
+    }
+  }
+
+  return { opcode, payload, bytesRead: offset + length };
+}
+
+function writeFrame(payload: Buffer): Buffer {
+  if (payload.length < 126) {
+    return Buffer.concat([Buffer.from([0x81, payload.length]), payload]);
+  }
+  if (payload.length <= 65535) {
+    const header = Buffer.alloc(4);
+    header[0] = 0x81;
+    header[1] = 126;
+    header.writeUInt16BE(payload.length, 2);
+    return Buffer.concat([header, payload]);
+  }
+  const header = Buffer.alloc(10);
+  header[0] = 0x81;
+  header[1] = 127;
+  header.writeBigUInt64BE(BigInt(payload.length), 2);
+  return Buffer.concat([header, payload]);
+}

package/gui/server/writer-lock.ts

@@ -0,0 +1,118 @@
+import { mkdirSync, openSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+export type ProcessKind = "tui" | "gui";
+
+export interface WriterLock {
+  pid: number;
+  processKind: ProcessKind;
+  acquiredAt: string;
+  lastHeartbeat: string;
+}
+
+export interface AcquireOptions {
+  pid?: number;
+  staleGraceMs?: number;
+}
+
+export type AcquireResult =
+  | { role: "writer"; lock: WriterLock }
+  | { role: "follower"; lock: WriterLock };
+
+const DEFAULT_STALE_GRACE_MS = 15_000;
+
+export async function acquireWriterLock(
+  sessionDir: string,
+  processKind: ProcessKind,
+  options: AcquireOptions = {},
+): Promise<AcquireResult> {
+  mkdirSync(sessionDir, { recursive: true });
+  const pid = options.pid ?? process.pid;
+  const staleGraceMs = options.staleGraceMs ?? DEFAULT_STALE_GRACE_MS;
+
+  const created = tryCreate(sessionDir, processKind, pid);
+  if (created) return { role: "writer", lock: created };
+
+  const existing = readWriterLock(sessionDir);
+  if (existing && isLockCurrent(existing, staleGraceMs)) {
+    return { role: "follower", lock: existing };
+  }
+
+  await sleep(staleGraceMs);
+  const afterGrace = readWriterLock(sessionDir);
+  if (afterGrace && isLockCurrent(afterGrace, staleGraceMs)) {
+    return { role: "follower", lock: afterGrace };
+  }
+
+  try {
+    unlinkSync(lockPath(sessionDir));
+  } catch {
+    // Missing or concurrently removed is fine; the next create decides ownership.
+  }
+
+  const recovered = tryCreate(sessionDir, processKind, pid);
+  if (recovered) return { role: "writer", lock: recovered };
+
+  return { role: "follower", lock: readWriterLock(sessionDir) ?? afterGrace ?? existing! };
+}
+
+export function readWriterLock(sessionDir: string): WriterLock | null {
+  try {
+    return JSON.parse(readFileSync(lockPath(sessionDir), "utf8")) as WriterLock;
+  } catch {
+    return null;
+  }
+}
+
+export function refreshWriterLock(sessionDir: string, pid = process.pid): void {
+  const lock = readWriterLock(sessionDir);
+  if (!lock || lock.pid !== pid) return;
+  writeFileSync(
+    lockPath(sessionDir),
+    JSON.stringify({ ...lock, lastHeartbeat: new Date().toISOString() }, null, 2),
+  );
+}
+
+export function releaseWriterLock(sessionDir: string, pid = process.pid): void {
+  const lock = readWriterLock(sessionDir);
+  if (!lock || lock.pid !== pid) return;
+  try {
+    unlinkSync(lockPath(sessionDir));
+  } catch {
+    // Best effort shutdown cleanup.
+  }
+}
+
+function tryCreate(sessionDir: string, processKind: ProcessKind, pid: number): WriterLock | null {
+  const now = new Date().toISOString();
+  const lock: WriterLock = { pid, processKind, acquiredAt: now, lastHeartbeat: now };
+  try {
+    const fd = openSync(lockPath(sessionDir), "wx");
+    writeFileSync(fd, JSON.stringify(lock, null, 2));
+    return lock;
+  } catch {
+    return null;
+  }
+}
+
+function isPidAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function isLockCurrent(lock: WriterLock, staleGraceMs: number): boolean {
+  const heartbeat = Date.parse(lock.lastHeartbeat);
+  return isPidAlive(lock.pid) && Number.isFinite(heartbeat) && Date.now() - heartbeat <= staleGraceMs;
+}
+
+function lockPath(sessionDir: string): string {
+  return join(sessionDir, "writer.lock");
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/gui/shared/chat-events.ts

@@ -0,0 +1,118 @@
+export type ChatRole = "user" | "assistant" | "system";
+
+export interface MessageTextContent {
+  type: "text";
+  text: string;
+}
+
+export interface MessageToolContent {
+  type: "tool";
+  toolCallId: string;
+}
+
+export interface MessageImageContent {
+  type: "image";
+  url: string;
+  alt?: string;
+}
+
+export type MessageContent = MessageTextContent | MessageToolContent | MessageImageContent;
+
+export interface ToolOutput {
+  content: Array<{ type: string; text?: string; data?: string; mimeType?: string }>;
+  details?: unknown;
+  isError?: boolean;
+  source?: string;
+}
+
+export interface ToolError {
+  message: string;
+  code?: string;
+  details?: unknown;
+}
+
+export interface RunError {
+  message: string;
+  code?: string;
+  details?: unknown;
+}
+
+export interface Usage {
+  input?: number;
+  output?: number;
+  totalTokens?: number;
+  cost?: unknown;
+}
+
+export type ChatEvent =
+  | { type: "run.started"; runId: string; sessionId: string; seq: number }
+  | { type: "thinking.delta"; runId: string; text: string; seq: number }
+  | { type: "thinking.completed"; runId: string; text?: string; seq: number }
+  | { type: "message.created"; messageId: string; role: ChatRole; seq: number }
+  | { type: "message.delta"; messageId: string; text: string; seq: number }
+  | { type: "message.completed"; messageId: string; content: MessageContent[]; seq: number }
+  | { type: "tool.started"; toolCallId: string; messageId: string; name: string; input: unknown; seq: number }
+  | { type: "tool.delta"; toolCallId: string; chunk: unknown; seq: number }
+  | { type: "tool.completed"; toolCallId: string; output: ToolOutput; seq: number }
+  | { type: "tool.failed"; toolCallId: string; error: ToolError; seq: number }
+  | { type: "run.completed"; runId: string; usage?: Usage; seq: number }
+  | { type: "run.failed"; runId: string; error: RunError; seq: number }
+  | { type: "session.updated"; sessionId: string; title?: string; updatedAt: string; seq: number };
+
+export interface RenderMessage {
+  id: string;
+  role: ChatRole;
+  status: "streaming" | "completed";
+  content: MessageContent[];
+  text: string;
+}
+
+export interface RenderToolCall {
+  id: string;
+  messageId: string;
+  name: string;
+  input: unknown;
+  status: "queued" | "running" | "completed" | "failed";
+  chunks: unknown[];
+  output?: ToolOutput;
+  error?: ToolError;
+}
+
+export interface RenderThinking {
+  runId: string;
+  status: "streaming" | "completed";
+  text: string;
+}
+
+export interface ChatRunState {
+  id: string;
+  sessionId?: string;
+  status: "running" | "completed" | "failed";
+  usage?: Usage;
+  error?: RunError;
+}
+
+export interface ChatRenderState {
+  lastSeq: number;
+  seenSeq: Set<number>;
+  messages: RenderMessage[];
+  messageById: Map<string, RenderMessage>;
+  tools: Map<string, RenderToolCall>;
+  runs: Map<string, ChatRunState>;
+  thinking: Map<string, RenderThinking>;
+  session?: { id: string; title?: string; updatedAt?: string };
+  gaps: Array<{ expected: number; received: number }>;
+}
+
+export function createChatRenderState(): ChatRenderState {
+  return {
+    lastSeq: 0,
+    seenSeq: new Set(),
+    messages: [],
+    messageById: new Map(),
+    tools: new Map(),
+    runs: new Map(),
+    thinking: new Map(),
+    gaps: [],
+  };
+}

package/gui/shared/event-reducer.ts

@@ -0,0 +1,186 @@
+import {
+  createChatRenderState,
+  type ChatEvent,
+  type ChatRenderState,
+  type MessageContent,
+  type RenderMessage,
+} from "./chat-events.js";
+
+export function reduceChatEvents(events: ChatEvent[]): ChatRenderState {
+  return [...events]
+    .sort((a, b) => a.seq - b.seq)
+    .reduce((state, event) => applyChatEvent(state, event), createChatRenderState());
+}
+
+export function applyChatEvent(state: ChatRenderState, event: ChatEvent): ChatRenderState {
+  if (state.seenSeq.has(event.seq)) return state;
+
+  const next = cloneState(state);
+  if (event.seq > next.lastSeq + 1 && next.lastSeq !== 0) {
+    next.gaps.push({ expected: next.lastSeq + 1, received: event.seq });
+  }
+  next.seenSeq.add(event.seq);
+  next.lastSeq = Math.max(next.lastSeq, event.seq);
+
+  switch (event.type) {
+    case "run.started":
+      next.runs.set(event.runId, {
+        id: event.runId,
+        sessionId: event.sessionId,
+        status: "running",
+      });
+      next.session = { ...next.session, id: event.sessionId };
+      break;
+
+    case "thinking.delta": {
+      const thinking = ensureThinking(next, event.runId);
+      thinking.status = "streaming";
+      thinking.text += event.text;
+      break;
+    }
+
+    case "thinking.completed": {
+      const thinking = ensureThinking(next, event.runId);
+      thinking.status = "completed";
+      if (event.text !== undefined) thinking.text = event.text;
+      break;
+    }
+
+    case "message.created":
+      ensureMessage(next, event.messageId, event.role);
+      break;
+
+    case "message.delta": {
+      const message = ensureMessage(next, event.messageId, "assistant");
+      message.status = "streaming";
+      message.text += event.text;
+      message.content = [{ type: "text", text: message.text }];
+      break;
+    }
+
+    case "message.completed": {
+      const message = ensureMessage(next, event.messageId, "assistant");
+      message.status = "completed";
+      message.content = event.content;
+      message.text = contentText(event.content);
+      break;
+    }
+
+    case "tool.started":
+      ensureMessage(next, event.messageId, "assistant");
+      next.tools.set(event.toolCallId, {
+        id: event.toolCallId,
+        messageId: event.messageId,
+        name: event.name,
+        input: event.input,
+        status: "running",
+        chunks: [],
+      });
+      break;
+
+    case "tool.delta": {
+      const tool = next.tools.get(event.toolCallId);
+      if (tool) tool.chunks.push(event.chunk);
+      break;
+    }
+
+    case "tool.completed": {
+      const tool = next.tools.get(event.toolCallId);
+      if (tool) {
+        tool.status = event.output.isError ? "failed" : "completed";
+        tool.output = event.output;
+      }
+      break;
+    }
+
+    case "tool.failed": {
+      const tool = next.tools.get(event.toolCallId);
+      if (tool) {
+        tool.status = "failed";
+        tool.error = event.error;
+      }
+      break;
+    }
+
+    case "run.completed": {
+      const run = next.runs.get(event.runId);
+      if (run) {
+        run.status = "completed";
+        run.usage = event.usage;
+      }
+      break;
+    }
+
+    case "run.failed": {
+      const run = next.runs.get(event.runId);
+      if (run) {
+        run.status = "failed";
+        run.error = event.error;
+      }
+      break;
+    }
+
+    case "session.updated":
+      next.session = {
+        id: event.sessionId,
+        title: event.title,
+        updatedAt: event.updatedAt,
+      };
+      break;
+  }
+
+  return next;
+}
+
+function ensureMessage(state: ChatRenderState, id: string, role: RenderMessage["role"]): RenderMessage {
+  const existing = state.messageById.get(id);
+  if (existing) return existing;
+
+  const message: RenderMessage = {
+    id,
+    role,
+    status: "streaming",
+    content: [],
+    text: "",
+  };
+  state.messageById.set(id, message);
+  state.messages.push(message);
+  return message;
+}
+
+function cloneState(state: ChatRenderState): ChatRenderState {
+  const messages = state.messages.map((message) => ({
+    ...message,
+    content: [...message.content],
+  }));
+  const messageById = new Map(messages.map((message) => [message.id, message]));
+  return {
+    ...state,
+    seenSeq: new Set(state.seenSeq),
+    messages,
+    messageById,
+    tools: new Map([...state.tools].map(([id, tool]) => [id, {
+      ...tool,
+      chunks: [...tool.chunks],
+    }])),
+    runs: new Map([...state.runs].map(([id, run]) => [id, { ...run }])),
+    thinking: new Map([...state.thinking].map(([id, thinking]) => [id, { ...thinking }])),
+    session: state.session ? { ...state.session } : undefined,
+    gaps: [...state.gaps],
+  };
+}
+
+function ensureThinking(state: ChatRenderState, runId: string) {
+  const existing = state.thinking.get(runId);
+  if (existing) return existing;
+  const thinking = { runId, status: "streaming" as const, text: "" };
+  state.thinking.set(runId, thinking);
+  return thinking;
+}
+
+function contentText(content: MessageContent[]): string {
+  return content
+    .filter((part): part is Extract<MessageContent, { type: "text" }> => part.type === "text")
+    .map((part) => part.text)
+    .join("");
+}