@code-yeongyu/senpi 2026.6.6-3 → 2026.6.10-2

package/dist/main.js

@@ -6,13 +6,14 @@
  */
 import { createInterface } from "node:readline";
 import { modelsAreEqual } from "@earendil-works/pi-ai";
-import { ProcessTerminal, setKeybindings, TUI } from "@earendil-works/pi-tui";
 import chalk from "chalk";
 import { parseArgs, printHelp } from "./cli/args.js";
 import { processFileArguments } from "./cli/file-processor.js";
 import { buildInitialMessage } from "./cli/initial-message.js";
 import { listModels } from "./cli/list-models.js";
+import { createProjectTrustContext } from "./cli/project-trust.js";
 import { selectSession } from "./cli/session-picker.js";
+import { showStartupSelector } from "./cli/startup-ui.js";
 import { ENV_SESSION_DIR, expandTildePath, getAgentDir, getPackageDir, VERSION } from "./config.js";
 import { createAgentSessionRuntime } from "./core/agent-session-runtime.js";
 import { createAgentSessionFromServices, createAgentSessionServices, } from "./core/agent-session-services.js";
@@ -20,9 +21,9 @@ import { formatNoModelsAvailableMessage } from "./core/auth-guidance.js";
 import { AuthStorage } from "./core/auth-storage.js";
 import { exportFromFile } from "./core/export-html/index.js";
 import { configureHttpDispatcher } from "./core/http-dispatcher.js";
-import { KeybindingsManager } from "./core/keybindings.js";
 import { getModelNarrowingPatterns, resolveCliModel, resolveModelScope, } from "./core/model-resolver.js";
 import { restoreStdout, takeOverStdout } from "./core/output-guard.js";
+import { resolveProjectTrusted } from "./core/project-trust.js";
 import { formatMissingSessionCwdPrompt, getMissingSessionCwdIssue, MissingSessionCwdError, } from "./core/session-cwd.js";
 import { assertValidSessionId, SessionManager } from "./core/session-manager.js";
 import { SettingsManager } from "./core/settings-manager.js";
@@ -30,7 +31,6 @@ import { printTimings, resetTimings, time } from "./core/timings.js";
 import { hasProjectTrustInputs, ProjectTrustStore } from "./core/trust-manager.js";
 import { runMigrations, showDeprecationWarnings } from "./migrations.js";
 import { InteractiveMode, runPrintMode, runRpcMode } from "./modes/index.js";
-import { ExtensionSelectorComponent } from "./modes/interactive/components/extension-selector.js";
 import { initTheme, stopThemeWatcher } from "./modes/interactive/theme/theme.js";
 import { handleConfigCommand, handlePackageCommand } from "./package-manager-cli.js";
 import { isLocalPath, normalizePath, resolvePath } from "./utils/paths.js";
@@ -74,14 +74,14 @@ function isTruthyEnvFlag(value) {
         return false;
     return value === "1" || value.toLowerCase() === "true" || value.toLowerCase() === "yes";
 }
