opencandle 0.11.0 → 0.12.0

package/gui/server/session-actions.ts

@@ -1,331 +0,0 @@
-import { unlink } from "node:fs/promises";
-import { type AgentSession, SessionManager } from "@earendil-works/pi-coding-agent";
-import type {
-  LocalSessionCoordinator,
-  SessionActionEnvelope,
-  SessionActionSource,
-} from "./local-session-coordinator.js";
-import type { ModelSetupState } from "./model-setup.js";
-import { type PromptObservation, selectReplayPrompt } from "./prompt-observation.js";
-import {
-  waitForNewEntryId,
-  waitForResolvedToolCalls,
-  waitForSessionTurnSettlement,
-} from "./session-entry-wait.js";
-import { readWriterLock, writerLockScopeForSession } from "./writer-lock.js";
-
-interface AskUserBridge {
-  answer(id: string, answer: string): boolean;
-  cancel(id: string): boolean;
-}
-
-interface SessionActionsRuntime {
-  newSession(): Promise<{ cancelled: boolean }>;
-  switchSession(path: string): Promise<{ cancelled: boolean }>;
-}
-
-interface SessionActionClient {
-  send(message: unknown): void;
-}
-
-export interface SessionActionsController {
-  handlePrompt(prompt: string): Promise<void>;
-  handleAskUserAnswer(id: string, value: unknown, action?: SessionActionMeta): Promise<void>;
-  handleAskUserCancel(id: string, action?: SessionActionMeta): Promise<void>;
-  handleNewSession(): Promise<void>;
-  handleOpenSession(path: string): Promise<void>;
-  handleRenameSession(path: string, name: string): Promise<void>;
-  handleDeleteSession(client: SessionActionClient, path: string): Promise<void>;
-}
-
-export interface SessionActionsControllerOptions {
-  role: string;
-  cwd: string;
-  sessionDir: string;
-  getSession: () => AgentSession;
-  getSessionManager: () => SessionManager;
-  getModelSetupState: () => ModelSetupState;
-  askUserBridge: AskUserBridge;
-  runtime: SessionActionsRuntime;
-  sendBoot: (client: SessionActionClient) => void;
-  broadcastState: () => void;
-  broadcastSessions: () => void;
-  localSessionCoordinator?: LocalSessionCoordinator;
-  now?: () => number;
-}
-
-export interface SessionActionMeta {
-  sessionId?: string;
-  actionId?: string;
-  source?: SessionActionSource;
-  allowProxy?: boolean;
-}
-
-export function createSessionActionsController({
-  role,
-  cwd,
-  sessionDir,
-  getSession,
-  getSessionManager,
-  getModelSetupState,
-  askUserBridge,
-  runtime,
-  sendBoot,
-  broadcastState,
-  broadcastSessions,
-  localSessionCoordinator,
-  now = Date.now,
-}: SessionActionsControllerOptions): SessionActionsController {
-  function ensureWriter(): void {
-    if (role !== "writer") throw new Error("Read-only follower mode");
-  }
-
-  async function handlePrompt(prompt: string): Promise<void> {
-    ensureWriter();
-
-    const modelSetup = getModelSetupState();
-    const sessionManager = getSessionManager();
-    const trimmedPrompt = prompt.trim();
-    if (!trimmedPrompt.startsWith("/") && modelSetup.requirement !== "ready") {
-      sessionManager.appendMessage({ role: "user", content: prompt, timestamp: now() });
-      broadcastState();
-      const message =
-        modelSetup.requirement === "select_model"
-          ? "Choose an available model before chat can run. OpenCandle found configured credentials but no active model."
-          : "Connect an AI model before chat can run. Paste a Google Gemini, OpenAI, or Anthropic API key in the setup panel.";
-      sessionManager.appendCustomMessageEntry("opencandle-model-setup", message, true, {
-        source: "gui",
-        requirement: modelSetup.requirement,
-      });
-      broadcastState();
-      return;
-    }
-
-    const beforeIds = new Set(sessionManager.getEntries().map((entry) => entry.id));
-    await promptAndSettle(getSession(), prompt, beforeIds);
-    broadcastState();
-  }
-
-  async function handleAskUserAnswer(
-    id: string,
-    value: unknown,
-    action?: SessionActionMeta,
-  ): Promise<void> {
-    const answer = String(value ?? "").trim();
-    if (!answer) throw new Error("Answer cannot be empty");
-    if (shouldProxyAskUserAction(action)) {
-      if (await proxyAskUserAction("ask_user.answer", { id, answer }, action)) return;
-      throw new Error("OpenCandle is reconnecting to this session.");
-    }
-    await runCoordinatedSessionAction("ask_user.answer", { id, answer }, action, async () => {
-      if (!askUserBridge.answer(id, answer)) throw new Error("Unknown or resolved question");
-    });
-  }
-
-  async function handleAskUserCancel(id: string, action?: SessionActionMeta): Promise<void> {
-    if (shouldProxyAskUserAction(action)) {
-      if (await proxyAskUserAction("ask_user.cancel", { id }, action)) return;
-      throw new Error("OpenCandle is reconnecting to this session.");
-    }
-    await runCoordinatedSessionAction("ask_user.cancel", { id }, action, async () => {
-      if (!askUserBridge.cancel(id)) throw new Error("Unknown or resolved question");
-    });
-  }
-
-  async function handleNewSession(): Promise<void> {
-    ensureWriter();
-    const result = await runtime.newSession();
-    if (result.cancelled) throw new Error("Session switch cancelled");
-  }
-
-  async function handleOpenSession(path: string): Promise<void> {
-    ensureWriter();
-    const sessions = await SessionManager.list(cwd, sessionDir);
-    const match = sessions.find((candidate) => candidate.path === path);
-    if (!match) throw new Error("Unknown saved session");
-    const result = await runtime.switchSession(match.path);
-    if (result.cancelled) throw new Error("Session switch cancelled");
-  }
-
-  async function handleRenameSession(path: string, name: string): Promise<void> {
-    ensureWriter();
-    const nextName = name.trim();
-    if (!nextName) throw new Error("Session name cannot be empty");
-    const sessionManager = getSessionManager();
-    if (sessionManager.getSessionFile() === path) {
-      sessionManager.appendSessionInfo(nextName);
-      return;
-    }
-    await renameSessionFile(cwd, sessionDir, path, nextName);
-  }
-
-  async function handleDeleteSession(client: SessionActionClient, path: string): Promise<void> {
-    ensureWriter();
-    const deletingCurrent = getSessionManager().getSessionFile() === path;
-    await deleteSessionFile(cwd, sessionDir, path);
-    if (deletingCurrent) {
-      await handleNewSession();
-      sendBoot(client);
-      broadcastState();
-    }
-    broadcastSessions();
-  }
-
-  return {
-    handlePrompt,
-    handleAskUserAnswer,
-    handleAskUserCancel,
-    handleNewSession,
-    handleOpenSession,
-    handleRenameSession,
-    handleDeleteSession,
-  };
-
-  async function runCoordinatedSessionAction(
-    actionType: SessionActionEnvelope["actionType"],
-    payload: Record<string, unknown>,
-    action: SessionActionMeta | undefined,
-    handler: () => Promise<void> | void,
-  ): Promise<void> {
-    if (!localSessionCoordinator || !action?.actionId) {
-      await handler();
-      return;
-    }
-    const sessionId = action.sessionId?.trim() || getSessionManager().getSessionId();
-    const result = await localSessionCoordinator.runSessionAction(
-      {
-        sessionId,
-        actionId: action.actionId,
-        actionType,
-        payload,
-        source: action.source ?? "gui",
-      },
-      async () => {
-        await handler();
-        return { accepted: true };
-      },
-    );
-    if (!result.ok) throw new Error(result.message);
-  }
-
-  async function proxyAskUserAction(
-    actionType: "ask_user.answer" | "ask_user.cancel",
-    payload: Record<string, unknown>,
-    action: SessionActionMeta | undefined,
-  ): Promise<boolean> {
-    if (action?.allowProxy === false) return false;
-    const sessionManager = await resolveActionSessionManager(action);
-    const lock = readWriterLock(writerLockScopeForSession(sessionManager));
-    if (!lock?.coordinatorEndpoint || !lock.coordinatorSecret || lock.pid === process.pid) {
-      return false;
-    }
-    if (lock.processKind === "tui") return false;
-    const endpoint = new URL("/api/local-coordinator/ask-user", lock.coordinatorEndpoint);
-    let response: Response;
-    try {
-      response = await fetch(endpoint, {
-        method: "POST",
-        headers: {
-          "content-type": "application/json",
-          "x-opencandle-coordinator-secret": lock.coordinatorSecret,
-        },
-        body: JSON.stringify({
-          sessionId: action?.sessionId || sessionManager.getSessionId(),
-          actionId: action?.actionId || "",
-          actionType,
-          payload,
-        }),
-      });
-    } catch {
-      return false;
-    }
-    if (response.ok) return true;
-    const body = (await response.json().catch(() => ({}))) as { error?: string };
-    throw new Error(body.error || "OpenCandle is reconnecting to this session.");
-  }
-
-  function shouldProxyAskUserAction(action: SessionActionMeta | undefined): boolean {
-    if (role !== "writer") return true;
-    const targetSessionId = action?.sessionId?.trim();
-    return Boolean(targetSessionId && targetSessionId !== getSessionManager().getSessionId());
-  }
-
-  async function resolveActionSessionManager(
-    action: SessionActionMeta | undefined,
-  ): Promise<SessionManager> {
-    const current = getSessionManager();
-    const targetSessionId = action?.sessionId?.trim();
-    if (!targetSessionId || targetSessionId === current.getSessionId()) return current;
-    const sessions = await SessionManager.list(cwd, sessionDir);
-    const match = sessions.find((candidate) => candidate.id === targetSessionId);
-    return match ? SessionManager.open(match.path, sessionDir, cwd) : current;
-  }
-}
-
-export async function promptAndSettle(
-  runSession: AgentSession,
-  prompt: string,
-  beforeIds: Set<string>,
-  observation?: PromptObservation,
-): Promise<void> {
-  await runSession.prompt(prompt);
-  await waitForSessionTurnSettlement(() => ({
-    isStreaming: runSession.isStreaming,
-    pendingMessageCount: runSession.pendingMessageCount,
-  }));
-  await waitForNewEntryId(
-    () => runSession.sessionManager.getEntries().map((entry) => entry.id),
-    beforeIds,
-  );
-  await waitForResolvedToolCalls(() => runSession.sessionManager.getEntries());
-  await replayObservedWorkflowPromptIfNeeded(runSession, prompt, observation);
-}
-
-export async function replayObservedWorkflowPromptIfNeeded(
-  runSession: AgentSession,
-  originalPrompt: string,
-  observation?: PromptObservation,
-): Promise<void> {
-  if (!observation) return;
-  const replayPrompt = selectReplayPrompt(observation, originalPrompt);
-  if (!replayPrompt) return;
-
-  await runSession.prompt(replayPrompt, {
-    expandPromptTemplates: false,
-    source: "extension",
-  });
-  await waitForSessionTurnSettlement(() => ({
-    isStreaming: runSession.isStreaming,
-    pendingMessageCount: runSession.pendingMessageCount,
-  }));
-  await waitForResolvedToolCalls(() => runSession.sessionManager.getEntries());
-}
-
-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

