indusagi-coding-agent 0.1.59 → 0.1.61

package/dist/main.js

@@ -1,750 +0,0 @@
-/**
- * Main entry point for the coding agent CLI.
- *
- * This file handles CLI argument parsing and translates them into
- * createAgentSession() options. The SDK does the heavy lifting.
- */
-import { modelsAreEqual, supportsXhigh } from "indusagi/ai";
-import chalk from "chalk";
-import { createInterface } from "readline";
-import { dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-import { parseArgs, printHelp } from "./command-line/args.js";
-import { selectConfig } from "./command-line/config-selector.js";
-import { processFileArguments } from "./command-line/file-processor.js";
-import { listModels } from "./command-line/list-models.js";
-import { selectSession } from "./command-line/session-picker.js";
-import { handleLoginCommand } from "./command-line/login-handler.js";
-import { getAgentDir, getModelsPath, VERSION } from "./config.js";
-import { AuthStorage } from "./runtime/auth-storage.js";
-import { exportFromFile } from "./runtime/html-export/index.js";
-import { KeybindingsManager } from "./runtime/keybindings.js";
-import { ModelRegistry } from "./runtime/model-registry.js";
-import { resolveModelScope } from "./runtime/model-resolver.js";
-import { createAppObserveContext } from "./runtime/observe.js";
-import { DefaultPackageManager } from "./runtime/package-manager.js";
-import { registerBuiltInProviderRuntimes } from "./runtime/providers/builtins.js";
-import { DefaultResourceLoader } from "./runtime/resource-loader.js";
-import { createAgentSession } from "./runtime/sdk.js";
-import { SessionManager } from "./runtime/session-manager.js";
-import { SettingsManager } from "./runtime/settings-manager.js";
-import { printTimings, time } from "./runtime/timings.js";
-import { allTools } from "./runtime/tooling/index.js";
-import { discoverIndusagiPackages } from "./runtime/discover-packages.js";
-import { runMigrations, showDeprecationWarnings } from "./migrations.js";
-import { InteractiveMode, runPrintMode, runRpcMode } from "./interfaces/index.js";
-import { initTheme, stopThemeWatcher } from "./interfaces/theme/theme.js";
-function shouldSuppressMcpLogs(message) {
-    if (process.env.INDUSAGI_DEBUG) {
-        return false;
-    }
-    return /^\[MCP[\]:]/.test(String(message ?? ""));
-}
-function installCliLogFilter() {
-    if (process.env.INDUSAGI_DEBUG) {
-        return;
-    }
-    const wrap = (method) => (...args) => {
-        if (!shouldSuppressMcpLogs(args[0])) {
-            method(...args);
-        }
-    };
-    console.log = wrap(console.log.bind(console));
-    console.warn = wrap(console.warn.bind(console));
-    console.error = wrap(console.error.bind(console));
-}
-async function handleUtilityCommands(args) {
-    if (await handleLoginCommand(args))
-        return true;
-    if (await handlePackageCommand(args))
-        return true;
-    if (await handleConfigCommand(args))
-        return true;
-    return false;
-}
-async function resolveStartupResources(args) {
-    const { migratedAuthProviders: migratedProviders, deprecationWarnings } = runMigrations(process.cwd());
-    const firstPass = parseArgs(args);
-    const cwd = process.cwd();
-    const agentDir = getAgentDir();
-    const settingsManager = SettingsManager.create(cwd, agentDir);
-    const authStorage = new AuthStorage();
-    const modelRegistry = new ModelRegistry(authStorage, getModelsPath());
-    registerBuiltInProviderRuntimes(modelRegistry);
-    const currentDir = dirname(fileURLToPath(import.meta.url));
-    time("imports_complete");
-    const packageNodeModules = dirname(dirname(currentDir)) + "/node_modules";
-    const discoveredPackages = discoverIndusagiPackages(packageNodeModules);
-    time("discover_packages");
-    const bgProcessExtPath = dirname(dirname(currentDir)) + "/../indusagi-bg-tool";
-    const allExtensionPaths = [...(firstPass.extensions ?? []), ...discoveredPackages, bgProcessExtPath];
-    const resourceLoader = new DefaultResourceLoader({
-        cwd,
-        agentDir,
-        extensionFactories: [],
-        additionalExtensionPaths: allExtensionPaths,
-        additionalHookPaths: firstPass.hooks,
-        additionalSkillPaths: firstPass.skills,
-        additionalPromptTemplatePaths: firstPass.promptTemplates,
-        additionalThemePaths: firstPass.themes,
-        noExtensions: firstPass.noExtensions,
-        noHooks: firstPass.noHooks,
-        noSkills: firstPass.noSkills,
-        noPromptTemplates: firstPass.noPromptTemplates,
-        noThemes: firstPass.noThemes,
-        systemPrompt: firstPass.systemPrompt,
-        appendSystemPrompt: firstPass.appendSystemPrompt,
-    });
-    await resourceLoader.reload();
-    time("resourceLoader.reload");
-    const extensionsResult = resourceLoader.getExtensions();
-    time("get_extensions");
-    for (const { path, error } of extensionsResult.errors) {
-        console.error(chalk.red(`Failed to load extension "${path}": ${error}`));
-    }
-    const hooksResult = resourceLoader.getHooks();
-    time("get_hooks");
-    for (const { path, error } of hooksResult.errors) {
-        console.error(chalk.red(`Failed to load hook "${path}": ${error}`));
-    }
-    for (const { name, config } of extensionsResult.runtime.pendingProviderRegistrations) {
-        modelRegistry.registerProvider(name, config);
-    }
-    extensionsResult.runtime.pendingProviderRegistrations = [];
-    const extensionFlags = new Map();
-    for (const extension of extensionsResult.extensions) {
-        for (const [name, flag] of extension.flags) {
-            extensionFlags.set(name, { type: flag.type });
-        }
-    }
-    const parsed = parseArgs(args, extensionFlags);
-    for (const [name, value] of parsed.unknownFlags) {
-        extensionsResult.runtime.flagValues.set(name, value);
-    }
-    return {
-        cwd,
-        agentDir,
-        settingsManager,
-        authStorage,
-        modelRegistry,
-        resourceLoader,
-        parsed,
-        firstPass,
-        deprecationWarnings,
-        migratedProviders,
-    };
-}
-async function handleParsedUtilityCommands(parsed, modelRegistry) {
-    if (parsed.version) {
-        console.log(VERSION);
-        return true;
-    }
-    if (parsed.help) {
-        printHelp();
-        return true;
-    }
-    if (parsed.listModels !== undefined) {
-        await listModels(modelRegistry, typeof parsed.listModels === "string" ? parsed.listModels : undefined);
-        return true;
-    }
-    if (parsed.export) {
-        try {
-            const outputPath = parsed.messages.length > 0 ? parsed.messages[0] : undefined;
-            const result = await exportFromFile(parsed.export, outputPath);
-            console.log(`Exported to: ${result}`);
-            return true;
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : "Failed to export session";
-            console.error(chalk.red(`Error: ${message}`));
-            process.exit(1);
-        }
-    }
-    return false;
-}
-async function resolveSessionFromArgs(parsed, cwd, modelRegistry, settingsManager) {
-    let scopedModels = [];
-    const modelPatterns = parsed.models ?? settingsManager.getEnabledModels();
-    if (modelPatterns && modelPatterns.length > 0) {
-        scopedModels = await resolveModelScope(modelPatterns, modelRegistry);
-    }
-    let sessionManager = await createSessionManager(parsed, cwd);
-    if (parsed.resume) {
-        KeybindingsManager.create();
-        const selectedPath = await selectSession((onProgress) => SessionManager.list(cwd, parsed.sessionDir, onProgress), SessionManager.listAll);
-        if (!selectedPath) {
-            console.log(chalk.dim("No session selected"));
-            stopThemeWatcher();
-            process.exit(0);
-        }
-        sessionManager = SessionManager.open(selectedPath);
-    }
-    return {
-        sessionOptions: buildSessionOptions(parsed, scopedModels, sessionManager, modelRegistry, settingsManager),
-        scopedModels,
-    };
-}
-function applyRuntimeAuthOverrides(parsed, sessionOptions, authStorage) {
-    if (parsed.apiKey) {
-        if (!sessionOptions.model) {
-            console.error(chalk.red("--api-key requires a model to be specified via --provider/--model or -m/--models"));
-            process.exit(1);
-        }
-        authStorage.setRuntimeApiKey(sessionOptions.model.provider, parsed.apiKey, parsed.account);
-    }
-    if (parsed.account && sessionOptions.model) {
-        authStorage.setDefaultAccount(sessionOptions.model.provider, parsed.account);
-    }
-}
-async function runSelectedMode(options) {
-    const { session, parsed, settingsManager, scopedModels, migratedProviders, modelFallbackMessage, initialMessage, initialImages } = options;
-    const isInteractive = !parsed.print && parsed.mode === undefined;
-    const mode = parsed.mode || "text";
-    if (!isInteractive && !session.model) {
-        console.error(chalk.red("No models available."));
-        console.error(chalk.yellow("\nSet an API key environment variable:"));
-        console.error("  ANTHROPIC_AINDUSAGI_KEY, OPENAI_AINDUSAGI_KEY, GEMINI_AINDUSAGI_KEY, etc.");
-        console.error(chalk.yellow(`\nOr create ${getModelsPath()}`));
-        process.exit(1);
-    }
-    if (session.model && parsed.thinking) {
-        let effectiveThinking = parsed.thinking;
-        if (!session.model.reasoning)
-            effectiveThinking = "off";
-        else if (effectiveThinking === "xhigh" && !supportsXhigh(session.model))
-            effectiveThinking = "high";
-        if (effectiveThinking !== session.thinkingLevel)
-            session.setThinkingLevel(effectiveThinking);
-    }
-    if (mode === "rpc") {
-        await runRpcMode(session);
-        return;
-    }
-    if (isInteractive) {
-        if (scopedModels.length > 0 && (parsed.verbose || !settingsManager.getQuietStartup())) {
-            const modelList = scopedModels
-                .map((entry) => `${entry.model.id}${entry.thinkingLevel ? `:${entry.thinkingLevel}` : ""}`)
-                .join(", ");
-            console.log(chalk.dim(`Model scope: ${modelList} ${chalk.gray("(Ctrl+P to cycle)")}`));
-        }
-        printTimings();
-        const modeRunner = new InteractiveMode(session, {
-            migratedProviders,
-            modelFallbackMessage,
-            initialMessage,
-            initialImages,
-            initialMessages: parsed.messages,
-            verbose: parsed.verbose,
-        });
-        await modeRunner.run();
-        return;
-    }
-    await runPrintMode(session, { mode, messages: parsed.messages, initialMessage, initialImages });
-    stopThemeWatcher();
-    if (process.stdout.writableLength > 0) {
-        await new Promise((resolve) => process.stdout.once("drain", resolve));
-    }
-    process.exit(0);
-}
-/**
- * Read all content from piped stdin.
- * Returns undefined if stdin is a TTY (interactive terminal).
- */
-async function readPipedStdin() {
-    // If stdin is a TTY, we're running interactively - don't read stdin
-    if (process.stdin.isTTY) {
-        return undefined;
-    }
-    return new Promise((resolve) => {
-        let data = "";
-        let dataReceived = false;
-        let timeoutId = null;
-        process.stdin.setEncoding("utf8");
-        const onData = (chunk) => {
-            dataReceived = true;
-            data += chunk;
-            // Clear timeout when we get data
-            if (timeoutId) {
-                clearTimeout(timeoutId);
-                timeoutId = null;
-            }
-        };
-        const onEnd = () => {
-            if (timeoutId) {
-                clearTimeout(timeoutId);
-            }
-            process.stdin.removeListener("data", onData);
-            process.stdin.removeListener("end", onEnd);
-            process.stdin.removeListener("error", onError);
-            resolve(data.trim() || undefined);
-        };
-        const onError = (error) => {
-            if (timeoutId) {
-                clearTimeout(timeoutId);
-            }
-            process.stdin.removeListener("data", onData);
-            process.stdin.removeListener("end", onEnd);
-            process.stdin.removeListener("error", onError);
-            // On error, just resolve as if no input was provided
-            resolve(undefined);
-        };
-        process.stdin.on("data", onData);
-        process.stdin.on("end", onEnd);
-        process.stdin.on("error", onError);
-        // Set a 5-second timeout for reading stdin
-        // If no data received after 5 seconds, assume no input and continue
-        timeoutId = setTimeout(() => {
-            timeoutId = null;
-            process.stdin.removeListener("data", onData);
-            process.stdin.removeListener("end", onEnd);
-            process.stdin.removeListener("error", onError);
-            // Don't resume stdin after timeout to avoid blocking
-            resolve(data.trim() || undefined);
-        }, 5000);
-        process.stdin.resume();
-    });
-}
-function parsePackageCommand(args) {
-    const [command, ...rest] = args;
-    if (command !== "install" && command !== "remove" && command !== "update" && command !== "list") {
-        return undefined;
-    }
-    let local = false;
-    const sources = [];
-    for (const arg of rest) {
-        if (arg === "-l" || arg === "--local") {
-            local = true;
-            continue;
-        }
-        sources.push(arg);
-    }
-    return { command, source: sources[0], local };
-}
-function normalizeExtensionSource(source) {
-    if (source.startsWith("npm:")) {
-        const spec = source.slice("npm:".length).trim();
-        const match = spec.match(/^(@?[^@]+(?:\/[^@]+)?)(?:@.+)?$/);
-        return { type: "npm", key: match?.[1] ?? spec };
-    }
-    if (source.startsWith("git:")) {
-        const repo = source.slice("git:".length).trim().split("@")[0] ?? "";
-        return { type: "git", key: repo.replace(/^https?:\/\//, "").replace(/\.git$/, "") };
-    }
-    // Raw git URLs
-    if (source.startsWith("https://") || source.startsWith("http://")) {
-        const repo = source.split("@")[0] ?? "";
-        return { type: "git", key: repo.replace(/^https?:\/\//, "").replace(/\.git$/, "") };
-    }
-    return { type: "local", key: source };
-}
-function sourcesMatch(a, b) {
-    const left = normalizeExtensionSource(a);
-    const right = normalizeExtensionSource(b);
-    return left.type === right.type && left.key === right.key;
-}
-function getPackageSourceString(pkg) {
-    return typeof pkg === "string" ? pkg : pkg.source;
-}
-function packageSourcesMatch(a, b) {
-    const aSource = getPackageSourceString(a);
-    return sourcesMatch(aSource, b);
-}
-function updatePackageSources(settingsManager, source, local, action) {
-    const currentSettings = local ? settingsManager.getProjectSettings() : settingsManager.getGlobalSettings();
-    const currentPackages = currentSettings.packages ?? [];
-    let nextPackages;
-    if (action === "add") {
-        const exists = currentPackages.some((existing) => packageSourcesMatch(existing, source));
-        nextPackages = exists ? currentPackages : [...currentPackages, source];
-    }
-    else {
-        nextPackages = currentPackages.filter((existing) => !packageSourcesMatch(existing, source));
-    }
-    if (local) {
-        settingsManager.setProjectPackages(nextPackages);
-    }
-    else {
-        settingsManager.setPackages(nextPackages);
-    }
-}
-async function handlePackageCommand(args) {
-    const options = parsePackageCommand(args);
-    if (!options) {
-        return false;
-    }
-    const cwd = process.cwd();
-    const agentDir = getAgentDir();
-    const settingsManager = SettingsManager.create(cwd, agentDir);
-    const packageManager = new DefaultPackageManager({ cwd, agentDir, settingsManager });
-    // Set up progress callback for CLI feedback
-    packageManager.setProgressCallback((event) => {
-        if (event.type === "start") {
-            process.stdout.write(chalk.dim(`${event.message}\n`));
-        }
-        else if (event.type === "error") {
-            console.error(chalk.red(`Error: ${event.message}`));
-        }
-    });
-    if (options.command === "install") {
-        if (!options.source) {
-            console.error(chalk.red("Missing install source."));
-            process.exit(1);
-        }
-        await packageManager.install(options.source, { local: options.local });
-        updatePackageSources(settingsManager, options.source, options.local, "add");
-        console.log(chalk.green(`Installed ${options.source}`));
-        return true;
-    }
-    if (options.command === "remove") {
-        if (!options.source) {
-            console.error(chalk.red("Missing remove source."));
-            process.exit(1);
-        }
-        await packageManager.remove(options.source, { local: options.local });
-        updatePackageSources(settingsManager, options.source, options.local, "remove");
-        console.log(chalk.green(`Removed ${options.source}`));
-        return true;
-    }
-    if (options.command === "list") {
-        const globalSettings = settingsManager.getGlobalSettings();
-        const projectSettings = settingsManager.getProjectSettings();
-        const globalPackages = globalSettings.packages ?? [];
-        const projectPackages = projectSettings.packages ?? [];
-        if (globalPackages.length === 0 && projectPackages.length === 0) {
-            console.log(chalk.dim("No packages installed."));
-            return true;
-        }
-        const formatPackage = (pkg, scope) => {
-            const source = typeof pkg === "string" ? pkg : pkg.source;
-            const filtered = typeof pkg === "object";
-            const display = filtered ? `${source} (filtered)` : source;
-            console.log(`  ${display}`);
-            // Show resolved path
-            const path = packageManager.getInstalledPath(source, scope);
-            if (path) {
-                console.log(chalk.dim(`    ${path}`));
-            }
-        };
-        if (globalPackages.length > 0) {
-            console.log(chalk.bold("User packages:"));
-            for (const pkg of globalPackages) {
-                formatPackage(pkg, "user");
-            }
-        }
-        if (projectPackages.length > 0) {
-            if (globalPackages.length > 0)
-                console.log();
-            console.log(chalk.bold("Project packages:"));
-            for (const pkg of projectPackages) {
-                formatPackage(pkg, "project");
-            }
-        }
-        return true;
-    }
-    await packageManager.update(options.source);
-    if (options.source) {
-        console.log(chalk.green(`Updated ${options.source}`));
-    }
-    else {
-        console.log(chalk.green("Updated packages"));
-    }
-    return true;
-}
-async function prepareInitialMessage(parsed, autoResizeImages) {
-    if (parsed.fileArgs.length === 0) {
-        return {};
-    }
-    const { text, images } = await processFileArguments(parsed.fileArgs, { autoResizeImages });
-    let initialMessage;
-    if (parsed.messages.length > 0) {
-        initialMessage = text + parsed.messages[0];
-        parsed.messages.shift();
-    }
-    else {
-        initialMessage = text;
-    }
-    return {
-        initialMessage,
-        initialImages: images.length > 0 ? images : undefined,
-    };
-}
-/**
- * Resolve a session argument to a file path.
- * If it looks like a path, use as-is. Otherwise try to match as session ID prefix.
- */
-async function resolveSessionPath(sessionArg, cwd, sessionDir) {
-    // If it looks like a file path, use as-is
-    if (sessionArg.includes("/") || sessionArg.includes("\\") || sessionArg.endsWith(".jsonl")) {
-        return { type: "path", path: sessionArg };
-    }
-    // Try to match as session ID in current project first
-    const localSessions = await SessionManager.list(cwd, sessionDir);
-    const localMatches = localSessions.filter((s) => s.id.startsWith(sessionArg));
-    if (localMatches.length >= 1) {
-        return { type: "local", path: localMatches[0].path };
-    }
-    // Try global search across all projects
-    const allSessions = await SessionManager.listAll();
-    const globalMatches = allSessions.filter((s) => s.id.startsWith(sessionArg));
-    if (globalMatches.length >= 1) {
-        const match = globalMatches[0];
-        return { type: "global", path: match.path, cwd: match.cwd };
-    }
-    // Not found anywhere
-    return { type: "not_found", arg: sessionArg };
-}
-/** Prompt user for yes/no confirmation */
-async function promptConfirm(message) {
-    return new Promise((resolve) => {
-        const rl = createInterface({
-            input: process.stdin,
-            output: process.stdout,
-        });
-        rl.question(`${message} [y/N] `, (answer) => {
-            rl.close();
-            resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
-        });
-    });
-}
-async function createSessionManager(parsed, cwd) {
-    if (parsed.noSession) {
-        return SessionManager.inMemory();
-    }
-    if (parsed.session) {
-        const resolved = await resolveSessionPath(parsed.session, cwd, parsed.sessionDir);
-        switch (resolved.type) {
-            case "path":
-            case "local":
-                return SessionManager.open(resolved.path, parsed.sessionDir);
-            case "global": {
-                // Session found in different project - ask user if they want to fork
-                console.log(chalk.yellow(`Session found in different project: ${resolved.cwd}`));
-                const shouldFork = await promptConfirm("Fork this session into current directory?");
-                if (!shouldFork) {
-                    console.log(chalk.dim("Aborted."));
-                    process.exit(0);
-                }
-                return SessionManager.forkFrom(resolved.path, cwd, parsed.sessionDir);
-            }
-            case "not_found":
-                console.error(chalk.red(`No session found matching '${resolved.arg}'`));
-                process.exit(1);
-        }
-    }
-    if (parsed.continue) {
-        return SessionManager.continueRecent(cwd, parsed.sessionDir);
-    }
-    // --resume is handled separately (needs picker UI)
-    // If --session-dir provided without --continue/--resume, create new session there
-    if (parsed.sessionDir) {
-        return SessionManager.create(cwd, parsed.sessionDir);
-    }
-    // Default case (new session) returns undefined, SDK will create one
-    return undefined;
-}
-function buildSessionOptions(parsed, scopedModels, sessionManager, modelRegistry, settingsManager) {
-    const options = {};
-    if (sessionManager) {
-        options.sessionManager = sessionManager;
-    }
-    // Model from CLI
-    if (parsed.provider && parsed.model) {
-        const model = modelRegistry.find(parsed.provider, parsed.model);
-        if (!model) {
-            console.error(chalk.red(`Model ${parsed.provider}/${parsed.model} not found`));
-            process.exit(1);
-        }
-        options.model = model;
-    }
-    else if (scopedModels.length > 0 && !parsed.continue && !parsed.resume) {
-        // Check if saved default is in scoped models - use it if so, otherwise first scoped model
-        const savedProvider = settingsManager.getDefaultProvider();
-        const savedModelId = settingsManager.getDefaultModel();
-        const savedModel = savedProvider && savedModelId ? modelRegistry.find(savedProvider, savedModelId) : undefined;
-        const savedInScope = savedModel ? scopedModels.find((sm) => modelsAreEqual(sm.model, savedModel)) : undefined;
-        if (savedInScope) {
-            options.model = savedInScope.model;
-            // Use thinking level from scoped model config if explicitly set
-            if (!parsed.thinking && savedInScope.thinkingLevel) {
-                options.thinkingLevel = savedInScope.thinkingLevel;
-            }
-        }
-        else {
-            options.model = scopedModels[0].model;
-            // Use thinking level from first scoped model if explicitly set
-            if (!parsed.thinking && scopedModels[0].thinkingLevel) {
-                options.thinkingLevel = scopedModels[0].thinkingLevel;
-            }
-        }
-    }
-    // Thinking level from CLI (takes precedence over scoped model thinking levels set above)
-    if (parsed.thinking) {
-        options.thinkingLevel = parsed.thinking;
-    }
-    // Scoped models for Ctrl+P cycling - fill in default thinking level for models without explicit level
-    if (scopedModels.length > 0) {
-        const defaultThinkingLevel = settingsManager.getDefaultThinkingLevel() ?? "off";
-        options.scopedModels = scopedModels.map((sm) => ({
-            model: sm.model,
-            thinkingLevel: sm.thinkingLevel ?? defaultThinkingLevel,
-        }));
-    }
-    // API key from CLI - set in authStorage
-    // (handled by caller before createAgentSession)
-    // Tools
-    if (parsed.noTools) {
-        // --no-tools: start with no built-in tools
-        // --tools can still add specific ones back
-        if (parsed.tools && parsed.tools.length > 0) {
-            options.tools = parsed.tools.map((name) => allTools[name]);
-        }
-        else {
-            options.tools = [];
-        }
-    }
-    else if (parsed.tools) {
-        options.tools = parsed.tools.map((name) => allTools[name]);
-    }
-    // MCP (Model Context Protocol)
-    if (parsed.noMcp) {
-        // --no-mcp: disable MCP entirely
-        options.mcp = { enabled: false };
-    }
-    else if (parsed.mcp || parsed.mcpConfig) {
-        // --mcp or --mcp-config: explicitly enable MCP
-        options.mcp = {
-            enabled: true,
-            configPath: parsed.mcpConfig,
-        };
-    }
-    // Otherwise, MCP is auto-detected based on config file existence (handled in createAgentSession)
-    // Memory System
-    if (parsed.noMemory) {
-        // --no-memory: disable memory entirely
-        options.memory = { enabled: false };
-    }
-    else if (parsed.memory || parsed.memoryConfig) {
-        // --memory or --memory-config: explicitly enable memory
-        options.memory = {
-            enabled: true,
-            configPath: parsed.memoryConfig,
-        };
-    }
-    // Otherwise, memory is auto-detected based on settings (handled in createAgentSession)
-    // Composio
-    if (parsed.noComposio) {
-        options.composio = { enabled: false };
-    }
-    else if (parsed.composio || parsed.composioToolkits?.length) {
-        options.composio = {
-            enabled: true,
-            autoConnect: parsed.composioToolkits?.length ? true : undefined,
-            toolkits: parsed.composioToolkits,
-            mode: parsed.composioToolkits?.length ? "preload" : undefined,
-        };
-    }
-    return options;
-}
-async function handleConfigCommand(args) {
-    if (args[0] !== "config") {
-        return false;
-    }
-    const cwd = process.cwd();
-    const agentDir = getAgentDir();
-    const settingsManager = SettingsManager.create(cwd, agentDir);
-    const packageManager = new DefaultPackageManager({ cwd, agentDir, settingsManager });
-    const resolvedPaths = await packageManager.resolve();
-    await selectConfig({
-        resolvedPaths: {
-            extensions: resolvedPaths.extensions.filter((item) => item.enabled).map((item) => item.path),
-            hooks: resolvedPaths.hooks.filter((item) => item.enabled).map((item) => item.path),
-            skills: resolvedPaths.skills.filter((item) => item.enabled).map((item) => item.path),
-            prompts: resolvedPaths.prompts.filter((item) => item.enabled).map((item) => item.path),
-            themes: resolvedPaths.themes.filter((item) => item.enabled).map((item) => item.path),
-        },
-        settingsManager,
-        cwd,
-        agentDir,
-    });
-    process.exit(0);
-}
-export async function main(args) {
-    installCliLogFilter();
-    if (await handleUtilityCommands(args)) {
-        return;
-    }
-    const startup = await resolveStartupResources(args);
-    const { cwd, settingsManager, authStorage, modelRegistry, resourceLoader, parsed, deprecationWarnings, migratedProviders } = startup;
-    if (await handleParsedUtilityCommands(parsed, modelRegistry)) {
-        return;
-    }
-    if (parsed.mode !== "rpc") {
-        const stdinContent = await readPipedStdin();
-        time("readPipedStdin");
-        if (stdinContent !== undefined) {
-            parsed.print = true;
-            parsed.messages.unshift(stdinContent);
-        }
-    }
-    if (parsed.mode === "rpc" && parsed.fileArgs.length > 0) {
-        console.error(chalk.red("Error: @file arguments are not supported in RPC mode"));
-        process.exit(1);
-    }
-    const { initialMessage, initialImages } = await prepareInitialMessage(parsed, settingsManager.getImageAutoResize());
-    const isInteractive = !parsed.print && parsed.mode === undefined;
-    initTheme(settingsManager.getTheme(), isInteractive);
-    if (isInteractive && deprecationWarnings.length > 0) {
-        await showDeprecationWarnings(deprecationWarnings);
-    }
-    const { sessionOptions, scopedModels } = await resolveSessionFromArgs(parsed, cwd, modelRegistry, settingsManager);
-    sessionOptions.authStorage = authStorage;
-    sessionOptions.modelRegistry = modelRegistry;
-    sessionOptions.resourceLoader = resourceLoader;
-    applyRuntimeAuthOverrides(parsed, sessionOptions, authStorage);
-    const observe = await createAppObserveContext({
-        agentDir: getAgentDir(),
-        cwd,
-    });
-    if (observe) {
-        sessionOptions.observe = observe;
-    }
-    let session;
-    try {
-        const created = await createAgentSession(sessionOptions);
-        session = created.session;
-        const { modelFallbackMessage, mcpResult, memoryResult, composioResult } = created;
-        time("createAgentSession");
-        if (observe?.dashboardUrl && (parsed.verbose || !settingsManager.getQuietStartup())) {
-            console.log(chalk.dim(`Observe: ${observe.dashboardUrl}`));
-        }
-        if (mcpResult && mcpResult.tools.length > 0 && (parsed.verbose || !settingsManager.getQuietStartup())) {
-            const connectedServers = Object.entries(mcpResult.status).filter(([, status]) => status.connected);
-            if (connectedServers.length > 0) {
-                console.log(chalk.dim(`MCP: ${mcpResult.tools.length} tools from ${connectedServers.map(([name]) => name).join(", ")}`));
-            }
-        }
-        if (memoryResult && memoryResult.tools.length > 0 && (parsed.verbose || !settingsManager.getQuietStartup())) {
-            console.log(chalk.dim("Memory: enabled"));
-        }
-        if (composioResult && composioResult.tools.length > 0 && (parsed.verbose || !settingsManager.getQuietStartup())) {
-            console.log(chalk.dim(`Composio: ${composioResult.tools.length} tools from ${composioResult.toolkits.join(", ")}`));
-        }
-        await runSelectedMode({
-            session,
-            parsed,
-            settingsManager,
-            scopedModels,
-            migratedProviders,
-            modelFallbackMessage,
-            initialMessage,
-            initialImages,
-        });
-    }
-    finally {
-        if (session && observe) {
-            await observe.endSession(session.getSessionId());
-        }
-        await observe?.shutdown();
-    }
-}
-//# sourceMappingURL=main.js.map