-function resolveAppMode(parsed, stdinIsTTY) {
+function resolveAppMode(parsed, stdinIsTTY, stdoutIsTTY) {
     if (parsed.mode === "rpc") {
         return "rpc";
     }
     if (parsed.mode === "json") {
         return "json";
     }
-    if (parsed.print || !stdinIsTTY) {
+    if (parsed.print || !stdinIsTTY || !stdoutIsTTY) {
         return "print";
     }
     return "interactive";
@@ -89,6 +89,9 @@ function resolveAppMode(parsed, stdinIsTTY) {
 function toPrintOutputMode(appMode) {
     return appMode === "json" ? "json" : "text";
 }
+function isPlainRuntimeMetadataCommand(parsed) {
+    return !parsed.print && parsed.mode === undefined && (parsed.help === true || parsed.listModels !== undefined);
+}
 async function prepareInitialMessage(parsed, autoResizeImages, stdinContent) {
     if (parsed.fileArgs.length === 0) {
         return buildInitialMessage({ parsed, stdinContent });
@@ -106,16 +109,9 @@ async function prepareInitialMessage(parsed, autoResizeImages, stdinContent) {
  * If it looks like a path, use as-is. Otherwise try to match as session ID prefix.
  */
 async function findLocalSessionByExactId(sessionId, cwd, sessionDir) {
-    const localSessions = await SessionManager.list(cwd, sessionDir);
+    const localSessions = sessionDir ? await SessionManager.listAll(sessionDir) : await SessionManager.list(cwd);
     const localMatch = localSessions.find((s) => s.id === sessionId);
-    if (localMatch) {
-        return { type: "local", path: localMatch.path };
-    }
-    if (!sessionDir) {
-        return undefined;
-    }
-    const customDirMatch = (await SessionManager.listAll(sessionDir)).find((s) => s.id === sessionId);
-    return customDirMatch ? { type: "local", path: customDirMatch.path } : undefined;
+    return localMatch ? { type: "local", path: localMatch.path } : undefined;
 }
 async function resolveSessionPath(sessionArg, cwd, sessionDir) {
     // If it looks like a file path, resolve it before handing it to the session manager.
@@ -318,14 +314,13 @@ function buildSessionOptions(parsed, scopedModels, hasExistingSession, modelRegi
     if (parsed.thinking) {
         options.thinkingLevel = parsed.thinking;
     }
-    // Global model catalog narrowing
+    // Scoped models for Ctrl+P cycling
     // Keep thinking level undefined when not explicitly set in the model pattern.
-    // Undefined means "inherit current session thinking level" when selecting the narrowed model.
+    // Undefined means "inherit current session thinking level" during cycling.
     if (scopedModels.length > 0) {
         options.scopedModels = scopedModels.map((sm) => ({
             model: sm.model,
             thinkingLevel: sm.thinkingLevel,
-            serviceTier: sm.serviceTier,
         }));
     }
     // API key from CLI - set in authStorage
@@ -348,64 +343,12 @@ function buildSessionOptions(parsed, scopedModels, hasExistingSession, modelRegi
 function resolveCliPaths(cwd, paths) {
     return paths?.map((value) => (isLocalPath(value) ? resolvePath(value, cwd) : value));
 }
-async function showStartupSelector(settingsManager, title, options) {
-    initTheme(settingsManager.getTheme());
-    setKeybindings(KeybindingsManager.create());
-    return new Promise((resolve) => {
-        const ui = new TUI(new ProcessTerminal(), settingsManager.getShowHardwareCursor());
-        ui.setClearOnShrink(settingsManager.getClearOnShrink());
-        let settled = false;
-        const finish = (result) => {
-            if (settled) {
-                return;
-            }
-            settled = true;
-            ui.stop();
-            resolve(result);
-        };
-        const selector = new ExtensionSelectorComponent(title, options.map((option) => option.label), (option) => finish(options.find((entry) => entry.label === option)?.value), () => finish(undefined), { tui: ui });
-        ui.addChild(selector);
-        ui.setFocus(selector);
-        ui.start();
-    });
-}
 async function promptForMissingSessionCwd(issue, settingsManager) {
     return showStartupSelector(settingsManager, formatMissingSessionCwdPrompt(issue), [
         { label: "Continue", value: issue.fallbackCwd },
         { label: "Cancel", value: undefined },
     ]);
 }
-async function promptForProjectTrust(cwd, settingsManager) {
-    return showStartupSelector(settingsManager, `Trust project folder?\n${cwd}\n\nThis allows pi to read project instructions (AGENTS.md/CLAUDE.md), load .pi settings and resources, install missing project packages, and execute project extensions.`, [
-        { label: "Trust", value: { trusted: true, remember: true } },
-        { label: "Trust (this session only)", value: { trusted: true, remember: false } },
-        { label: "Do not trust", value: { trusted: false, remember: true } },
-        { label: "Do not trust (this session only)", value: { trusted: false, remember: false } },
-    ]);
-}
-async function resolveProjectTrusted(options) {
-    if (options.trustOverride !== undefined) {
-        return options.trustOverride;
-    }
-    if (!hasProjectTrustInputs(options.cwd)) {
-        return true;
-    }
-    const decision = options.trustStore.get(options.cwd);
-    if (decision !== null) {
-        return decision;
-    }
-    if (options.appMode !== "interactive") {
-        return false;
-    }
-    const selected = await promptForProjectTrust(options.cwd, options.settingsManagerForPrompt);
-    if (selected !== undefined) {
-        if (selected.remember) {
-            options.trustStore.set(options.cwd, selected.trusted);
-        }
-        return selected.trusted;
-    }
-    return false;
-}
 export async function main(args, options) {
     resetTimings();
     const offlineMode = args.includes("--offline") || isTruthyEnvFlag(process.env.PI_OFFLINE);
@@ -416,10 +359,10 @@ export async function main(args, options) {
     if (process.platform === "win32") {
         cleanupWindowsSelfUpdateQuarantine(getPackageDir());
     }
-    if (await handlePackageCommand(args)) {
+    if (await handlePackageCommand(args, { extensionFactories: options?.extensionFactories })) {
         return;
     }
-    if (await handleConfigCommand(args)) {
+    if (await handleConfigCommand(args, { extensionFactories: options?.extensionFactories })) {
         return;
     }
     const parsed = parseArgs(args);
@@ -433,11 +376,6 @@ export async function main(args, options) {
         }
     }
     time("parseArgs");
-    let appMode = resolveAppMode(parsed, process.stdin.isTTY);
-    const shouldTakeOverStdout = appMode !== "interactive";
-    if (shouldTakeOverStdout) {
-        takeOverStdout();
-    }
     if (parsed.version) {
         console.log(VERSION);
         process.exit(0);
@@ -445,9 +383,8 @@ export async function main(args, options) {
     if (parsed.export) {
         let result;
         try {
-            const inputPath = expandTildePath(parsed.export);
-            const outputPath = parsed.messages.length > 0 ? expandTildePath(parsed.messages[0]) : undefined;
-            result = await exportFromFile(inputPath, outputPath);
+            const outputPath = parsed.messages.length > 0 ? parsed.messages[0] : undefined;
+            result = await exportFromFile(parsed.export, outputPath);
         }
         catch (error) {
             const message = error instanceof Error ? error.message : "Failed to export session";
@@ -457,6 +394,11 @@ export async function main(args, options) {
         console.log(`Exported to: ${result}`);
         process.exit(0);
     }
+    let appMode = resolveAppMode(parsed, process.stdin.isTTY, process.stdout.isTTY);
+    const shouldTakeOverStdout = appMode !== "interactive" && !isPlainRuntimeMetadataCommand(parsed);
+    if (shouldTakeOverStdout) {
+        takeOverStdout();
+    }
     if (parsed.mode === "rpc" && parsed.fileArgs.length > 0) {
         console.error(chalk.red("Error: @file arguments are not supported in RPC mode"));
         process.exit(1);
@@ -470,6 +412,39 @@ export async function main(args, options) {
     const agentDir = getAgentDir();
     const startupSettingsManager = SettingsManager.create(cwd, agentDir);
     reportDiagnostics(collectSettingsDiagnostics(startupSettingsManager, "startup session lookup"));
+    const resolvedExtensionPaths = resolveCliPaths(cwd, parsed.extensions);
+    const resolvedSkillPaths = resolveCliPaths(cwd, parsed.skills);
+    const resolvedPromptTemplatePaths = resolveCliPaths(cwd, parsed.promptTemplates);
+    const resolvedThemePaths = resolveCliPaths(cwd, parsed.themes);
+    const authStorage = AuthStorage.create();
+    if (parsed.listModels !== undefined) {
+        const services = await createAgentSessionServices({
+            cwd,
+            agentDir,
+            authStorage,
+            settingsManager: startupSettingsManager,
+            extensionFlagValues: parsed.unknownFlags,
+            resourceLoaderOptions: {
+                additionalExtensionPaths: resolvedExtensionPaths,
+                additionalSkillPaths: resolvedSkillPaths,
+                additionalPromptTemplatePaths: resolvedPromptTemplatePaths,
+                additionalThemePaths: resolvedThemePaths,
+                noExtensions: parsed.noExtensions,
+                noSkills: true,
+                noPromptTemplates: true,
+                noThemes: true,
+                noContextFiles: true,
+                extensionFactories: options?.extensionFactories,
+            },
+        });
+        reportDiagnostics([
+            ...services.diagnostics,
+            ...collectSettingsDiagnostics(services.settingsManager, "model listing"),
+        ]);
+        const searchPattern = typeof parsed.listModels === "string" ? parsed.listModels : undefined;
+        await listModels(services.modelRegistry, searchPattern);
+        process.exit(0);
+    }
     // Decide the final runtime cwd before creating cwd-bound runtime services.
     // --session and --resume may select a session from another project, so project-local
     // settings, resources, provider registrations, and models must be resolved only after
@@ -504,23 +479,19 @@ export async function main(args, options) {
     }
     time("createSessionManager");
     const trustStore = new ProjectTrustStore(agentDir);
+    const sessionCwd = sessionManager.getCwd();
+    const autoTrustOnReloadCwd = parsed.projectTrustOverride === undefined && !hasProjectTrustInputs(sessionCwd) ? sessionCwd : undefined;
     const trustPromptMode = parsed.help || parsed.listModels !== undefined ? "print" : appMode;
-    const projectTrustedForSession = await resolveProjectTrusted({
-        cwd: sessionManager.getCwd(),
-        trustStore,
-        trustOverride: parsed.projectTrustOverride,
-        appMode: trustPromptMode,
-        settingsManagerForPrompt: startupSettingsManager,
-    });
-    const resolvedExtensionPaths = resolveCliPaths(cwd, parsed.extensions);
-    const resolvedSkillPaths = resolveCliPaths(cwd, parsed.skills);
-    const resolvedPromptTemplatePaths = resolveCliPaths(cwd, parsed.promptTemplates);
-    const resolvedThemePaths = resolveCliPaths(cwd, parsed.themes);
-    const authStorage = AuthStorage.create();
-    const createRuntime = async ({ cwd, agentDir, sessionManager, sessionStartEvent, }) => {
-        const projectTrusted = cwd === sessionManager.getCwd()
-            ? projectTrustedForSession
-            : (parsed.projectTrustOverride ?? (!hasProjectTrustInputs(cwd) || trustStore.get(cwd) === true));
+    const projectTrustByCwd = new Map();
+    const createRuntime = async ({ cwd, agentDir, sessionManager, sessionStartEvent, projectTrustContext, }) => {
+        const isInitialRuntime = sessionStartEvent === undefined;
+        const projectTrustDiagnostics = [];
+        const cachedProjectTrust = projectTrustByCwd.get(cwd);
+        const hasTrustInputs = hasProjectTrustInputs(cwd);
+        const shouldResolveProjectTrust = parsed.projectTrustOverride === undefined && cachedProjectTrust === undefined && hasTrustInputs;
+        const projectTrusted = shouldResolveProjectTrust
+            ? false
+            : (cachedProjectTrust ?? parsed.projectTrustOverride ?? (!hasTrustInputs || trustStore.get(cwd) === true));
         const runtimeSettingsManager = SettingsManager.create(cwd, agentDir, { projectTrusted });
         const services = await createAgentSessionServices({
             cwd,
@@ -528,6 +499,29 @@ export async function main(args, options) {
             authStorage,
             settingsManager: runtimeSettingsManager,
             extensionFlagValues: parsed.unknownFlags,
+            resourceLoaderReloadOptions: shouldResolveProjectTrust
+                ? {
+                    resolveProjectTrust: async ({ extensionsResult }) => {
+                        const trusted = await resolveProjectTrusted({
+                            cwd,
+                            trustStore,
+                            trustOverride: parsed.projectTrustOverride,
+                            defaultProjectTrust: startupSettingsManager.getDefaultProjectTrust(),
+                            extensionsResult,
+                            projectTrustContext: projectTrustContext ??
+                                createProjectTrustContext({
+                                    cwd,
+                                    mode: isInitialRuntime ? trustPromptMode : appMode,
+                                    settingsManager: startupSettingsManager,
+                                    hasUI: isInitialRuntime && trustPromptMode === "interactive",
+                                }),
+                            onExtensionError: (message) => projectTrustDiagnostics.push({ type: "warning", message }),
+                        });
+                        projectTrustByCwd.set(cwd, trusted);
+                        return trusted;
+                    },
+                }
+                : undefined,
             resourceLoaderOptions: {
                 additionalExtensionPaths: resolvedExtensionPaths,
                 additionalSkillPaths: resolvedSkillPaths,
@@ -543,6 +537,7 @@ export async function main(args, options) {
         });
         const { settingsManager, modelRegistry, resourceLoader } = services;
         const diagnostics = [
+            ...projectTrustDiagnostics,
             ...services.diagnostics,
             ...collectSettingsDiagnostics(settingsManager, "runtime creation"),
             ...resourceLoader.getExtensions().errors.map(({ path, error }) => ({
@@ -555,7 +550,6 @@ export async function main(args, options) {
             legacyEnabledPatterns: settingsManager.getEnabledModels(),
         });
         const scopedModels = modelPatterns && modelPatterns.length > 0 ? await resolveModelScope(modelPatterns, modelRegistry) : [];
-        const favoriteModels = await resolveModelScope(settingsManager.getFavoriteModels() ?? [], modelRegistry);
         const { options: sessionOptions, cliThinkingFromModel, diagnostics: sessionOptionDiagnostics, } = buildSessionOptions(parsed, scopedModels, sessionManager.buildSessionContext().messages.length > 0, modelRegistry, settingsManager);
         diagnostics.push(...sessionOptionDiagnostics);
         if (parsed.apiKey) {
@@ -576,7 +570,6 @@ export async function main(args, options) {
             model: sessionOptions.model,
             thinkingLevel: sessionOptions.thinkingLevel,
             scopedModels: sessionOptions.scopedModels,
-            favoriteModels,
             tools: sessionOptions.tools,
             excludeTools: sessionOptions.excludeTools,
             noTools: sessionOptions.noTools,
@@ -600,7 +593,7 @@ export async function main(args, options) {
     });
     time("createAgentSessionRuntime");
     const { services, session, modelFallbackMessage } = runtime;
-    const { settingsManager, modelRegistry, resourceLoader } = services;
+    const { settingsManager, resourceLoader } = services;
     configureHttpDispatcher(settingsManager.getHttpIdleTimeoutMs());
     if (parsed.help) {
         const extensionFlags = resourceLoader
@@ -609,11 +602,6 @@ export async function main(args, options) {
         printHelp(extensionFlags);
         process.exit(0);
     }
-    if (parsed.listModels !== undefined) {
-        const searchPattern = typeof parsed.listModels === "string" ? parsed.listModels : undefined;
-        await listModels(modelRegistry, searchPattern);
-        process.exit(0);
-    }
     // Read piped stdin content (if any) - skip for RPC mode which uses stdin for JSON-RPC
     let stdinContent;
     if (appMode !== "rpc") {
@@ -631,14 +619,6 @@ export async function main(args, options) {
     if (appMode === "interactive" && deprecationWarnings.length > 0) {
         await showDeprecationWarnings(deprecationWarnings);
     }
-    const scopedModels = [...session.scopedModels];
-    const favoriteModels = [...session.favoriteModels];
-    const narrowedModelIds = scopedModels.length > 0
-        ? new Set(scopedModels.map((scoped) => `${scoped.model.provider}/${scoped.model.id}`))
-        : null;
-    const favoriteModelsForCycle = narrowedModelIds
-        ? favoriteModels.filter((favorite) => narrowedModelIds.has(`${favorite.model.provider}/${favorite.model.id}`))
-        : favoriteModels;
     time("resolveModelScope");
     reportDiagnostics(runtime.diagnostics);
     if (runtime.diagnostics.some((diagnostic) => diagnostic.type === "error")) {
@@ -659,27 +639,10 @@ export async function main(args, options) {
         await runRpcMode(runtime);
     }
     else if (appMode === "interactive") {
-        if (scopedModels.length > 0 && (parsed.verbose || !settingsManager.getQuietStartup())) {
-            const modelList = scopedModels
-                .map((sm) => {
-                const thinkingStr = sm.thinkingLevel ? `:${sm.thinkingLevel}` : "";
-                return `${sm.model.id}${thinkingStr}`;
-            })
-                .join(", ");
-            console.log(chalk.dim(`Model catalog: ${modelList} ${chalk.gray("(narrowed)")}`));
-        }
-        if (favoriteModelsForCycle.length > 0 && (parsed.verbose || !settingsManager.getQuietStartup())) {
-            const modelList = favoriteModelsForCycle
-                .map((favorite) => {
-                const thinkingStr = favorite.thinkingLevel ? `:${favorite.thinkingLevel}` : "";
-                return `${favorite.model.id}${thinkingStr}`;
-            })
-                .join(", ");
-            console.log(chalk.dim(`Favorite models: ${modelList} ${chalk.gray("(Ctrl+P to cycle)")}`));
-        }
         const interactiveMode = new InteractiveMode(runtime, {
             migratedProviders,
             modelFallbackMessage,
+            autoTrustOnReloadCwd,
             initialMessage,
             initialImages,
             initialMessages: parsed.messages,