@@ -1,160 +0,0 @@
-import type { SessionEntry } from "@earendil-works/pi-coding-agent";
-
-export interface WaitForEntryCountOptions {
-  timeoutMs?: number;
-  intervalMs?: number;
-}
-
-export interface WaitForSessionTurnSettlementOptions extends WaitForEntryCountOptions {
-  idleGraceMs?: number;
-}
-
-export interface SessionRunStatus {
-  isStreaming: boolean;
-  pendingMessageCount: number;
-}
-
-export interface UnresolvedToolCall {
-  id: string;
-  name: string;
-}
-
-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");
-}
-
-export function findUnresolvedToolCalls(entries: SessionEntry[]): UnresolvedToolCall[] {
-  const latestAssistantIndex = latestAssistantToolUseIndex(entries);
-  if (latestAssistantIndex === -1) return [];
-
-  const assistant = asMessage(entries[latestAssistantIndex]);
-  const calls = toolCallsFromContent(assistant?.content);
-  if (calls.length === 0) return [];
-
-  const resolved = new Set<string>();
-  for (const entry of entries.slice(latestAssistantIndex + 1)) {
-    const message = asMessage(entry);
-    if (message?.role !== "toolResult") continue;
-    const toolCallId = typeof message.toolCallId === "string" ? message.toolCallId : "";
-    if (toolCallId) resolved.add(toolCallId);
-  }
-
-  return calls.filter((call) => !resolved.has(call.id));
-}
-
-export async function waitForResolvedToolCalls(
-  getEntries: () => SessionEntry[],
-  options: WaitForEntryCountOptions = {},
-): Promise<void> {
-  const timeoutMs = options.timeoutMs ?? 120_000;
-  const intervalMs = options.intervalMs ?? 25;
-  const deadline = Date.now() + timeoutMs;
-
-  while (Date.now() < deadline) {
-    if (findUnresolvedToolCalls(getEntries()).length === 0) return;
-    await delay(intervalMs);
-  }
-
-  const unresolved = findUnresolvedToolCalls(getEntries());
-  if (unresolved.length > 0) {
-    throw new Error(
-      `Timed out waiting for tool results: ${unresolved.map((call) => call.name).join(", ")}`,
-    );
-  }
-}
-
-function delay(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-function latestAssistantToolUseIndex(entries: SessionEntry[]): number {
-  for (let index = entries.length - 1; index >= 0; index--) {
-    const message = asMessage(entries[index]);
-    if (message?.role === "assistant") {
-      if (toolCallsFromContent(message.content).length > 0) return index;
-      if (message.stopReason === "stop") return -1;
-    }
-    if (message?.role === "user") return -1;
-  }
-  return -1;
-}
-
-function asMessage(entry: SessionEntry | undefined): Record<string, unknown> | undefined {
-  if (entry?.type !== "message") return undefined;
-  const message = (entry as { message?: unknown }).message;
-  return typeof message === "object" && message !== null && !Array.isArray(message)
-    ? (message as Record<string, unknown>)
-    : undefined;
-}
-
-function toolCallsFromContent(content: unknown): UnresolvedToolCall[] {
-  if (!Array.isArray(content)) return [];
-  return content.flatMap((part): UnresolvedToolCall[] => {
-    if (typeof part !== "object" || part === null || Array.isArray(part)) return [];
-    const record = part as Record<string, unknown>;
-    if (record.type !== "toolCall") return [];
-    const id = typeof record.id === "string" ? record.id : "";
-    const name = typeof record.name === "string" ? record.name : "tool";
-    return id ? [{ id, name }] : [];
-  });
-}

package/gui/server/shutdown.ts

@@ -1,47 +0,0 @@
-import type { Server } from "node:http";
-
-type Cleanup = () => void | Promise<void>;
-
-export interface GracefulShutdownOptions {
-  server: Server;
-  cleanup: Cleanup;
-  exit: (code: number) => void;
-  timeoutMs?: number;
-}
-
-export function createGracefulShutdown({
-  server,
-  cleanup,
-  exit,
-  timeoutMs = 1000,
-}: GracefulShutdownOptions): () => void {
-  let shuttingDown = false;
-  let exited = false;
-
-  const finish = () => {
-    if (exited) return;
-    exited = true;
-    exit(0);
-  };
-
-  return () => {
-    if (shuttingDown) return;
-    shuttingDown = true;
-
-    const timeout = setTimeout(() => {
-      server.closeAllConnections?.();
-      finish();
-    }, timeoutMs);
-    timeout.unref?.();
-
-    void Promise.resolve()
-      .then(cleanup)
-      .catch(() => undefined)
-      .finally(() => {
-        server.close(() => {
-          clearTimeout(timeout);
-          finish();
-        });
-      });
-  };
-}

package/gui/server/tool-invoke-ack.ts

@@ -1,49 +0,0 @@
-import type { InvokeToolResult } from "./invoke-tool.js";
-
-export interface ToolInvokeAckMessage {
-  type: "tool.invoke.result";
-  requestId: string;
-  ok: boolean;
-  toolName: string;
-  result?: {
-    toolCallId: string;
-    content: InvokeToolResult["result"]["content"];
-    details: unknown;
-    isError: boolean;
-  };
-  error?: {
-    message: string;
-  };
-}
-
-export function buildToolInvokeAckMessage(
-  requestId: string,
-  toolName: string,
-  invocation: InvokeToolResult,
-): ToolInvokeAckMessage {
-  const message: ToolInvokeAckMessage = {
-    type: "tool.invoke.result",
-    requestId,
-    ok: !invocation.isError,
-    toolName,
-    result: {
-      toolCallId: invocation.toolCallId,
-      content: invocation.result.content,
-      details: invocation.result.details,
-      isError: invocation.isError,
-    },
-  };
-  if (invocation.isError) {
-    message.error = { message: toolResultMessage(invocation) };
-  }
-  return message;
-}
-
-function toolResultMessage(invocation: InvokeToolResult): string {
-  for (const item of invocation.result.content) {
-    if (item?.type === "text" && typeof item.text === "string" && item.text.trim()) {
-      return item.text.trim();
-    }
-  }
-  return `${invocation.toolCallId} failed`;
-}