opencandle 0.11.0 → 0.12.0

package/gui/server/tool-metadata.ts

@@ -1,167 +0,0 @@
-import { getOpenCandleToolDefinitions } from "../../src/index.js";
-import { getAllDefaults, setDefault } from "../../src/memory/tool-defaults.js";
-import {
-  getCredential,
-  isApiKeyProvider,
-  isExternalToolProvider,
-  isPublicHttpProvider,
-  PROVIDERS,
-  type ProviderDescriptor,
-} from "../../src/onboarding/providers.js";
-import { loadOnboardingState, type OnboardingState } from "../../src/onboarding/state.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 onboardingState = loadOnboardingState();
-  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) => serializeProvider(provider, onboardingState)),
-  };
-}
-
-function serializeProvider(provider: ProviderDescriptor, onboardingState: OnboardingState) {
-  const common = {
-    id: provider.id,
-    kind: provider.kind,
-    displayName: provider.displayName,
-    category: provider.category,
-    tier: provider.tier,
-    aliases: provider.aliases,
-    unlocks: provider.unlocks,
-    fallbackDescription: provider.fallbackDescription,
-    instructionsHint: provider.instructionsHint,
-  };
-
-  if (isApiKeyProvider(provider)) {
-    // Never serialize the credential value: this payload reaches the browser DOM.
-    const credential = getCredential(provider.id);
-    const source = credential.source;
-    return {
-      ...common,
-      source,
-      configured: source !== "absent",
-      maskedKeyHint: credential.value ? `…${credential.value.slice(-4)}` : undefined,
-      status: source,
-      signupUrl: provider.signupUrl,
-      freeTier: provider.freeTier,
-      envVar: provider.envVar,
-    };
-  }
-
-  if (isExternalToolProvider(provider)) {
-    if (onboardingState.providers[provider.id]?.status === "never_ask") {
-      return {
-        ...common,
-        status: "skipped",
-        statusDetail: {
-          providerId: provider.id,
-          kind: "external-tool",
-          mode: "install",
-          state: "skipped",
-          installCmd: provider.installCmd,
-          message: `Skipped by user preference; run opencandle doctor --enable ${provider.id} to re-enable.`,
-          checkedAt: new Date().toISOString(),
-          cacheHit: false,
-        },
-        binary: provider.binary,
-        installCmd: provider.installCmd,
-        sessionSource: provider.sessionSource,
-        supportedBrowsers: provider.supportedBrowsers,
-      };
-    }
-    return {
-      ...common,
-      status: "unknown",
-      binary: provider.binary,
-      installCmd: provider.installCmd,
-      sessionSource: provider.sessionSource,
-      supportedBrowsers: provider.supportedBrowsers,
-    };
-  }
-
-  if (isPublicHttpProvider(provider)) {
-    return {
-      ...common,
-      status: "unknown",
-      probeUrl: provider.probeUrl,
-    };
-  }
-
-  const exhaustive: never = provider;
-  return exhaustive;
-}
-
-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

