thaddeus 1.0.18 → 1.0.27

package/src/services/oauth/crypto.js

@@ -0,0 +1,19 @@
+import { createHash, randomBytes } from 'crypto';
+function base64URLEncode(buffer) {
+    return buffer
+        .toString('base64')
+        .replace(/\+/g, '-')
+        .replace(/\//g, '_')
+        .replace(/=/g, '');
+}
+export function generateCodeVerifier() {
+    return base64URLEncode(randomBytes(32));
+}
+export function generateCodeChallenge(verifier) {
+    const hash = createHash('sha256');
+    hash.update(verifier);
+    return base64URLEncode(hash.digest());
+}
+export function generateState() {
+    return base64URLEncode(randomBytes(32));
+}

package/src/services/oauth/getOauthProfile.js

@@ -0,0 +1,48 @@
+import axios from 'axios';
+import { getOauthConfig, OAUTH_BETA_HEADER } from 'src/constants/oauth.js';
+import { getAnthropicApiKey } from 'src/utils/auth.js';
+import { getGlobalConfig } from 'src/utils/config.js';
+import { logError } from 'src/utils/log.js';
+export async function getOauthProfileFromApiKey() {
+    // Assumes interactive session
+    const config = getGlobalConfig();
+    const accountUuid = config.oauthAccount?.accountUuid;
+    const apiKey = getAnthropicApiKey();
+    // Need both account UUID and API key to check
+    if (!accountUuid || !apiKey) {
+        return;
+    }
+    const endpoint = `${getOauthConfig().BASE_API_URL}/api/claude_cli_profile`;
+    try {
+        const response = await axios.get(endpoint, {
+            headers: {
+                'x-api-key': apiKey,
+                'anthropic-beta': OAUTH_BETA_HEADER,
+            },
+            params: {
+                account_uuid: accountUuid,
+            },
+            timeout: 10000,
+        });
+        return response.data;
+    }
+    catch (error) {
+        logError(error);
+    }
+}
+export async function getOauthProfileFromOauthToken(accessToken) {
+    const endpoint = `${getOauthConfig().BASE_API_URL}/api/oauth/profile`;
+    try {
+        const response = await axios.get(endpoint, {
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                'Content-Type': 'application/json',
+            },
+            timeout: 10000,
+        });
+        return response.data;
+    }
+    catch (error) {
+        logError(error);
+    }
+}

package/src/services/oauth/index.js

