@psnext/slingcli 2.5.20260607-2 → 2.5.20260615-2

package/node_modules/@earendil-works/pi-coding-agent/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 { shouldRunFirstTimeSetup, showFirstTimeSetup, 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,17 +21,16 @@ 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 { 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";
 import { printTimings, resetTimings, time } from "./core/timings.js";
-import { hasProjectTrustInputs, ProjectTrustStore } from "./core/trust-manager.js";
+import { hasTrustRequiringProjectResources, 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 });
@@ -268,6 +271,7 @@ function buildSessionOptions(parsed, scopedModels, hasExistingSession, modelRegi
         const resolved = resolveCliModel({
             cliProvider: parsed.provider,
             cliModel: parsed.model,
+            cliThinking: parsed.thinking,
             modelRegistry,
         });
         if (resolved.warning) {
@@ -340,64 +344,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 sling to read project instructions (AGENTS.md/CLAUDE.md), load .sling 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);
@@ -408,10 +360,11 @@ export async function main(args, options) {
     if (process.platform === "win32") {
         cleanupWindowsSelfUpdateQuarantine(getPackageDir());
     }
-    if (await handlePackageCommand(args)) {
+    if (await handlePackageCommand(args, { extensionFactories: options?.extensionFactories })) {
+        process.exit(process.exitCode ?? 0);
         return;
     }
-    if (await handleConfigCommand(args)) {
+    if (await handleConfigCommand(args, { extensionFactories: options?.extensionFactories })) {
         return;
     }
     const parsed = parseArgs(args);
@@ -425,11 +378,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);
@@ -448,6 +396,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);
@@ -461,6 +414,12 @@ export async function main(args, options) {
     const agentDir = getAgentDir();
     const startupSettingsManager = SettingsManager.create(cwd, agentDir);
     reportDiagnostics(collectSettingsDiagnostics(startupSettingsManager, "startup session lookup"));
+    // Experimental first-time setup: theme choice and analytics opt-in.
+    // Runs before any runtime services are created so the chosen settings apply everywhere.
+    if (appMode === "interactive" && !parsed.help && parsed.listModels === undefined && shouldRunFirstTimeSetup()) {
+        await showFirstTimeSetup(startupSettingsManager);
+        time("firstTimeSetup");
+    }
     // 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
@@ -495,23 +454,28 @@ export async function main(args, options) {
     }
     time("createSessionManager");
     const trustStore = new ProjectTrustStore(agentDir);
+    const sessionCwd = sessionManager.getCwd();
+    const autoTrustOnReloadCwd = parsed.projectTrustOverride === undefined && !hasTrustRequiringProjectResources(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 projectTrustByCwd = new Map();
     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 createRuntime = async ({ cwd, agentDir, sessionManager, sessionStartEvent, projectTrustContext, }) => {
+        const isInitialRuntime = sessionStartEvent === undefined;
+        const projectTrustDiagnostics = [];
+        const cachedProjectTrust = projectTrustByCwd.get(cwd);
+        const hasTrustRequiringResources = hasTrustRequiringProjectResources(cwd);
+        const shouldResolveProjectTrust = parsed.projectTrustOverride === undefined && cachedProjectTrust === undefined && hasTrustRequiringResources;
+        const projectTrusted = shouldResolveProjectTrust
+            ? false
+            : (cachedProjectTrust ??
+                parsed.projectTrustOverride ??
+                (!hasTrustRequiringResources || trustStore.get(cwd) === true));
         const runtimeSettingsManager = SettingsManager.create(cwd, agentDir, { projectTrusted });
         const services = await createAgentSessionServices({
             cwd,
@@ -519,6 +483,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,
@@ -536,6 +523,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 }) => ({
@@ -642,6 +630,7 @@ export async function main(args, options) {
         const interactiveMode = new InteractiveMode(runtime, {
             migratedProviders,
             modelFallbackMessage,
+            autoTrustOnReloadCwd,
             initialMessage,
             initialImages,
             initialMessages: parsed.messages,

package/node_modules/@earendil-works/pi-coding-agent/dist/migrations.js

@@ -2,12 +2,10 @@
  * One-time migrations that run on startup.
  */
 import chalk from "chalk";
-import { chmodSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "fs";
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "fs";
 import { dirname, join } from "path";
 import { CONFIG_DIR_NAME, getAgentDir, getBinDir } from "./config.js";
 import { migrateKeybindingsConfig } from "./core/keybindings.js";
-import { isLegacyEnvVarNameConfigValue } from "./core/resolve-config-value.js";
-import { stripJsonComments } from "./utils/json.js";
 const MIGRATION_GUIDE_URL = "https://github.com/earendil-works/pi-mono/blob/main/packages/coding-agent/CHANGELOG.md#extensions-migration";
 const EXTENSIONS_DOC_URL = "https://github.com/earendil-works/pi-mono/blob/main/packages/coding-agent/docs/extensions.md";
 /**
@@ -65,120 +63,6 @@ export function migrateAuthToAuthJson() {
     }
     return providers;
 }
-function migrateLegacyEnvVarString(value) {
-    return isLegacyEnvVarNameConfigValue(value) ? `$${value}` : undefined;
-}
-function migrateStringProperty(record, key, location, migrations) {
-    const value = record[key];
-    if (typeof value !== "string")
-        return false;
-    const migrated = migrateLegacyEnvVarString(value);
-    if (migrated === undefined)
-        return false;
-    record[key] = migrated;
-    migrations.push({ location, from: value, to: migrated });
-    return true;
-}
-function migrateHeadersConfig(headers, location, migrations) {
-    if (typeof headers !== "object" || headers === null || Array.isArray(headers))
-        return false;
-    const headerRecord = headers;
-    let migrated = false;
-    for (const [key, value] of Object.entries(headerRecord)) {
-        if (typeof value !== "string")
-            continue;
-        const migratedValue = migrateLegacyEnvVarString(value);
-        if (migratedValue === undefined)
-            continue;
-        headerRecord[key] = migratedValue;
-        migrations.push({ location: `${location}[${JSON.stringify(key)}]`, from: value, to: migratedValue });
-        migrated = true;
-    }
-    return migrated;
-}
-function migrateAuthJsonConfigValues(agentDir) {
-    const authPath = join(agentDir, "auth.json");
-    if (!existsSync(authPath))
-        return [];
-    try {
-        const parsed = JSON.parse(readFileSync(authPath, "utf-8"));
-        if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
-            return [];
-        const authData = parsed;
-        const migrations = [];
-        for (const [provider, credential] of Object.entries(authData)) {
-            if (typeof credential !== "object" || credential === null || Array.isArray(credential))
-                continue;
-            const credentialRecord = credential;
-            if (credentialRecord.type !== "api_key")
-                continue;
-            migrateStringProperty(credentialRecord, "key", `auth.json[${JSON.stringify(provider)}].key`, migrations);
-        }
-        if (migrations.length === 0)
-            return [];
-        writeFileSync(authPath, `${JSON.stringify(parsed, null, 2)}\n`, "utf-8");
-        chmodSync(authPath, 0o600);
-        return migrations;
-    }
-    catch {
-        return [];
-    }
-}
-function migrateModelsJsonConfigValues(agentDir) {
-    const modelsPath = join(agentDir, "models.json");
-    if (!existsSync(modelsPath))
-        return [];
-    const parsed = JSON.parse(stripJsonComments(readFileSync(modelsPath, "utf-8")));
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
-        return [];
-    const modelsData = parsed;
-    const providers = modelsData.providers;
-    if (typeof providers !== "object" || providers === null || Array.isArray(providers))
-        return [];
-    const migrations = [];
-    for (const [provider, providerConfig] of Object.entries(providers)) {
-        if (typeof providerConfig !== "object" || providerConfig === null || Array.isArray(providerConfig))
-            continue;
-        const providerRecord = providerConfig;
-        const providerLocation = `models.json.providers[${JSON.stringify(provider)}]`;
-        migrateStringProperty(providerRecord, "apiKey", `${providerLocation}.apiKey`, migrations);
-        migrateHeadersConfig(providerRecord.headers, `${providerLocation}.headers`, migrations);
-        if (Array.isArray(providerRecord.models)) {
-            for (let index = 0; index < providerRecord.models.length; index++) {
-                const modelConfig = providerRecord.models[index];
-                if (typeof modelConfig !== "object" || modelConfig === null || Array.isArray(modelConfig))
-                    continue;
-                const modelRecord = modelConfig;
-                const modelKey = typeof modelRecord.id === "string" ? JSON.stringify(modelRecord.id) : String(index);
-                migrateHeadersConfig(modelRecord.headers, `${providerLocation}.models[${modelKey}].headers`, migrations);
-            }
-        }
-        const modelOverrides = providerRecord.modelOverrides;
-        if (typeof modelOverrides === "object" && modelOverrides !== null && !Array.isArray(modelOverrides)) {
-            for (const [modelId, modelOverride] of Object.entries(modelOverrides)) {
-                if (typeof modelOverride !== "object" || modelOverride === null || Array.isArray(modelOverride))
-                    continue;
-                const modelOverrideRecord = modelOverride;
-                migrateHeadersConfig(modelOverrideRecord.headers, `${providerLocation}.modelOverrides[${JSON.stringify(modelId)}].headers`, migrations);
-            }
-        }
-    }
-    if (migrations.length === 0)
-        return [];
-    writeFileSync(modelsPath, `${JSON.stringify(parsed, null, 2)}\n`, "utf-8");
-    return migrations;
-}
-function migrateExplicitEnvVarConfigValues() {
-    const agentDir = getAgentDir();
-    const migrations = [...migrateAuthJsonConfigValues(agentDir), ...migrateModelsJsonConfigValues(agentDir)];
-    if (migrations.length === 0)
-        return;
-    const details = migrations.map((migration) => `  - ${migration.location}: ${migration.from} -> ${migration.to}`);
-    console.log(chalk.yellow([
-        "Warning: Migrated API key/header environment references to explicit $ENV_VAR syntax. Plain strings will be treated as literals.",
-        ...details,
-    ].join("\n")));
-}
 /**
  * Migrate sessions from ~/.pi/agent/*.jsonl to proper session directories.
  *
@@ -388,7 +272,6 @@ export async function showDeprecationWarnings(warnings) {
  */
 export function runMigrations(cwd) {
     const migratedAuthProviders = migrateAuthToAuthJson();
-    migrateExplicitEnvVarConfigValues();
     migrateSessionsFromAgentRoot();
     migrateToolsToBin();
     migrateKeybindingsConfigFile();

package/node_modules/@earendil-works/pi-coding-agent/dist/modes/interactive/components/first-time-setup.js

@@ -0,0 +1,103 @@
+import { Container, getKeybindings, Spacer, Text } from "@earendil-works/pi-tui";
+import { APP_NAME } from "../../../config.js";
+import { theme } from "../theme/theme.js";
+import { DynamicBorder } from "./dynamic-border.js";
+import { keyHint, rawKeyHint } from "./keybinding-hints.js";
+const THEME_OPTIONS = [
+    { value: "dark", label: "Dark" },
+    { value: "light", label: "Light" },
+];
+const ANALYTICS_OPTIONS = [
+    { value: true, label: "Share anonymous usage data" },
+    { value: false, label: "Don't share" },
+];
+const SETUP_LOGO_LINES = ["██████", "██  ██", "████  ██", "██    ██"];
+/** First-time setup dialog: theme choice and analytics opt-in. */
+export class FirstTimeSetupComponent extends Container {
+    step = "theme";
+    themeIndex;
+    analyticsIndex = 0;
+    options;
+    constructor(options) {
+        super();
+        this.options = options;
+        this.themeIndex = Math.max(0, THEME_OPTIONS.findIndex((option) => option.value === options.detectedTheme));
+        this.update();
+    }
+    // Rebuild the whole dialog on every change so theme previews recolor all text.
+    update() {
+        this.clear();
+        this.addChild(new DynamicBorder());
+        this.addChild(new Spacer(1));
+        this.addChild(new Text(theme.fg("accent", SETUP_LOGO_LINES.join("\n")), 1, 0));
+        this.addChild(new Spacer(1));
+        this.addChild(new Text(theme.fg("accent", theme.bold(`Welcome to ${APP_NAME}, the minimal coding agent.`)), 1, 0));
+        this.addChild(new Spacer(1));
+        if (this.step === "theme") {
+            this.addChild(new Text(theme.fg("text", "Pick a theme."), 1, 0));
+            this.addChild(new Text(theme.fg("muted", `Detected system appearance: ${this.options.detectedTheme}`), 1, 0));
+            this.addChild(new Spacer(1));
+            this.addOptionList(THEME_OPTIONS.map((option) => option.label), this.themeIndex);
+        }
+        else {
+            this.addChild(new Text(theme.fg("text", "Opt-in to anonymous usage data sharing?"), 1, 0));
+            this.addChild(new Text(theme.fg("muted", "Opting in stores a tracking identifier in settings.json and enables anonymous\nusage analytics. This helps us to better debug, reproduce, and resolve issues\nand bugs within Pi. You can observe what is shared using /privacy and make\nchanges anytime in settings.json."), 1, 0));
+            this.addChild(new Spacer(1));
+            this.addOptionList(ANALYTICS_OPTIONS.map((option) => option.label), this.analyticsIndex);
+        }
+        this.addChild(new Spacer(1));
+        this.addChild(new Text(rawKeyHint("↑↓", "navigate") +
+            "  " +
+            keyHint("tui.select.confirm", this.step === "theme" ? "continue" : "finish") +
+            "  " +
+            keyHint("tui.select.cancel", "skip setup"), 1, 0));
+        this.addChild(new Spacer(1));
+        this.addChild(new DynamicBorder());
+    }
+    addOptionList(labels, selectedIndex) {
+        for (let i = 0; i < labels.length; i++) {
+            const isSelected = i === selectedIndex;
+            const prefix = isSelected ? theme.fg("accent", "→ ") : "  ";
+            const label = isSelected ? theme.fg("accent", labels[i]) : theme.fg("text", labels[i]);
+            this.addChild(new Text(`${prefix}${label}`, 1, 0));
+        }
+    }
+    moveSelection(delta) {
+        if (this.step === "theme") {
+            const next = Math.max(0, Math.min(THEME_OPTIONS.length - 1, this.themeIndex + delta));
+            if (next !== this.themeIndex) {
+                this.themeIndex = next;
+                this.options.onThemePreview(THEME_OPTIONS[this.themeIndex].value);
+            }
+        }
+        else {
+            this.analyticsIndex = Math.max(0, Math.min(ANALYTICS_OPTIONS.length - 1, this.analyticsIndex + delta));
+        }
+        this.update();
+    }
+    handleInput(keyData) {
+        const kb = getKeybindings();
+        if (kb.matches(keyData, "tui.select.up") || keyData === "k") {
+            this.moveSelection(-1);
+        }
+        else if (kb.matches(keyData, "tui.select.down") || keyData === "j") {
+            this.moveSelection(1);
+        }
+        else if (kb.matches(keyData, "tui.select.confirm") || keyData === "\n") {
+            if (this.step === "theme") {
+                this.step = "analytics";
+                this.update();
+            }
+            else {
+                this.options.onSubmit({
+                    theme: THEME_OPTIONS[this.themeIndex].value,
+                    shareAnalytics: ANALYTICS_OPTIONS[this.analyticsIndex].value,
+                });
+            }
+        }
+        else if (kb.matches(keyData, "tui.select.cancel")) {
+            this.options.onCancel();
+        }
+    }
+}
+//# sourceMappingURL=first-time-setup.js.map

package/node_modules/@earendil-works/pi-coding-agent/dist/modes/interactive/components/index.js

@@ -13,6 +13,7 @@ export { DynamicBorder } from "./dynamic-border.js";
 export { ExtensionEditorComponent } from "./extension-editor.js";
 export { ExtensionInputComponent } from "./extension-input.js";
 export { ExtensionSelectorComponent } from "./extension-selector.js";
+export { FirstTimeSetupComponent, } from "./first-time-setup.js";
 export { FooterComponent } from "./footer.js";
 export { keyHint, keyText, rawKeyHint } from "./keybinding-hints.js";
 export { LoginDialogComponent } from "./login-dialog.js";

package/node_modules/@earendil-works/pi-coding-agent/dist/modes/interactive/components/login-dialog.js

@@ -42,7 +42,9 @@ export class LoginDialogComponent extends Container {
         this.input = new Input();
         this.input.onSubmit = () => {
             if (this.inputResolver) {
-                this.inputResolver(this.input.getValue());
+                const value = this.input.getValue();
+                this.replaceInputWithSubmittedText(value);
+                this.inputResolver(value);
                 this.inputResolver = undefined;
                 this.inputRejecter = undefined;
             }
@@ -56,6 +58,9 @@ export class LoginDialogComponent extends Container {
     get signal() {
         return this.abortController.signal;
     }
+    replaceInputWithSubmittedText(value) {
+        this.contentContainer.children = this.contentContainer.children.map((child) => child === this.input ? new Text(`> ${value}`, 0, 0) : child);
+    }
     cancel() {
         this.abortController.abort();
         if (this.inputRejecter) {
@@ -103,6 +108,7 @@ export class LoginDialogComponent extends Container {
      * Show input for manual code/URL entry (for callback server providers)
      */
     showManualInput(prompt) {
+        this.input.setValue("");
         this.contentContainer.addChild(new Spacer(1));
         this.contentContainer.addChild(new Text(theme.fg("dim", prompt), 1, 0));
         this.contentContainer.addChild(this.input);

package/node_modules/@earendil-works/pi-coding-agent/dist/modes/interactive/components/settings-selector.js

@@ -15,6 +15,12 @@ const THINKING_DESCRIPTIONS = {
     high: "Deep reasoning (~16k tokens)",
     xhigh: "Maximum reasoning (~32k tokens)",
 };
+const DEFAULT_PROJECT_TRUST_LABELS = {
+    ask: "Ask",
+    always: "Always trust",
+    never: "Never trust",
+};
+const DEFAULT_PROJECT_TRUST_BY_LABEL = new Map(Object.entries(DEFAULT_PROJECT_TRUST_LABELS).map(([value, label]) => [label, value]));
 /**
  * A submenu component for selecting from a list of options.
  */
@@ -159,6 +165,13 @@ export class SettingsSelectorComponent extends Container {
                 currentValue: config.enableInstallTelemetry ? "true" : "false",
                 values: ["true", "false"],
             },
+            {
+                id: "default-project-trust",
+                label: "Default project trust",
+                description: "Fallback behavior when no extension or saved trust decision decides project trust",
+                currentValue: DEFAULT_PROJECT_TRUST_LABELS[config.defaultProjectTrust],
+                values: Object.values(DEFAULT_PROJECT_TRUST_LABELS),
+            },
             {
                 id: "double-escape-action",
                 label: "Double-escape action",
@@ -357,6 +370,13 @@ export class SettingsSelectorComponent extends Container {
                 case "install-telemetry":
                     callbacks.onEnableInstallTelemetryChange(newValue === "true");
                     break;
+                case "default-project-trust": {
+                    const defaultProjectTrust = DEFAULT_PROJECT_TRUST_BY_LABEL.get(newValue);
+                    if (defaultProjectTrust) {
+                        callbacks.onDefaultProjectTrustChange(defaultProjectTrust);
+                    }
+                    break;
+                }
                 case "double-escape-action":
                     callbacks.onDoubleEscapeActionChange(newValue);
                     break;