opencandle 0.3.0 → 0.5.0

package/gui/server/session-actions.ts

@@ -0,0 +1,31 @@
+import { unlink } from "node:fs/promises";
+import { SessionManager } from "@earendil-works/pi-coding-agent";
+
+export async function renameSessionFile(
+  cwd: string,
+  sessionDir: string,
+  sessionPath: string,
+  nextName: string,
+): Promise<void> {
+  const target = await resolveListedSession(cwd, sessionDir, sessionPath);
+  const name = nextName.trim();
+  if (!name) throw new Error("Session name cannot be empty");
+  const manager = SessionManager.open(target.path);
+  manager.appendSessionInfo(name);
+}
+
+export async function deleteSessionFile(
+  cwd: string,
+  sessionDir: string,
+  sessionPath: string,
+): Promise<void> {
+  const target = await resolveListedSession(cwd, sessionDir, sessionPath);
+  await unlink(target.path);
+}
+
+async function resolveListedSession(cwd: string, sessionDir: string, sessionPath: string) {
+  const sessions = await SessionManager.list(cwd, sessionDir);
+  const target = sessions.find((session) => session.path === sessionPath);
+  if (!target) throw new Error("Unknown saved session");
+  return target;
+}

package/gui/server/session-entry-wait.ts

@@ -0,0 +1,81 @@
+export interface WaitForEntryCountOptions {
+  timeoutMs?: number;
+  intervalMs?: number;
+}
+
+export interface WaitForSessionTurnSettlementOptions extends WaitForEntryCountOptions {
+  idleGraceMs?: number;
+}
+
+export interface SessionRunStatus {
+  isStreaming: boolean;
+  pendingMessageCount: number;
+}
+
+export async function waitForEntryCount(
+  getCount: () => number,
+  previousCount: number,
+  options: WaitForEntryCountOptions = {},
+): Promise<void> {
+  const timeoutMs = options.timeoutMs ?? 2_000;
+  const intervalMs = options.intervalMs ?? 25;
+  const deadline = Date.now() + timeoutMs;
+
+  while (getCount() <= previousCount && Date.now() < deadline) {
+    await delay(intervalMs);
+  }
+  if (getCount() <= previousCount) {
+    throw new Error("Timed out waiting for a new session entry");
+  }
+}
+
+export async function waitForNewEntryId(
+  getIds: () => string[],
+  previousIds: Set<string>,
+  options: WaitForEntryCountOptions = {},
+): Promise<void> {
+  const timeoutMs = options.timeoutMs ?? 2_000;
+  const intervalMs = options.intervalMs ?? 25;
+  const deadline = Date.now() + timeoutMs;
+
+  while (!getIds().some((id) => !previousIds.has(id)) && Date.now() < deadline) {
+    await delay(intervalMs);
+  }
+  if (!getIds().some((id) => !previousIds.has(id))) {
+    throw new Error("Timed out waiting for a new session entry");
+  }
+}
+
+export async function waitForSessionTurnSettlement(
+  getStatus: () => SessionRunStatus,
+  options: WaitForSessionTurnSettlementOptions = {},
+): Promise<void> {
+  const timeoutMs = options.timeoutMs ?? 120_000;
+  const intervalMs = options.intervalMs ?? 25;
+  const idleGraceMs = options.idleGraceMs ?? 250;
+  const deadline = Date.now() + timeoutMs;
+  let idleSince: number | undefined;
+
+  while (Date.now() < deadline) {
+    const status = getStatus();
+    const active = status.isStreaming || status.pendingMessageCount > 0;
+
+    if (active) {
+      idleSince = undefined;
+      await delay(intervalMs);
+      continue;
+    }
+
+    idleSince ??= Date.now();
+    if (Date.now() - idleSince >= idleGraceMs) {
+      return;
+    }
+
+    await delay(intervalMs);
+  }
+  throw new Error("Timed out waiting for the session turn to settle");
+}
+
+function delay(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

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: [],
+  };
+}