opencandle 0.11.0 → 0.12.0

package/dist/gui/server/local-session-coordinator.js

@@ -0,0 +1,53 @@
+const DEFAULT_DEDUPE_RETENTION_MS = 10 * 60 * 1000;
+const BUSY_MESSAGE = "OpenCandle is still working in this session. Try again when it finishes.";
+export function createLocalSessionCoordinator(options = {}) {
+    const now = options.now ?? Date.now;
+    const dedupeRetentionMs = options.dedupeRetentionMs ?? DEFAULT_DEDUPE_RETENTION_MS;
+    const acceptedActions = new Map();
+    const activeActions = new Map();
+    const activeRunSessions = new Set();
+    async function runSessionAction(action, handler) {
+        pruneExpiredActions();
+        const actionKey = `${action.sessionId}:${action.actionId}`;
+        const accepted = acceptedActions.get(actionKey);
+        if (accepted)
+            return { ok: true, duplicate: true, result: accepted.result };
+        const active = activeActions.get(actionKey);
+        if (active)
+            return { ok: true, duplicate: true, result: (await active) };
+        if (isRunAdmissionAction(action) && activeRunSessions.has(action.sessionId)) {
+            return { ok: false, code: "session_busy", message: BUSY_MESSAGE };
+        }
+        if (isRunAdmissionAction(action))
+            activeRunSessions.add(action.sessionId);
+        const runAction = (async () => {
+            const result = await handler(action);
+            acceptedActions.set(actionKey, {
+                expiresAt: now() + dedupeRetentionMs,
+                result,
+            });
+            return result;
+        })();
+        activeActions.set(actionKey, runAction);
+        try {
+            const result = await runAction;
+            return { ok: true, duplicate: false, result };
+        }
+        finally {
+            activeActions.delete(actionKey);
+            if (isRunAdmissionAction(action))
+                activeRunSessions.delete(action.sessionId);
+        }
+    }
+    function pruneExpiredActions() {
+        const currentTime = now();
+        for (const [actionKey, accepted] of acceptedActions) {
+            if (accepted.expiresAt <= currentTime)
+                acceptedActions.delete(actionKey);
+        }
+    }
+    return { runSessionAction };
+}
+function isRunAdmissionAction(action) {
+    return action.actionType === "chat.prompt" || action.actionType === "tool.invoke";
+}

package/dist/gui/server/market-state-api.d.ts

