shortcutxl 0.2.0

package/dist/core/auth-storage.js

@@ -0,0 +1,456 @@
+/**
+ * Credential storage for API keys and OAuth tokens.
+ * Handles loading, saving, and refreshing credentials from auth.json.
+ *
+ * Uses file locking to prevent race conditions when multiple pi instances
+ * try to refresh tokens simultaneously.
+ */
+import { getEnvApiKey, getOAuthApiKey, getOAuthProvider, getOAuthProviders } from '@mariozechner/pi-ai';
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { dirname, join } from 'path';
+import lockfile from 'proper-lockfile';
+import { getAgentDir } from '../config.js';
+import { resolveConfigValue } from './resolve-config-value.js';
+export class FileAuthStorageBackend {
+    authPath;
+    constructor(authPath = join(getAgentDir(), 'auth.json')) {
+        this.authPath = authPath;
+    }
+    ensureParentDir() {
+        const dir = dirname(this.authPath);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true, mode: 0o700 });
+        }
+    }
+    ensureFileExists() {
+        if (!existsSync(this.authPath)) {
+            writeFileSync(this.authPath, '{}', 'utf-8');
+            chmodSync(this.authPath, 0o600);
+        }
+    }
+    withLock(fn) {
+        this.ensureParentDir();
+        this.ensureFileExists();
+        let release;
+        try {
+            release = lockfile.lockSync(this.authPath, { realpath: false });
+            const current = existsSync(this.authPath) ? readFileSync(this.authPath, 'utf-8') : undefined;
+            const { result, next } = fn(current);
+            if (next !== undefined) {
+                writeFileSync(this.authPath, next, 'utf-8');
+                chmodSync(this.authPath, 0o600);
+            }
+            return result;
+        }
+        finally {
+            if (release) {
+                release();
+            }
+        }
+    }
+    async withLockAsync(fn) {
+        this.ensureParentDir();
+        this.ensureFileExists();
+        let release;
+        let lockCompromised = false;
+        let lockCompromisedError;
+        const throwIfCompromised = () => {
+            if (lockCompromised) {
+                throw lockCompromisedError ?? new Error('Auth storage lock was compromised');
+            }
+        };
+        try {
+            release = await lockfile.lock(this.authPath, {
+                retries: {
+                    retries: 10,
+                    factor: 2,
+                    minTimeout: 100,
+                    maxTimeout: 10000,
+                    randomize: true
+                },
+                stale: 30000,
+                onCompromised: (err) => {
+                    lockCompromised = true;
+                    lockCompromisedError = err;
+                }
+            });
+            throwIfCompromised();
+            const current = existsSync(this.authPath) ? readFileSync(this.authPath, 'utf-8') : undefined;
+            const { result, next } = await fn(current);
+            throwIfCompromised();
+            if (next !== undefined) {
+                writeFileSync(this.authPath, next, 'utf-8');
+                chmodSync(this.authPath, 0o600);
+            }
+            throwIfCompromised();
+            return result;
+        }
+        finally {
+            if (release) {
+                try {
+                    await release();
+                }
+                catch {
+                    // Ignore unlock errors when lock is compromised.
+                }
+            }
+        }
+    }
+}
+/**
+ * Read-only file backend for subagents.
+ * Reads auth.json without file locking to avoid contention when multiple
+ * subagents spawn concurrently. Never writes — the parent process owns
+ * token refresh and persists updated credentials.
+ */
+export class ReadOnlyFileAuthStorageBackend {
+    authPath;
+    constructor(authPath = join(getAgentDir(), 'auth.json')) {
+        this.authPath = authPath;
+    }
+    withLock(fn) {
+        let content;
+        try {
+            if (existsSync(this.authPath)) {
+                content = readFileSync(this.authPath, 'utf-8');
+            }
+        }
+        catch {
+            // File may be mid-write by parent — return undefined, caller will retry later
+        }
+        const { result } = fn(content);
+        // Ignore `next` — read-only backend never writes
+        return result;
+    }
+    async withLockAsync(fn) {
+        let content;
+        try {
+            if (existsSync(this.authPath)) {
+                content = readFileSync(this.authPath, 'utf-8');
+            }
+        }
+        catch {
+            // File may be mid-write by parent — return undefined, caller will retry later
+        }
+        const { result } = await fn(content);
+        // Ignore `next` — read-only backend never writes
+        return result;
+    }
+}
+export class InMemoryAuthStorageBackend {
+    value;
+    withLock(fn) {
+        const { result, next } = fn(this.value);
+        if (next !== undefined) {
+            this.value = next;
+        }
+        return result;
+    }
+    async withLockAsync(fn) {
+        const { result, next } = await fn(this.value);
+        if (next !== undefined) {
+            this.value = next;
+        }
+        return result;
+    }
+}
+/**
+ * Credential storage backed by a JSON file.
+ */
+export class AuthStorage {
+    storage;
+    data = {};
+    runtimeOverrides = new Map();
+    fallbackResolver;
+    loadError = null;
+    errors = [];
+    _readOnly = false;
+    constructor(storage) {
+        this.storage = storage;
+        this.reload();
+    }
+    static create(authPath) {
+        return new AuthStorage(new FileAuthStorageBackend(authPath ?? join(getAgentDir(), 'auth.json')));
+    }
+    static fromStorage(storage) {
+        return new AuthStorage(storage);
+    }
+    /**
+     * Create a read-only AuthStorage backed by auth.json.
+     * Reads without file locking — safe for concurrent subagents.
+     * Never writes or refreshes tokens; call reload() periodically
+     * to pick up tokens refreshed by the parent process.
+     */
+    static createReadOnly(authPath) {
+        const instance = new AuthStorage(new ReadOnlyFileAuthStorageBackend(authPath ?? join(getAgentDir(), 'auth.json')));
+        instance._readOnly = true;
+        return instance;
+    }
+    static inMemory(data = {}) {
+        const storage = new InMemoryAuthStorageBackend();
+        storage.withLock(() => ({ result: undefined, next: JSON.stringify(data, null, 2) }));
+        return AuthStorage.fromStorage(storage);
+    }
+    /**
+     * Set a runtime API key override (not persisted to disk).
+     * Used for CLI --api-key flag.
+     */
+    setRuntimeApiKey(provider, apiKey) {
+        this.runtimeOverrides.set(provider, apiKey);
+    }
+    /**
+     * Remove a runtime API key override.
+     */
+    removeRuntimeApiKey(provider) {
+        this.runtimeOverrides.delete(provider);
+    }
+    /**
+     * Set a fallback resolver for API keys not found in auth.json or env vars.
+     * Used for custom provider keys from models.json.
+     */
+    setFallbackResolver(resolver) {
+        this.fallbackResolver = resolver;
+    }
+    recordError(error) {
+        const normalizedError = error instanceof Error ? error : new Error(String(error));
+        this.errors.push(normalizedError);
+    }
+    parseStorageData(content) {
+        if (!content) {
+            return {};
+        }
+        return JSON.parse(content);
+    }
+    /**
+     * Reload credentials from storage.
+     */
+    reload() {
+        let content;
+        try {
+            this.storage.withLock((current) => {
+                content = current;
+                return { result: undefined };
+            });
+            this.data = this.parseStorageData(content);
+            this.loadError = null;
+        }
+        catch (error) {
+            this.loadError = error;
+            this.recordError(error);
+        }
+    }
+    persistProviderChange(provider, credential) {
+        if (this.loadError) {
+            return;
+        }
+        try {
+            this.storage.withLock((current) => {
+                const currentData = this.parseStorageData(current);
+                const merged = { ...currentData };
+                if (credential) {
+                    merged[provider] = credential;
+                }
+                else {
+                    delete merged[provider];
+                }
+                return { result: undefined, next: JSON.stringify(merged, null, 2) };
+            });
+        }
+        catch (error) {
+            this.recordError(error);
+        }
+    }
+    /**
+     * Get credential for a provider.
+     */
+    get(provider) {
+        return this.data[provider] ?? undefined;
+    }
+    /**
+     * Set credential for a provider.
+     */
+    set(provider, credential) {
+        this.data[provider] = credential;
+        this.persistProviderChange(provider, credential);
+    }
+    /**
+     * Remove credential for a provider.
+     */
+    remove(provider) {
+        delete this.data[provider];
+        this.persistProviderChange(provider, undefined);
+    }
+    /**
+     * List all providers with credentials.
+     */
+    list() {
+        return Object.keys(this.data);
+    }
+    /**
+     * Check if credentials exist for a provider in auth.json.
+     */
+    has(provider) {
+        return provider in this.data;
+    }
+    /**
+     * Check if any form of auth is configured for a provider.
+     * Only checks OAuth/stored credentials and runtime overrides — ignores
+     * environment variables so that e.g. ANTHROPIC_API_KEY doesn't cause
+     * Anthropic models to appear when the user hasn't logged in via OAuth.
+     */
+    hasAuth(provider) {
+        if (this.runtimeOverrides.has(provider))
+            return true;
+        if (this.data[provider])
+            return true;
+        if (this.fallbackResolver?.(provider))
+            return true;
+        return false;
+    }
+    /**
+     * Get all credentials (for passing to getOAuthApiKey).
+     */
+    getAll() {
+        return { ...this.data };
+    }
+    drainErrors() {
+        const drained = [...this.errors];
+        this.errors = [];
+        return drained;
+    }
+    /**
+     * Login to an OAuth provider.
+     */
+    async login(providerId, callbacks) {
+        const provider = getOAuthProvider(providerId);
+        if (!provider) {
+            throw new Error(`Unknown OAuth provider: ${providerId}`);
+        }
+        const credentials = await provider.login(callbacks);
+        this.set(providerId, { type: 'oauth', ...credentials });
+    }
+    /**
+     * Logout from a provider.
+     */
+    logout(provider) {
+        this.remove(provider);
+    }
+    /**
+     * Refresh OAuth token with backend locking to prevent race conditions.
+     * Multiple pi instances may try to refresh simultaneously when tokens expire.
+     */
+    async refreshOAuthTokenWithLock(providerId) {
+        const provider = getOAuthProvider(providerId);
+        if (!provider) {
+            return null;
+        }
+        const result = await this.storage.withLockAsync(async (current) => {
+            const currentData = this.parseStorageData(current);
+            this.data = currentData;
+            this.loadError = null;
+            const cred = currentData[providerId];
+            if (cred?.type !== 'oauth') {
+                return { result: null };
+            }
+            if (Date.now() < cred.expires) {
+                return { result: { apiKey: provider.getApiKey(cred), newCredentials: cred } };
+            }
+            const oauthCreds = {};
+            for (const [key, value] of Object.entries(currentData)) {
+                if (value.type === 'oauth') {
+                    oauthCreds[key] = value;
+                }
+            }
+            const refreshed = await getOAuthApiKey(providerId, oauthCreds);
+            if (!refreshed) {
+                return { result: null };
+            }
+            const merged = {
+                ...currentData,
+                [providerId]: { type: 'oauth', ...refreshed.newCredentials }
+            };
+            this.data = merged;
+            this.loadError = null;
+            return { result: refreshed, next: JSON.stringify(merged, null, 2) };
+        });
+        return result;
+    }
+    /**
+     * Get API key for a provider.
+     * Priority:
+     * 1. Runtime override (CLI --api-key)
+     * 2. API key from auth.json
+     * 3. OAuth token from auth.json (auto-refreshed with locking)
+     * 4. Environment variable
+     * 5. Fallback resolver (models.json custom providers)
+     */
+    async getApiKey(providerId) {
+        // Runtime override takes highest priority
+        const runtimeKey = this.runtimeOverrides.get(providerId);
+        if (runtimeKey) {
+            return runtimeKey;
+        }
+        const cred = this.data[providerId];
+        if (cred?.type === 'api_key') {
+            return resolveConfigValue(cred.key);
+        }
+        if (cred?.type === 'oauth') {
+            const provider = getOAuthProvider(providerId);
+            if (!provider) {
+                // Unknown OAuth provider, can't get API key
+                return undefined;
+            }
+            // Check if token needs refresh
+            const needsRefresh = Date.now() >= cred.expires;
+            if (needsRefresh) {
+                if (this._readOnly) {
+                    // Read-only mode (subagents): never refresh — re-read the file
+                    // to pick up tokens the parent process may have refreshed.
+                    this.reload();
+                    const updatedCred = this.data[providerId];
+                    if (updatedCred?.type === 'oauth') {
+                        return provider.getApiKey(updatedCred);
+                    }
+                    return undefined;
+                }
+                // Use locked refresh to prevent race conditions
+                try {
+                    const result = await this.refreshOAuthTokenWithLock(providerId);
+                    if (result) {
+                        return result.apiKey;
+                    }
+                }
+                catch (error) {
+                    this.recordError(error);
+                    // Refresh failed - re-read file to check if another instance succeeded
+                    this.reload();
+                    const updatedCred = this.data[providerId];
+                    if (updatedCred?.type === 'oauth' && Date.now() < updatedCred.expires) {
+                        // Another instance refreshed successfully, use those credentials
+                        return provider.getApiKey(updatedCred);
+                    }
+                    // Refresh truly failed - return undefined so model discovery skips this provider
+                    // User can /login to re-authenticate (credentials preserved for retry)
+                    return undefined;
+                }
+            }
+            else {
+                // Token not expired, use current access token
+                return provider.getApiKey(cred);
+            }
+        }
+        // Fall back to environment variable
+        const envKey = getEnvApiKey(providerId);
+        if (envKey)
+            return envKey;
+        // Fall back to custom resolver (e.g., models.json custom providers)
+        return this.fallbackResolver?.(providerId) ?? undefined;
+    }
+    /**
+     * Get all registered OAuth providers
+     */
+    getOAuthProviders() {
+        return getOAuthProviders();
+    }
+}
+//# sourceMappingURL=auth-storage.js.map