@@ -1,138 +0,0 @@
-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"));
-        for (const handler of messageHandlers) {
-          handler(parsed);
-        }
-      } catch {
-        // Ignore malformed client frames; the GUI reconnects on protocol errors.
-      }
-    }
-  });
-
-  socket.on("close", () => {
-    for (const handler of closeHandlers) {
-      handler();
-    }
-  });
-  socket.on("error", () => {
-    for (const handler of closeHandlers) {
-      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

@@ -1 +0,0 @@
-export * from "../../src/pi/session-writer-lock.js";

package/gui/server/ws-hub.ts

@@ -1,391 +0,0 @@
-import type { IncomingMessage } from "node:http";
-import type { Duplex } from "node:stream";
-import {
-  type AgentSession,
-  type SessionEntry,
-  SessionManager,
-} from "@earendil-works/pi-coding-agent";
-import { probeProviderStatus } from "../../src/onboarding/provider-status.js";
-import { getProvider, type ProviderId } from "../../src/onboarding/providers.js";
-import {
-  clearProviderOnboardingEntry,
-  loadOnboardingState,
-  saveOnboardingState,
-} from "../../src/onboarding/state.js";
-import type { ChatEvent } from "../shared/chat-events.js";
-import type { BackgroundQuoteRefreshes } from "./background-quotes.js";
-import { sessionEntriesToChatEvents } from "./chat-event-adapter.js";
-import type { ToolInvokeController } from "./invoke-tool.js";
-import type { ModelSetupController } from "./model-setup.js";
-import { projectDashboard } from "./projector.js";
-import type { SessionActionsController } from "./session-actions.js";
-import { buildCatalog, setToolEnabled } from "./tool-metadata.js";
-import { acceptWebSocket, type WsClient } from "./websocket.js";
-import { readWriterLock, writerLockScopeForSession } from "./writer-lock.js";
-
-interface AskUserBridge {
-  getPrompts(): unknown[];
-}
-
-export interface WsHub {
-  handleUpgrade(req: IncomingMessage, socket: Duplex): void;
-  getClientCount(): number;
-  closeClients(): void;
-  sendBoot(client: WsClient): void;
-  buildBootstrapPayload(): Promise<Record<string, unknown>>;
-  broadcast(message: unknown): void;
-  broadcastModelSetup(): void;
-  broadcastState(): void;
-  broadcastSessionSnapshot(sessionManager: SessionManager): void;
-  broadcastSessions(): void;
-  buildStateSnapshot(): {
-    sessionId: string;
-    state: unknown;
-    entries: SessionEntry[];
-    events: ChatEvent[];
-  };
-  currentChatEvents(entries?: SessionEntry[]): ChatEvent[];
-  subscribeToSessionEvents(): () => void;
-}
-
-export interface WsHubOptions {
-  role: string;
-  lock: unknown;
-  cwd: string;
-  sessionDir: string;
-  getSession: () => AgentSession;
-  getSessionManager: () => SessionManager;
-  backgroundQuoteRefreshes: BackgroundQuoteRefreshes;
-  askUserBridge: AskUserBridge;
-  modelSetupController: ModelSetupController;
-  toolInvokeController: ToolInvokeController;
-  sessionActionsController: SessionActionsController;
-  onClientCountChanged: () => void;
-  isTrustedRequest?: (req: IncomingMessage) => boolean;
-  acceptWebSocketFn?: typeof acceptWebSocket;
-}
-
-export function createWsHub({
-  role,
-  lock,
-  cwd,
-  sessionDir,
-  getSession,
-  getSessionManager,
-  backgroundQuoteRefreshes,
-  askUserBridge,
-  modelSetupController,
-  toolInvokeController,
-  sessionActionsController,
-  onClientCountChanged,
-  isTrustedRequest = () => true,
-  acceptWebSocketFn = acceptWebSocket,
-}: WsHubOptions): WsHub {
-  const clients = new Set<WsClient>();
-
-  function handleUpgrade(req: IncomingMessage, socket: Duplex): void {
-    if (req.url !== "/ws") {
-      socket.destroy();
-      return;
-    }
-    if (!isTrustedRequest(req)) {
-      socket.destroy();
-      return;
-    }
-
-    const client = acceptWebSocketFn(req, socket);
-    clients.add(client);
-    client.onClose(() => {
-      clients.delete(client);
-      onClientCountChanged();
-    });
-    client.onMessage((message) => void handleClientMessage(client, message));
-    sendBoot(client);
-    onClientCountChanged();
-  }
-
-  async function handleClientMessage(client: WsClient, message: unknown): Promise<void> {
-    const data = asRecord(message);
-    try {
-      switch (data.type) {
-        case "chat.prompt":
-          await sessionActionsController.handlePrompt(String(data.prompt ?? ""));
-          break;
-        case "ask_user.answer":
-          await sessionActionsController.handleAskUserAnswer(String(data.id ?? ""), data.answer, {
-            actionId: String(data.actionId ?? ""),
-            sessionId: String(data.sessionId ?? ""),
-            source: "browser",
-          });
-          break;
-        case "ask_user.cancel":
-          await sessionActionsController.handleAskUserCancel(String(data.id ?? ""), {
-            actionId: String(data.actionId ?? ""),
-            sessionId: String(data.sessionId ?? ""),
-            source: "browser",
-          });
-          break;
-        case "tool.invoke":
-          await toolInvokeController.handleToolInvokeMessage(client, data);
-          break;
-        case "tool.enabled":
-          if (role !== "writer") throw new Error("Read-only follower mode");
-          setToolEnabled(String(data.toolName), Boolean(data.enabled));
-          broadcast({ type: "catalog", catalog: buildCatalog(), restartRequired: true });
-          break;
-        case "catalog.refresh":
-          client.send({ type: "catalog", catalog: buildCatalog() });
-          break;
-        case "model.setup.refresh":
-          getSession().modelRegistry.refresh();
-          broadcastModelSetup();
-          break;
-        case "model.setup.save_api_key":
-          await modelSetupController.handleSaveModelApiKey(
-            String(data.provider ?? ""),
-            String(data.apiKey ?? ""),
-          );
-          broadcastModelSetup();
-          break;
-        case "model.setup.select_model":
-          await modelSetupController.handleSelectModel(
-            String(data.provider ?? ""),
-            String(data.modelId ?? ""),
-          );
-          broadcastModelSetup();
-          break;
-        case "provider.save_api_key":
-          await modelSetupController.handleSaveProviderApiKey(
-            String(data.providerId ?? ""),
-            String(data.apiKey ?? ""),
-          );
-          broadcast({ type: "catalog", catalog: buildCatalog() });
-          break;
-        case "provider.status.check": {
-          const providerId = String(data.providerId ?? "") as ProviderId;
-          getProvider(providerId);
-          const mode = data.mode === "session" ? "session" : "install";
-          if (data.reenable === true) {
-            saveOnboardingState(clearProviderOnboardingEntry(loadOnboardingState(), providerId));
-            broadcast({ type: "catalog", catalog: buildCatalog() });
-          }
-          const status = await probeProviderStatus(providerId, { mode, force: true });
-          client.send({ type: "provider.status", providerId, status });
-          break;
-        }
-        case "session.new":
-          await sessionActionsController.handleNewSession();
-          sendBoot(client);
-          broadcastState();
-          broadcastSessions();
-          break;
-        case "session.open":
-          await sessionActionsController.handleOpenSession(String(data.path ?? ""));
-          sendBoot(client);
-          broadcastState();
-          broadcastSessions();
-          break;
-        case "session.rename":
-          await sessionActionsController.handleRenameSession(
-            String(data.path ?? ""),
-            String(data.name ?? ""),
-          );
-          broadcastState();
-          broadcastSessions();
-          break;
-        case "session.delete":
-          await sessionActionsController.handleDeleteSession(client, String(data.path ?? ""));
-          break;
-      }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      client.send({
-        type: "error",
-        message:
-          errorMessage === "Read-only follower mode"
-            ? "OpenCandle is reconnecting to this session."
-            : errorMessage,
-      });
-    }
-  }
-
-  function getClientCount(): number {
-    return clients.size;
-  }
-
-  function closeClients(): void {
-    for (const client of clients) client.close();
-    clients.clear();
-  }
-
-  function sendBoot(client: WsClient): void {
-    const snapshot = buildStateSnapshot();
-    const sessionManager = getSessionManager();
-    client.send({
-      type: "boot",
-      role,
-      lock: publicWriterLock(lock),
-      sessionId: sessionManager.getSessionId(),
-      coordination: coordinationStateForSession(sessionManager, role, lock),
-      catalog: buildCatalog(),
-      modelSetup: modelSetupController.buildCurrentModelSetupState(),
-      askUserPrompts: askUserBridge.getPrompts(),
-    });
-    client.send({
-      type: "state.snapshot",
-      ...snapshot,
-    });
-    void SessionManager.list(cwd, sessionDir).then((sessions) =>
-      client.send({ type: "sessions", sessions }),
-    );
-  }
-
-  async function buildBootstrapPayload(): Promise<Record<string, unknown>> {
-    const sessionManager = getSessionManager();
-    return {
-      role,
-      sessionId: sessionManager.getSessionId(),
-      coordination: coordinationStateForSession(sessionManager, role, lock),
-      catalog: buildCatalog(),
-      modelSetup: modelSetupController.buildCurrentModelSetupState(),
-      askUserPrompts: askUserBridge.getPrompts(),
-      sessions: await SessionManager.list(cwd, sessionDir),
-      snapshot: buildStateSnapshot(),
-    };
-  }
-
-  function broadcastModelSetup(): void {
-    broadcast({
-      type: "model.setup",
-      modelSetup: modelSetupController.buildCurrentModelSetupState(),
-    });
-  }
-
-  function broadcastState(): void {
-    broadcast({
-      type: "state.snapshot",
-      ...buildStateSnapshot(),
-    });
-  }
-
-  function broadcastSessionSnapshot(sessionManager: SessionManager): void {
-    broadcast({
-      type: "session.snapshot",
-      ...buildSnapshotForSession(sessionManager),
-    });
-  }
-
-  function buildStateSnapshot() {
-    const sessionManager = getSessionManager();
-    const sessionId = sessionManager.getSessionId();
-    const entries = sessionManager.getEntries();
-    return {
-      sessionId,
-      state: projectDashboard(backgroundQuoteRefreshes.withEntries(entries), sessionId),
-      entries,
-      events: currentChatEvents(entries),
-      // Ownership can change mid-run (e.g. a TUI takes over the session), so
-      // snapshots re-derive coordination instead of relying on boot state.
-      coordination: coordinationStateForSession(sessionManager, role, lock),
-    };
-  }
-
-  function buildSnapshotForSession(sessionManager: SessionManager) {
-    const sessionId = sessionManager.getSessionId();
-    const entries = sessionManager.getEntries();
-    return {
-      sessionId,
-      state: projectDashboard(backgroundQuoteRefreshes.withEntries(entries), sessionId),
-      entries,
-      events: sessionEntriesToChatEvents(entries, {
-        sessionId,
-        title: sessionManager.getSessionName(),
-      }),
-    };
-  }
-
-  function currentChatEvents(entries = getSessionManager().getEntries()): ChatEvent[] {
-    const sessionManager = getSessionManager();
-    const session = getSession();
-    return sessionEntriesToChatEvents(entries, {
-      sessionId: sessionManager.getSessionId(),
-      title: sessionManager.getSessionName(),
-      markUnresolvedToolCalls: !(session.isStreaming || session.pendingMessageCount > 0),
-    });
-  }
-
-  function broadcastSessions(): void {
-    void SessionManager.list(cwd, sessionDir).then((sessions) =>
-      broadcast({ type: "sessions", sessions }),
-    );
-  }
-
-  function broadcast(message: unknown): void {
-    for (const client of clients) client.send(message);
-  }
-
-  function subscribeToSessionEvents(): () => void {
-    return getSession().subscribe((event) => {
-      broadcast({ type: "session.event", event });
-      broadcastState();
-    });
-  }
-
-  return {
-    handleUpgrade,
-    getClientCount,
-    closeClients,
-    sendBoot,
-    buildBootstrapPayload,
-    broadcast,
-    broadcastModelSetup,
-    broadcastState,
-    broadcastSessionSnapshot,
-    broadcastSessions,
-    buildStateSnapshot,
-    currentChatEvents,
-    subscribeToSessionEvents,
-  };
-}
-
-function coordinationStateForSession(
-  sessionManager: SessionManager,
-  role: string,
-  fallbackLock: unknown,
-) {
-  let sessionLock: unknown = fallbackLock;
-  try {
-    sessionLock = readWriterLock(writerLockScopeForSession(sessionManager)) ?? fallbackLock;
-  } catch {
-    sessionLock = fallbackLock;
-  }
-  const sessionId = sessionManager.getSessionId();
-  const publicLock = asRecord(publicWriterLock(sessionLock));
-  const ownedByThisProcess = publicLock.pid === process.pid;
-  const status =
-    role === "writer" && (!publicLock.pid || ownedByThisProcess)
-      ? "ready"
-      : role === "connecting"
-        ? "connecting"
-        : role === "disconnected"
-          ? "reconnecting"
-          : "syncing";
-  return {
-    sessionId,
-    status,
-    ...(typeof publicLock.processKind === "string" ? { ownerKind: publicLock.processKind } : {}),
-  };
-}
-
-function publicWriterLock(lock: unknown): unknown {
-  const record = asRecord(lock);
-  if (Object.keys(record).length === 0) return lock;
-  const { coordinatorSecret: _coordinatorSecret, ...publicLock } = record;
-  return publicLock;
-}
-
-function asRecord(value: unknown): Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value)
-    ? (value as Record<string, unknown>)
-    : {};
-}