@@ -0,0 +1,133 @@
+import { logEvent } from 'src/services/analytics/index.js';
+import { openBrowser } from '../../utils/browser.js';
+import { AuthCodeListener } from './auth-code-listener.js';
+import * as client from './client.js';
+import * as crypto from './crypto.js';
+/**
+ * OAuth service that handles the OAuth 2.0 authorization code flow with PKCE.
+ *
+ * Supports two ways to get authorization codes:
+ * 1. Automatic: Opens browser, redirects to localhost where we capture the code
+ * 2. Manual: User manually copies and pastes the code (used in non-browser environments)
+ */
+export class OAuthService {
+    codeVerifier;
+    authCodeListener = null;
+    port = null;
+    manualAuthCodeResolver = null;
+    constructor() {
+        this.codeVerifier = crypto.generateCodeVerifier();
+    }
+    async startOAuthFlow(authURLHandler, options) {
+        // Create OAuth callback listener and start it
+        this.authCodeListener = new AuthCodeListener();
+        this.port = await this.authCodeListener.start();
+        // Generate PKCE values and state
+        const codeChallenge = crypto.generateCodeChallenge(this.codeVerifier);
+        const state = crypto.generateState();
+        // Build auth URLs for both automatic and manual flows
+        const opts = {
+            codeChallenge,
+            state,
+            port: this.port,
+            loginWithClaudeAi: options?.loginWithClaudeAi,
+            inferenceOnly: options?.inferenceOnly,
+            orgUUID: options?.orgUUID,
+            loginHint: options?.loginHint,
+            loginMethod: options?.loginMethod,
+        };
+        const manualFlowUrl = client.buildAuthUrl({ ...opts, isManual: true });
+        const automaticFlowUrl = client.buildAuthUrl({ ...opts, isManual: false });
+        // Wait for either automatic or manual auth code
+        const authorizationCode = await this.waitForAuthorizationCode(state, async () => {
+            if (options?.skipBrowserOpen) {
+                // Hand both URLs to the caller. The automatic one still works
+                // if the caller opens it on the same host (localhost listener
+                // is running); the manual one works from anywhere.
+                await authURLHandler(manualFlowUrl, automaticFlowUrl);
+            }
+            else {
+                await authURLHandler(manualFlowUrl); // Show manual option to user
+                await openBrowser(automaticFlowUrl); // Try automatic flow
+            }
+        });
+        // Check if the automatic flow is still active (has a pending response)
+        const isAutomaticFlow = this.authCodeListener?.hasPendingResponse() ?? false;
+        logEvent('thaddeus_oauth_auth_code_received', { automatic: isAutomaticFlow });
+        try {
+            // Exchange authorization code for tokens
+            const tokenResponse = await client.exchangeCodeForTokens(authorizationCode, state, this.codeVerifier, this.port, !isAutomaticFlow, // Pass isManual=true if it's NOT automatic flow
+            options?.expiresIn);
+            // Fetch profile info (subscription type and rate limit tier) for the
+            // returned OAuthTokens. Logout and account storage are handled by the
+            // caller (installOAuthTokens in auth.ts).
+            const profileInfo = await client.fetchProfileInfo(tokenResponse.access_token);
+            // Handle success redirect for automatic flow
+            if (isAutomaticFlow) {
+                const scopes = client.parseScopes(tokenResponse.scope);
+                this.authCodeListener?.handleSuccessRedirect(scopes);
+            }
+            return this.formatTokens(tokenResponse, profileInfo.subscriptionType, profileInfo.rateLimitTier, profileInfo.rawProfile);
+        }
+        catch (error) {
+            // If we have a pending response, send an error redirect before closing
+            if (isAutomaticFlow) {
+                this.authCodeListener?.handleErrorRedirect();
+            }
+            throw error;
+        }
+        finally {
+            // Always cleanup
+            this.authCodeListener?.close();
+        }
+    }
+    async waitForAuthorizationCode(state, onReady) {
+        return new Promise((resolve, reject) => {
+            // Set up manual auth code resolver
+            this.manualAuthCodeResolver = resolve;
+            // Start automatic flow
+            this.authCodeListener
+                ?.waitForAuthorization(state, onReady)
+                .then(authorizationCode => {
+                this.manualAuthCodeResolver = null;
+                resolve(authorizationCode);
+            })
+                .catch(error => {
+                this.manualAuthCodeResolver = null;
+                reject(error);
+            });
+        });
+    }
+    // Handle manual flow callback when user pastes the auth code
+    handleManualAuthCodeInput(params) {
+        if (this.manualAuthCodeResolver) {
+            this.manualAuthCodeResolver(params.authorizationCode);
+            this.manualAuthCodeResolver = null;
+            // Close the auth code listener since manual input was used
+            this.authCodeListener?.close();
+        }
+    }
+    formatTokens(response, subscriptionType, rateLimitTier, profile) {
+        return {
+            accessToken: response.access_token,
+            refreshToken: response.refresh_token,
+            expiresAt: Date.now() + response.expires_in * 1000,
+            scopes: client.parseScopes(response.scope),
+            subscriptionType,
+            rateLimitTier,
+            profile,
+            tokenAccount: response.account
+                ? {
+                    uuid: response.account.uuid,
+                    emailAddress: response.account.email_address,
+                    organizationUuid: response.organization?.uuid,
+                }
+                : undefined,
+        };
+    }
+    // Clean up any resources (like the local server)
+    cleanup() {
+        this.authCodeListener?.close();
+        this.manualAuthCodeResolver = null;
+    }
+}