package/dist/core/bash-executor.js

@@ -0,0 +1,222 @@
+/**
+ * Bash command execution with streaming support and cancellation.
+ *
+ * This module provides a unified bash execution implementation used by:
+ * - AgentSession.executeBash() for interactive and RPC modes
+ * - Direct calls from modes that need bash execution
+ */
+import { spawn } from 'child_process';
+import { randomBytes } from 'node:crypto';
+import { createWriteStream } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import stripAnsi from 'strip-ansi';
+import { getShellConfig, getShellEnv, killProcessTree, sanitizeBinaryOutput } from '../utils/shell.js';
+import { SettingsManager } from './settings-manager.js';
+import { DEFAULT_MAX_CHARS, truncateHead } from './tools/truncate.js';
+// ============================================================================
+// Implementation
+// ============================================================================
+/**
+ * Execute a bash command with optional streaming and cancellation support.
+ *
+ * Features:
+ * - Streams sanitized output via onChunk callback
+ * - Writes large output to temp file for later retrieval
+ * - Supports cancellation via AbortSignal
+ * - Sanitizes output (strips ANSI, removes binary garbage, normalizes newlines)
+ * - Truncates output to first 20k chars via head truncation
+ *
+ * @param command - The bash command to execute
+ * @param options - Optional streaming callback and abort signal
+ * @returns Promise resolving to execution result
+ */
+export function executeBash(command, options) {
+    return new Promise((resolve, reject) => {
+        const { shell, args } = getShellConfig(SettingsManager.create().getShellPath());
+        const child = spawn(shell, [...args, command], {
+            detached: true,
+            env: getShellEnv(),
+            stdio: ['ignore', 'pipe', 'pipe']
+        });
+        const outputChunks = [];
+        let totalChars = 0;
+        // Temp file for large output
+        let tempFilePath;
+        let tempFileStream;
+        let settled = false;
+        // Handle abort signal — kill process tree and force-close pipes.
+        // On Windows, `start`-spawned processes can hold pipe handles open even
+        // after taskkill kills the shell, preventing the 'close' event from firing.
+        const abortHandler = () => {
+            if (child.pid) {
+                killProcessTree(child.pid);
+            }
+            child.stdout?.destroy();
+            child.stderr?.destroy();
+            // Safety net: if 'close' still doesn't fire (orphaned pipe handles),
+            // force-settle after 2 seconds so the command doesn't hang forever.
+            setTimeout(() => {
+                if (!settled) {
+                    settled = true;
+                    if (options?.signal) {
+                        options.signal.removeEventListener('abort', abortHandler);
+                    }
+                    if (tempFileStream) {
+                        tempFileStream.end();
+                    }
+                    const fullOutput = outputChunks.join('');
+                    const truncationResult = truncateHead(fullOutput);
+                    resolve({
+                        output: truncationResult.truncated ? truncationResult.content : fullOutput,
+                        exitCode: undefined,
+                        cancelled: true,
+                        truncated: truncationResult.truncated,
+                        fullOutputPath: tempFilePath
+                    });
+                }
+            }, 2000);
+        };
+        if (options?.signal) {
+            if (options.signal.aborted) {
+                child.kill();
+                resolve({
+                    output: '',
+                    exitCode: undefined,
+                    cancelled: true,
+                    truncated: false
+                });
+                return;
+            }
+            options.signal.addEventListener('abort', abortHandler, { once: true });
+        }
+        const decoder = new TextDecoder();
+        const handleData = (data) => {
+            // Sanitize once at the source: strip ANSI, replace binary garbage, normalize newlines
+            const text = sanitizeBinaryOutput(stripAnsi(decoder.decode(data, { stream: true }))).replace(/\r/g, '');
+            totalChars += text.length;
+            // Start writing to temp file if exceeds threshold
+            if (totalChars > DEFAULT_MAX_CHARS && !tempFilePath) {
+                const id = randomBytes(8).toString('hex');
+                tempFilePath = join(tmpdir(), `pi-bash-${id}.log`);
+                tempFileStream = createWriteStream(tempFilePath);
+                for (const chunk of outputChunks) {
+                    tempFileStream.write(chunk);
+                }
+            }
+            if (tempFileStream) {
+                tempFileStream.write(text);
+            }
+            outputChunks.push(text);
+            // Stream to callback if provided
+            if (options?.onChunk) {
+                options.onChunk(text);
+            }
+        };
+        child.stdout?.on('data', handleData);
+        child.stderr?.on('data', handleData);
+        child.on('close', (code) => {
+            if (options?.signal) {
+                options.signal.removeEventListener('abort', abortHandler);
+            }
+            if (tempFileStream) {
+                tempFileStream.end();
+            }
+            if (settled)
+                return;
+            settled = true;
+            const fullOutput = outputChunks.join('');
+            const truncationResult = truncateHead(fullOutput);
+            const cancelled = code === null;
+            resolve({
+                output: truncationResult.truncated ? truncationResult.content : fullOutput,
+                exitCode: cancelled ? undefined : code,
+                cancelled,
+                truncated: truncationResult.truncated,
+                fullOutputPath: tempFilePath
+            });
+        });
+        child.on('error', (err) => {
+            if (options?.signal) {
+                options.signal.removeEventListener('abort', abortHandler);
+            }
+            if (tempFileStream) {
+                tempFileStream.end();
+            }
+            if (!settled) {
+                settled = true;
+                reject(err);
+            }
+        });
+    });
+}
+/**
+ * Execute a bash command using custom BashOperations.
+ * Used for remote execution (SSH, containers, etc.).
+ */
+export async function executeBashWithOperations(command, cwd, operations, options) {
+    const outputChunks = [];
+    let totalChars = 0;
+    let tempFilePath;
+    let tempFileStream;
+    const decoder = new TextDecoder();
+    const onData = (data) => {
+        // Sanitize: strip ANSI, replace binary garbage, normalize newlines
+        const text = sanitizeBinaryOutput(stripAnsi(decoder.decode(data, { stream: true }))).replace(/\r/g, '');
+        totalChars += text.length;
+        // Start writing to temp file if exceeds threshold
+        if (totalChars > DEFAULT_MAX_CHARS && !tempFilePath) {
+            const id = randomBytes(8).toString('hex');
+            tempFilePath = join(tmpdir(), `pi-bash-${id}.log`);
+            tempFileStream = createWriteStream(tempFilePath);
+            for (const chunk of outputChunks) {
+                tempFileStream.write(chunk);
+            }
+        }
+        if (tempFileStream) {
+            tempFileStream.write(text);
+        }
+        outputChunks.push(text);
+        // Stream to callback
+        if (options?.onChunk) {
+            options.onChunk(text);
+        }
+    };
+    try {
+        const result = await operations.exec(command, cwd, {
+            onData,
+            signal: options?.signal
+        });
+        if (tempFileStream) {
+            tempFileStream.end();
+        }
+        const fullOutput = outputChunks.join('');
+        const truncationResult = truncateHead(fullOutput);
+        const cancelled = options?.signal?.aborted ?? false;
+        return {
+            output: truncationResult.truncated ? truncationResult.content : fullOutput,
+            exitCode: cancelled ? undefined : (result.exitCode ?? undefined),
+            cancelled,
+            truncated: truncationResult.truncated,
+            fullOutputPath: tempFilePath
+        };
+    }
+    catch (err) {
+        if (tempFileStream) {
+            tempFileStream.end();
+        }
+        if (options?.signal?.aborted) {
+            const fullOutput = outputChunks.join('');
+            const truncationResult = truncateHead(fullOutput);
+            return {
+                output: truncationResult.truncated ? truncationResult.content : fullOutput,
+                exitCode: undefined,
+                cancelled: true,
+                truncated: truncationResult.truncated,
+                fullOutputPath: tempFilePath
+            };
+        }
+        throw err;
+    }
+}
+//# sourceMappingURL=bash-executor.js.map