@@ -0,0 +1,138 @@
+import type Database from "better-sqlite3";
+import { searchYahooInstruments } from "../../market-state/resolve.js";
+import { MarketStateService } from "../../market-state/service.js";
+export interface MarketStateSnapshot {
+    instruments: Array<NonNullable<ReturnType<MarketStateService["getInstrument"]>>>;
+    watchlists: ReturnType<MarketStateService["listWatchlists"]>;
+    portfolios: ReturnType<MarketStateService["listPortfolios"]>;
+    watchlist: ReturnType<MarketStateService["listWatchlistItems"]>;
+    portfolio: ReturnType<MarketStateService["listPortfolioLots"]>;
+    alerts: ReturnType<MarketStateService["listAlertRules"]>;
+    alertEvents: ReturnType<MarketStateService["listAlertEvents"]>;
+    alertCheckRuns: ReturnType<MarketStateService["listAlertCheckRuns"]>;
+    reportTemplates: ReturnType<MarketStateService["listReportTemplates"]>;
+    reportRuns: ReturnType<MarketStateService["listReportRuns"]>;
+    runnerLease: ReturnType<MarketStateService["getAutomationRunnerLease"]>;
+    notifications: ReturnType<MarketStateService["listNotificationEvents"]>;
+    notificationDeliveryAttempts: ReturnType<MarketStateService["listNotificationDeliveryAttempts"]>;
+}
+export interface MarketStateQuoteSnapshot {
+    generatedAt: string;
+    watchlistQuotes: Array<{
+        itemId: number;
+        instrumentId: number;
+        symbol: string;
+        name?: string;
+        status: "ok" | "unavailable";
+        price?: number;
+        change?: number;
+        changePercent?: number;
+        volume?: number;
+        dayHigh?: number;
+        dayLow?: number;
+        week52High?: number;
+        week52Low?: number;
+        currency?: string | null;
+        fetchedAt?: string;
+        dataAsOf?: string;
+        marketState?: "PRE" | "REGULAR" | "POST" | "CLOSED";
+        extendedPrice?: number;
+        extendedChange?: number;
+        extendedChangePercent?: number;
+        extendedAsOf?: string;
+        stale?: boolean;
+        reason?: string;
+    }>;
+    portfolioQuotes: Array<{
+        lotId: number;
+        portfolioId: number;
+        instrumentId: number;
+        symbol: string;
+        name?: string;
+        status: "ok" | "unavailable";
+        currentPrice?: number | null;
+        changePercent?: number;
+        marketValue?: number | null;
+        totalCost: number;
+        pnl?: number | null;
+        pnlPercent?: number | null;
+        allocationPercent?: number;
+        currency: string;
+        includedInTotals: boolean;
+        fetchedAt?: string;
+        dataAsOf?: string;
+        marketState?: "PRE" | "REGULAR" | "POST" | "CLOSED";
+        extendedPrice?: number;
+        extendedChange?: number;
+        extendedChangePercent?: number;
+        extendedAsOf?: string;
+        stale?: boolean;
+        reason?: string;
+    }>;
+    portfolioSummary: {
+        portfolioId: number;
+        baseCurrency: string;
+        totalValue: number;
+        totalCost: number;
+        totalPnl: number;
+        totalPnlPercent: number;
+        excludedFromTotals: Array<{
+            symbol: string;
+            currency: string;
+            reason: string;
+        }>;
+    };
+    portfolioSummaries: Array<{
+        portfolioId: number;
+        baseCurrency: string;
+        totalValue: number;
+        totalCost: number;
+        totalPnl: number;
+        totalPnlPercent: number;
+        excludedFromTotals: Array<{
+            symbol: string;
+            currency: string;
+            reason: string;
+        }>;
+    }>;
+}
+interface SavedSymbolsMemoOptions {
+    ttlMs?: number;
+    now?: () => number;
+}
+export declare function createSavedSymbolsMemo(load: () => string[], options?: SavedSymbolsMemoOptions): () => string[];
+export declare const getSavedMarketStateSymbols: () => string[];
+export declare function buildMarketStateSnapshot(db?: Database.Database): MarketStateSnapshot;
+export declare function buildMarketStateQuoteSnapshot(db?: Database.Database): Promise<MarketStateQuoteSnapshot>;
+export declare function searchInstrumentCandidates(query: string): Promise<{
+    query: string;
+    candidates: Awaited<ReturnType<typeof searchYahooInstruments>>;
+    error?: string;
+}>;
+export declare function getInstrumentQuoteSnapshot(symbol: string): Promise<{
+    symbol: string;
+    status: "ok";
+    name?: string;
+    price: number;
+    change: number;
+    changePercent: number;
+    volume: number;
+    high: number;
+    low: number;
+    week52High: number;
+    week52Low: number;
+    fetchedAt: string;
+    dataAsOf?: string;
+    marketState?: "PRE" | "REGULAR" | "POST" | "CLOSED";
+    extendedPrice?: number;
+    extendedChange?: number;
+    extendedChangePercent?: number;
+    extendedAsOf?: string;
+    stale: boolean;
+    currency: string | null;
+} | {
+    symbol: string;
+    status: "unavailable";
+    reason: string;
+}>;
+export {};

package/dist/gui/server/market-state-api.js

