sidekick-shared 0.27.6 → 0.28.0

package/dist/esm/pricingCatalog.js

@@ -0,0 +1,247 @@
+/**
+ * Runtime pricing catalog hydration (Node-only).
+ *
+ * Fetches LiteLLM's community-maintained model pricing catalog, caches the
+ * normalized result to disk, and pushes it into `modelInfo.ts` as an override
+ * map. Static `PRICING_TABLE` remains the offline baseline.
+ *
+ * This module lives on the `sidekick-shared/node` subpath so browser bundles
+ * (VS Code webviews) never pull it in. Webviews receive pre-computed costs
+ * from the extension host and don't need pricing data locally.
+ *
+ * Non-goals:
+ *   - Perfect billing reconciliation. Best-effort estimate based on LiteLLM.
+ *   - Aggressive refresh. Default 24h TTL is plenty for a pricing table.
+ *   - Blocking startup. Every error path is non-fatal; static table keeps working.
+ *
+ * @module pricingCatalog
+ */
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+import { _setCatalogContextWindows } from './modelContext';
+import { _setPricingOverrides } from './modelInfo';
+import { getConfigDir } from './paths';
+import { atomicWriteJson } from './writers/atomic';
+// ── Constants ──
+export const LITELLM_CATALOG_URL = 'https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json';
+const CACHE_FILE_NAME = 'pricing-catalog.json';
+const DEFAULT_TTL_MS = 24 * 60 * 60 * 1000;
+const DEFAULT_TIMEOUT_MS = 3_000;
+// ── Public API ──
+/**
+ * Hydrate the pricing override map.
+ *
+ * Order:
+ *   1. If a fresh on-disk cache exists (< ttlMs old), load it and return.
+ *   2. Otherwise attempt a network fetch; on success, persist + apply.
+ *   3. On any failure, load a stale cache if present; else leave overrides empty.
+ *
+ * Always resolves — never throws. Offline-safe.
+ */
+export async function hydratePricingCatalog(options = {}) {
+    const { cacheDir = getConfigDir(), fetchImpl = globalThis.fetch, ttlMs = DEFAULT_TTL_MS, timeoutMs = DEFAULT_TIMEOUT_MS, url = LITELLM_CATALOG_URL, logger, offline = false, } = options;
+    const cachePath = path.join(cacheDir, CACHE_FILE_NAME);
+    const now = Date.now();
+    // 1. Fresh cache? (Offline callers take any cache, however old.)
+    const cached = await readCache(cachePath);
+    if (cached && (offline || now - Date.parse(cached.fetchedAt) < ttlMs)) {
+        return applyCacheFile(cached, 'cache');
+    }
+    // 2. Try network.
+    if (fetchImpl && !offline) {
+        const fetched = await fetchCatalog(url, fetchImpl, timeoutMs, logger);
+        if (fetched) {
+            const payload = {
+                fetchedAt: new Date(now).toISOString(),
+                url,
+                overrides: normalizeLiteLlmCatalog(fetched),
+                contextWindows: normalizeLiteLlmContextWindows(fetched),
+            };
+            await writeCache(cachePath, payload, logger);
+            return applyCacheFile(payload, 'network');
+        }
+    }
+    // 3. Fall back to stale cache if present.
+    if (cached) {
+        return applyCacheFile(cached, 'cache');
+    }
+    // 4. Nothing we can do — stay on static tables.
+    return {
+        source: 'offline',
+        entries: 0,
+        contextWindowEntries: 0,
+        fetchedAt: new Date(now).toISOString(),
+    };
+}
+/**
+ * Push a cache payload into both override maps and describe what was applied.
+ * `contextWindows` is absent on caches written before context hydration; those
+ * contribute no overrides rather than clearing whatever is already loaded.
+ */
+function applyCacheFile(cache, source) {
+    const contextWindows = cache.contextWindows ?? {};
+    _setPricingOverrides(cache.overrides);
+    if (Object.keys(contextWindows).length > 0) {
+        _setCatalogContextWindows(contextWindows);
+    }
+    return {
+        source,
+        entries: Object.keys(cache.overrides).length,
+        contextWindowEntries: Object.keys(contextWindows).length,
+        fetchedAt: cache.fetchedAt,
+    };
+}
+/**
+ * Convert a LiteLLM catalog payload to our `ModelPricing` override map.
+ * Exported for tests; rarely called directly.
+ */
+export function normalizeLiteLlmCatalog(raw) {
+    const out = {};
+    if (!raw || typeof raw !== 'object')
+        return out;
+    for (const [key, entry] of Object.entries(raw)) {
+        // LiteLLM ships a `sample_spec` header entry. Skip it.
+        if (key === 'sample_spec')
+            continue;
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const pricing = liteLlmEntryToPricing(entry);
+        if (!pricing)
+            continue;
+        // Catalog keys use both `provider/model` and bare `model` forms. Record both
+        // the raw key and the bare-model form so lookups work regardless of caller.
+        out[key] = pricing;
+        const bare = stripProviderPrefix(key);
+        if (bare && bare !== key && !out[bare]) {
+            out[bare] = pricing;
+        }
+    }
+    return out;
+}
+/**
+ * Convert a LiteLLM catalog payload to a model → context-window override map.
+ *
+ * Kept separate from `normalizeLiteLlmCatalog` rather than folded into its
+ * return type: that function is public API on a published package, and pricing
+ * and context coverage differ (an entry can have one without the other).
+ *
+ * Exported for tests; rarely called directly.
+ */
+export function normalizeLiteLlmContextWindows(raw) {
+    const out = {};
+    if (!raw || typeof raw !== 'object')
+        return out;
+    // Bare-model aliases are gathered separately rather than written as we go. A
+    // `provider/model` entry describes that *provider's deployment* window, which
+    // is often a truncation of the model's own — the live catalog carries five
+    // different windows for `claude-sonnet-4`, from GitHub Copilot's 128K to
+    // Vertex's 1M. Taking whichever appeared first in the JSON is a coin flip, so
+    // an alias is only promoted when every provider mentioning it agrees.
+    const aliasWindows = new Map();
+    for (const [key, entry] of Object.entries(raw)) {
+        // LiteLLM ships a `sample_spec` header entry. Skip it.
+        if (key === 'sample_spec')
+            continue;
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const window = entry.max_input_tokens;
+        if (typeof window !== 'number' || !Number.isFinite(window) || window <= 0)
+            continue;
+        out[key] = window;
+        const bare = stripProviderPrefix(key);
+        if (bare && bare !== key) {
+            const seen = aliasWindows.get(bare) ?? new Set();
+            seen.add(window);
+            aliasWindows.set(bare, seen);
+        }
+    }
+    for (const [bare, windows] of aliasWindows) {
+        // A top-level entry for the same ID is authoritative — never shadow it.
+        if (out[bare] !== undefined)
+            continue;
+        // Providers disagree, so none of their numbers can be attributed to the
+        // bare model. Record nothing and let a more trusted layer answer.
+        if (windows.size !== 1)
+            continue;
+        const [only] = windows;
+        if (typeof only === 'number')
+            out[bare] = only;
+    }
+    return out;
+}
+// ── Internals ──
+function liteLlmEntryToPricing(entry) {
+    const input = entry.input_cost_per_token;
+    const output = entry.output_cost_per_token;
+    // Need at least input+output to be useful.
+    if (typeof input !== 'number' || typeof output !== 'number')
+        return null;
+    // LiteLLM sometimes reports cached input under `input_cost_per_token_cached`.
+    const cacheRead = typeof entry.cache_read_input_token_cost === 'number'
+        ? entry.cache_read_input_token_cost
+        : typeof entry.input_cost_per_token_cached === 'number'
+            ? entry.input_cost_per_token_cached
+            : 0;
+    const cacheWrite = typeof entry.cache_creation_input_token_cost === 'number'
+        ? entry.cache_creation_input_token_cost
+        : 0;
+    return {
+        inputCostPerMillion: input * 1_000_000,
+        outputCostPerMillion: output * 1_000_000,
+        cacheWriteCostPerMillion: cacheWrite * 1_000_000,
+        cacheReadCostPerMillion: cacheRead * 1_000_000,
+    };
+}
+function stripProviderPrefix(key) {
+    const slash = key.indexOf('/');
+    if (slash < 0)
+        return null;
+    return key.slice(slash + 1);
+}
+async function readCache(cachePath) {
+    try {
+        const raw = await fs.readFile(cachePath, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (!parsed ||
+            typeof parsed !== 'object' ||
+            typeof parsed.fetchedAt !== 'string' ||
+            !parsed.overrides ||
+            typeof parsed.overrides !== 'object') {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+async function writeCache(cachePath, payload, logger) {
+    try {
+        await fs.mkdir(path.dirname(cachePath), { recursive: true });
+        // The CLI and the extension host can both refresh the catalog at once;
+        // the atomic writer keeps a reader from ever seeing a half-written file.
+        await atomicWriteJson(cachePath, payload);
+    }
+    catch (err) {
+        logger?.(`pricingCatalog: failed to write cache: ${String(err)}`);
+    }
+}
+async function fetchCatalog(url, fetchImpl, timeoutMs, logger) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const res = await fetchImpl(url, { signal: controller.signal });
+        if (!res.ok) {
+            logger?.(`pricingCatalog: HTTP ${res.status} from ${url}`);
+            return null;
+        }
+        return await res.json();
+    }
+    catch (err) {
+        logger?.(`pricingCatalog: fetch failed: ${String(err)}`);
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}

package/dist/esm/processDetection.js

@@ -0,0 +1,200 @@
+/**
+ * Cross-platform detection of running CLI/app processes that hold provider
+ * credentials in memory. Bounded, never throws, never spawns a shell.
+ */
+import { execFile, spawnSync } from 'child_process';
+import * as path from 'path';
+const PROBE_TIMEOUT_MS = 4000;
+const CLAUDE_NPM_ENTRY = /claude-code[\\/]cli\.js/;
+const CODEX_NPM_ENTRY = /(?:@openai[\\/]codex|codex[\\/]bin)[\\/].*codex\.js/;
+function parseUnixTable(stdout) {
+    const rows = [];
+    for (const line of stdout.split('\n')) {
+        const match = line.match(/^\s*(\d+)\s+(\S+)\s*(.*)$/);
+        if (!match)
+            continue;
+        rows.push({ pid: Number(match[1]), command: match[2], args: match[3] ?? '' });
+    }
+    return rows;
+}
+function parseWindowsCsv(stdout) {
+    const rows = [];
+    for (const line of stdout.split(/\r?\n/)) {
+        const match = line.match(/^"([^"]+)","(\d+)"/);
+        if (!match)
+            continue;
+        rows.push({ pid: Number(match[2]), command: match[1], args: '' });
+    }
+    return rows;
+}
+function matchRows(rows, names) {
+    const wanted = new Set(names);
+    const found = [];
+    for (const row of rows) {
+        if (!Number.isFinite(row.pid) || row.pid === process.pid)
+            continue;
+        const base = path.basename(row.command);
+        // The native Claude Code binary is invoked through a `claude` symlink but
+        // its executable is the versioned file (`.../versions/2.1.273`), so `comm`
+        // never says `claude`; argv[0] does.
+        const argv0 = row.args.trim().split(/\s+/)[0] ?? '';
+        const candidates = [base, base.replace(/\.exe$/i, ''), path.basename(argv0)];
+        let name = candidates.find((candidate) => candidate && wanted.has(candidate));
+        // An npm-installed `claude` runs under `node`; recognise it by its entry file.
+        if (!name &&
+            wanted.has('claude') &&
+            /^node(\.exe)?$/i.test(base) &&
+            CLAUDE_NPM_ENTRY.test(row.args)) {
+            name = 'claude';
+        }
+        if (!name &&
+            wanted.has('codex') &&
+            /^node(\.exe)?$/i.test(base) &&
+            CODEX_NPM_ENTRY.test(row.args))
+            name = 'codex';
+        if (!name &&
+            wanted.has('Codex') &&
+            /(?:^|[\\/])Codex\.app[\\/]/.test(row.command + ' ' + row.args))
+            name = 'Codex';
+        if (name)
+            found.push({ pid: row.pid, name, command: row.command });
+    }
+    return found;
+}
+function probeCommand() {
+    return process.platform === 'win32'
+        ? { command: 'tasklist', args: ['/FO', 'CSV', '/NH'] }
+        : { command: 'ps', args: ['-axo', 'pid=,comm=,args='] };
+}
+function parseOutput(stdout) {
+    return process.platform === 'win32' ? parseWindowsCsv(stdout) : parseUnixTable(stdout);
+}
+/** Sync sibling of {@link findRunningProcesses}; blocks up to 4 s. */
+function inspectProcessesSync(names) {
+    if (names.length === 0)
+        return { ok: true, processes: [] };
+    try {
+        const { command, args } = probeCommand();
+        const result = spawnSync(command, args, {
+            encoding: 'utf8',
+            maxBuffer: 16 * 1024 * 1024,
+            timeout: PROBE_TIMEOUT_MS,
+            killSignal: 'SIGKILL',
+            windowsHide: true,
+        });
+        if (result.error || result.status !== 0)
+            return { ok: false, processes: [] };
+        return { ok: true, processes: matchRows(parseOutput(String(result.stdout ?? '')), names) };
+    }
+    catch {
+        return { ok: false, processes: [] };
+    }
+}
+function inspectProcesses(names) {
+    if (names.length === 0)
+        return Promise.resolve({ ok: true, processes: [] });
+    return new Promise((resolve) => {
+        try {
+            const { command, args } = probeCommand();
+            execFile(command, args, {
+                encoding: 'utf8',
+                timeout: PROBE_TIMEOUT_MS,
+                killSignal: 'SIGKILL',
+                windowsHide: true,
+                maxBuffer: 16 * 1024 * 1024,
+            }, (error, stdout) => {
+                resolve({
+                    ok: !error,
+                    processes: error ? [] : matchRows(parseOutput(String(stdout ?? '')), names),
+                });
+            });
+        }
+        catch {
+            resolve({ ok: false, processes: [] });
+        }
+    });
+}
+const CONSUMER_PROCESS_NAMES = {
+    'claude-cli': 'claude',
+    'claude-desktop': 'Claude',
+    'codex-cli': 'codex',
+    'codex-app': 'Codex',
+};
+export const ACCOUNT_CONSUMER_REACHABILITY = {
+    'claude-cli': {
+        switched: true,
+        reachability: 'Running claude sessions keep the previous account until restarted; a running session can rotate the refresh token of the account you just left.',
+    },
+    'claude-desktop': {
+        switched: false,
+        reachability: 'Claude Desktop is not switched by sidekick (it keeps its own web session) and its embedded engine can rotate the shared CLI token.',
+    },
+    'codex-cli': {
+        switched: true,
+        reachability: 'Running codex sessions keep the previous account until restarted.',
+    },
+    'codex-app': {
+        switched: true,
+        reachability: 'The Codex app shares the CLI login; restart it to pick up the switch. While running it can refresh and rotate the live token.',
+    },
+    'vscode-extension-host': {
+        switched: true,
+        reachability: 'The Claude Code extension host keeps the previous account until the window reloads.',
+    },
+};
+function toConsumer(kind, pids) {
+    return { kind, pids, ...ACCOUNT_CONSUMER_REACHABILITY[kind] };
+}
+function groupConsumers(processes, kinds) {
+    const consumers = [];
+    for (const kind of kinds) {
+        const pids = processes.filter((p) => p.name === CONSUMER_PROCESS_NAMES[kind]).map((p) => p.pid);
+        if (pids.length > 0)
+            consumers.push(toConsumer(kind, pids));
+    }
+    return consumers;
+}
+function kindsForProvider(provider) {
+    if (provider === 'claude-code')
+        return ['claude-cli', 'claude-desktop'];
+    if (provider === 'codex')
+        return ['codex-cli', 'codex-app'];
+    return ['claude-cli', 'claude-desktop', 'codex-cli', 'codex-app'];
+}
+/**
+ * Which credential consumers are running right now, with the reachability
+ * sentence to show for each. Optionally scoped to one provider.
+ */
+export async function detectRunningAccountConsumers(provider) {
+    const kinds = kindsForProvider(provider);
+    const processes = await findRunningProcesses(kinds.map((kind) => CONSUMER_PROCESS_NAMES[kind]));
+    return groupConsumers(processes, kinds);
+}
+/** Sync sibling of {@link detectRunningAccountConsumers}; blocks up to 4 s. */
+export function detectRunningAccountConsumersSync(provider) {
+    const kinds = kindsForProvider(provider);
+    const processes = findRunningProcessesSync(kinds.map((kind) => CONSUMER_PROCESS_NAMES[kind]));
+    return groupConsumers(processes, kinds);
+}
+/** Build a consumer entry for a kind the host detects itself (e.g. its own extension host). */
+export function describeAccountConsumer(kind, pids = []) {
+    return toConsumer(kind, pids);
+}
+/** Compatibility wrappers keep the established best-effort list API. */
+export function findRunningProcessesSync(names) {
+    return inspectProcessesSync(names).processes;
+}
+export async function findRunningProcesses(names) {
+    return (await inspectProcesses(names)).processes;
+}
+/** Safety decisions must distinguish a failed process scan from an empty one. */
+export function inspectRunningAccountConsumersSync(provider) {
+    const kinds = kindsForProvider(provider);
+    const result = inspectProcessesSync(kinds.map((kind) => CONSUMER_PROCESS_NAMES[kind]));
+    return { ok: result.ok, consumers: groupConsumers(result.processes, kinds) };
+}
+export async function inspectRunningAccountConsumers(provider) {
+    const kinds = kindsForProvider(provider);
+    const result = await inspectProcesses(kinds.map((kind) => CONSUMER_PROCESS_NAMES[kind]));
+    return { ok: result.ok, consumers: groupConsumers(result.processes, kinds) };
+}

package/dist/esm/projectMigration.js

@@ -0,0 +1,59 @@
+/**
+ * @fileoverview One-time migration of legacy raw-slug project stores.
+ *
+ * 0.23.0 switched all readers and writers to the canonical
+ * (symlink-resolved) project slug. Workspaces whose literal path differs
+ * from its realpath still hold pre-0.23 data under the legacy raw slug;
+ * this helper copies those stores to the canonical slug so they stay
+ * visible without any manual merge.
+ *
+ * @module projectMigration
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { getConfigDir, getProjectDataPath, resolveProjectIdentity, } from './paths';
+/** Project-scoped JSON store subdomains shared by the extension and CLI. */
+const PROJECT_STORE_SUBDOMAINS = [
+    'tasks',
+    'decisions',
+    'notifications',
+    'knowledge-notes',
+    'plans',
+];
+/**
+ * Copies legacy raw-slug project stores to the canonical slug, once.
+ *
+ * Only copies when the canonical file does not exist yet, so it can never
+ * overwrite newer data; the legacy file is kept as a read-only fallback.
+ * Best-effort per store — a failed copy leaves that store on the legacy
+ * read path.
+ *
+ * @returns The canonical paths that were created (empty when none).
+ */
+export function migrateLegacyProjectStores(cwdOrIdentity) {
+    const identity = typeof cwdOrIdentity === 'string' ? resolveProjectIdentity(cwdOrIdentity) : cwdOrIdentity;
+    if (!identity.hasLegacyMismatch)
+        return [];
+    const pairs = PROJECT_STORE_SUBDOMAINS.map((subdomain) => [
+        getProjectDataPath(identity.legacySlug, subdomain),
+        getProjectDataPath(identity.canonicalSlug, subdomain),
+    ]);
+    pairs.push([
+        path.join(getConfigDir(), 'handoffs', `${identity.legacySlug}-latest.md`),
+        path.join(getConfigDir(), 'handoffs', `${identity.canonicalSlug}-latest.md`),
+    ]);
+    const migrated = [];
+    for (const [legacyPath, canonicalPath] of pairs) {
+        try {
+            if (!fs.existsSync(legacyPath) || fs.existsSync(canonicalPath))
+                continue;
+            fs.mkdirSync(path.dirname(canonicalPath), { recursive: true });
+            fs.copyFileSync(legacyPath, canonicalPath, fs.constants.COPYFILE_EXCL);
+            migrated.push(canonicalPath);
+        }
+        catch {
+            // Best effort: an unmigrated store falls back to the legacy read path.
+        }
+    }
+    return migrated;
+}