@ashx-j/lunr 0.2.17 → 0.2.18

package/dist/node-runtime/chunk-NI6OTSBH.js

@@ -0,0 +1,966 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  lightBuiltinExtensions,
+  loadAllBuiltinExtensions
+} from "./chunk-ZBV7FAHG.js";
+import {
+  createProjectTrustContext,
+  createStartupTui,
+  resolveProjectTrusted,
+  shouldRunFirstTimeSetup,
+  showFirstTimeSetup,
+  showStartupSelector,
+  startStartupTui
+} from "./chunk-4DJ6HEGH.js";
+import {
+  ProjectTrustStore,
+  hasTrustRequiringProjectResources
+} from "./chunk-AROOY4BB.js";
+import {
+  applyInheritedSubagentPermissions
+} from "./chunk-XATUM2HK.js";
+import {
+  MissingSessionCwdError,
+  createAgentSessionFromServices,
+  createAgentSessionRuntime,
+  createAgentSessionServices,
+  formatMissingSessionCwdPrompt,
+  formatNoModelsAvailableMessage,
+  getMissingSessionCwdIssue
+} from "./chunk-ATGA2WLC.js";
+import {
+  resolveCliModel,
+  resolveModelScope
+} from "./chunk-STERBGUB.js";
+import {
+  restoreStdout,
+  takeOverStdout
+} from "./chunk-OBMWP3I5.js";
+import {
+  detectSupportedImageMimeTypeFromFile,
+  resolveReadPath
+} from "./chunk-WKDK4C5P.js";
+import {
+  SettingsManager,
+  applyHttpProxySettings,
+  configureHttpDispatcher
+} from "./chunk-CBGB57XT.js";
+import {
+  SessionManager,
+  assertValidSessionId
+} from "./chunk-GKLEQ3I4.js";
+import {
+  bindRuntimeBridges
+} from "./chunk-3NMWLTPV.js";
+import {
+  registerModelTierBridge
+} from "./chunk-W3CVH5RX.js";
+import {
+  processImage
+} from "./chunk-AD6VXAO7.js";
+import {
+  migrateLegacyGlobalInstructions
+} from "./chunk-M3LZLQW2.js";
+import {
+  printTimings,
+  resetTimings,
+  time
+} from "./chunk-PVCDKGR6.js";
+import {
+  registerCustomizeBridge
+} from "./chunk-HQCKFM2O.js";
+import {
+  registerMemoryCapBridge
+} from "./chunk-AY6CAJSL.js";
+import {
+  parseArgs,
+  printHelp
+} from "./chunk-QZMODZQ2.js";
+import {
+  markStartupMilestone
+} from "./chunk-CCZJ3PYY.js";
+import {
+  SessionSelectorComponent
+} from "./chunk-JZQ7F36T.js";
+import {
+  KeybindingsManager,
+  migrateKeybindingsConfig
+} from "./chunk-5EFIU3OM.js";
+import {
+  initTheme,
+  stopThemeWatcher
+} from "./chunk-RNBHABBA.js";
+import {
+  APP_NAME,
+  CONFIG_DIR_NAME,
+  ENV_SESSION_DIR,
+  VERSION,
+  appendDebugLog,
+  expandTildePath,
+  getAgentDir,
+  getBinDir,
+  getSessionsDir,
+  isLocalPath,
+  normalizePath,
+  resolvePath
+} from "./chunk-FQMM2EZ2.js";
+
+// packages/coding-agent/dist/main.js
+import { createInterface } from "node:readline";
+import { modelsAreEqual } from "@ashx-j/lunr-ai";
+import chalk4 from "chalk";
+
+// packages/coding-agent/dist/cli/file-processor.js
+import { access, readFile, stat } from "node:fs/promises";
+import chalk from "chalk";
+import { resolve } from "path";
+async function processFileArguments(fileArgs, options) {
+  let autoResizeImages = options?.autoResizeImages ?? !0, text = "", images = [];
+  for (let fileArg of fileArgs) {
+    let absolutePath = resolve(resolveReadPath(fileArg, process.cwd()));
+    try {
+      await access(absolutePath);
+    } catch {
+      console.error(chalk.red(`Error: File not found: ${absolutePath}`)), process.exit(1);
+    }
+    if ((await stat(absolutePath)).size === 0)
+      continue;
+    let mimeType = await detectSupportedImageMimeTypeFromFile(absolutePath);
+    if (mimeType) {
+      let content = await readFile(absolutePath), processed = await processImage(content, mimeType, { autoResizeImages });
+      if (!processed.ok) {
+        text += `<file name="${absolutePath}">${processed.message}</file>
+`;
+        continue;
+      }
+      let attachment = {
+        type: "image",
+        mimeType: processed.mimeType,
+        data: processed.data
+      };
+      images.push(attachment), processed.hints.length > 0 ? text += `<file name="${absolutePath}">${processed.hints.join(`
+`)}</file>
+` : text += `<file name="${absolutePath}"></file>
+`;
+    } else
+      try {
+        let content = await readFile(absolutePath, "utf-8");
+        text += `<file name="${absolutePath}">
+${content}
+</file>
+`;
+      } catch (error) {
+        let message = error instanceof Error ? error.message : String(error);
+        console.error(chalk.red(`Error: Could not read file ${absolutePath}: ${message}`)), process.exit(1);
+      }
+  }
+  return { text, images };
+}
+
+// packages/coding-agent/dist/cli/initial-message.js
+function buildInitialMessage({ parsed, fileText, fileImages, stdinContent }) {
+  let parts = [];
+  return stdinContent !== void 0 && parts.push(stdinContent), fileText && parts.push(fileText), parsed.messages.length > 0 && (parts.push(parsed.messages[0]), parsed.messages.shift()), {
+    initialMessage: parts.length > 0 ? parts.join("") : void 0,
+    initialImages: fileImages && fileImages.length > 0 ? fileImages : void 0
+  };
+}
+
+// packages/coding-agent/dist/cli/list-models.js
+import { fuzzyFilter } from "@ashx-j/lunr-tui";
+import chalk2 from "chalk";
+function formatTokenCount(count) {
+  if (count >= 1e6) {
+    let millions = count / 1e6;
+    return millions % 1 === 0 ? `${millions}M` : `${millions.toFixed(1)}M`;
+  }
+  if (count >= 1e3) {
+    let thousands = count / 1e3;
+    return thousands % 1 === 0 ? `${thousands}K` : `${thousands.toFixed(1)}K`;
+  }
+  return count.toString();
+}
+async function listModels(modelRuntime, searchPattern) {
+  await modelRuntime.refreshIfStale();
+  let loadError = modelRuntime.getError();
+  loadError && console.error(chalk2.yellow(`Warning: errors loading models.json:
+${loadError}`));
+  let models = [...await modelRuntime.getAvailable()];
+  if (models.length === 0) {
+    console.log(formatNoModelsAvailableMessage());
+    return;
+  }
+  let filteredModels = models;
+  if (searchPattern && (filteredModels = fuzzyFilter(models, searchPattern, (m) => `${m.provider} ${m.id}`)), filteredModels.length === 0) {
+    console.log(`No models matching "${searchPattern}"`);
+    return;
+  }
+  filteredModels.sort((a, b) => {
+    let providerCmp = a.provider.localeCompare(b.provider);
+    return providerCmp !== 0 ? providerCmp : a.id.localeCompare(b.id);
+  });
+  let rows = filteredModels.map((m) => ({
+    provider: m.provider,
+    model: m.id,
+    context: formatTokenCount(m.contextWindow),
+    maxOut: formatTokenCount(m.maxTokens),
+    thinking: m.reasoning ? "yes" : "no",
+    images: m.input.includes("image") ? "yes" : "no"
+  })), headers = {
+    provider: "provider",
+    model: "model",
+    context: "context",
+    maxOut: "max-out",
+    thinking: "thinking",
+    images: "images"
+  }, widths = {
+    provider: Math.max(headers.provider.length, ...rows.map((r) => r.provider.length)),
+    model: Math.max(headers.model.length, ...rows.map((r) => r.model.length)),
+    context: Math.max(headers.context.length, ...rows.map((r) => r.context.length)),
+    maxOut: Math.max(headers.maxOut.length, ...rows.map((r) => r.maxOut.length)),
+    thinking: Math.max(headers.thinking.length, ...rows.map((r) => r.thinking.length)),
+    images: Math.max(headers.images.length, ...rows.map((r) => r.images.length))
+  }, headerLine = [
+    headers.provider.padEnd(widths.provider),
+    headers.model.padEnd(widths.model),
+    headers.context.padEnd(widths.context),
+    headers.maxOut.padEnd(widths.maxOut),
+    headers.thinking.padEnd(widths.thinking),
+    headers.images.padEnd(widths.images)
+  ].join("  ");
+  console.log(headerLine);
+  for (let row of rows) {
+    let line = [
+      row.provider.padEnd(widths.provider),
+      row.model.padEnd(widths.model),
+      row.context.padEnd(widths.context),
+      row.maxOut.padEnd(widths.maxOut),
+      row.thinking.padEnd(widths.thinking),
+      row.images.padEnd(widths.images)
+    ].join("  ");
+    console.log(line);
+  }
+}
+
+// packages/coding-agent/dist/cli/session-picker.js
+import { setKeybindings } from "@ashx-j/lunr-tui";
+async function selectSession(currentSessionsLoader, allSessionsLoader, settingsManager) {
+  let ui = await createStartupTui(settingsManager);
+  return new Promise((resolve3) => {
+    let keybindings = KeybindingsManager.create();
+    setKeybindings(keybindings);
+    let resolved = !1, selector = new SessionSelectorComponent(currentSessionsLoader, allSessionsLoader, (path) => {
+      resolved || (resolved = !0, ui.stop(), resolve3(path));
+    }, () => {
+      resolved || (resolved = !0, ui.stop(), resolve3(null));
+    }, () => {
+      ui.stop(), process.exit(0);
+    }, () => ui.requestRender(), { showRenameHint: !1, keybindings });
+    ui.addChild(selector), ui.setFocus(selector.getSessionList()), startStartupTui(ui, settingsManager);
+  });
+}
+
+// packages/coding-agent/dist/core/session-retention.js
+import { readdir, stat as stat2, unlink } from "node:fs/promises";
+import { join, resolve as resolve2 } from "node:path";
+var DAY_MS = 1440 * 60 * 1e3;
+function sameFile(a, b) {
+  let ra = resolve2(a), rb = resolve2(b);
+  return process.platform === "win32" ? ra.toLowerCase() === rb.toLowerCase() : ra === rb;
+}
+async function pruneDir(dir, cutoffMs, excludeFile, deleted) {
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: !0 });
+  } catch {
+    return;
+  }
+  for (let entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".jsonl"))
+      continue;
+    let filePath = join(dir, entry.name);
+    if (!(excludeFile && sameFile(filePath, excludeFile)))
+      try {
+        (await stat2(filePath)).mtimeMs < cutoffMs && (await unlink(filePath), deleted.push(filePath));
+      } catch {
+      }
+  }
+}
+async function pruneOldSessions(sessionsRoot, retentionDays, options = {}) {
+  let deleted = [];
+  if (!Number.isFinite(retentionDays) || retentionDays <= 0)
+    return { deleted };
+  let cutoffMs = (options.now ?? Date.now()) - retentionDays * DAY_MS;
+  await pruneDir(sessionsRoot, cutoffMs, options.excludeFile, deleted);
+  let subdirs;
+  try {
+    subdirs = await readdir(sessionsRoot, { withFileTypes: !0 });
+  } catch {
+    return { deleted };
+  }
+  for (let entry of subdirs)
+    entry.isDirectory() && await pruneDir(join(sessionsRoot, entry.name), cutoffMs, options.excludeFile, deleted);
+  return { deleted };
+}
+
+// packages/coding-agent/dist/migrations.js
+import chalk3 from "chalk";
+import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join as join2 } from "path";
+var MIGRATION_GUIDE_URL = "https://github.com/earendil-works/pi-mono/blob/main/packages/coding-agent/CHANGELOG.md#extensions-migration", EXTENSIONS_DOC_URL = "https://github.com/earendil-works/pi-mono/blob/main/packages/coding-agent/docs/extensions.md";
+function migrateAuthToAuthJson() {
+  let agentDir = getAgentDir(), authPath = join2(agentDir, "auth.json"), oauthPath = join2(agentDir, "oauth.json"), settingsPath = join2(agentDir, "settings.json");
+  if (existsSync(authPath))
+    return [];
+  let migrated = {}, providers = [];
+  if (existsSync(oauthPath))
+    try {
+      let oauth = JSON.parse(readFileSync(oauthPath, "utf-8"));
+      for (let [provider, cred] of Object.entries(oauth))
+        migrated[provider] = { type: "oauth", ...cred }, providers.push(provider);
+      renameSync(oauthPath, `${oauthPath}.migrated`);
+    } catch {
+    }
+  if (existsSync(settingsPath))
+    try {
+      let content = readFileSync(settingsPath, "utf-8"), settings = JSON.parse(content);
+      if (settings.apiKeys && typeof settings.apiKeys == "object") {
+        for (let [provider, key] of Object.entries(settings.apiKeys))
+          !migrated[provider] && typeof key == "string" && (migrated[provider] = { type: "api_key", key }, providers.push(provider));
+        delete settings.apiKeys, writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+      }
+    } catch {
+    }
+  return Object.keys(migrated).length > 0 && (mkdirSync(dirname(authPath), { recursive: !0 }), writeFileSync(authPath, JSON.stringify(migrated, null, 2), { mode: 384 })), providers;
+}
+function removeRetiredGlobalSettings(keys, agentDir = getAgentDir()) {
+  let settingsPath = join2(agentDir, "settings.json");
+  if (!existsSync(settingsPath))
+    return !1;
+  try {
+    let parsed = JSON.parse(readFileSync(settingsPath, "utf-8"));
+    if (typeof parsed != "object" || parsed === null || Array.isArray(parsed))
+      return !1;
+    let settings = parsed, retired = keys.filter((key) => key in settings);
+    if (retired.length === 0)
+      return !1;
+    for (let key of retired)
+      delete settings[key];
+    return writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}
+`, "utf-8"), !0;
+  } catch {
+    return !1;
+  }
+}
+function removeRetiredBehaviorPresetSetting(agentDir = getAgentDir()) {
+  return removeRetiredGlobalSettings(["behaviorPreset"], agentDir);
+}
+function removeRetiredTuiSettings(agentDir = getAgentDir()) {
+  return removeRetiredGlobalSettings(["gutterRail", "promptSymbol"], agentDir);
+}
+function migrateSessionsFromAgentRoot() {
+  let agentDir = getAgentDir(), files;
+  try {
+    files = readdirSync(agentDir).filter((f) => f.endsWith(".jsonl")).map((f) => join2(agentDir, f));
+  } catch {
+    return;
+  }
+  if (files.length !== 0)
+    for (let file of files)
+      try {
+        let firstLine = readFileSync(file, "utf8").split(`
+`)[0];
+        if (!firstLine?.trim())
+          continue;
+        let header = JSON.parse(firstLine);
+        if (header.type !== "session" || !header.cwd)
+          continue;
+        let safePath = `--${header.cwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`, correctDir = join2(agentDir, "sessions", safePath);
+        existsSync(correctDir) || mkdirSync(correctDir, { recursive: !0 });
+        let fileName = file.split("/").pop() || file.split("\\").pop(), newPath = join2(correctDir, fileName);
+        if (existsSync(newPath))
+          continue;
+        renameSync(file, newPath);
+      } catch {
+      }
+}
+function migrateCommandsToPrompts(baseDir, label) {
+  let commandsDir = join2(baseDir, "commands"), promptsDir = join2(baseDir, "prompts");
+  if (existsSync(commandsDir) && !existsSync(promptsDir))
+    try {
+      return renameSync(commandsDir, promptsDir), console.log(chalk3.green(`Migrated ${label} commands/ \u2192 prompts/`)), !0;
+    } catch (err) {
+      console.log(chalk3.yellow(`Warning: Could not migrate ${label} commands/ to prompts/: ${err instanceof Error ? err.message : err}`));
+    }
+  return !1;
+}
+function migrateKeybindingsConfigFile() {
+  let configPath = join2(getAgentDir(), "keybindings.json");
+  if (existsSync(configPath))
+    try {
+      let parsed = JSON.parse(readFileSync(configPath, "utf-8"));
+      if (typeof parsed != "object" || parsed === null || Array.isArray(parsed))
+        return;
+      let { config, migrated } = migrateKeybindingsConfig(parsed);
+      if (!migrated)
+        return;
+      writeFileSync(configPath, `${JSON.stringify(config, null, 2)}
+`, "utf-8");
+    } catch {
+    }
+}
+function migrateToolsToBin() {
+  let agentDir = getAgentDir(), toolsDir = join2(agentDir, "tools"), binDir = getBinDir();
+  if (!existsSync(toolsDir))
+    return;
+  let binaries = ["fd", "rg", "fd.exe", "rg.exe"], movedAny = !1;
+  for (let bin of binaries) {
+    let oldPath = join2(toolsDir, bin), newPath = join2(binDir, bin);
+    if (existsSync(oldPath))
+      if (existsSync(binDir) || mkdirSync(binDir, { recursive: !0 }), existsSync(newPath))
+        try {
+          rmSync?.(oldPath, { force: !0 });
+        } catch {
+        }
+      else
+        try {
+          renameSync(oldPath, newPath), movedAny = !0;
+        } catch {
+        }
+  }
+  movedAny && console.log(chalk3.green("Migrated managed binaries tools/ \u2192 bin/"));
+}
+function checkDeprecatedExtensionDirs(baseDir, label) {
+  let hooksDir = join2(baseDir, "hooks"), toolsDir = join2(baseDir, "tools"), warnings = [];
+  if (existsSync(hooksDir) && warnings.push(`${label} hooks/ directory found. Hooks have been renamed to extensions.`), existsSync(toolsDir))
+    try {
+      readdirSync(toolsDir).filter((e) => {
+        let lower = e.toLowerCase();
+        return lower !== "fd" && lower !== "rg" && lower !== "fd.exe" && lower !== "rg.exe" && !e.startsWith(".");
+      }).length > 0 && warnings.push(`${label} tools/ directory contains custom tools. Custom tools have been merged into extensions.`);
+    } catch {
+    }
+  return warnings;
+}
+function migrateExtensionSystem(cwd) {
+  let agentDir = getAgentDir(), projectDir = join2(cwd, CONFIG_DIR_NAME);
+  return migrateCommandsToPrompts(agentDir, "Global"), migrateCommandsToPrompts(projectDir, "Project"), [
+    ...checkDeprecatedExtensionDirs(agentDir, "Global"),
+    ...checkDeprecatedExtensionDirs(projectDir, "Project")
+  ];
+}
+async function showDeprecationWarnings(warnings) {
+  if (warnings.length !== 0) {
+    for (let warning of warnings)
+      console.log(chalk3.yellow(`Warning: ${warning}`));
+    console.log(chalk3.yellow(`
+Move your extensions to the extensions/ directory.`)), console.log(chalk3.yellow(`Migration guide: ${MIGRATION_GUIDE_URL}`)), console.log(chalk3.yellow(`Documentation: ${EXTENSIONS_DOC_URL}`)), process.stdin.isTTY && (console.log(chalk3.dim(`
+Press any key to continue...`)), await new Promise((resolve3) => {
+      process.stdin.setRawMode?.(!0), process.stdin.resume(), process.stdin.once("data", () => {
+        process.stdin.setRawMode?.(!1), process.stdin.pause(), resolve3();
+      });
+    }), console.log());
+  }
+}
+function migratePiStateToLunr(piHome = join2(homedir(), ".pi"), lunrAgentDir = getAgentDir()) {
+  let copied = [], copyFileIfMissing = (src, dest) => {
+    try {
+      if (!existsSync(src) || existsSync(dest))
+        return;
+      mkdirSync(dirname(dest), { recursive: !0 }), copyFileSync(src, dest), copied.push(dest);
+    } catch {
+    }
+  }, copyDirIfMissing = (srcDir, destDir) => {
+    try {
+      if (!existsSync(srcDir))
+        return;
+      for (let entry of readdirSync(srcDir, { withFileTypes: !0 })) {
+        let src = join2(srcDir, entry.name), dest = join2(destDir, entry.name);
+        entry.isDirectory() ? copyDirIfMissing(src, dest) : entry.isFile() && copyFileIfMissing(src, dest);
+      }
+    } catch {
+    }
+  };
+  try {
+    let piAgent = join2(piHome, "agent");
+    for (let name of [
+      "mcp.json",
+      "mcp-cache.json",
+      "mcp-npx-cache.json",
+      "mcp-onboarding.json",
+      "pi-goal-state.json"
+    ])
+      copyFileIfMissing(join2(piAgent, name), join2(lunrAgentDir, name));
+    copyDirIfMissing(join2(piAgent, "mcp-oauth"), join2(lunrAgentDir, "mcp-oauth")), copyFileIfMissing(join2(piHome, "web-search.json"), join2(lunrAgentDir, "web-search.json"));
+    let lunrMemoryDir = join2(dirname(lunrAgentDir), "simple-memory");
+    for (let name of ["memory.md", "config.json"])
+      copyFileIfMissing(join2(piHome, "simple-memory", name), join2(lunrMemoryDir, name));
+  } catch {
+  }
+  return copied;
+}
+function runMigrations(cwd) {
+  let migratedAuthProviders = migrateAuthToAuthJson();
+  removeRetiredBehaviorPresetSetting(), removeRetiredTuiSettings(), migrateSessionsFromAgentRoot(), migrateToolsToBin(), migrateKeybindingsConfigFile(), migratePiStateToLunr();
+  let instructionMigration = migrateLegacyGlobalInstructions(getAgentDir());
+  instructionMigration.diagnostic && console.warn(chalk3.yellow(`Warning: ${instructionMigration.diagnostic}`));
+  let deprecationWarnings = migrateExtensionSystem(cwd);
+  return { migratedAuthProviders, deprecationWarnings };
+}
+
+// packages/coding-agent/dist/main.js
+var EXTENSION_LOAD_FAILURE_HINT = `Hint: Start without extensions using "${APP_NAME} -ne".`, PIPED_STDIN_FIRST_CHUNK_MS = 50, PIPED_STDIN_IDLE_MS = 2e3;
+async function readPipedStdin(stream = process.stdin, options = {}) {
+  if (stream.isTTY)
+    return;
+  let firstChunkMs = options.firstChunkMs ?? PIPED_STDIN_FIRST_CHUNK_MS, idleMs = options.idleMs ?? PIPED_STDIN_IDLE_MS;
+  return new Promise((resolve3) => {
+    let data = "", settled = !1, sawData = !1, idleTimer, firstChunkTimer = setTimeout(() => {
+      sawData || finish(void 0);
+    }, firstChunkMs), finish = (value) => {
+      settled || (settled = !0, clearTimeout(firstChunkTimer), idleTimer && clearTimeout(idleTimer), stream.off("data", onData), stream.off("end", onEnd), stream.off("error", onEnd), resolve3(value));
+    }, onEnd = () => finish(data.trim() || void 0), onData = (chunk) => {
+      sawData = !0, data += typeof chunk == "string" ? chunk : chunk.toString("utf8"), idleTimer && clearTimeout(idleTimer), idleTimer = setTimeout(onEnd, idleMs);
+    };
+    stream.setEncoding("utf8"), stream.on("data", onData), stream.on("end", onEnd), stream.on("error", onEnd), stream.resume();
+  });
+}
+function collectSettingsDiagnostics(settingsManager, context) {
+  return settingsManager.drainErrors().map(({ scope, error }) => ({
+    type: "warning",
+    message: `(${context}, ${scope} settings) ${error.message}`
+  }));
+}
+function reportDiagnostics(diagnostics) {
+  for (let diagnostic of diagnostics) {
+    let color = diagnostic.type === "error" ? chalk4.red : diagnostic.type === "warning" ? chalk4.yellow : chalk4.dim, prefix = diagnostic.type === "error" ? "Error: " : diagnostic.type === "warning" ? "Warning: " : "";
+    console.error(color(`${prefix}${diagnostic.message}`));
+  }
+}
+function isTruthyEnvFlag(value) {
+  return value ? value === "1" || value.toLowerCase() === "true" || value.toLowerCase() === "yes" : !1;
+}
+function resolveAppMode(parsed, stdinIsTTY, stdoutIsTTY) {
+  return parsed.mode === "rpc" ? "rpc" : parsed.mode === "json" ? "json" : isTruthyEnvFlag(process.env.PI_STARTUP_BENCHMARK) && !parsed.print ? "interactive" : parsed.print || !stdinIsTTY || !stdoutIsTTY ? "print" : "interactive";
+}
+function toPrintOutputMode(appMode) {
+  return appMode === "json" ? "json" : "text";
+}
+function isPlainRuntimeMetadataCommand(parsed) {
+  return !parsed.print && parsed.mode === void 0 && (parsed.help === !0 || parsed.listModels !== void 0);
+}
+async function prepareInitialMessage(parsed, autoResizeImages, stdinContent) {
+  if (parsed.fileArgs.length === 0)
+    return buildInitialMessage({ parsed, stdinContent });
+  let { text, images } = await processFileArguments(parsed.fileArgs, { autoResizeImages });
+  return buildInitialMessage({
+    parsed,
+    fileText: text,
+    fileImages: images,
+    stdinContent
+  });
+}
+async function findLocalSessionByExactId(sessionId, cwd, sessionDir) {
+  let localMatch = (await SessionManager.list(cwd, sessionDir)).find((s) => s.id === sessionId);
+  return localMatch ? { type: "local", path: localMatch.path } : void 0;
+}
+async function resolveSessionPath(sessionArg, cwd, sessionDir) {
+  if (sessionArg.includes("/") || sessionArg.includes("\\") || sessionArg.endsWith(".jsonl"))
+    return { type: "path", path: resolvePath(sessionArg, cwd) };
+  let localSessions = await SessionManager.list(cwd, sessionDir), localMatch = localSessions.find((s) => s.id === sessionArg) ?? localSessions.find((s) => s.id.startsWith(sessionArg));
+  if (localMatch)
+    return { type: "local", path: localMatch.path };
+  let allSessions = await SessionManager.listAll(sessionDir), globalMatch = allSessions.find((s) => s.id === sessionArg) ?? allSessions.find((s) => s.id.startsWith(sessionArg));
+  return globalMatch ? { type: "global", path: globalMatch.path, cwd: globalMatch.cwd } : { type: "not_found", arg: sessionArg };
+}
+async function promptConfirm(message, startupView) {
+  return startupView ? startupView.confirm("Confirm", message) : new Promise((resolve3) => {
+    let rl = createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    rl.question(`${message} [y/N] `, (answer) => {
+      rl.close(), resolve3(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+    });
+  });
+}
+function validateForkFlags(parsed) {
+  if (!parsed.fork)
+    return;
+  let conflictingFlags = [
+    parsed.session ? "--session" : void 0,
+    parsed.continue ? "--continue" : void 0,
+    parsed.resume ? "--resume" : void 0,
+    parsed.noSession ? "--no-session" : void 0
+  ].filter((flag) => flag !== void 0);
+  conflictingFlags.length > 0 && (console.error(chalk4.red(`Error: --fork cannot be combined with ${conflictingFlags.join(", ")}`)), process.exit(1));
+}
+function validateSessionIdFlags(parsed) {
+  if (parsed.sessionId === void 0)
+    return;
+  let conflictingFlags = [
+    parsed.session ? "--session" : void 0,
+    parsed.continue ? "--continue" : void 0,
+    parsed.resume ? "--resume" : void 0
+  ].filter((flag) => flag !== void 0);
+  conflictingFlags.length > 0 && (console.error(chalk4.red(`Error: --session-id cannot be combined with ${conflictingFlags.join(", ")}`)), process.exit(1));
+  try {
+    assertValidSessionId(parsed.sessionId);
+  } catch (error) {
+    let message = error instanceof Error ? error.message : String(error);
+    console.error(chalk4.red(`Error: ${message}`)), process.exit(1);
+  }
+}
+function openSessionOrExit(path, sessionDir) {
+  try {
+    return SessionManager.open(path, sessionDir);
+  } catch (error) {
+    let message = error instanceof Error ? error.message : String(error);
+    console.error(chalk4.red(`Error: ${message}`)), process.exit(1);
+  }
+}
+function forkSessionOrExit(sourcePath, cwd, sessionDir, sessionId) {
+  try {
+    return SessionManager.forkFrom(sourcePath, cwd, sessionDir, { id: sessionId });
+  } catch (error) {
+    let message = error instanceof Error ? error.message : String(error);
+    console.error(chalk4.red(`Error: ${message}`)), process.exit(1);
+  }
+}
+async function createSessionManager(parsed, cwd, sessionDir, settingsManager, startupView) {
+  if (parsed.noSession || parsed.help || parsed.listModels !== void 0)
+    return SessionManager.inMemory(cwd, parsed.sessionId !== void 0 ? { id: parsed.sessionId } : void 0);
+  if (parsed.fork) {
+    parsed.sessionId && await findLocalSessionByExactId(parsed.sessionId, cwd, sessionDir) && (console.error(chalk4.red(`Session already exists with id '${parsed.sessionId}'`)), process.exit(1));
+    let resolved = await resolveSessionPath(parsed.fork, cwd, sessionDir);
+    switch (resolved.type) {
+      case "path":
+      case "local":
+      case "global":
+        return forkSessionOrExit(resolved.path, cwd, sessionDir, parsed.sessionId);
+      case "not_found":
+        console.error(chalk4.red(`No session found matching '${resolved.arg}'`)), process.exit(1);
+    }
+  }
+  if (parsed.session) {
+    let resolved = await resolveSessionPath(parsed.session, cwd, sessionDir);
+    switch (resolved.type) {
+      case "path":
+      case "local":
+        return openSessionOrExit(resolved.path, sessionDir);
+      case "global":
+        return console.log(chalk4.yellow(`Session found in different project: ${resolved.cwd}`)), await promptConfirm("Fork this session into current directory?", startupView) || (console.log(chalk4.dim("Aborted.")), process.exit(0)), forkSessionOrExit(resolved.path, cwd, sessionDir);
+      case "not_found":
+        console.error(chalk4.red(`No session found matching '${resolved.arg}'`)), process.exit(1);
+    }
+  }
+  if (parsed.resume)
+    try {
+      let currentSessionsLoader = (onProgress) => SessionManager.list(cwd, sessionDir, onProgress), allSessionsLoader = (onProgress) => SessionManager.listAll(sessionDir, onProgress), selectedPath = startupView ? await startupView.selectSession(currentSessionsLoader, allSessionsLoader) : await selectSession(currentSessionsLoader, allSessionsLoader, settingsManager);
+      return selectedPath || (console.log(chalk4.dim("No session selected")), process.exit(0)), SessionManager.open(selectedPath, sessionDir);
+    } finally {
+      stopThemeWatcher();
+    }
+  if (parsed.continue)
+    return SessionManager.continueRecent(cwd, sessionDir);
+  if (parsed.sessionId) {
+    let existingSession = await findLocalSessionByExactId(parsed.sessionId, cwd, sessionDir);
+    if (existingSession)
+      return SessionManager.open(existingSession.path, sessionDir);
+    console.error(chalk4.yellow(`Warning: No project session found with id '${parsed.sessionId}'; creating a new session with that id.`));
+  }
+  return SessionManager.create(cwd, sessionDir, { id: parsed.sessionId });
+}
+function buildSessionOptions(parsed, scopedModels, hasExistingSession, modelRuntime, settingsManager) {
+  let options = {}, diagnostics = [], cliThinkingFromModel = !1;
+  if (parsed.model) {
+    let resolved = resolveCliModel({
+      cliProvider: parsed.provider,
+      cliModel: parsed.model,
+      cliThinking: parsed.thinking,
+      modelRuntime
+    });
+    resolved.warning && diagnostics.push({ type: "warning", message: resolved.warning }), resolved.error && diagnostics.push({ type: "error", message: resolved.error }), resolved.model && (options.model = resolved.model, !parsed.thinking && resolved.thinkingLevel && (options.thinkingLevel = resolved.thinkingLevel, cliThinkingFromModel = !0));
+  }
+  if (!options.model && scopedModels.length > 0 && !hasExistingSession) {
+    let savedProvider = settingsManager.getDefaultProvider(), savedModelId = settingsManager.getDefaultModel(), savedModel = savedProvider && savedModelId ? modelRuntime.getModel(savedProvider, savedModelId) : void 0, savedInScope = savedModel ? scopedModels.find((sm) => modelsAreEqual(sm.model, savedModel)) : void 0;
+    savedInScope ? (options.model = savedInScope.model, !parsed.thinking && savedInScope.thinkingLevel && (options.thinkingLevel = savedInScope.thinkingLevel)) : (options.model = scopedModels[0].model, !parsed.thinking && scopedModels[0].thinkingLevel && (options.thinkingLevel = scopedModels[0].thinkingLevel));
+  }
+  return parsed.thinking && (options.thinkingLevel = parsed.thinking), scopedModels.length > 0 && (options.scopedModels = scopedModels.map((sm) => ({
+    model: sm.model,
+    thinkingLevel: sm.thinkingLevel
+  }))), parsed.noTools ? options.noTools = "all" : parsed.noBuiltinTools && (options.noTools = "builtin"), parsed.tools && (options.tools = [...parsed.tools]), parsed.excludeTools && (options.excludeTools = [...parsed.excludeTools]), { options, cliThinkingFromModel, diagnostics };
+}
+function resolveCliPaths(cwd, paths) {
+  return paths?.map((value) => isLocalPath(value) ? resolvePath(value, cwd) : value);
+}
+function createStartupViewTrustContext(cwd, startupView) {
+  return {
+    cwd,
+    mode: "tui",
+    hasUI: !0,
+    ui: {
+      select: (title, options) => startupView.select(title, options.map((option) => ({ label: option, value: option }))),
+      confirm: (title, message) => startupView.confirm(title, message),
+      input: (title, placeholder) => startupView.input(title, placeholder),
+      notify: () => {
+      }
+    }
+  };
+}
+async function promptForMissingSessionCwd(issue, settingsManager, startupView) {
+  let options = [
+    { label: "Continue", value: issue.fallbackCwd },
+    { label: "Cancel", value: void 0 }
+  ];
+  return startupView ? startupView.select(formatMissingSessionCwdPrompt(issue), options) : showStartupSelector(settingsManager, formatMissingSessionCwdPrompt(issue), options);
+}
+async function main(args, options) {
+  resetTimings(), (args.includes("--offline") || isTruthyEnvFlag(process.env.PI_OFFLINE)) && (process.env.PI_OFFLINE = "1");
+  let cwd = process.cwd(), agentDir = getAgentDir(), bootstrapSettingsManager = SettingsManager.create(cwd, agentDir, { projectTrusted: !1 });
+  if (applyHttpProxySettings(bootstrapSettingsManager.getGlobalSettings().httpProxy), configureHttpDispatcher(), ["setup", "features", "uninstall"].includes(args[0])) {
+    let { handleInstallCli } = await import("./install-cli-EXMJQESX.js");
+    if (await handleInstallCli(args))
+      return;
+  }
+  if (args[0] === "update") {
+    let { handleUpdateCli } = await import("./update-cli-L3JIBH2U.js");
+    if (await handleUpdateCli(args))
+      return;
+  }
+  if (["install", "remove", "uninstall", "list", "config"].includes(args[0])) {
+    let { handleConfigCommand, handlePackageCommand } = await import("./package-manager-cli-7RKSZGEN.js");
+    if (await handlePackageCommand(args, { extensionFactories: options?.extensionFactories })) {
+      process.exit(process.exitCode ?? 0);
+      return;
+    }
+    if (await handleConfigCommand(args, { extensionFactories: options?.extensionFactories }))
+      return;
+  }
+  if (args[0] === "gateway") {
+    let { handleGatewayCommand } = await import("./command-AAV3YRR5.js");
+    if (await handleGatewayCommand(args))
+      return;
+  }
+  let parsed = parseArgs(args);
+  if (parsed.diagnostics.length > 0) {
+    for (let d of parsed.diagnostics) {
+      let color = d.type === "error" ? chalk4.red : chalk4.yellow;
+      console.error(color(`${d.type === "error" ? "Error" : "Warning"}: ${d.message}`));
+    }
+    parsed.diagnostics.some((d) => d.type === "error") && process.exit(1);
+  }
+  if (time("parseArgs"), parsed.version && (console.log(VERSION), process.exit(0)), parsed.export) {
+    let result;
+    try {
+      let { exportFromFile } = await import("./export-html-TEXVV5RP.js"), outputPath = parsed.messages.length > 0 ? parsed.messages[0] : void 0;
+      result = await exportFromFile(parsed.export, outputPath);
+    } catch (error) {
+      let message = error instanceof Error ? error.message : "Failed to export session";
+      console.error(chalk4.red(`Error: ${message}`)), process.exit(1);
+    }
+    console.log(`Exported to: ${result}`), process.exit(0);
+  }
+  let appMode = resolveAppMode(parsed, process.stdin.isTTY, process.stdout.isTTY), interactiveModeImport = appMode === "interactive" ? import("./interactive-mode-2SZUO53H.js") : void 0, startupView = appMode === "interactive" ? options?.startupView : void 0;
+  options?.startupView && !startupView && options.startupView.stop(), applyInheritedSubagentPermissions(), appMode !== "interactive" && !isPlainRuntimeMetadataCommand(parsed) && takeOverStdout(), parsed.mode === "rpc" && parsed.fileArgs.length > 0 && (console.error(chalk4.red("Error: @file arguments are not supported in RPC mode")), process.exit(1)), validateForkFlags(parsed), validateSessionIdFlags(parsed);
+  let { migratedAuthProviders: migratedProviders, deprecationWarnings } = runMigrations(cwd);
+  time("runMigrations");
+  let startupSettingsManager = SettingsManager.create(cwd, agentDir);
+  reportDiagnostics(collectSettingsDiagnostics(startupSettingsManager, "startup session lookup")), registerModelTierBridge(startupSettingsManager), registerMemoryCapBridge(startupSettingsManager), registerCustomizeBridge(startupSettingsManager), appMode === "interactive" && !parsed.help && parsed.listModels === void 0 && shouldRunFirstTimeSetup() && (startupView?.pause(), await showFirstTimeSetup(startupSettingsManager), startupView?.resume(), time("firstTimeSetup"));
+  let envSessionDir = process.env[ENV_SESSION_DIR], sessionDir = (parsed.sessionDir ? normalizePath(parsed.sessionDir) : void 0) ?? (envSessionDir ? expandTildePath(envSessionDir) : void 0) ?? startupSettingsManager.getSessionDir(), sessionManager = await createSessionManager(parsed, cwd, sessionDir, startupSettingsManager, startupView), missingSessionCwdIssue = getMissingSessionCwdIssue(sessionManager, cwd);
+  if (missingSessionCwdIssue)
+    if (appMode === "interactive") {
+      let selectedCwd = await promptForMissingSessionCwd(missingSessionCwdIssue, startupSettingsManager, startupView);
+      selectedCwd || process.exit(0), sessionManager = SessionManager.open(missingSessionCwdIssue.sessionFile, sessionDir, selectedCwd);
+    } else
+      console.error(chalk4.red(new MissingSessionCwdError(missingSessionCwdIssue).message)), process.exit(1);
+  if (parsed.name !== void 0) {
+    let name = parsed.name.trim();
+    name || (console.error(chalk4.red("Error: --name requires a non-empty value")), process.exit(1)), sessionManager.appendSessionInfo(name);
+  }
+  time("createSessionManager");
+  let runSessionRetention = async () => {
+    try {
+      let retentionDays = startupSettingsManager.getSessionRetentionDays();
+      if (retentionDays <= 0)
+        return;
+      let activeSessionFile = sessionManager.getSessionFile(), { deleted } = await pruneOldSessions(getSessionsDir(), retentionDays, {
+        excludeFile: activeSessionFile
+      });
+      if (sessionDir) {
+        let extra = await pruneOldSessions(sessionDir, retentionDays, { excludeFile: activeSessionFile });
+        deleted.push(...extra.deleted);
+      }
+      deleted.length > 0 && appendDebugLog(`session-retention: deleted ${deleted.length} file(s):
+${deleted.map((path) => `  ${path}`).join(`
+`)}`);
+    } catch (error) {
+      appendDebugLog(`session-retention: prune failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }, trustStore = new ProjectTrustStore(agentDir), sessionCwd = sessionManager.getCwd(), autoTrustOnReloadCwd = parsed.projectTrustOverride === void 0 && !hasTrustRequiringProjectResources(sessionCwd) ? sessionCwd : void 0, trustPromptMode = parsed.help || parsed.listModels !== void 0 ? "print" : appMode, projectTrustByCwd = /* @__PURE__ */ new Map(), resolvedExtensionPaths = resolveCliPaths(cwd, parsed.extensions), resolvedSkillPaths = resolveCliPaths(cwd, parsed.skills), resolvedPromptTemplatePaths = resolveCliPaths(cwd, parsed.promptTemplates), resolvedThemePaths = resolveCliPaths(cwd, parsed.themes), builtinRoster = appMode === "interactive" ? [...lightBuiltinExtensions] : await loadAllBuiltinExtensions(), rememberAttachedFactories = (factories) => {
+    let seen = new Set(builtinRoster.map((entry) => typeof entry == "function" ? void 0 : entry.name).filter(Boolean));
+    for (let factory of factories) {
+      let name = typeof factory == "function" ? void 0 : factory.name;
+      name && seen.has(name) || (name && seen.add(name), builtinRoster.push(factory));
+    }
+  }, createRuntime = async ({ cwd: cwd2, agentDir: agentDir2, sessionManager: sessionManager2, sessionStartEvent, projectTrustContext }) => {
+    let isInitialRuntime = sessionStartEvent === void 0, projectTrustDiagnostics = [], cachedProjectTrust = projectTrustByCwd.get(cwd2), hasTrustRequiringResources = hasTrustRequiringProjectResources(cwd2), shouldResolveProjectTrust = parsed.projectTrustOverride === void 0 && cachedProjectTrust === void 0 && hasTrustRequiringResources, projectTrusted = shouldResolveProjectTrust ? !1 : cachedProjectTrust ?? parsed.projectTrustOverride ?? (!hasTrustRequiringResources || trustStore.get(cwd2) === !0), runtimeSettingsManager = SettingsManager.create(cwd2, agentDir2, { projectTrusted }), skipMissingPackageInstall = isInitialRuntime && appMode === "interactive", services2 = await createAgentSessionServices({
+      cwd: cwd2,
+      agentDir: agentDir2,
+      settingsManager: runtimeSettingsManager,
+      extensionFlagValues: parsed.unknownFlags,
+      resourceLoaderReloadOptions: shouldResolveProjectTrust ? {
+        skipMissingPackageInstall,
+        resolveProjectTrust: async ({ extensionsResult }) => {
+          let trusted = await resolveProjectTrusted({
+            cwd: cwd2,
+            trustStore,
+            trustOverride: parsed.projectTrustOverride,
+            defaultProjectTrust: startupSettingsManager.getDefaultProjectTrust(),
+            extensionsResult,
+            projectTrustContext: projectTrustContext ?? (isInitialRuntime && startupView ? createStartupViewTrustContext(cwd2, startupView) : createProjectTrustContext({
+              cwd: cwd2,
+              mode: isInitialRuntime ? trustPromptMode : appMode,
+              settingsManager: startupSettingsManager,
+              hasUI: isInitialRuntime && trustPromptMode === "interactive"
+            })),
+            onExtensionError: (message) => projectTrustDiagnostics.push({ type: "warning", message })
+          });
+          return projectTrustByCwd.set(cwd2, trusted), trusted;
+        }
+      } : skipMissingPackageInstall ? { skipMissingPackageInstall } : void 0,
+      resourceLoaderOptions: {
+        additionalExtensionPaths: resolvedExtensionPaths,
+        additionalSkillPaths: resolvedSkillPaths,
+        additionalPromptTemplatePaths: resolvedPromptTemplatePaths,
+        additionalThemePaths: resolvedThemePaths,
+        noExtensions: parsed.noExtensions,
+        noSkills: parsed.noSkills,
+        noPromptTemplates: parsed.noPromptTemplates,
+        noThemes: parsed.noThemes,
+        noContextFiles: parsed.noContextFiles,
+        systemPrompt: parsed.systemPrompt,
+        appendSystemPrompt: parsed.appendSystemPrompt,
+        extensionFactories: [...builtinRoster, ...options?.extensionFactories ?? []]
+      }
+    }), { settingsManager: settingsManager2, modelRuntime: modelRuntime2, resourceLoader: resourceLoader2 } = services2;
+    parsed.model && !resolveCliModel({
+      cliProvider: parsed.provider,
+      cliModel: parsed.model,
+      cliThinking: parsed.thinking,
+      modelRuntime: modelRuntime2
+    }).model && await modelRuntime2.refreshIfStale();
+    let diagnostics = [
+      ...projectTrustDiagnostics,
+      ...services2.diagnostics,
+      ...collectSettingsDiagnostics(settingsManager2, "runtime creation"),
+      ...resourceLoader2.getExtensions().errors.map(({ path, error }) => ({
+        type: "error",
+        message: `Failed to load extension "${path}": ${error}`
+      }))
+    ], modelPatterns = parsed.models ?? settingsManager2.getEnabledModels(), scopedModels = modelPatterns && modelPatterns.length > 0 ? await resolveModelScope(modelPatterns, modelRuntime2) : [], { options: sessionOptions, cliThinkingFromModel, diagnostics: sessionOptionDiagnostics } = buildSessionOptions(parsed, scopedModels, sessionManager2.buildSessionContext().messages.length > 0, modelRuntime2, settingsManager2);
+    diagnostics.push(...sessionOptionDiagnostics), parsed.apiKey && (sessionOptions.model ? await modelRuntime2.setRuntimeApiKey(sessionOptions.model.provider, parsed.apiKey, {
+      allowNetwork: !1
+    }) : diagnostics.push({
+      type: "error",
+      message: "--api-key requires a model to be specified via --model, --provider/--model, or --models"
+    }));
+    let created = await createAgentSessionFromServices({
+      services: services2,
+      sessionManager: sessionManager2,
+      sessionStartEvent,
+      model: sessionOptions.model,
+      thinkingLevel: sessionOptions.thinkingLevel,
+      scopedModels: sessionOptions.scopedModels,
+      tools: sessionOptions.tools,
+      excludeTools: sessionOptions.excludeTools,
+      noTools: sessionOptions.noTools,
+      customTools: sessionOptions.customTools
+    }), cliThinkingOverride = parsed.thinking !== void 0 || cliThinkingFromModel;
+    return created.session.model && cliThinkingOverride && created.session.setThinkingLevel(created.session.thinkingLevel), {
+      ...created,
+      services: services2,
+      diagnostics
+    };
+  };
+  time("createRuntime");
+  let runtime = await createAgentSessionRuntime(createRuntime, {
+    cwd: sessionManager.getCwd(),
+    agentDir,
+    sessionManager,
+    onRuntimeApplied: bindRuntimeBridges
+  });
+  if (startupView?.isExitRequested) {
+    await runtime.dispose();
+    return;
+  }
+  markStartupMilestone("runtime_hydrated"), time("createAgentSessionRuntime"), appMode !== "interactive" && await runSessionRetention();
+  let { services, session, modelFallbackMessage } = runtime, { settingsManager, modelRuntime, resourceLoader } = services;
+  if (applyHttpProxySettings(settingsManager.getGlobalSettings().httpProxy), configureHttpDispatcher(settingsManager.getHttpIdleTimeoutMs()), parsed.help) {
+    let extensionFlags = resourceLoader.getExtensions().extensions.flatMap((extension) => Array.from(extension.flags.values()));
+    printHelp(extensionFlags), process.exit(0);
+  }
+  if (parsed.listModels !== void 0) {
+    let searchPattern = typeof parsed.listModels == "string" ? parsed.listModels : void 0;
+    await listModels(modelRuntime, searchPattern), process.exit(0);
+  }
+  let stdinContent, startupBenchmark = isTruthyEnvFlag(process.env.PI_STARTUP_BENCHMARK);
+  appMode !== "rpc" && !startupBenchmark && (stdinContent = await readPipedStdin(), stdinContent !== void 0 && appMode === "interactive" && (appMode = "print")), time("readPipedStdin");
+  let { initialMessage, initialImages } = await prepareInitialMessage(parsed, settingsManager.getImageAutoResize(), stdinContent);
+  if (time("prepareInitialMessage"), initTheme(settingsManager.getTheme(), appMode === "interactive"), time("initTheme"), appMode === "interactive" && !startupView && deprecationWarnings.length > 0 && await showDeprecationWarnings(deprecationWarnings), time("resolveModelScope"), appMode === "interactive" && startupView || reportDiagnostics(runtime.diagnostics), runtime.diagnostics.some((diagnostic) => diagnostic.type === "error")) {
+    let extensionHint = runtime.diagnostics.some((diagnostic) => diagnostic.message.includes("Failed to load extension")) ? `
+${EXTENSION_LOAD_FAILURE_HINT}` : "";
+    if (startupView) {
+      process.exitCode = 1, await startupView.fail(`${runtime.diagnostics.map((diagnostic) => diagnostic.message).join(`
+`)}${extensionHint}`);
+      return;
+    }
+    extensionHint && console.error(chalk4.yellow(EXTENSION_LOAD_FAILURE_HINT)), process.exit(1);
+  }
+  if (time("createAgentSession"), appMode !== "interactive" && !session.model && (console.error(chalk4.red(formatNoModelsAvailableMessage())), process.exit(1)), startupBenchmark && appMode !== "interactive" && (console.error(chalk4.red("Error: PI_STARTUP_BENCHMARK only supports interactive mode")), process.exit(1)), appMode === "rpc") {
+    let { runRpcMode } = await import("./rpc-mode-W5ZTLTMZ.js");
+    printTimings(), await runRpcMode(runtime);
+  } else if (appMode === "interactive") {
+    let [{ InteractiveMode }, { loadDeferredBuiltinExtensions }] = await Promise.all([
+      interactiveModeImport,
+      import("./builtin-extensions-QATGXENO.js")
+    ]), interactiveMode = new InteractiveMode(runtime, {
+      migratedProviders,
+      modelFallbackMessage,
+      autoTrustOnReloadCwd,
+      initialMessage,
+      initialImages,
+      initialMessages: parsed.messages,
+      verbose: parsed.verbose,
+      deprecationWarnings: startupView ? deprecationWarnings : void 0,
+      startupDiagnostics: startupView ? runtime.diagnostics.filter((diagnostic) => diagnostic.type !== "error") : void 0,
+      startupView: startupView?.binding(),
+      deferredMaintenance: runSessionRetention,
+      deferredBuiltinFactories: parsed.noExtensions ? void 0 : loadDeferredBuiltinExtensions,
+      onDeferredBuiltinsAttached: rememberAttachedFactories
+    });
+    if (startupBenchmark) {
+      let { prepareBenchmarkRequest } = await import("./benchmark-request-UC7PD3V3.js"), request = await prepareBenchmarkRequest(session);
+      await interactiveMode.init(), time("interactiveMode.init"), await interactiveMode.waitForStartupReady(), time("promptBarrier"), await request(), await new Promise((resolve3) => setTimeout(resolve3, 150)), interactiveMode.stop(), await runtime.dispose(), stopThemeWatcher(), printTimings(), process.stdout.writableLength > 0 && await new Promise((resolve3) => process.stdout.once("drain", resolve3)), process.stderr.writableLength > 0 && await new Promise((resolve3) => process.stderr.once("drain", resolve3));
+      return;
+    }
+    await interactiveMode.init(), time("interactiveMode.init"), printTimings(), await interactiveMode.run();
+  } else {
+    let { runPrintMode } = await import("./print-mode-XSFM26EL.js");
+    printTimings();
+    let exitCode = await runPrintMode(runtime, {
+      mode: toPrintOutputMode(appMode),
+      messages: parsed.messages,
+      initialMessage,
+      initialImages
+    });
+    stopThemeWatcher(), restoreStdout(), exitCode !== 0 && (process.exitCode = exitCode);
+    return;
+  }
+}
+
+export {
+  readPipedStdin,
+  main
+};