package/src/services/plugins/PluginInstallationManager.js

@@ -0,0 +1,139 @@
+/**
+ * Background plugin and marketplace installation manager
+ *
+ * This module handles automatic installation of plugins and marketplaces
+ * from trusted sources (repository and user settings) without blocking startup.
+ */
+import { logForDebugging } from '../../utils/debug.js';
+import { logForDiagnosticsNoPII } from '../../utils/diagLogs.js';
+import { logError } from '../../utils/log.js';
+import { clearMarketplacesCache, getDeclaredMarketplaces, loadKnownMarketplacesConfig, } from '../../utils/plugins/marketplaceManager.js';
+import { clearPluginCache } from '../../utils/plugins/pluginLoader.js';
+import { diffMarketplaces, reconcileMarketplaces, } from '../../utils/plugins/reconciler.js';
+import { refreshActivePlugins } from '../../utils/plugins/refresh.js';
+import { logEvent } from '../analytics/index.js';
+/**
+ * Update marketplace installation status in app state
+ */
+function updateMarketplaceStatus(setAppState, name, status, error) {
+    setAppState(prevState => ({
+        ...prevState,
+        plugins: {
+            ...prevState.plugins,
+            installationStatus: {
+                ...prevState.plugins.installationStatus,
+                marketplaces: prevState.plugins.installationStatus.marketplaces.map(m => (m.name === name ? { ...m, status, error } : m)),
+            },
+        },
+    }));
+}
+/**
+ * Perform background plugin startup checks and installations.
+ *
+ * This is a thin wrapper around reconcileMarketplaces() that maps onProgress
+ * events to AppState updates for the REPL UI. After marketplaces are
+ * reconciled:
+ * - New installs → auto-refresh plugins (fixes "plugin-not-found" errors
+ *   from the initial cache-only load on fresh homespace/cleared cache)
+ * - Updates only → set needsRefresh, show notification for /reload-plugins
+ */
+export async function performBackgroundPluginInstallations(setAppState) {
+    logForDebugging('performBackgroundPluginInstallations called');
+    try {
+        // Compute diff upfront for initial UI status (pending spinners)
+        const declared = getDeclaredMarketplaces();
+        const materialized = await loadKnownMarketplacesConfig().catch(() => ({}));
+        const diff = diffMarketplaces(declared, materialized);
+        const pendingNames = [
+            ...diff.missing,
+            ...diff.sourceChanged.map(c => c.name),
+        ];
+        // Initialize AppState with pending status. No per-plugin pending status —
+        // plugin load is fast (cache hit or local copy); marketplace clone is the
+        // slow part worth showing progress for.
+        setAppState(prev => ({
+            ...prev,
+            plugins: {
+                ...prev.plugins,
+                installationStatus: {
+                    marketplaces: pendingNames.map(name => ({
+                        name,
+                        status: 'pending',
+                    })),
+                    plugins: [],
+                },
+            },
+        }));
+        if (pendingNames.length === 0) {
+            return;
+        }
+        logForDebugging(`Installing ${pendingNames.length} marketplace(s) in background`);
+        const result = await reconcileMarketplaces({
+            onProgress: event => {
+                switch (event.type) {
+                    case 'installing':
+                        updateMarketplaceStatus(setAppState, event.name, 'installing');
+                        break;
+                    case 'installed':
+                        updateMarketplaceStatus(setAppState, event.name, 'installed');
+                        break;
+                    case 'failed':
+                        updateMarketplaceStatus(setAppState, event.name, 'failed', event.error);
+                        break;
+                }
+            },
+        });
+        const metrics = {
+            installed_count: result.installed.length,
+            updated_count: result.updated.length,
+            failed_count: result.failed.length,
+            up_to_date_count: result.upToDate.length,
+        };
+        logEvent('thaddeus_marketplace_background_install', metrics);
+        logForDiagnosticsNoPII('info', 'thaddeus_marketplace_background_install', metrics);
+        if (result.installed.length > 0) {
+            // New marketplaces were installed — auto-refresh plugins. This fixes
+            // "Plugin not found in marketplace" errors from the initial cache-only
+            // load (e.g., fresh homespace where marketplace cache was empty).
+            // refreshActivePlugins clears all caches, reloads plugins, and bumps
+            // pluginReconnectKey so MCP connections are re-established.
+            clearMarketplacesCache();
+            logForDebugging(`Auto-refreshing plugins after ${result.installed.length} new marketplace(s) installed`);
+            try {
+                await refreshActivePlugins(setAppState);
+            }
+            catch (refreshError) {
+                // If auto-refresh fails, fall back to needsRefresh notification so
+                // the user can manually run /reload-plugins to recover.
+                logError(refreshError);
+                logForDebugging(`Auto-refresh failed, falling back to needsRefresh: ${refreshError}`, { level: 'warn' });
+                clearPluginCache('performBackgroundPluginInstallations: auto-refresh failed');
+                setAppState(prev => {
+                    if (prev.plugins.needsRefresh)
+                        return prev;
+                    return {
+                        ...prev,
+                        plugins: { ...prev.plugins, needsRefresh: true },
+                    };
+                });
+            }
+        }
+        else if (result.updated.length > 0) {
+            // Existing marketplaces updated — notify user to run /reload-plugins.
+            // Updates are less urgent and the user should choose when to apply them.
+            clearMarketplacesCache();
+            clearPluginCache('performBackgroundPluginInstallations: marketplaces reconciled');
+            setAppState(prev => {
+                if (prev.plugins.needsRefresh)
+                    return prev;
+                return {
+                    ...prev,
+                    plugins: { ...prev.plugins, needsRefresh: true },
+                };
+            });
+        }
+    }
+    catch (error) {
+        logError(error);
+    }
+}

