shortcutxl 0.2.0

package/dist/custom/providers/shortcut-stream.js

@@ -0,0 +1,252 @@
+/**
+ * Custom streamSimple for Shortcut provider.
+ *
+ * Thin composition: converts context → request body, fetches SSE stream,
+ * maps SSE events → pi-ai AssistantMessageEvents.
+ *
+ * Message conversion lives in message-converter.ts.
+ * SSE protocol types live in sse-protocol.ts.
+ */
+import { createAssistantMessageEventStream } from '@mariozechner/pi-ai';
+import { APP_NAME } from '../../config.js';
+import { buildUsage, mapStopReason } from './llm-usage.js';
+import { convertMessages, convertTools } from './message-converter.js';
+import { SHORTCUT_PROVIDER_ID } from './provider-ids.js';
+import { THINKING_TO_EFFORT, parseSSE } from './sse-protocol.js';
+export function createShortcutStream(baseUrl) {
+    return function shortcutStream(model, context, options) {
+        const stream = createAssistantMessageEventStream();
+        const partial = {
+            role: 'assistant',
+            content: [],
+            api: 'shortcut-llm',
+            provider: SHORTCUT_PROVIDER_ID,
+            model: model.id,
+            usage: {
+                input: 0,
+                output: 0,
+                cacheRead: 0,
+                cacheWrite: 0,
+                totalTokens: 0,
+                cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+            },
+            stopReason: 'stop',
+            timestamp: Date.now()
+        };
+        const body = {
+            model: model.id,
+            messages: convertMessages(context),
+            tools: convertTools(context.tools),
+            effort_level: options?.reasoning ? THINKING_TO_EFFORT[options.reasoning] || 'low' : undefined,
+            thinking_type: 'adaptive'
+        };
+        const thinkingText = {};
+        const toolCallArgs = {};
+        (async () => {
+            try {
+                const apiKey = options?.apiKey ?? '';
+                const response = await fetch(`${baseUrl}/api/llm/stream`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        Authorization: `Bearer ${apiKey}`,
+                        'User-Agent': `Mozilla/5.0 (compatible; ${APP_NAME}-coding-agent/1.0)`
+                    },
+                    body: JSON.stringify(body),
+                    signal: options?.signal
+                });
+                if (!response.ok) {
+                    const raw = await response.text();
+                    const text = raw.split('\n').slice(0, 20).join('\n');
+                    throw new Error(`LLM proxy error ${response.status}: ${text}`);
+                }
+                stream.push({ type: 'start', partial });
+                const reader = response.body.getReader();
+                const decoder = new TextDecoder();
+                let buffer = '';
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    buffer += decoder.decode(value, { stream: true });
+                    const events = buffer.split('\n\n');
+                    buffer = events.pop() || '';
+                    for (const eventBlock of events) {
+                        if (!eventBlock.trim())
+                            continue;
+                        const parsed = parseSSE(eventBlock.split('\n'));
+                        if (!parsed)
+                            continue;
+                        const { event, data } = parsed;
+                        let payload;
+                        try {
+                            payload = JSON.parse(data);
+                        }
+                        catch {
+                            continue;
+                        }
+                        handleSSEEvent(event, payload, partial, stream, thinkingText, toolCallArgs, model);
+                    }
+                }
+            }
+            catch (err) {
+                const isAbort = options?.signal?.aborted ||
+                    (err instanceof Error && err.name === 'AbortError');
+                const errMsg = err instanceof Error ? err.message : 'Request failed';
+                partial.stopReason = isAbort ? 'aborted' : 'error';
+                partial.errorMessage = isAbort ? 'Request was aborted' : errMsg;
+                stream.push({ type: 'error', reason: isAbort ? 'aborted' : 'error', error: partial });
+            }
+        })();
+        return stream;
+    };
+}
+/** Pad partial.content with empty text placeholders up to the given index. */
+function padContent(partial, ci) {
+    while (partial.content.length <= ci) {
+        partial.content.push({ type: 'text', text: '' });
+    }
+}
+/** Map a single SSE event to pi-ai stream events and update partial state. */
+function handleSSEEvent(event, payload, partial, stream, thinkingText, toolCallArgs, model) {
+    switch (event) {
+        case 'thinking_start': {
+            const p = payload;
+            const ci = p.content_index;
+            thinkingText[ci] = '';
+            padContent(partial, ci);
+            partial.content[ci] = {
+                type: 'thinking',
+                thinking: '',
+                redacted: false,
+                thinkingSignature: ''
+            };
+            stream.push({ type: 'thinking_start', contentIndex: ci, partial });
+            break;
+        }
+        case 'thinking_delta': {
+            const p = payload;
+            const ci = p.content_index;
+            thinkingText[ci] = (thinkingText[ci] || '') + p.delta;
+            const tc = partial.content[ci];
+            if (tc)
+                tc.thinking = thinkingText[ci];
+            stream.push({ type: 'thinking_delta', contentIndex: ci, delta: p.delta, partial });
+            break;
+        }
+        case 'thinking_end': {
+            const p = payload;
+            const ci = p.content_index;
+            const tc = partial.content[ci];
+            if (tc)
+                tc.thinkingSignature = p.signature;
+            stream.push({
+                type: 'thinking_end',
+                contentIndex: ci,
+                content: thinkingText[ci] || '',
+                partial
+            });
+            break;
+        }
+        case 'thinking_redacted': {
+            const p = payload;
+            const ci = p.content_index;
+            padContent(partial, ci);
+            partial.content[ci] = {
+                type: 'thinking',
+                thinking: '',
+                redacted: true,
+                thinkingSignature: p.signature
+            };
+            stream.push({ type: 'thinking_start', contentIndex: ci, partial });
+            stream.push({ type: 'thinking_end', contentIndex: ci, content: '', partial });
+            break;
+        }
+        case 'text_start': {
+            const p = payload;
+            const ci = p.content_index;
+            padContent(partial, ci);
+            partial.content[ci] = { type: 'text', text: '' };
+            stream.push({ type: 'text_start', contentIndex: ci, partial });
+            break;
+        }
+        case 'text_delta': {
+            const p = payload;
+            const ci = p.content_index;
+            const tc = partial.content[ci];
+            if (tc)
+                tc.text += p.delta;
+            stream.push({ type: 'text_delta', contentIndex: ci, delta: p.delta, partial });
+            break;
+        }
+        case 'text_end': {
+            const ci = payload.content_index;
+            const tc = partial.content[ci];
+            stream.push({
+                type: 'text_end',
+                contentIndex: ci,
+                content: tc?.text || '',
+                partial
+            });
+            break;
+        }
+        case 'toolcall_start': {
+            const p = payload;
+            const ci = p.content_index;
+            toolCallArgs[ci] = '';
+            padContent(partial, ci);
+            partial.content[ci] = {
+                type: 'toolCall',
+                id: p.id,
+                name: p.name,
+                arguments: {}
+            };
+            stream.push({ type: 'toolcall_start', contentIndex: ci, partial });
+            break;
+        }
+        case 'toolcall_delta': {
+            const p = payload;
+            const ci = p.content_index;
+            toolCallArgs[ci] = (toolCallArgs[ci] || '') + p.delta;
+            stream.push({ type: 'toolcall_delta', contentIndex: ci, delta: p.delta, partial });
+            break;
+        }
+        case 'toolcall_end': {
+            const p = payload;
+            const ci = p.content_index;
+            let args = {};
+            try {
+                args = JSON.parse(p.arguments);
+            }
+            catch {
+                // keep empty
+            }
+            const toolCall = {
+                type: 'toolCall',
+                id: p.id,
+                name: p.name,
+                arguments: args
+            };
+            partial.content[ci] = toolCall;
+            stream.push({ type: 'toolcall_end', contentIndex: ci, toolCall, partial });
+            break;
+        }
+        case 'done': {
+            const p = payload;
+            partial.usage = buildUsage(p.usage, model);
+            const reason = mapStopReason(p.stop_reason);
+            partial.stopReason = reason;
+            stream.push({
+                type: 'done',
+                reason: reason,
+                message: partial
+            });
+            break;
+        }
+        case 'error': {
+            const p = payload;
+            throw new Error(p.message);
+        }
+    }
+}
+//# sourceMappingURL=shortcut-stream.js.map

