opencandle 0.11.1 → 0.13.0

package/dist/doctor/report.js

@@ -2,10 +2,13 @@ import { accessSync, constants, existsSync, readFileSync, statSync } from "node:
 import { createRequire } from "node:module";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { getConfig } from "../config.js";
+import { getUsage, isOverSoftThreshold, LSE_MONTHLY_BYTE_CAP } from "../infra/lse-byte-budget.js";
 import { getUnsupportedNodeVersionMessage } from "../infra/node-version.js";
 import { getConfigPath, getOnboardingPath, getOpenCandleHomeDir, getStateDbPath, resolveOpenCandlePath, } from "../infra/opencandle-paths.js";
 import { probeAllProviderStatuses, probeProviderStatus, } from "../onboarding/provider-status.js";
 import { getProvider, isExternalToolProvider, listAllProviders, } from "../onboarding/providers.js";
+import { loadOnboardingState } from "../onboarding/state.js";
 export const DOCTOR_REPORT_SCHEMA_VERSION = 1;
 const PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
 const require = createRequire(import.meta.url);
@@ -48,8 +51,8 @@ export function deriveDoctorStatus(checks) {
         return "blocked";
     }
     if (checks.some((candidate) => candidate.status === "warn" ||
-        candidate.status === "unknown" ||
-        (candidate.capability === "optional" && candidate.status === "fail"))) {
+        (candidate.capability === "optional" && candidate.status === "fail") ||
+        (candidate.capability === "core" && candidate.status === "unknown"))) {
         return "degraded";
     }
     return "ready";
@@ -261,6 +264,17 @@ async function buildProviderChecks(options) {
             respectSkipped: true,
         }));
     const checks = statuses.map((status) => providerStatusCheck(status));