package/src/services/plugins/pluginCliCommands.js

@@ -0,0 +1,230 @@
+/**
+ * CLI command wrappers for plugin operations
+ *
+ * This module provides thin wrappers around the core plugin operations
+ * that handle CLI-specific concerns like console output and process exit.
+ *
+ * For the core operations (without CLI side effects), see pluginOperations.ts
+ */
+import figures from 'figures';
+import { errorMessage } from '../../utils/errors.js';
+import { gracefulShutdown } from '../../utils/gracefulShutdown.js';
+import { logError } from '../../utils/log.js';
+import { getManagedPluginNames } from '../../utils/plugins/managedPlugins.js';
+import { parsePluginIdentifier } from '../../utils/plugins/pluginIdentifier.js';
+import { writeToStdout } from '../../utils/process.js';
+import { buildPluginTelemetryFields, classifyPluginCommandError, } from '../../utils/telemetry/pluginTelemetry.js';
+import { logEvent, } from '../analytics/index.js';
+import { disableAllPluginsOp, disablePluginOp, enablePluginOp, installPluginOp, uninstallPluginOp, updatePluginOp, VALID_INSTALLABLE_SCOPES, VALID_UPDATE_SCOPES, } from './pluginOperations.js';
+export { VALID_INSTALLABLE_SCOPES, VALID_UPDATE_SCOPES };
+/**
+ * Generic error handler for plugin CLI commands. Emits
+ * thaddeus_plugin_command_failed before exit so dashboards can compute a
+ * success rate against the corresponding success events.
+ */
+function handlePluginCommandError(error, command, plugin) {
+    logError(error);
+    const operation = plugin
+        ? `${command} plugin "${plugin}"`
+        : command === 'disable-all'
+            ? 'disable all plugins'
+            : `${command} plugins`;
+    // biome-ignore lint/suspicious/noConsole:: intentional console output
+    console.error(`${figures.cross} Failed to ${operation}: ${errorMessage(error)}`);
+    const telemetryFields = plugin
+        ? (() => {
+            const { name, marketplace } = parsePluginIdentifier(plugin);
+            return {
+                _PROTO_plugin_name: name,
+                ...(marketplace && {
+                    _PROTO_marketplace_name: marketplace,
+                }),
+                ...buildPluginTelemetryFields(name, marketplace, getManagedPluginNames()),
+            };
+        })()
+        : {};
+    logEvent('thaddeus_plugin_command_failed', {
+        command: command,
+        error_category: classifyPluginCommandError(error),
+        ...telemetryFields,
+    });
+    // eslint-disable-next-line custom-rules/no-process-exit
+    process.exit(1);
+}
+/**
+ * CLI command: Install a plugin non-interactively
+ * @param plugin Plugin identifier (name or plugin@marketplace)
+ * @param scope Installation scope: user, project, or local (defaults to 'user')
+ */
+export async function installPlugin(plugin, scope = 'user') {
+    try {
+        // biome-ignore lint/suspicious/noConsole:: intentional console output
+        console.log(`Installing plugin "${plugin}"...`);
+        const result = await installPluginOp(plugin, scope);
+        if (!result.success) {
+            throw new Error(result.message);
+        }
+        // biome-ignore lint/suspicious/noConsole:: intentional console output
+        console.log(`${figures.tick} ${result.message}`);
+        // _PROTO_* routes to PII-tagged plugin_name/marketplace_name BQ columns.
+        // Unredacted plugin_id was previously logged to general-access
+        // additional_metadata for all users — dropped in favor of the privileged
+        // column route.
+        const { name, marketplace } = parsePluginIdentifier(result.pluginId || plugin);
+        logEvent('thaddeus_plugin_installed_cli', {
+            _PROTO_plugin_name: name,
+            ...(marketplace && {
+                _PROTO_marketplace_name: marketplace,
+            }),
+            scope: (result.scope ||
+                scope),
+            install_source: 'cli-explicit',
+            ...buildPluginTelemetryFields(name, marketplace, getManagedPluginNames()),
+        });
+        // eslint-disable-next-line custom-rules/no-process-exit
+        process.exit(0);
+    }
+    catch (error) {
+        handlePluginCommandError(error, 'install', plugin);
+    }
+}
+/**
+ * CLI command: Uninstall a plugin non-interactively
+ * @param plugin Plugin name or plugin@marketplace identifier
+ * @param scope Uninstall from scope: user, project, or local (defaults to 'user')
+ */
+export async function uninstallPlugin(plugin, scope = 'user', keepData = false) {
+    try {
+        const result = await uninstallPluginOp(plugin, scope, !keepData);
+        if (!result.success) {
+            throw new Error(result.message);
+        }
+        // biome-ignore lint/suspicious/noConsole:: intentional console output
+        console.log(`${figures.tick} ${result.message}`);
+        const { name, marketplace } = parsePluginIdentifier(result.pluginId || plugin);
+        logEvent('thaddeus_plugin_uninstalled_cli', {
+            _PROTO_plugin_name: name,
+            ...(marketplace && {
+                _PROTO_marketplace_name: marketplace,
+            }),
+            scope: (result.scope ||
+                scope),
+            ...buildPluginTelemetryFields(name, marketplace, getManagedPluginNames()),
+        });
+        // eslint-disable-next-line custom-rules/no-process-exit
+        process.exit(0);
+    }
+    catch (error) {
+        handlePluginCommandError(error, 'uninstall', plugin);
+    }
+}
+/**
+ * CLI command: Enable a plugin non-interactively
+ * @param plugin Plugin name or plugin@marketplace identifier
+ * @param scope Optional scope. If not provided, finds the most specific scope for the current project.
+ */
+export async function enablePlugin(plugin, scope) {
+    try {
+        const result = await enablePluginOp(plugin, scope);
+        if (!result.success) {
+            throw new Error(result.message);
+        }
+        // biome-ignore lint/suspicious/noConsole:: intentional console output
+        console.log(`${figures.tick} ${result.message}`);
+        const { name, marketplace } = parsePluginIdentifier(result.pluginId || plugin);
+        logEvent('thaddeus_plugin_enabled_cli', {
+            _PROTO_plugin_name: name,
+            ...(marketplace && {
+                _PROTO_marketplace_name: marketplace,
+            }),
+            scope: result.scope,
+            ...buildPluginTelemetryFields(name, marketplace, getManagedPluginNames()),
+        });
+        // eslint-disable-next-line custom-rules/no-process-exit
+        process.exit(0);
+    }
+    catch (error) {
+        handlePluginCommandError(error, 'enable', plugin);
+    }
+}
+/**
+ * CLI command: Disable a plugin non-interactively
+ * @param plugin Plugin name or plugin@marketplace identifier
+ * @param scope Optional scope. If not provided, finds the most specific scope for the current project.
+ */
+export async function disablePlugin(plugin, scope) {
+    try {
+        const result = await disablePluginOp(plugin, scope);
+        if (!result.success) {
+            throw new Error(result.message);
+        }
+        // biome-ignore lint/suspicious/noConsole:: intentional console output
+        console.log(`${figures.tick} ${result.message}`);
+        const { name, marketplace } = parsePluginIdentifier(result.pluginId || plugin);
+        logEvent('thaddeus_plugin_disabled_cli', {
+            _PROTO_plugin_name: name,
+            ...(marketplace && {
+                _PROTO_marketplace_name: marketplace,
+            }),
+            scope: result.scope,
+            ...buildPluginTelemetryFields(name, marketplace, getManagedPluginNames()),
+        });
+        // eslint-disable-next-line custom-rules/no-process-exit
+        process.exit(0);
+    }
+    catch (error) {
+        handlePluginCommandError(error, 'disable', plugin);
+    }
+}
+/**
+ * CLI command: Disable all enabled plugins non-interactively
+ */
+export async function disableAllPlugins() {
+    try {
+        const result = await disableAllPluginsOp();
+        if (!result.success) {
+            throw new Error(result.message);
+        }
+        // biome-ignore lint/suspicious/noConsole:: intentional console output
+        console.log(`${figures.tick} ${result.message}`);
+        logEvent('thaddeus_plugin_disabled_all_cli', {});
+        // eslint-disable-next-line custom-rules/no-process-exit
+        process.exit(0);
+    }
+    catch (error) {
+        handlePluginCommandError(error, 'disable-all');
+    }
+}
+/**
+ * CLI command: Update a plugin non-interactively
+ * @param plugin Plugin name or plugin@marketplace identifier
+ * @param scope Scope to update
+ */
+export async function updatePluginCli(plugin, scope) {
+    try {
+        writeToStdout(`Checking for updates for plugin "${plugin}" at ${scope} scope…\n`);
+        const result = await updatePluginOp(plugin, scope);
+        if (!result.success) {
+            throw new Error(result.message);
+        }
+        writeToStdout(`${figures.tick} ${result.message}\n`);
+        if (!result.alreadyUpToDate) {
+            const { name, marketplace } = parsePluginIdentifier(result.pluginId || plugin);
+            logEvent('thaddeus_plugin_updated_cli', {
+                _PROTO_plugin_name: name,
+                ...(marketplace && {
+                    _PROTO_marketplace_name: marketplace,
+                }),
+                old_version: (result.oldVersion ||
+                    'unknown'),
+                new_version: (result.newVersion ||
+                    'unknown'),
+                ...buildPluginTelemetryFields(name, marketplace, getManagedPluginNames()),
+            });
+        }
+        await gracefulShutdown(0);
+    }
+    catch (error) {
+        handlePluginCommandError(error, 'update', plugin);
+    }
+}