package/dist/custom/providers/sse-protocol.js

@@ -0,0 +1,38 @@
+/**
+ * SSE protocol contract between the Python backend and the TS client.
+ *
+ * This file defines every SSE event type that /api/llm/stream can emit.
+ * It is the single source of truth. If the Python backend changes an event
+ * shape, this file must change first, and both sides' tests must be updated.
+ *
+ * Counterpart: backend/server/routes/llm_stream.py (_sse_event, _stream_llm)
+ */
+// --- SSE line parser ---
+/**
+ * Parse a single SSE event block (lines between double-newlines) into
+ * its event name and JSON data string. Returns null if the block is
+ * incomplete or malformed.
+ */
+export function parseSSE(lines) {
+    let event = '';
+    let data = '';
+    for (const line of lines) {
+        if (line.startsWith('event: '))
+            event = line.slice(7);
+        else if (line.startsWith('data: '))
+            data = line.slice(6);
+    }
+    if (!event || !data)
+        return null;
+    return { event, data };
+}
+// --- Thinking level mapping ---
+/** Map pi-ai thinking levels to backend effort levels. */
+export const THINKING_TO_EFFORT = {
+    minimal: 'low',
+    low: 'low',
+    medium: 'medium',
+    high: 'high',
+    xhigh: 'max'
+};
+//# sourceMappingURL=sse-protocol.js.map

package/dist/custom/sync-xll.js

