shortcutxl 0.2.0

package/dist/core/tools/path-utils.js

@@ -0,0 +1,81 @@
+import { accessSync, constants } from 'node:fs';
+import * as os from 'node:os';
+import { isAbsolute, resolve as resolvePath } from 'node:path';
+const UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
+const NARROW_NO_BREAK_SPACE = '\u202F';
+function normalizeUnicodeSpaces(str) {
+    return str.replace(UNICODE_SPACES, ' ');
+}
+function tryMacOSScreenshotPath(filePath) {
+    return filePath.replace(/ (AM|PM)\./g, `${NARROW_NO_BREAK_SPACE}$1.`);
+}
+function tryNFDVariant(filePath) {
+    // macOS stores filenames in NFD (decomposed) form, try converting user input to NFD
+    return filePath.normalize('NFD');
+}
+function tryCurlyQuoteVariant(filePath) {
+    // macOS uses U+2019 (right single quotation mark) in screenshot names like "Capture d'écran"
+    // Users typically type U+0027 (straight apostrophe)
+    return filePath.replace(/'/g, '\u2019');
+}
+function fileExists(filePath) {
+    try {
+        accessSync(filePath, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function normalizeAtPrefix(filePath) {
+    return filePath.startsWith('@') ? filePath.slice(1) : filePath;
+}
+export function expandPath(filePath) {
+    const normalized = normalizeUnicodeSpaces(normalizeAtPrefix(filePath));
+    if (normalized === '~') {
+        return os.homedir();
+    }
+    if (normalized.startsWith('~/')) {
+        return os.homedir() + normalized.slice(1);
+    }
+    return normalized;
+}
+/**
+ * Resolve a path relative to the given cwd.
+ * Handles ~ expansion and absolute paths.
+ */
+export function resolveToCwd(filePath, cwd) {
+    const expanded = expandPath(filePath);
+    if (isAbsolute(expanded)) {
+        return expanded;
+    }
+    return resolvePath(cwd, expanded);
+}
+export function resolveReadPath(filePath, cwd) {
+    const resolved = resolveToCwd(filePath, cwd);
+    if (fileExists(resolved)) {
+        return resolved;
+    }
+    // Try macOS AM/PM variant (narrow no-break space before AM/PM)
+    const amPmVariant = tryMacOSScreenshotPath(resolved);
+    if (amPmVariant !== resolved && fileExists(amPmVariant)) {
+        return amPmVariant;
+    }
+    // Try NFD variant (macOS stores filenames in NFD form)
+    const nfdVariant = tryNFDVariant(resolved);
+    if (nfdVariant !== resolved && fileExists(nfdVariant)) {
+        return nfdVariant;
+    }
+    // Try curly quote variant (macOS uses U+2019 in screenshot names)
+    const curlyVariant = tryCurlyQuoteVariant(resolved);
+    if (curlyVariant !== resolved && fileExists(curlyVariant)) {
+        return curlyVariant;
+    }
+    // Try combined NFD + curly quote (for French macOS screenshots like "Capture d'écran")
+    const nfdCurlyVariant = tryCurlyQuoteVariant(nfdVariant);
+    if (nfdCurlyVariant !== resolved && fileExists(nfdCurlyVariant)) {
+        return nfdCurlyVariant;
+    }
+    return resolved;
+}
+//# sourceMappingURL=path-utils.js.map

package/dist/core/tools/read.js

@@ -0,0 +1,160 @@
+import { Type } from '@sinclair/typebox';
+import { ABORT_AGENT_MESSAGE } from '../abort.js';
+import { constants } from 'fs';
+import { access as fsAccess, readFile as fsReadFile } from 'fs/promises';
+import { READ } from '../../tool-names.js';
+import { formatDimensionNote, resizeImage } from '../../utils/image-resize.js';
+import { detectSupportedImageMimeTypeFromFile } from '../../utils/mime.js';
+import { resolveReadPath } from './path-utils.js';
+import { DEFAULT_MAX_CHARS, formatSize, truncateHead } from './truncate.js';
+const readSchema = Type.Object({
+    path: Type.String({ description: 'Path to the file to read (relative or absolute)' }),
+    offset: Type.Optional(Type.Number({ description: 'Line number to start reading from (1-indexed)' })),
+    limit: Type.Optional(Type.Number({ description: 'Maximum number of lines to read' }))
+});
+const defaultReadOperations = {
+    readFile: (path) => fsReadFile(path),
+    access: (path) => fsAccess(path, constants.R_OK),
+    detectImageMimeType: detectSupportedImageMimeTypeFromFile
+};
+export function createReadTool(cwd, options) {
+    const autoResizeImages = options?.autoResizeImages ?? true;
+    const ops = options?.operations ?? defaultReadOperations;
+    return {
+        name: READ,
+        label: READ,
+        description: `Read the contents of a file. Supports text files and images (jpg, png, gif, webp). Images are sent as attachments. For text files, output is truncated to ${DEFAULT_MAX_CHARS} characters. Use offset/limit for large files. When you need the full file, continue with offset until complete.`,
+        parameters: readSchema,
+        execute: async (_toolCallId, { path, offset, limit }, signal) => {
+            const absolutePath = resolveReadPath(path, cwd);
+            return new Promise((resolve, reject) => {
+                // Check if already aborted
+                if (signal?.aborted) {
+                    reject(new Error(ABORT_AGENT_MESSAGE));
+                    return;
+                }
+                let aborted = false;
+                // Set up abort handler
+                const onAbort = () => {
+                    aborted = true;
+                    reject(new Error(ABORT_AGENT_MESSAGE));
+                };
+                if (signal) {
+                    signal.addEventListener('abort', onAbort, { once: true });
+                }
+                // Perform the read operation
+                (async () => {
+                    try {
+                        // Check if file exists
+                        await ops.access(absolutePath);
+                        // Check if aborted before reading
+                        if (aborted) {
+                            return;
+                        }
+                        const mimeType = ops.detectImageMimeType
+                            ? await ops.detectImageMimeType(absolutePath)
+                            : undefined;
+                        // Read the file based on type
+                        let content;
+                        let details;
+                        if (mimeType) {
+                            // Read as image (binary)
+                            const buffer = await ops.readFile(absolutePath);
+                            const base64 = buffer.toString('base64');
+                            if (autoResizeImages) {
+                                // Resize image if needed
+                                const resized = await resizeImage({ type: 'image', data: base64, mimeType });
+                                const dimensionNote = formatDimensionNote(resized);
+                                let textNote = `Read image file [${resized.mimeType}]`;
+                                if (dimensionNote) {
+                                    textNote += `\n${dimensionNote}`;
+                                }
+                                content = [
+                                    { type: 'text', text: textNote },
+                                    { type: 'image', data: resized.data, mimeType: resized.mimeType }
+                                ];
+                            }
+                            else {
+                                const textNote = `Read image file [${mimeType}]`;
+                                content = [
+                                    { type: 'text', text: textNote },
+                                    { type: 'image', data: base64, mimeType }
+                                ];
+                            }
+                        }
+                        else {
+                            // Read as text
+                            const buffer = await ops.readFile(absolutePath);
+                            const textContent = buffer.toString('utf-8');
+                            const allLines = textContent.split('\n');
+                            const totalFileLines = allLines.length;
+                            // Apply offset if specified (1-indexed to 0-indexed)
+                            const startLine = offset ? Math.max(0, offset - 1) : 0;
+                            const startLineDisplay = startLine + 1; // For display (1-indexed)
+                            // Check if offset is out of bounds
+                            if (startLine >= allLines.length) {
+                                throw new Error(`Offset ${offset} is beyond end of file (${allLines.length} lines total)`);
+                            }
+                            // If limit is specified by user, use it; otherwise we'll let truncateHead decide
+                            let selectedContent;
+                            let userLimitedLines;
+                            if (limit !== undefined) {
+                                const endLine = Math.min(startLine + limit, allLines.length);
+                                selectedContent = allLines.slice(startLine, endLine).join('\n');
+                                userLimitedLines = endLine - startLine;
+                            }
+                            else {
+                                selectedContent = allLines.slice(startLine).join('\n');
+                            }
+                            // Apply truncation (respects both line and byte limits)
+                            const truncation = truncateHead(selectedContent);
+                            let outputText;
+                            if (truncation.truncated) {
+                                const outputLineCount = truncation.content.split('\n').length;
+                                const endLineDisplay = startLineDisplay + outputLineCount - 1;
+                                const nextOffset = endLineDisplay + 1;
+                                outputText = truncation.content;
+                                outputText += `\n\n[Showing lines ${startLineDisplay}-${endLineDisplay} of ${totalFileLines} (${formatSize(DEFAULT_MAX_CHARS)} limit). Use offset=${nextOffset} to continue.]`;
+                                details = { truncation };
+                            }
+                            else if (userLimitedLines !== undefined &&
+                                startLine + userLimitedLines < allLines.length) {
+                                // User specified limit, there's more content, but no truncation
+                                const remaining = allLines.length - (startLine + userLimitedLines);
+                                const nextOffset = startLine + userLimitedLines + 1;
+                                outputText = truncation.content;
+                                outputText += `\n\n[${remaining} more lines in file. Use offset=${nextOffset} to continue.]`;
+                            }
+                            else {
+                                // No truncation, no user limit exceeded
+                                outputText = truncation.content;
+                            }
+                            content = [{ type: 'text', text: outputText }];
+                        }
+                        // Check if aborted after reading
+                        if (aborted) {
+                            return;
+                        }
+                        // Clean up abort handler
+                        if (signal) {
+                            signal.removeEventListener('abort', onAbort);
+                        }
+                        resolve({ content, details });
+                    }
+                    catch (error) {
+                        // Clean up abort handler
+                        if (signal) {
+                            signal.removeEventListener('abort', onAbort);
+                        }
+                        if (!aborted) {
+                            reject(error);
+                        }
+                    }
+                })();
+            });
+        }
+    };
+}
+/** Default read tool using process.cwd() - for backwards compatibility */
+export const readTool = createReadTool(process.cwd());
+//# sourceMappingURL=read.js.map

package/dist/core/tools/truncate.js

@@ -0,0 +1,70 @@
+/**
+ * Shared truncation utilities for tool outputs.
+ *
+ * Single limit: character count (default 20,000 chars).
+ * Truncation always happens at line boundaries — never mid-line.
+ */
+export const DEFAULT_MAX_CHARS = 20_000;
+export const GREP_MAX_LINE_LENGTH = 500; // Max chars per grep match line
+export const ERROR_MAX_CHARS_UI = 200; // Max chars for error messages shown to user
+export const ERROR_MAX_CHARS_LLM = 500; // Max chars for error messages sent to LLM context
+/**
+ * Format character count as human-readable size.
+ */
+export function formatSize(chars) {
+    if (chars < 1000) {
+        return `${chars} chars`;
+    }
+    else if (chars < 1_000_000) {
+        return `${(chars / 1000).toFixed(1)}k chars`;
+    }
+    else {
+        return `${(chars / 1_000_000).toFixed(1)}M chars`;
+    }
+}
+/**
+ * Truncate content from the head (keep first N chars).
+ * Cuts at the last complete line boundary before maxChars.
+ * If the first line alone exceeds maxChars, returns it hard-cut at maxChars.
+ */
+export function truncateHead(content, maxChars = DEFAULT_MAX_CHARS) {
+    const totalChars = content.length;
+    if (totalChars <= maxChars) {
+        return { content, truncated: false, totalChars, outputChars: totalChars, maxChars };
+    }
+    // Find the last newline before the limit
+    const cutPoint = content.lastIndexOf('\n', maxChars);
+    // If no newline found (single huge line), hard-cut at maxChars
+    const truncated = cutPoint > 0 ? content.slice(0, cutPoint) : content.slice(0, maxChars);
+    return {
+        content: truncated,
+        truncated: true,
+        totalChars,
+        outputChars: truncated.length,
+        maxChars
+    };
+}
+/**
+ * Truncate content and return a single string with a notice appended if truncated.
+ * This is the main entry point for tool outputs going back to the LLM.
+ *
+ * Returns content as-is if no truncation needed, or:
+ *   <truncated content>\n\n[Truncated: showing 5.0k of 50.0k chars]
+ */
+export function truncateOutput(content, maxChars = DEFAULT_MAX_CHARS) {
+    const result = truncateHead(content, maxChars);
+    if (!result.truncated)
+        return content;
+    return `${result.content}\n\n[Truncated: showing ${formatSize(result.outputChars)} of ${formatSize(result.totalChars)}]`;
+}
+/**
+ * Truncate a single line to max characters, adding [truncated] suffix.
+ * Used for grep match lines.
+ */
+export function truncateLine(line, maxChars = GREP_MAX_LINE_LENGTH) {
+    if (line.length <= maxChars) {
+        return { text: line, wasTruncated: false };
+    }
+    return { text: `${line.slice(0, maxChars)}... [truncated]`, wasTruncated: true };
+}
+//# sourceMappingURL=truncate.js.map

package/dist/core/tools/write.js

@@ -0,0 +1,82 @@
+import { Type } from '@sinclair/typebox';
+import { mkdir as fsMkdir, writeFile as fsWriteFile } from 'fs/promises';
+import { dirname } from 'path';
+import { ABORT_AGENT_MESSAGE } from '../abort.js';
+import { WRITE } from '../../tool-names.js';
+import { resolveToCwd } from './path-utils.js';
+const writeSchema = Type.Object({
+    path: Type.String({ description: 'Path to the file to write (relative or absolute)' }),
+    content: Type.String({ description: 'Content to write to the file' })
+});
+const defaultWriteOperations = {
+    writeFile: (path, content) => fsWriteFile(path, content, 'utf-8'),
+    mkdir: (dir) => fsMkdir(dir, { recursive: true }).then(() => { })
+};
+export function createWriteTool(cwd, options) {
+    const ops = options?.operations ?? defaultWriteOperations;
+    return {
+        name: WRITE,
+        label: WRITE,
+        description: "Write content to a file. Creates the file if it doesn't exist, overwrites if it does. Automatically creates parent directories.",
+        parameters: writeSchema,
+        execute: async (_toolCallId, { path, content }, signal) => {
+            const absolutePath = resolveToCwd(path, cwd);
+            const dir = dirname(absolutePath);
+            return new Promise((resolve, reject) => {
+                // Check if already aborted
+                if (signal?.aborted) {
+                    reject(new Error(ABORT_AGENT_MESSAGE));
+                    return;
+                }
+                let aborted = false;
+                // Set up abort handler
+                const onAbort = () => {
+                    aborted = true;
+                    reject(new Error(ABORT_AGENT_MESSAGE));
+                };
+                if (signal) {
+                    signal.addEventListener('abort', onAbort, { once: true });
+                }
+                // Perform the write operation
+                (async () => {
+                    try {
+                        // Create parent directories if needed
+                        await ops.mkdir(dir);
+                        // Check if aborted before writing
+                        if (aborted) {
+                            return;
+                        }
+                        // Write the file
+                        await ops.writeFile(absolutePath, content);
+                        // Check if aborted after writing
+                        if (aborted) {
+                            return;
+                        }
+                        // Clean up abort handler
+                        if (signal) {
+                            signal.removeEventListener('abort', onAbort);
+                        }
+                        resolve({
+                            content: [
+                                { type: 'text', text: `Successfully wrote ${content.length} bytes to ${path}` }
+                            ],
+                            details: undefined
+                        });
+                    }
+                    catch (error) {
+                        // Clean up abort handler
+                        if (signal) {
+                            signal.removeEventListener('abort', onAbort);
+                        }
+                        if (!aborted) {
+                            reject(error);
+                        }
+                    }
+                })();
+            });
+        }
+    };
+}
+/** Default write tool using process.cwd() - for backwards compatibility */
+export const writeTool = createWriteTool(process.cwd());
+//# sourceMappingURL=write.js.map

package/dist/custom/agents/action.js

@@ -0,0 +1,13 @@
+import { BASH, EDIT, EXCEL_EXEC, GREP, READ, SWITCH_MODE, TASK, TODO_LIST, WRITE } from '../../tool-names.js';
+import { buildActionPrompt } from '../prompts/action.js';
+const ACTION_TOOLS = [READ, BASH, EDIT, WRITE, GREP, EXCEL_EXEC, TASK, TODO_LIST, SWITCH_MODE];
+export function actionAgent() {
+    return {
+        name: 'action',
+        description: 'Normal agent mode with Excel superpowers',
+        systemPrompt: buildActionPrompt(),
+        tools: ACTION_TOOLS,
+        switchTo: ['installation']
+    };
+}
+//# sourceMappingURL=action.js.map

package/dist/custom/agents/document-reader.js

@@ -0,0 +1,70 @@
+/**
+ * Document reader subagent — extracts structured data from PDFs, images, and documents.
+ *
+ * Mirrors the backend's DocumentReaderSubagent but runs locally.
+ * Tools: bash (programmatic extraction) + llm_analysis (multimodal LLM).
+ */
+import { BASH, LLM_ANALYSIS } from '../../tool-names.js';
+export const documentReaderAgent = {
+    name: 'document_reader',
+    description: `\
+Extract structured data from PDFs, images, and documents with high accuracy.
+Tools: bash (Python packages for programmatic extraction) and llm_analysis (multimodal LLM for visual/complex content).
+Use for: PDF table extraction, financial statement parsing, image/chart analysis, document scanning, and data verification.
+Prefers programmatic extraction for large structured data (>500 data points), multimodal LLMs for visual content and verification.`,
+    systemPrompt: `\
+======================
+DOCUMENT READER AGENT
+======================
+You extract structured data from files (PDFs, images, HTML, documents) with 100% accuracy as the goal.
+You must extract values exactly as they appear in the source: preserve original formatting, spacing, and symbols.
+
+WORKFLOW:
+1. Scan the document structure first using llm_analysis to understand the layout, sections, and where key data lives.
+2. For structured data (>500 data points): use programmatic extraction via bash (Python packages). This is fast, cheap, and deterministic.
+3. For everything else (images, charts, complex layouts, scanned docs): use llm_analysis with multimodal LLMs.
+4. Always sanity-check and verify extractions — use both methods and compare when accuracy is critical.
+
+PROGRAMMATIC EXTRACTION (bash + Python):
+- camelot: Default for tables. Returns pre-split DataFrame columns. Use flavor='stream' for borderless tables.
+- pdftotext -layout: Cleanest column-aligned output (CLI tool).
+- PyMuPDF (fitz): Fastest Python-native option. Use sort=True for layout-aware extraction.
+- pdfplumber: Good table detection but loses internal spaces.
+- Use multiple methods and compare results to minimize errors.
+
+MULTIMODAL LLM EXTRACTION (llm_analysis):
+- Slower and more expensive — use when programmatic extraction fails or visual understanding is required.
+- Handles images, charts, tables, and complex visual layouts.
+- For large PDFs, split into chunks <20 pages for best accuracy.
+- Call llm_analysis multiple times concurrently for different sections.
+- Models: gemini-3-flash-preview (best for images/tables), claude-haiku-4-5-20251001 (quick scanning).
+
+PAGE SPLITTING:
+- Use qpdf to split PDFs: qpdf "input.pdf" --pages . 1-10 -- "output.pdf"
+- Always wrap file paths in double quotes.
+- For filenames with $, use single quotes to prevent shell expansion.
+
+LARGE FILE HANDLING:
+- If llm_analysis fails due to file size, downsample via ghostscript: gs -sDEVICE=pdfwrite -dCompatibilityLevel=1.4 -dPDFSETTINGS=/ebook -dNOPAUSE -dBATCH -sOutputFile=output.pdf input.pdf
+
+SEC FILINGS:
+- Do NOT parse XBRL or use EdgarTools.
+- Convert SEC filings to PDF first, then extract.
+
+REFERENCING:
+- Note page numbers, table/chart/section names above data sections.
+- Use absolute page numbers (bottom-right of page images), NOT internal document numbering.
+- Flag uncertainties, ambiguities, and conflicting data.
+
+OUTPUT:
+- Use pipe | as delimiter for structured data. Handle empty values as "| |".
+- Large structured outputs (>500 entries): JSON format. Smaller/unstructured: markdown.
+- Do NOT create summary, README, or "simplified" files.
+- Do NOT consolidate data into a single file unless you can do it programmatically.
+- Once data is extracted, list file paths and STOP.`,
+    tools: [BASH, LLM_ANALYSIS],
+    model: 'shortcut/claude-opus-4-6',
+    thinkingLevel: 'low',
+    timeoutSeconds: 900
+};
+//# sourceMappingURL=document-reader.js.map

package/dist/custom/agents/general.js

@@ -0,0 +1,26 @@
+/**
+ * General-purpose subagent — research, computation, and Excel tasks.
+ */
+import { BASH, EXCEL_EXEC } from '../../tool-names.js';
+export const generalAgent = {
+    name: 'general',
+    description: `\
+General-purpose agent for research, computation, and Excel tasks.
+Tools: bash (includes curl/wget for web) and excel_exec (Excel COM API via Python).
+Use for: data analysis, web research, file manipulation, spreadsheet operations, multi-step computations.
+Each agent can handle approximately 50 tool calls per task. Launch multiple concurrently for large workloads.`,
+    systemPrompt: `\
+You are a general-purpose agent. You handle research, computation, data processing, and Excel tasks.
+Use bash for computation, file processing, and fetching URLs (curl/wget).
+Use excel_exec to read/write Excel workbooks via the COM API.
+
+OUTPUT:
+- Be concise and precise. Report findings directly.
+- If you create files, list the file paths at the end.
+- Do NOT create summary or README files unless asked.`,
+    tools: [BASH, EXCEL_EXEC],
+    model: 'shortcut/claude-opus-4-6',
+    thinkingLevel: 'low',
+    timeoutSeconds: 900
+};
+//# sourceMappingURL=general.js.map

package/dist/custom/agents/index.js

@@ -0,0 +1,49 @@
+/**
+ * Agent registry — single source of truth for all agent definitions.
+ *
+ * Both interactive modes (installation, action) and subagents (general)
+ * are defined here using the same AgentDefinition type.
+ *
+ * To add a new agent:
+ * 1. Create a new file in this directory
+ * 2. Define and export an AgentDefinition
+ * 3. Import it here and add to the appropriate array
+ */
+export { actionAgent } from './action.js';
+export { installationAgent } from './installation.js';
+import { documentReaderAgent } from './document-reader.js';
+import { generalAgent } from './general.js';
+/** All subagent definitions (used internally by accessor functions below) */
+const SUBAGENTS = [documentReaderAgent, generalAgent];
+/** Get a subagent config by name */
+export function getSubagent(name) {
+    return SUBAGENTS.find((a) => a.name === name);
+}
+/** Get all subagent names (for task tool enum) */
+export function getSubagentNames() {
+    return SUBAGENTS.map((a) => a.name);
+}
+/** Build the task tool description from the subagent registry */
+export function buildTaskToolDescription() {
+    const preamble = `\
+Launch a subagent to handle a complex task autonomously. Each subagent runs in its own context window with its own set of tools (see descriptions below).
+
+Task queries should be self-contained, clear, and concise. The subagent CANNOT see your conversation history.
+Include file paths, sheet names, cell ranges, and specific instructions in the query.
+
+When multiple tasks are needed, launch them concurrently. NEVER call them sequentially — each agent takes time to complete.
+
+Choose the subagent_type carefully based on the task:
+- document_reader: PDFs, images, document extraction (has llm_analysis for multimodal + bash for programmatic extraction)
+- general: research, computation, Excel tasks (has excel_exec + bash)`;
+    const lines = [preamble];
+    for (const agent of SUBAGENTS) {
+        lines.push('');
+        lines.push('================');
+        lines.push(agent.name);
+        lines.push('================');
+        lines.push(agent.description.trim());
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=index.js.map

package/dist/custom/agents/installation.js

@@ -0,0 +1,13 @@
+import { BASH, EDIT, EXCEL_EXEC, GREP, READ, SWITCH_MODE, WRITE } from '../../tool-names.js';
+import { buildInstallationPrompt } from '../prompts/installation.js';
+const INSTALLATION_TOOLS = [READ, BASH, EDIT, WRITE, GREP, EXCEL_EXEC, SWITCH_MODE];
+export function installationAgent() {
+    return {
+        name: 'installation',
+        description: 'First-time setup for ShortcutXL',
+        systemPrompt: buildInstallationPrompt(),
+        tools: INSTALLATION_TOOLS,
+        switchTo: ['action']
+    };
+}
+//# sourceMappingURL=installation.js.map

package/dist/custom/agents/types.js

@@ -0,0 +1,7 @@
+/**
+ * Unified agent definition — used for both interactive modes and subagents.
+ *
+ * Every agent explicitly declares its tools. No defaults, no categories.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/custom/auth/refresh-timer.js

@@ -0,0 +1,33 @@
+/**
+ * Proactive OAuth token refresh timer.
+ *
+ * Web clients use BaseTokenManager.scheduleRefresh() to refresh tokens before
+ * they expire. The agent has no equivalent — it only refreshes reactively when
+ * getApiKey() is called. If the TUI is idle, the token expires silently.
+ *
+ * This module adds a simple timer that calls getApiKey() periodically to
+ * trigger the reactive refresh logic in AuthStorage before the token expires.
+ */
+const REFRESH_INTERVAL_MS = 60 * 1000; // Check every 60 seconds
+let timer = null;
+/**
+ * Start a background timer that keeps OAuth tokens fresh.
+ * Calls authStorage.getApiKey() periodically, which triggers refresh
+ * when the token is within the buffer window of expiry.
+ */
+export function startProactiveRefresh(authStorage, providerId) {
+    stopProactiveRefresh();
+    timer = setInterval(() => {
+        // Fire-and-forget — getApiKey() handles refresh internally
+        void authStorage.getApiKey(providerId);
+    }, REFRESH_INTERVAL_MS);
+    // Don't block process exit
+    timer.unref();
+}
+function stopProactiveRefresh() {
+    if (timer) {
+        clearInterval(timer);
+        timer = null;
+    }
+}
+//# sourceMappingURL=refresh-timer.js.map