+    if (getConfig().lseApiKey && isOverSoftThreshold()) {
+        const percentUsed = Math.round((getUsage().bytesUsed / LSE_MONTHLY_BYTE_CAP) * 100);
+        checks.push({
+            id: "provider.lse.byte_budget",
+            label: "London Strategic Edge",
+            status: "warn",
+            capability: "optional",
+            summary: `London Strategic Edge monthly data allowance is ${percentUsed}% used; answers use Yahoo/Alpha Vantage until the month resets.`,
+            remediation: "Wait for the monthly allowance to reset before relying on this provider again.",
+        });
+    }
     for (const provider of providers.filter(isExternalToolProvider)) {
         const installStatus = statuses.find((status) => status.providerId === provider.id && status.kind === "external-tool");
         if (installStatus?.state === "skipped")
@@ -301,16 +315,22 @@ function providerStatusCheck(status, modeOverride) {
         tier: provider.tier,
         kind: status.kind,
         state: status.state,
+        unlocks: provider.unlocks,
     };
     if (status.kind === "api-key") {
+        const configuredBefore = wasProviderConfigured(status.providerId);
+        const missing = status.state === "missing";
+        const neverConnected = missing && !configuredBefore;
         return {
             id: `provider.${status.providerId}.credential`,
             label: provider.displayName,
-            status: status.state === "configured" ? "pass" : "warn",
+            status: status.state === "configured" ? "pass" : neverConnected ? "skip" : "warn",
             capability,
             summary: status.state === "configured"
                 ? `Configured via ${status.credentialSource}`
-                : "Credential is missing",
+                : neverConnected
+                    ? "Not connected — optional."
+                    : "Credential is missing",
             remediation: status.state === "configured"
                 ? undefined
                 : `${provider.instructionsHint}. Run /connect ${provider.id}.`,
@@ -344,6 +364,7 @@ function providerStatusCheck(status, modeOverride) {
         };
     }
     const installed = status.state === "installed";
+    const missingBeforeSetup = status.state === "missing" && !wasProviderConfigured(status.providerId);
     return {
         id: `provider.${status.providerId}.binary`,
         label: `${provider.displayName} CLI`,
@@ -352,10 +373,16 @@ function providerStatusCheck(status, modeOverride) {
             : status.state === "skipped"
                 ? "skip"
                 : status.state === "missing"
-                    ? "warn"
+                    ? missingBeforeSetup
+                        ? "skip"
+                        : "warn"
                     : "unknown",
         capability: "optional",
-        summary: installed ? "Installed" : (status.message ?? `CLI ${status.state}`),
+        summary: installed
+            ? "Installed"
+            : missingBeforeSetup
+                ? "Not connected — optional."
+                : (status.message ?? `CLI ${status.state}`),
         remediation: installed
             ? undefined
             : status.state === "skipped"
@@ -364,6 +391,9 @@ function providerStatusCheck(status, modeOverride) {
         metadata,
     };
 }
+function wasProviderConfigured(providerId) {
+    return loadOnboardingState().providers[providerId]?.status === "completed";
+}
 function sessionNotCheckedCheck(provider) {
     return {
         id: `provider.${provider.id}.session`,
@@ -385,7 +415,11 @@ async function buildGuiChecks(options) {
                 label: "GUI server",
                 status: reachable ? (role === "follower" ? "warn" : "pass") : "skip",
                 capability: "optional",
-                summary: reachable ? `GUI server is ${role}` : "GUI server is not running",
+                summary: reachable
+                    ? role === "writer"
+                        ? "GUI server is running and can run sessions"
+                        : `GUI server is ${role}`
+                    : "GUI server is not running",
                 remediation: role === "follower"
                     ? "Open the writer GUI process to perform setup mutations."
                     : reachable
@@ -415,7 +449,9 @@ async function buildGuiChecks(options) {
                 status: verified ? (role === "follower" ? "warn" : "pass") : "warn",
                 capability: "optional",
                 summary: verified
-                    ? `GUI server is ${role}`
+                    ? role === "writer"
+                        ? "GUI server is running and can run sessions"
+                        : `GUI server is ${role}`
                     : response.ok
                         ? "OpenCandle GUI health payload was not verified"
                         : `GUI health returned HTTP ${response.status}`,
@@ -449,8 +485,15 @@ function sessionRemediation(providerId, installCmd) {
     return installCmd ?? "Install and authenticate the external tool.";
 }
 function buildSummary(status, checks) {
-    if (status === "ready")
-        return "OpenCandle core health is ready.";
+    if (status === "ready") {
+        const unchecked = checks.filter((candidate) => candidate.status === "unknown");
+        if (unchecked.length === 0)
+            return "OpenCandle core health is ready.";
+        if (unchecked.every((candidate) => candidate.capability === "optional")) {
+            return `OpenCandle core health is ready with ${unchecked.length} optional ${unchecked.length === 1 ? "capability" : "capabilities"} unchecked.`;
+        }
+        return `OpenCandle is usable with ${unchecked.length} unchecked ${unchecked.length === 1 ? "capability" : "capabilities"}.`;
+    }
     const firstBlocking = checks.find((candidate) => candidate.capability === "core" && candidate.status === "fail");
     if (firstBlocking)
         return `OpenCandle is blocked: ${firstBlocking.summary}.`;
@@ -497,4 +540,3 @@ function canAccess(path, mode = constants.R_OK | constants.W_OK) {
         return false;
     }
 }
-//# sourceMappingURL=report.js.map

package/dist/gui/server/ask-user-bridge.d.ts

@@ -0,0 +1,19 @@
+import type { AskUserHandler } from "../../types/index.js";
+type AskUserParams = Parameters<AskUserHandler>[0];
+export interface GuiAskUserPrompt extends AskUserParams {
+    id: string;
+    sessionId: string;
+    status: "pending" | "answered" | "cancelled";
+    answer: string | null;
+}
+export declare function createAskUserBridge({ broadcast, getSessionId, }: {
+    broadcast: (message: unknown) => void;
+    getSessionId: () => string;
+}): {
+    ask: AskUserHandler;
+    askForSession: (sessionId: string) => AskUserHandler;
+    answer: (id: string, answer: string) => boolean;
+    cancel: (id: string) => boolean;
+    getPrompts: () => GuiAskUserPrompt[];
+};
+export {};

package/dist/gui/server/ask-user-bridge.js

@@ -0,0 +1,55 @@
+export function createAskUserBridge({ broadcast, getSessionId, }) {
+    let nextId = 1;
+    const prompts = new Map();
+    const pending = new Map();
+    const createAskHandler = (resolveSessionId) => async (params) => {
+        const id = `ask-user-${Date.now()}-${nextId++}`;
+        const prompt = {
+            id,
+            sessionId: resolveSessionId(),
+            question: params.question,
+            questionType: params.questionType,
+            options: params.options,
+            placeholder: params.placeholder,
+            reason: params.reason,
+            status: "pending",
+            answer: null,
+        };
+        prompts.set(id, prompt);
+        broadcast({ type: "ask_user.prompt", prompt });
+        return new Promise((resolve) => {
+            pending.set(id, { prompt, resolve });
+        });
+    };
+    const ask = createAskHandler(getSessionId);
+    const resolvePrompt = (id, result) => {
+        const item = pending.get(id);
+        if (!item)
+            return false;
+        pending.delete(id);
+        const prompt = {
+            ...item.prompt,
+            status: result.cancelled ? "cancelled" : "answered",
+            answer: result.cancelled ? null : (result.answer ?? null),
+        };
+        prompts.set(id, prompt);
+        broadcast({ type: "ask_user.resolved", prompt });
+        item.resolve(result);
+        return true;
+    };
+    return {
+        ask,
+        askForSession(sessionId) {
+            return createAskHandler(() => sessionId);
+        },
+        answer(id, answer) {
+            return resolvePrompt(id, { answer, cancelled: false });
+        },
+        cancel(id) {
+            return resolvePrompt(id, { answer: null, cancelled: true });
+        },
+        getPrompts() {
+            return [...prompts.values()];
+        },
+    };
+}

package/dist/gui/server/automation-heartbeat.d.ts

@@ -0,0 +1,25 @@
+import { runLocalAutomationHeartbeat } from "../../market-state/local-automation-service.js";
+import { initDefaultDatabase } from "../../memory/sqlite.js";
+export declare const DEFAULT_AUTOMATION_HEARTBEAT_MS = 60000;
+export declare const MIN_AUTOMATION_HEARTBEAT_MS = 5000;
+export declare function normalizeAutomationHeartbeatMs(raw: string | undefined): number;
+export declare function createAutomationHeartbeatRunner(run: (checkAlerts: boolean) => Promise<void>): (checkAlerts: boolean) => Promise<boolean>;
+type IntervalHandle = ReturnType<typeof setInterval>;
+type SetIntervalFn = (callback: () => void, ms: number) => IntervalHandle;
+type ClearIntervalFn = (handle: IntervalHandle) => void;
+export interface LocalAutomationHeartbeat {
+    start(): void;
+    stop(): void;
+}
+export interface LocalAutomationHeartbeatOptions {
+    role: string;
+    getSessionId: () => string;
+    intervalMs: number;
+    initDatabase?: typeof initDefaultDatabase;
+    runHeartbeat?: typeof runLocalAutomationHeartbeat;
+    setIntervalFn?: SetIntervalFn;
+    clearIntervalFn?: ClearIntervalFn;
+    warn?: (message: string) => void;
+}
+export declare function createLocalAutomationHeartbeat({ role, getSessionId, intervalMs, initDatabase, runHeartbeat, setIntervalFn, clearIntervalFn, warn, }: LocalAutomationHeartbeatOptions): LocalAutomationHeartbeat;
+export {};

package/dist/gui/server/automation-heartbeat.js

@@ -0,0 +1,61 @@
+import { runLocalAutomationHeartbeat } from "../../market-state/local-automation-service.js";
+import { initDefaultDatabase } from "../../memory/sqlite.js";
+export const DEFAULT_AUTOMATION_HEARTBEAT_MS = 60_000;
+export const MIN_AUTOMATION_HEARTBEAT_MS = 5_000;
+export function normalizeAutomationHeartbeatMs(raw) {
+    if (raw == null || raw.trim() === "")
+        return DEFAULT_AUTOMATION_HEARTBEAT_MS;
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed) || parsed < MIN_AUTOMATION_HEARTBEAT_MS)
+        return DEFAULT_AUTOMATION_HEARTBEAT_MS;
+    return Math.floor(parsed);
+}
+export function createAutomationHeartbeatRunner(run) {
+    let inFlight = false;
+    return async (checkAlerts) => {
+        if (inFlight)
+            return false;
+        inFlight = true;
+        try {
+            await run(checkAlerts);
+            return true;
+        }
+        finally {
+            inFlight = false;
+        }
+    };
+}
+export function createLocalAutomationHeartbeat({ role, getSessionId, intervalMs, initDatabase = initDefaultDatabase, runHeartbeat = runLocalAutomationHeartbeat, setIntervalFn = setInterval, clearIntervalFn = clearInterval, warn = (message) => console.warn(message), }) {
+    let automationHeartbeat = null;
+    async function executeGuiAutomationHeartbeat(checkAlerts) {
+        const db = initDatabase();
+        try {
+            await runHeartbeat(db, {
+                ownerId: `gui:${getSessionId()}`,
+                ownerKind: "writer",
+                ttlSeconds: Math.max(90, Math.ceil((intervalMs * 2) / 1000)),
+                checkAlerts,
+            });
+        }
+        catch (error) {
+            warn(`Local automation heartbeat failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        finally {
+            db.close();
+        }
+    }
+    const runGuiAutomationHeartbeat = createAutomationHeartbeatRunner(executeGuiAutomationHeartbeat);
+    function start() {
+        if (role !== "writer")
+            return;
+        void runGuiAutomationHeartbeat(true);
+        automationHeartbeat = setIntervalFn(() => void runGuiAutomationHeartbeat(true), intervalMs);
+    }
+    function stop() {
+        if (automationHeartbeat) {
+            clearIntervalFn(automationHeartbeat);
+            automationHeartbeat = null;
+        }
+    }
+    return { start, stop };
+}

package/dist/gui/server/background-quotes.d.ts

@@ -0,0 +1,39 @@
+import type { ToolResultMessage } from "@earendil-works/pi-ai";
+import type { SessionEntry, SessionManager } from "@earendil-works/pi-coding-agent";
+import { getAllTools } from "../../tools/index.js";
+import { invokeToolFromUi } from "./invoke-tool.js";
+export declare const BACKGROUND_QUOTE_POLL_INTERVAL_MS = 30000;
+export interface BackgroundQuoteRefresh {
+    symbol: string;
+    toolName: string;
+    args: Record<string, unknown>;
+    value: unknown;
+    content: ToolResultMessage["content"];
+    isError: boolean;
+}
+export declare class BackgroundQuoteRefreshes {
+    private readonly entriesBySymbol;
+    upsert(refresh: BackgroundQuoteRefresh): void;
+    withEntries(entries: SessionEntry[]): SessionEntry[];
+}
+type IntervalHandle = ReturnType<typeof setInterval>;
+type SetIntervalFn = (callback: () => void, ms: number) => IntervalHandle;
+type ClearIntervalFn = (handle: IntervalHandle) => void;
+export interface BackgroundQuotePoller {
+    updatePoller(): void;
+    pollVisibleQuotes(): Promise<void>;
+    stop(): void;
+}
+export interface BackgroundQuotePollerOptions {
+    getClientCount: () => number;
+    getSessionManager: () => SessionManager;
+    refreshes: BackgroundQuoteRefreshes;
+    broadcastState: () => void;
+    getTools?: typeof getAllTools;
+    invokeTool?: typeof invokeToolFromUi;
+    setIntervalFn?: SetIntervalFn;
+    clearIntervalFn?: ClearIntervalFn;
+    warn?: (message: string) => void;
+}
+export declare function createBackgroundQuotePoller({ getClientCount, getSessionManager, refreshes, broadcastState, getTools, invokeTool, setIntervalFn, clearIntervalFn, warn, }: BackgroundQuotePollerOptions): BackgroundQuotePoller;
+export {};

package/dist/gui/server/background-quotes.js

@@ -0,0 +1,71 @@
+import { getAllTools } from "../../tools/index.js";
+import { invokeToolFromUi } from "./invoke-tool.js";
+import { projectDashboard } from "./projector.js";
+export const BACKGROUND_QUOTE_POLL_INTERVAL_MS = 30_000;
+export class BackgroundQuoteRefreshes {
+    entriesBySymbol = new Map();
+    upsert(refresh) {
+        const timestamp = new Date().toISOString();
+        this.entriesBySymbol.set(refresh.symbol, {
+            type: "custom",
+            id: `background-quote-${refresh.symbol}`,
+            parentId: null,
+            timestamp,
+            customType: "opencandle-quote-refresh",
+            data: refresh,
+        });
+    }
+    withEntries(entries) {
+        return [...entries, ...this.entriesBySymbol.values()];
+    }
+}
+export function createBackgroundQuotePoller({ getClientCount, getSessionManager, refreshes, broadcastState, getTools = getAllTools, invokeTool = invokeToolFromUi, setIntervalFn = setInterval, clearIntervalFn = clearInterval, warn = (message) => console.warn(message), }) {
+    let poller = null;
+    let quotePollInFlight = false;
+    async function pollVisibleQuotes() {
+        if (quotePollInFlight)
+            return;
+        quotePollInFlight = true;
+        try {
+            const sessionManager = getSessionManager();
+            const state = projectDashboard(sessionManager.getEntries(), sessionManager.getSessionId());
+            const tool = getTools().find((candidate) => candidate.name === "get_stock_quote");
+            if (!tool)
+                return;
+            for (const row of state.watchlist.filter((item) => item.pinned || item.quote)) {
+                const result = await invokeTool(sessionManager, tool, { symbol: row.symbol }, "background", { recordTranscript: false });
+                refreshes.upsert({
+                    symbol: row.symbol,
+                    toolName: tool.name,
+                    args: { symbol: row.symbol },
+                    value: result.result.details,
+                    content: result.result.content,
+                    isError: result.isError,
+                });
+            }
+            broadcastState();
+        }
+        catch (error) {
+            warn(`Background quote refresh failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        finally {
+            quotePollInFlight = false;
+        }
+    }
+    function updatePoller() {
+        if (getClientCount() > 0 && !poller) {
+            poller = setIntervalFn(() => void pollVisibleQuotes(), BACKGROUND_QUOTE_POLL_INTERVAL_MS);
+        }
+        if (getClientCount() === 0 && poller) {
+            clearIntervalFn(poller);
+            poller = null;
+        }
+    }
+    function stop() {
+        if (poller) {
+            clearIntervalFn(poller);
+            poller = null;
+        }
+    }
+    return { updatePoller, pollVisibleQuotes, stop };
+}

package/dist/gui/server/chat-event-adapter.d.ts

@@ -0,0 +1,16 @@
+import type { SessionEntry } from "@earendil-works/pi-coding-agent";
+import type { ChatEvent } from "../shared/chat-events.js";
+export interface SessionEventOptions {
+    sessionId: string;
+    title?: string;
+    updatedAt?: string;
+    startSeq?: number;
+    markUnresolvedToolCalls?: boolean;
+}
+export declare function sessionEntriesToChatEvents(entries: SessionEntry[], options: SessionEventOptions): ChatEvent[];
+export declare function isOriginalInputEntry(entry: SessionEntry): boolean;
+export declare function originalInputText(entry: SessionEntry): string | null;
+export declare function originalInputAttachments(entry: SessionEntry): Array<{
+    kind: string;
+    label: string;
+}>;