@@ -0,0 +1,355 @@
+import { buildFreshnessStamp } from "../../infra/freshness.js";
+import { isZeroFilledQuote, searchYahooInstruments } from "../../market-state/resolve.js";
+import { MarketStateService } from "../../market-state/service.js";
+import { initDefaultDatabase } from "../../memory/sqlite.js";
+import { wrapProvider } from "../../providers/wrap-provider.js";
+import { getQuote } from "../../providers/yahoo-finance.js";
+export function createSavedSymbolsMemo(load, options = {}) {
+    const ttlMs = options.ttlMs ?? 30_000;
+    const now = options.now ?? Date.now;
+    let cachedAt = 0;
+    let cached = null;
+    return () => {
+        const current = now();
+        if (cached && current - cachedAt < ttlMs)
+            return cached;
+        cached = load();
+        cachedAt = current;
+        return cached;
+    };
+}
+export const getSavedMarketStateSymbols = createSavedSymbolsMemo(loadSavedMarketStateSymbols);
+export function buildMarketStateSnapshot(db) {
+    const ownedDb = db ?? initDefaultDatabase();
+    const service = new MarketStateService(ownedDb);
+    try {
+        const alerts = service.listAlertRules();
+        const instrumentIds = [
+            ...new Set(alerts.map((rule) => rule.instrumentId).filter((id) => id != null)),
+        ];
+        const watchlists = service.listWatchlists();
+        const portfolios = service.listPortfolios();
+        return {
+            instruments: instrumentIds
+                .map((id) => service.getInstrument(id))
+                .filter((instrument) => instrument != null),
+            watchlists,
+            portfolios,
+            watchlist: watchlists.flatMap((watchlist) => service.listWatchlistItems(watchlist.id)),
+            portfolio: portfolios.flatMap((portfolio) => service.listPortfolioLots(portfolio.id)),
+            alerts,
+            alertEvents: service.listAlertEvents(),
+            alertCheckRuns: service.listAlertCheckRuns(),
+            reportTemplates: service.listReportTemplates(),
+            reportRuns: service.listReportRuns(),
+            runnerLease: service.getAutomationRunnerLease(),
+            notifications: service.listNotificationEvents(),
+            notificationDeliveryAttempts: service.listNotificationDeliveryAttempts(),
+        };
+    }
+    finally {
+        if (!db)
+            ownedDb.close();
+    }
+}
+function loadSavedMarketStateSymbols() {
+    const db = initDefaultDatabase();
+    const service = new MarketStateService(db);
+    try {
+        const symbols = [
+            ...service
+                .listWatchlists()
+                .flatMap((watchlist) => service.listWatchlistItems(watchlist.id).map((item) => item.symbol)),
+            ...service
+                .listPortfolios()
+                .flatMap((portfolio) => service.listPortfolioLots(portfolio.id).map((lot) => lot.symbol)),
+        ];
+        return normalizeSymbols(symbols);
+    }
+    finally {
+        db.close();
+    }
+}
+function normalizeSymbols(symbols) {
+    const normalized = [];
+    for (const symbol of symbols) {
+        const next = symbol.trim().toUpperCase();
+        if (!next || normalized.includes(next))
+            continue;
+        normalized.push(next);
+    }
+    return normalized;
+}
+export async function buildMarketStateQuoteSnapshot(db) {
+    const ownedDb = db ?? initDefaultDatabase();
+    const service = new MarketStateService(ownedDb);
+    try {
+        const watchlist = service
+            .listWatchlists()
+            .flatMap((watchlist) => service.listWatchlistItems(watchlist.id));
+        const portfolios = service.listPortfolios();
+        const portfolioLots = portfolios.flatMap((portfolio) => service.listPortfolioLots(portfolio.id));
+        const symbols = [
+            ...new Set([
+                ...watchlist.map((item) => item.symbol),
+                ...portfolioLots.map((lot) => lot.symbol),
+            ]),
+        ];
+        const quoteMap = new Map();
+        for (const symbol of symbols) {
+            quoteMap.set(symbol, await fetchQuoteSnapshot(symbol));
+        }
+        const generatedAt = new Date().toISOString();
+        const watchlistQuotes = watchlist.map((item) => {
+            const quote = quoteMap.get(item.symbol);
+            if (quote == null || quote.status === "unavailable") {
+                return {
+                    itemId: item.id,
+                    instrumentId: item.instrumentId,
+                    symbol: item.symbol,
+                    status: "unavailable",
+                    reason: quote?.reason ?? "quote unavailable",
+                };
+            }
+            return {
+                itemId: item.id,
+                instrumentId: item.instrumentId,
+                symbol: item.symbol,
+                name: quote.name,
+                status: "ok",
+                price: quote.price,
+                change: quote.change,
+                changePercent: quote.changePercent,
+                volume: quote.volume,
+                dayHigh: quote.high,
+                dayLow: quote.low,
+                week52High: quote.week52High,
+                week52Low: quote.week52Low,
+                currency: quote.currency,
+                fetchedAt: quote.fetchedAt,
+                dataAsOf: quote.dataAsOf,
+                marketState: quote.marketState,
+                extendedPrice: quote.extendedPrice,
+                extendedChange: quote.extendedChange,
+                extendedChangePercent: quote.extendedChangePercent,
+                extendedAsOf: quote.extendedAsOf,
+                stale: quote.stale,
+            };
+        });
+        const portfolioResults = portfolios.map((portfolio) => buildPortfolioQuoteResult({
+            portfolio,
+            lots: portfolioLots.filter((lot) => lot.portfolioId === portfolio.id),
+            quoteMap,
+        }));
+        const defaultPortfolio = portfolios.find((portfolio) => portfolio.isDefault) ?? portfolios[0];
+        const defaultResult = portfolioResults.find((result) => result.summary.portfolioId === defaultPortfolio.id) ??
+            portfolioResults[0];
+        return {
+            generatedAt,
+            watchlistQuotes,
+            portfolioQuotes: portfolioResults.flatMap((result) => result.quotes),
+            portfolioSummary: defaultResult.summary,
+            portfolioSummaries: portfolioResults.map((result) => result.summary),
+        };
+    }
+    finally {
+        if (!db)
+            ownedDb.close();
+    }
+}
+function buildPortfolioQuoteResult({ portfolio, lots, quoteMap, }) {
+    const baseCurrency = portfolio.baseCurrency ?? "USD";
+    const portfolioQuotes = lots.map((lot) => {
+        const quote = quoteMap.get(lot.symbol);
+        const lotCurrency = lot.currency || baseCurrency;
+        const quoteCurrency = lot.instrumentCurrency || lotCurrency;
+        const includedInTotals = lotCurrency === baseCurrency && quoteCurrency === baseCurrency;
+        const totalCost = lot.avgCost * lot.quantity;
+        if (quote == null || quote.status === "unavailable") {
+            return {
+                lotId: lot.id,
+                portfolioId: lot.portfolioId,
+                instrumentId: lot.instrumentId,
+                symbol: lot.symbol,
+                name: quote.name,
+                status: "unavailable",
+                totalCost,
+                currency: lotCurrency,
+                includedInTotals: false,
+                reason: quote?.reason ?? "quote unavailable",
+            };
+        }
+        const resolvedQuoteCurrency = quote.currency ?? quoteCurrency;
+        if (resolvedQuoteCurrency !== lotCurrency) {
+            return {
+                lotId: lot.id,
+                portfolioId: lot.portfolioId,
+                instrumentId: lot.instrumentId,
+                symbol: lot.symbol,
+                status: "unavailable",
+                currentPrice: null,
+                marketValue: null,
+                totalCost,
+                pnl: null,
+                pnlPercent: null,
+                currency: lotCurrency,
+                includedInTotals: false,
+                reason: `No FX conversion from ${resolvedQuoteCurrency} to ${lotCurrency}`,
+                fetchedAt: quote.fetchedAt,
+                dataAsOf: quote.dataAsOf,
+                marketState: quote.marketState,
+                extendedPrice: quote.extendedPrice,
+                extendedChange: quote.extendedChange,
+                extendedChangePercent: quote.extendedChangePercent,
+                extendedAsOf: quote.extendedAsOf,
+                stale: quote.stale,
+            };
+        }
+        const marketValue = quote.price * lot.quantity;
+        return {
+            lotId: lot.id,
+            portfolioId: lot.portfolioId,
+            instrumentId: lot.instrumentId,
+            symbol: lot.symbol,
+            name: quote.name,
+            status: "ok",
+            currentPrice: quote.price,
+            changePercent: quote.changePercent,
+            marketValue,
+            totalCost,
+            pnl: marketValue - totalCost,
+            pnlPercent: totalCost > 0 ? ((marketValue - totalCost) / totalCost) * 100 : 0,
+            currency: lotCurrency,
+            includedInTotals,
+            fetchedAt: quote.fetchedAt,
+            dataAsOf: quote.dataAsOf,
+            marketState: quote.marketState,
+            extendedPrice: quote.extendedPrice,
+            extendedChange: quote.extendedChange,
+            extendedChangePercent: quote.extendedChangePercent,
+            extendedAsOf: quote.extendedAsOf,
+            stale: quote.stale,
+            reason: includedInTotals
+                ? undefined
+                : `No FX conversion from ${lotCurrency === baseCurrency ? quoteCurrency : lotCurrency} to ${baseCurrency}`,
+        };
+    });
+    const included = portfolioQuotes.filter((quote) => quote.status === "ok" && quote.includedInTotals);
+    const totalValue = included.reduce((sum, quote) => sum + (quote.marketValue ?? 0), 0);
+    const totalCost = included.reduce((sum, quote) => sum + quote.totalCost, 0);
+    const quotes = portfolioQuotes.map((quote) => {
+        if (quote.status !== "ok" || !quote.includedInTotals || totalValue <= 0)
+            return quote;
+        return {
+            ...quote,
+            allocationPercent: ((quote.marketValue ?? 0) / totalValue) * 100,
+        };
+    });
+    const excludedFromTotals = quotes
+        .filter((quote) => quote.status !== "ok" || !quote.includedInTotals)
+        .map((quote) => ({
+        symbol: quote.symbol,
+        currency: quote.currency,
+        reason: quote.reason ?? "quote unavailable",
+    }));
+    return {
+        quotes,
+        summary: {
+            portfolioId: portfolio.id,
+            baseCurrency,
+            totalValue,
+            totalCost,
+            totalPnl: totalValue - totalCost,
+            totalPnlPercent: totalCost > 0 ? ((totalValue - totalCost) / totalCost) * 100 : 0,
+            excludedFromTotals,
+        },
+    };
+}
+export async function searchInstrumentCandidates(query) {
+    const trimmed = query.trim();
+    if (!trimmed)
+        return { query: "", candidates: [] };
+    try {
+        return {
+            query: trimmed,
+            candidates: await searchYahooInstruments(trimmed),
+        };
+    }
+    catch (err) {
+        return {
+            query: trimmed,
+            candidates: [],
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+export async function getInstrumentQuoteSnapshot(symbol) {
+    const normalized = symbol.trim().toUpperCase();
+    if (!normalized)
+        return { symbol: "", status: "unavailable", reason: "symbol is required" };
+    const quote = await fetchQuoteSnapshot(normalized);
+    if (quote.status === "unavailable")
+        return { symbol: normalized, ...quote };
+    return {
+        symbol: normalized,
+        status: quote.status,
+        name: quote.name,
+        price: quote.price,
+        change: quote.change,
+        changePercent: quote.changePercent,
+        volume: quote.volume,
+        high: quote.high,
+        low: quote.low,
+        week52High: quote.week52High,
+        week52Low: quote.week52Low,
+        fetchedAt: quote.fetchedAt,
+        dataAsOf: quote.dataAsOf,
+        marketState: quote.marketState,
+        extendedPrice: quote.extendedPrice,
+        extendedChange: quote.extendedChange,
+        extendedChangePercent: quote.extendedChangePercent,
+        extendedAsOf: quote.extendedAsOf,
+        stale: quote.stale,
+        currency: quote.currency,
+    };
+}
+async function fetchQuoteSnapshot(symbol) {
+    const result = await wrapProvider("yahoo", () => getQuote(symbol));
+    if (result.status === "unavailable")
+        return { status: "unavailable", reason: result.reason };
+    if (result.stale)
+        return { status: "unavailable", reason: "provider returned stale market data" };
+    if (isZeroFilledQuote(result.data)) {
+        return { status: "unavailable", reason: "Yahoo returned no valid market data." };
+    }
+    const freshness = buildFreshnessStamp({
+        asOf: result.data.asOf,
+        cached: result.cached,
+        stale: result.stale,
+        cachedAt: result.timestamp,
+    });
+    if (freshness.isStaleForSession) {
+        return { status: "unavailable", reason: "provider returned stale market data" };
+    }
+    return {
+        status: "ok",
+        name: result.data.name,
+        price: result.data.price,
+        change: result.data.change,
+        changePercent: result.data.changePercent,
+        volume: result.data.volume,
+        high: result.data.high,
+        low: result.data.low,
+        week52High: result.data.week52High,
+        week52Low: result.data.week52Low,
+        fetchedAt: result.timestamp,
+        dataAsOf: freshness.providerDataAt,
+        marketState: result.data.marketState,
+        extendedPrice: result.data.extendedPrice,
+        extendedChange: result.data.extendedChange,
+        extendedChangePercent: result.data.extendedChangePercent,
+        extendedAsOf: result.data.extendedAsOf,
+        stale: Boolean(result.stale),
+        currency: result.data.currency ?? null,
+    };
+}

package/dist/gui/server/model-setup.d.ts

@@ -0,0 +1,64 @@
+import type { Api, Model } from "@earendil-works/pi-ai";
+export type ModelSetupRequirement = "ready" | "select_model" | "connect_auth";
+export interface ModelSetupProvider {
+    id: string;
+    label: string;
+    envVar: string;
+    defaultProvider: string;
+    defaultModel: string;
+    signupUrl: string;
+}
+export interface ModelSetupState {
+    requirement: ModelSetupRequirement;
+    currentModel?: string;
+    providers: ModelSetupProvider[];
+    availableModels: Array<{
+        provider: string;
+        id: string;
+        label: string;
+    }>;
+}
+export interface ModelSetupRegistry {
+    refresh(): void;
+    getAvailable(): Model<Api>[];
+    hasConfiguredAuth(model: Model<Api>): boolean;
+}
+interface ModelSetupAuthStorage {
+    set(provider: string, credential: {
+        type: "api_key";
+        key: string;
+    }): void;
+}
+interface MutableModelSetupRegistry extends ModelSetupRegistry {
+    authStorage: ModelSetupAuthStorage;
+    find(provider: string, modelId: string): Model<Api> | undefined;
+}
+interface ModelSetupSession {
+    modelRegistry: MutableModelSetupRegistry;
+    model?: Model<Api>;
+    setModel(model: Model<Api>): Promise<void>;
+    settingsManager: {
+        flush(): Promise<void>;
+    };
+}
+interface ModelSetupSessionManager {
+    appendCustomMessageEntry(customType: string, content: string, isActive: boolean, data: Record<string, unknown>): void;
+}
+export interface ModelSetupController {
+    buildCurrentModelSetupState(): ModelSetupState;
+    handleSaveModelApiKey(providerId: string, apiKey: string): Promise<void>;
+    handleSaveProviderApiKey(providerId: string, apiKey: string): Promise<void>;
+    handleSelectModel(provider: string, modelId: string): Promise<void>;
+}
+export interface ModelSetupControllerOptions {
+    role: string;
+    getSession: () => ModelSetupSession;
+    getSessionManager: () => ModelSetupSessionManager;
+    broadcastState: () => void;
+}
+export declare const modelSetupProviders: ModelSetupProvider[];
+export declare function buildModelSetupState(registry: ModelSetupRegistry, currentModel: Model<Api> | undefined): ModelSetupState;
+export declare function findPreferredModel(registry: Pick<ModelSetupRegistry, "getAvailable">, provider: ModelSetupProvider): Model<Api> | undefined;
+export declare function sortModels(models: Model<Api>[], preferredProvider?: string): Model<Api>[];
+export declare function createModelSetupController({ role, getSession, getSessionManager, broadcastState, }: ModelSetupControllerOptions): ModelSetupController;
+export {};