@@ -0,0 +1,130 @@
+/**
+ * Sync the shipped XLL directory to a stable user-local path.
+ *
+ * The npm package ships xll/ containing everything the XLL needs:
+ *   xll/ShortcutXL.xll    — the add-in DLL
+ *   xll/python3.dll etc.   — Python runtime DLLs
+ *   xll/modules/            — shortcut_xl.py and user UDF modules
+ *
+ * On every startup we sync xll/ to ~/.shortcut/agent/xll/ so the
+ * Windows registry key always points to a stable path that survives
+ * npm re-installs.
+ *
+ * Note: files removed from the shipped directory are NOT deleted from the
+ * stable directory. This is intentional — Excel may still have the old DLL
+ * loaded, and stale files are harmless.
+ */
+import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync, unlinkSync, utimesSync } from 'fs';
+import { createHash } from 'crypto';
+import { join } from 'path';
+import { getAgentDir, getPackageDir } from '../config.js';
+/** Stable XLL directory that the registry should point to. */
+export function getStableXllDir() {
+    return join(getAgentDir(), 'xll');
+}
+/** Strip the NTFS Zone.Identifier alternate data stream (Mark of the Web). */
+function stripMotw(filePath) {
+    try {
+        unlinkSync(`${filePath}:Zone.Identifier`);
+    }
+    catch {
+        // No MOTW or not on NTFS — nothing to do
+    }
+}
+/**
+ * Returns true if `src` and `dest` have identical size and mtime.
+ * Avoids reading file contents — stat-only comparison is ~100x faster
+ * than MD5 hashing multi-MB DLLs on every startup.
+ */
+function filesMatch(src, dest) {
+    if (!existsSync(dest))
+        return false;
+    const srcStat = statSync(src);
+    const destStat = statSync(dest);
+    return srcStat.size === destStat.size && srcStat.mtimeMs === destStat.mtimeMs;
+}
+/** Returns true if two files have identical content (SHA-256). */
+function filesContentMatch(src, dest) {
+    const hash = (p) => createHash('sha256').update(readFileSync(p)).digest('hex');
+    return hash(src) === hash(dest);
+}
+/**
+ * Recursively copy `src` directory to `dest`, only overwriting files
+ * whose content has changed. Creates directories as needed.
+ */
+function syncDir(src, dest) {
+    if (!existsSync(src))
+        return { updated: 0, staleLocked: false };
+    mkdirSync(dest, { recursive: true });
+    let updated = 0;
+    let staleLocked = false;
+    for (const entry of readdirSync(src)) {
+        const srcPath = join(src, entry);
+        const destPath = join(dest, entry);
+        const stat = statSync(srcPath);
+        if (stat.isDirectory()) {
+            const sub = syncDir(srcPath, destPath);
+            updated += sub.updated;
+            staleLocked = staleLocked || sub.staleLocked;
+        }
+        else if (stat.isFile()) {
+            if (!filesMatch(srcPath, destPath)) {
+                try {
+                    copyFileSync(srcPath, destPath);
+                    // Preserve mtime so the stat-based filesMatch() short-circuits next startup.
+                    const srcMtime = statSync(srcPath).mtime;
+                    utimesSync(destPath, srcMtime, srcMtime);
+                    // Strip Mark of the Web so Excel doesn't show "file format mismatch" dialogs.
+                    // npm downloads carry a Zone.Identifier ADS that Windows propagates through copies.
+                    stripMotw(destPath);
+                    updated++;
+                }
+                catch (err) {
+                    // On Windows, Excel may have the XLL/DLL locked (EBUSY/EPERM).
+                    const code = err.code;
+                    if (code === 'EBUSY' || code === 'EPERM') {
+                        // The stat-based check flagged a difference (usually just mtime after
+                        // npm reinstall). Check actual content before alarming the user.
+                        if (!filesContentMatch(srcPath, destPath)) {
+                            staleLocked = true;
+                        }
+                        // If content matches, silently skip — no update needed.
+                    }
+                    else {
+                        throw err;
+                    }
+                }
+            }
+        }
+    }
+    return { updated, staleLocked };
+}
+/**
+ * Sync shipped XLL files to the stable user-local directory.
+ *
+ * Safe to call on every startup — only copies files that actually changed.
+ * Callers should check `xllReady` — if false on first install, the agent
+ * cannot proceed with registration.
+ */
+export function syncXll() {
+    const shippedDir = join(getPackageDir(), 'xll');
+    const stableDir = getStableXllDir();
+    if (existsSync(shippedDir)) {
+        try {
+            const { updated, staleLocked } = syncDir(shippedDir, stableDir);
+            if (staleLocked) {
+                console.warn('Warning: A ShortcutXL update is available but Excel has files locked. ' +
+                    'Please close Excel and restart the Shortcut agent to apply it.');
+            }
+            const xllReady = existsSync(join(stableDir, 'ShortcutXL.xll'));
+            return { updated, stableDir, xllReady };
+        }
+        catch (err) {
+            console.warn(`Warning: XLL sync failed: ${err}`);
+        }
+    }
+    // Sync failed or shipped dir missing — check if stable dir has a prior copy
+    const xllReady = existsSync(join(stableDir, 'ShortcutXL.xll'));
+    return { updated: 0, stableDir, xllReady };
+}
+//# sourceMappingURL=sync-xll.js.map