1047 lines
33 KiB
TypeScript
1047 lines
33 KiB
TypeScript
/**
|
|
* Main entry point for the coding agent CLI.
|
|
*
|
|
* This file handles CLI argument parsing and translates them into
|
|
* createAgentSession() options. The SDK does the heavy lifting.
|
|
*/
|
|
|
|
import { createInterface } from "node:readline";
|
|
import { type ImageContent, modelsAreEqual } from "@earendil-works/pi-ai";
|
|
import { ProcessTerminal, setKeybindings, TUI } from "@earendil-works/pi-tui";
|
|
import chalk from "chalk";
|
|
import { type Args, type Mode, parseArgs, printHelp } from "./cli/args.ts";
|
|
import { processFileArguments } from "./cli/file-processor.ts";
|
|
import { buildInitialMessage } from "./cli/initial-message.ts";
|
|
import { listModels } from "./cli/list-models.ts";
|
|
import { selectSession } from "./cli/session-picker.ts";
|
|
import { ENV_SESSION_DIR, expandTildePath, getAgentDir, getPackageDir, VERSION } from "./config.ts";
|
|
import { type CreateAgentSessionRuntimeFactory, createAgentSessionRuntime } from "./core/agent-session-runtime.ts";
|
|
import {
|
|
type AgentSessionRuntimeDiagnostic,
|
|
createAgentSessionFromServices,
|
|
createAgentSessionServices,
|
|
} from "./core/agent-session-services.ts";
|
|
import { formatNoModelsAvailableMessage } from "./core/auth-guidance.ts";
|
|
import { AuthStorage } from "./core/auth-storage.ts";
|
|
import { exportFromFile } from "./core/export-html/index.ts";
|
|
import { emitProjectTrustEvent } from "./core/extensions/runner.ts";
|
|
import type { ExtensionFactory, LoadExtensionsResult, ProjectTrustContext } from "./core/extensions/types.ts";
|
|
import { configureHttpDispatcher } from "./core/http-dispatcher.ts";
|
|
import { KeybindingsManager } from "./core/keybindings.ts";
|
|
import type { ModelRegistry } from "./core/model-registry.ts";
|
|
import { resolveCliModel, resolveModelScope, type ScopedModel } from "./core/model-resolver.ts";
|
|
import { restoreStdout, takeOverStdout } from "./core/output-guard.ts";
|
|
import type { CreateAgentSessionOptions } from "./core/sdk.ts";
|
|
import {
|
|
formatMissingSessionCwdPrompt,
|
|
getMissingSessionCwdIssue,
|
|
MissingSessionCwdError,
|
|
type SessionCwdIssue,
|
|
} from "./core/session-cwd.ts";
|
|
import { assertValidSessionId, SessionManager } from "./core/session-manager.ts";
|
|
import { SettingsManager } from "./core/settings-manager.ts";
|
|
import { printTimings, resetTimings, time } from "./core/timings.ts";
|
|
import { hasProjectTrustInputs, ProjectTrustStore } from "./core/trust-manager.ts";
|
|
import { runMigrations, showDeprecationWarnings } from "./migrations.ts";
|
|
import { InteractiveMode, runPrintMode, runRpcMode } from "./modes/index.ts";
|
|
import { ExtensionInputComponent } from "./modes/interactive/components/extension-input.ts";
|
|
import { ExtensionSelectorComponent } from "./modes/interactive/components/extension-selector.ts";
|
|
import { initTheme, stopThemeWatcher } from "./modes/interactive/theme/theme.ts";
|
|
import { handleConfigCommand, handlePackageCommand } from "./package-manager-cli.ts";
|
|
import { isLocalPath, normalizePath, resolvePath } from "./utils/paths.ts";
|
|
import { cleanupWindowsSelfUpdateQuarantine } from "./utils/windows-self-update.ts";
|
|
|
|
/**
|
|
* Read all content from piped stdin.
|
|
* Returns undefined if stdin is a TTY (interactive terminal).
|
|
*/
|
|
async function readPipedStdin(): Promise<string | undefined> {
|
|
// If stdin is a TTY, we're running interactively - don't read stdin
|
|
if (process.stdin.isTTY) {
|
|
return undefined;
|
|
}
|
|
|
|
return new Promise((resolve) => {
|
|
let data = "";
|
|
process.stdin.setEncoding("utf8");
|
|
process.stdin.on("data", (chunk) => {
|
|
data += chunk;
|
|
});
|
|
process.stdin.on("end", () => {
|
|
resolve(data.trim() || undefined);
|
|
});
|
|
process.stdin.resume();
|
|
});
|
|
}
|
|
|
|
function collectSettingsDiagnostics(
|
|
settingsManager: SettingsManager,
|
|
context: string,
|
|
): AgentSessionRuntimeDiagnostic[] {
|
|
return settingsManager.drainErrors().map(({ scope, error }) => ({
|
|
type: "warning",
|
|
message: `(${context}, ${scope} settings) ${error.message}`,
|
|
}));
|
|
}
|
|
|
|
function reportDiagnostics(diagnostics: readonly AgentSessionRuntimeDiagnostic[]): void {
|
|
for (const diagnostic of diagnostics) {
|
|
const color = diagnostic.type === "error" ? chalk.red : diagnostic.type === "warning" ? chalk.yellow : chalk.dim;
|
|
const prefix = diagnostic.type === "error" ? "Error: " : diagnostic.type === "warning" ? "Warning: " : "";
|
|
console.error(color(`${prefix}${diagnostic.message}`));
|
|
}
|
|
}
|
|
|
|
function isTruthyEnvFlag(value: string | undefined): boolean {
|
|
if (!value) return false;
|
|
return value === "1" || value.toLowerCase() === "true" || value.toLowerCase() === "yes";
|
|
}
|
|
|
|
type AppMode = "interactive" | "print" | "json" | "rpc";
|
|
|
|
function resolveAppMode(parsed: Args, stdinIsTTY: boolean): AppMode {
|
|
if (parsed.mode === "rpc") {
|
|
return "rpc";
|
|
}
|
|
if (parsed.mode === "json") {
|
|
return "json";
|
|
}
|
|
if (parsed.print || !stdinIsTTY) {
|
|
return "print";
|
|
}
|
|
return "interactive";
|
|
}
|
|
|
|
function toPrintOutputMode(appMode: AppMode): Exclude<Mode, "rpc"> {
|
|
return appMode === "json" ? "json" : "text";
|
|
}
|
|
|
|
async function prepareInitialMessage(
|
|
parsed: Args,
|
|
autoResizeImages: boolean,
|
|
stdinContent?: string,
|
|
): Promise<{
|
|
initialMessage?: string;
|
|
initialImages?: ImageContent[];
|
|
}> {
|
|
if (parsed.fileArgs.length === 0) {
|
|
return buildInitialMessage({ parsed, stdinContent });
|
|
}
|
|
|
|
const { text, images } = await processFileArguments(parsed.fileArgs, { autoResizeImages });
|
|
return buildInitialMessage({
|
|
parsed,
|
|
fileText: text,
|
|
fileImages: images,
|
|
stdinContent,
|
|
});
|
|
}
|
|
|
|
/** Result from resolving a session argument */
|
|
type ResolvedSession =
|
|
| { type: "path"; path: string } // Direct file path
|
|
| { type: "local"; path: string } // Found in current project
|
|
| { type: "global"; path: string; cwd: string } // Found in different project
|
|
| { type: "not_found"; arg: string }; // Not found anywhere
|
|
|
|
/**
|
|
* Resolve a session argument to a file path.
|
|
* If it looks like a path, use as-is. Otherwise try to match as session ID prefix.
|
|
*/
|
|
async function findLocalSessionByExactId(
|
|
sessionId: string,
|
|
cwd: string,
|
|
sessionDir?: string,
|
|
): Promise<{ type: "local"; path: string } | undefined> {
|
|
const localSessions = await SessionManager.list(cwd, sessionDir);
|
|
const localMatch = localSessions.find((s) => s.id === sessionId);
|
|
return localMatch ? { type: "local", path: localMatch.path } : undefined;
|
|
}
|
|
|
|
async function resolveSessionPath(sessionArg: string, cwd: string, sessionDir?: string): Promise<ResolvedSession> {
|
|
// If it looks like a file path, resolve it before handing it to the session manager.
|
|
if (sessionArg.includes("/") || sessionArg.includes("\\") || sessionArg.endsWith(".jsonl")) {
|
|
return { type: "path", path: resolvePath(sessionArg, cwd) };
|
|
}
|
|
|
|
// Try to match as session ID in current project first
|
|
const localSessions = await SessionManager.list(cwd, sessionDir);
|
|
const localMatch =
|
|
localSessions.find((s) => s.id === sessionArg) ?? localSessions.find((s) => s.id.startsWith(sessionArg));
|
|
|
|
if (localMatch) {
|
|
return { type: "local", path: localMatch.path };
|
|
}
|
|
|
|
// Try global search across all projects
|
|
const allSessions = await SessionManager.listAll(sessionDir);
|
|
const globalMatch =
|
|
allSessions.find((s) => s.id === sessionArg) ?? allSessions.find((s) => s.id.startsWith(sessionArg));
|
|
|
|
if (globalMatch) {
|
|
return { type: "global", path: globalMatch.path, cwd: globalMatch.cwd };
|
|
}
|
|
|
|
// Not found anywhere
|
|
return { type: "not_found", arg: sessionArg };
|
|
}
|
|
|
|
/** Prompt user for yes/no confirmation */
|
|
async function promptConfirm(message: string): Promise<boolean> {
|
|
return new Promise((resolve) => {
|
|
const rl = createInterface({
|
|
input: process.stdin,
|
|
output: process.stdout,
|
|
});
|
|
rl.question(`${message} [y/N] `, (answer) => {
|
|
rl.close();
|
|
resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
|
|
});
|
|
});
|
|
}
|
|
|
|
function validateForkFlags(parsed: Args): void {
|
|
if (!parsed.fork) return;
|
|
|
|
const conflictingFlags = [
|
|
parsed.session ? "--session" : undefined,
|
|
parsed.continue ? "--continue" : undefined,
|
|
parsed.resume ? "--resume" : undefined,
|
|
parsed.noSession ? "--no-session" : undefined,
|
|
].filter((flag): flag is string => flag !== undefined);
|
|
|
|
if (conflictingFlags.length > 0) {
|
|
console.error(chalk.red(`Error: --fork cannot be combined with ${conflictingFlags.join(", ")}`));
|
|
process.exit(1);
|
|
}
|
|
}
|
|
|
|
function validateSessionIdFlags(parsed: Args): void {
|
|
if (parsed.sessionId === undefined) return;
|
|
|
|
const conflictingFlags = [
|
|
parsed.session ? "--session" : undefined,
|
|
parsed.continue ? "--continue" : undefined,
|
|
parsed.resume ? "--resume" : undefined,
|
|
parsed.noSession ? "--no-session" : undefined,
|
|
].filter((flag): flag is string => flag !== undefined);
|
|
|
|
if (conflictingFlags.length > 0) {
|
|
console.error(chalk.red(`Error: --session-id cannot be combined with ${conflictingFlags.join(", ")}`));
|
|
process.exit(1);
|
|
}
|
|
|
|
try {
|
|
assertValidSessionId(parsed.sessionId);
|
|
} catch (error: unknown) {
|
|
const message = error instanceof Error ? error.message : String(error);
|
|
console.error(chalk.red(`Error: ${message}`));
|
|
process.exit(1);
|
|
}
|
|
}
|
|
|
|
function forkSessionOrExit(sourcePath: string, cwd: string, sessionDir?: string, sessionId?: string): SessionManager {
|
|
try {
|
|
return SessionManager.forkFrom(sourcePath, cwd, sessionDir, { id: sessionId });
|
|
} catch (error: unknown) {
|
|
const message = error instanceof Error ? error.message : String(error);
|
|
console.error(chalk.red(`Error: ${message}`));
|
|
process.exit(1);
|
|
}
|
|
}
|
|
|
|
async function createSessionManager(
|
|
parsed: Args,
|
|
cwd: string,
|
|
sessionDir: string | undefined,
|
|
settingsManager: SettingsManager,
|
|
): Promise<SessionManager> {
|
|
if (parsed.noSession || parsed.help || parsed.listModels !== undefined) {
|
|
return SessionManager.inMemory(cwd);
|
|
}
|
|
|
|
if (parsed.fork) {
|
|
if (parsed.sessionId) {
|
|
const existingTarget = await findLocalSessionByExactId(parsed.sessionId, cwd, sessionDir);
|
|
if (existingTarget) {
|
|
console.error(chalk.red(`Session already exists with id '${parsed.sessionId}'`));
|
|
process.exit(1);
|
|
}
|
|
}
|
|
|
|
const 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(chalk.red(`No session found matching '${resolved.arg}'`));
|
|
process.exit(1);
|
|
}
|
|
}
|
|
|
|
if (parsed.session) {
|
|
const resolved = await resolveSessionPath(parsed.session, cwd, sessionDir);
|
|
|
|
switch (resolved.type) {
|
|
case "path":
|
|
case "local":
|
|
return SessionManager.open(resolved.path, sessionDir);
|
|
|
|
case "global": {
|
|
console.log(chalk.yellow(`Session found in different project: ${resolved.cwd}`));
|
|
const shouldFork = await promptConfirm("Fork this session into current directory?");
|
|
if (!shouldFork) {
|
|
console.log(chalk.dim("Aborted."));
|
|
process.exit(0);
|
|
}
|
|
return forkSessionOrExit(resolved.path, cwd, sessionDir);
|
|
}
|
|
|
|
case "not_found":
|
|
console.error(chalk.red(`No session found matching '${resolved.arg}'`));
|
|
process.exit(1);
|
|
}
|
|
}
|
|
|
|
if (parsed.resume) {
|
|
initTheme(settingsManager.getTheme(), true);
|
|
try {
|
|
const selectedPath = await selectSession(
|
|
(onProgress) => SessionManager.list(cwd, sessionDir, onProgress),
|
|
(onProgress) => SessionManager.listAll(sessionDir, onProgress),
|
|
);
|
|
if (!selectedPath) {
|
|
console.log(chalk.dim("No session selected"));
|
|
process.exit(0);
|
|
}
|
|
return SessionManager.open(selectedPath, sessionDir);
|
|
} finally {
|
|
stopThemeWatcher();
|
|
}
|
|
}
|
|
|
|
if (parsed.continue) {
|
|
return SessionManager.continueRecent(cwd, sessionDir);
|
|
}
|
|
|
|
if (parsed.sessionId) {
|
|
const existingSession = await findLocalSessionByExactId(parsed.sessionId, cwd, sessionDir);
|
|
if (existingSession) {
|
|
return SessionManager.open(existingSession.path, sessionDir);
|
|
}
|
|
}
|
|
|
|
return SessionManager.create(cwd, sessionDir, { id: parsed.sessionId });
|
|
}
|
|
|
|
function buildSessionOptions(
|
|
parsed: Args,
|
|
scopedModels: ScopedModel[],
|
|
hasExistingSession: boolean,
|
|
modelRegistry: ModelRegistry,
|
|
settingsManager: SettingsManager,
|
|
): {
|
|
options: CreateAgentSessionOptions;
|
|
cliThinkingFromModel: boolean;
|
|
diagnostics: AgentSessionRuntimeDiagnostic[];
|
|
} {
|
|
const options: CreateAgentSessionOptions = {};
|
|
const diagnostics: AgentSessionRuntimeDiagnostic[] = [];
|
|
let cliThinkingFromModel = false;
|
|
|
|
// Model from CLI
|
|
// - supports --provider <name> --model <pattern>
|
|
// - supports --model <provider>/<pattern>
|
|
if (parsed.model) {
|
|
const resolved = resolveCliModel({
|
|
cliProvider: parsed.provider,
|
|
cliModel: parsed.model,
|
|
modelRegistry,
|
|
});
|
|
if (resolved.warning) {
|
|
diagnostics.push({ type: "warning", message: resolved.warning });
|
|
}
|
|
if (resolved.error) {
|
|
diagnostics.push({ type: "error", message: resolved.error });
|
|
}
|
|
if (resolved.model) {
|
|
options.model = resolved.model;
|
|
// Allow "--model <pattern>:<thinking>" as a shorthand.
|
|
// Explicit --thinking still takes precedence (applied later).
|
|
if (!parsed.thinking && resolved.thinkingLevel) {
|
|
options.thinkingLevel = resolved.thinkingLevel;
|
|
cliThinkingFromModel = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!options.model && scopedModels.length > 0 && !hasExistingSession) {
|
|
// Check if saved default is in scoped models - use it if so, otherwise first scoped model
|
|
const savedProvider = settingsManager.getDefaultProvider();
|
|
const savedModelId = settingsManager.getDefaultModel();
|
|
const savedModel = savedProvider && savedModelId ? modelRegistry.find(savedProvider, savedModelId) : undefined;
|
|
const savedInScope = savedModel ? scopedModels.find((sm) => modelsAreEqual(sm.model, savedModel)) : undefined;
|
|
|
|
if (savedInScope) {
|
|
options.model = savedInScope.model;
|
|
// Use thinking level from scoped model config if explicitly set
|
|
if (!parsed.thinking && savedInScope.thinkingLevel) {
|
|
options.thinkingLevel = savedInScope.thinkingLevel;
|
|
}
|
|
} else {
|
|
options.model = scopedModels[0].model;
|
|
// Use thinking level from first scoped model if explicitly set
|
|
if (!parsed.thinking && scopedModels[0].thinkingLevel) {
|
|
options.thinkingLevel = scopedModels[0].thinkingLevel;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Thinking level from CLI (takes precedence over scoped model thinking levels set above)
|
|
if (parsed.thinking) {
|
|
options.thinkingLevel = parsed.thinking;
|
|
}
|
|
|
|
// Scoped models for Ctrl+P cycling
|
|
// Keep thinking level undefined when not explicitly set in the model pattern.
|
|
// Undefined means "inherit current session thinking level" during cycling.
|
|
if (scopedModels.length > 0) {
|
|
options.scopedModels = scopedModels.map((sm) => ({
|
|
model: sm.model,
|
|
thinkingLevel: sm.thinkingLevel,
|
|
}));
|
|
}
|
|
|
|
// API key from CLI - set in authStorage
|
|
// (handled by caller before createAgentSession)
|
|
|
|
// Tools
|
|
if (parsed.noTools) {
|
|
options.noTools = "all";
|
|
} else if (parsed.noBuiltinTools) {
|
|
options.noTools = "builtin";
|
|
}
|
|
if (parsed.tools) {
|
|
options.tools = [...parsed.tools];
|
|
}
|
|
if (parsed.excludeTools) {
|
|
options.excludeTools = [...parsed.excludeTools];
|
|
}
|
|
|
|
return { options, cliThinkingFromModel, diagnostics };
|
|
}
|
|
|
|
function resolveCliPaths(cwd: string, paths: string[] | undefined): string[] | undefined {
|
|
return paths?.map((value) => (isLocalPath(value) ? resolvePath(value, cwd) : value));
|
|
}
|
|
|
|
function createStartupTui(settingsManager: SettingsManager): TUI {
|
|
initTheme(settingsManager.getTheme());
|
|
setKeybindings(KeybindingsManager.create());
|
|
const ui = new TUI(new ProcessTerminal(), settingsManager.getShowHardwareCursor());
|
|
ui.setClearOnShrink(settingsManager.getClearOnShrink());
|
|
return ui;
|
|
}
|
|
|
|
async function clearStartupTui(ui: TUI): Promise<void> {
|
|
ui.clear();
|
|
ui.requestRender();
|
|
await new Promise((resolve) => setTimeout(resolve, 25));
|
|
}
|
|
|
|
async function showStartupSelector<T>(
|
|
settingsManager: SettingsManager,
|
|
title: string,
|
|
options: Array<{ label: string; value: T }>,
|
|
): Promise<T | undefined> {
|
|
return new Promise((resolve) => {
|
|
const ui = createStartupTui(settingsManager);
|
|
|
|
let settled = false;
|
|
const finish = async (result: T | undefined) => {
|
|
if (settled) {
|
|
return;
|
|
}
|
|
settled = true;
|
|
await clearStartupTui(ui);
|
|
ui.stop();
|
|
resolve(result);
|
|
};
|
|
|
|
const selector = new ExtensionSelectorComponent(
|
|
title,
|
|
options.map((option) => option.label),
|
|
(option) => void finish(options.find((entry) => entry.label === option)?.value),
|
|
() => void finish(undefined),
|
|
{ tui: ui },
|
|
);
|
|
ui.addChild(selector);
|
|
ui.setFocus(selector);
|
|
ui.start();
|
|
});
|
|
}
|
|
|
|
async function showStartupInput(
|
|
settingsManager: SettingsManager,
|
|
title: string,
|
|
placeholder?: string,
|
|
): Promise<string | undefined> {
|
|
return new Promise((resolve) => {
|
|
const ui = createStartupTui(settingsManager);
|
|
|
|
let settled = false;
|
|
const finish = async (result: string | undefined) => {
|
|
if (settled) {
|
|
return;
|
|
}
|
|
settled = true;
|
|
input.dispose();
|
|
await clearStartupTui(ui);
|
|
ui.stop();
|
|
resolve(result);
|
|
};
|
|
|
|
const input = new ExtensionInputComponent(
|
|
title,
|
|
placeholder,
|
|
(value) => void finish(value),
|
|
() => void finish(undefined),
|
|
{
|
|
tui: ui,
|
|
},
|
|
);
|
|
ui.addChild(input);
|
|
ui.setFocus(input);
|
|
ui.start();
|
|
});
|
|
}
|
|
|
|
async function promptForMissingSessionCwd(
|
|
issue: SessionCwdIssue,
|
|
settingsManager: SettingsManager,
|
|
): Promise<string | undefined> {
|
|
return showStartupSelector(settingsManager, formatMissingSessionCwdPrompt(issue), [
|
|
{ label: "Continue", value: issue.fallbackCwd },
|
|
{ label: "Cancel", value: undefined },
|
|
]);
|
|
}
|
|
|
|
interface ProjectTrustPromptResult {
|
|
trusted: boolean;
|
|
remember: boolean;
|
|
}
|
|
|
|
const PROJECT_TRUST_PROMPT_OPTIONS: Array<{ label: string; value: ProjectTrustPromptResult }> = [
|
|
{ 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 } },
|
|
];
|
|
|
|
function formatProjectTrustPrompt(cwd: string): string {
|
|
return `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.`;
|
|
}
|
|
|
|
async function promptForProjectTrust(
|
|
cwd: string,
|
|
settingsManager: SettingsManager,
|
|
): Promise<ProjectTrustPromptResult | undefined> {
|
|
return showStartupSelector(settingsManager, formatProjectTrustPrompt(cwd), PROJECT_TRUST_PROMPT_OPTIONS);
|
|
}
|
|
|
|
async function promptForProjectTrustWithContext(
|
|
cwd: string,
|
|
ctx: ProjectTrustContext,
|
|
): Promise<ProjectTrustPromptResult | undefined> {
|
|
const selected = await ctx.ui.select(
|
|
formatProjectTrustPrompt(cwd),
|
|
PROJECT_TRUST_PROMPT_OPTIONS.map((option) => option.label),
|
|
);
|
|
return PROJECT_TRUST_PROMPT_OPTIONS.find((option) => option.label === selected)?.value;
|
|
}
|
|
|
|
function createProjectTrustContext(options: {
|
|
cwd: string;
|
|
mode: AppMode;
|
|
settingsManager: SettingsManager;
|
|
hasUI: boolean;
|
|
}): ProjectTrustContext {
|
|
return {
|
|
cwd: options.cwd,
|
|
mode: options.mode === "interactive" ? "tui" : options.mode,
|
|
hasUI: options.hasUI,
|
|
ui: {
|
|
select: async (title, selectOptions) => {
|
|
if (!options.hasUI) {
|
|
return undefined;
|
|
}
|
|
if (options.mode !== "interactive") {
|
|
return undefined;
|
|
}
|
|
return showStartupSelector(
|
|
options.settingsManager,
|
|
title,
|
|
selectOptions.map((option) => ({ label: option, value: option })),
|
|
);
|
|
},
|
|
confirm: async (title, message) => {
|
|
if (!options.hasUI) {
|
|
return false;
|
|
}
|
|
if (options.mode !== "interactive") {
|
|
return false;
|
|
}
|
|
return (
|
|
(await showStartupSelector(options.settingsManager, `${title}\n${message}`, [
|
|
{ label: "Yes", value: true },
|
|
{ label: "No", value: false },
|
|
])) ?? false
|
|
);
|
|
},
|
|
input: async (title, placeholder) => {
|
|
if (!options.hasUI) {
|
|
return undefined;
|
|
}
|
|
if (options.mode !== "interactive") {
|
|
return undefined;
|
|
}
|
|
return showStartupInput(options.settingsManager, title, placeholder);
|
|
},
|
|
notify: (message, type = "info") => {
|
|
if (options.mode !== "interactive") {
|
|
const color = type === "error" ? chalk.red : type === "warning" ? chalk.yellow : chalk.cyan;
|
|
console.error(color(message));
|
|
}
|
|
},
|
|
},
|
|
};
|
|
}
|
|
|
|
async function resolveProjectTrusted(options: {
|
|
cwd: string;
|
|
trustStore: ProjectTrustStore;
|
|
trustOverride?: boolean;
|
|
appMode: AppMode;
|
|
settingsManagerForPrompt: SettingsManager;
|
|
extensionsResult?: LoadExtensionsResult;
|
|
projectTrustContext?: ProjectTrustContext;
|
|
onExtensionError?: (message: string) => void;
|
|
}): Promise<boolean> {
|
|
if (options.trustOverride !== undefined) {
|
|
return options.trustOverride;
|
|
}
|
|
if (!hasProjectTrustInputs(options.cwd)) {
|
|
return true;
|
|
}
|
|
|
|
if (options.extensionsResult && options.projectTrustContext) {
|
|
const { result, errors } = await emitProjectTrustEvent(
|
|
options.extensionsResult,
|
|
{ type: "project_trust", cwd: options.cwd },
|
|
options.projectTrustContext,
|
|
);
|
|
for (const error of errors) {
|
|
options.onExtensionError?.(`Extension "${error.extensionPath}" project_trust error: ${error.error}`);
|
|
}
|
|
if (result) {
|
|
const trusted = result.trusted === "yes";
|
|
if (result.remember === true) {
|
|
options.trustStore.set(options.cwd, trusted);
|
|
}
|
|
return trusted;
|
|
}
|
|
}
|
|
|
|
const decision = options.trustStore.get(options.cwd);
|
|
if (decision !== null) {
|
|
return decision;
|
|
}
|
|
if (options.projectTrustContext?.hasUI) {
|
|
const selected = await promptForProjectTrustWithContext(options.cwd, options.projectTrustContext);
|
|
if (selected !== undefined) {
|
|
if (selected.remember) {
|
|
options.trustStore.set(options.cwd, selected.trusted);
|
|
}
|
|
return selected.trusted;
|
|
}
|
|
return false;
|
|
}
|
|
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 interface MainOptions {
|
|
extensionFactories?: ExtensionFactory[];
|
|
}
|
|
|
|
export async function main(args: string[], options?: MainOptions) {
|
|
resetTimings();
|
|
const offlineMode = args.includes("--offline") || isTruthyEnvFlag(process.env.PI_OFFLINE);
|
|
if (offlineMode) {
|
|
process.env.PI_OFFLINE = "1";
|
|
process.env.PI_SKIP_VERSION_CHECK = "1";
|
|
}
|
|
|
|
if (process.platform === "win32") {
|
|
cleanupWindowsSelfUpdateQuarantine(getPackageDir());
|
|
}
|
|
|
|
if (await handlePackageCommand(args)) {
|
|
return;
|
|
}
|
|
|
|
if (await handleConfigCommand(args)) {
|
|
return;
|
|
}
|
|
|
|
const parsed = parseArgs(args);
|
|
if (parsed.diagnostics.length > 0) {
|
|
for (const d of parsed.diagnostics) {
|
|
const color = d.type === "error" ? chalk.red : chalk.yellow;
|
|
console.error(color(`${d.type === "error" ? "Error" : "Warning"}: ${d.message}`));
|
|
}
|
|
if (parsed.diagnostics.some((d) => d.type === "error")) {
|
|
process.exit(1);
|
|
}
|
|
}
|
|
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);
|
|
}
|
|
|
|
if (parsed.export) {
|
|
let result: string;
|
|
try {
|
|
const outputPath = parsed.messages.length > 0 ? parsed.messages[0] : undefined;
|
|
result = await exportFromFile(parsed.export, outputPath);
|
|
} catch (error: unknown) {
|
|
const message = error instanceof Error ? error.message : "Failed to export session";
|
|
console.error(chalk.red(`Error: ${message}`));
|
|
process.exit(1);
|
|
}
|
|
console.log(`Exported to: ${result}`);
|
|
process.exit(0);
|
|
}
|
|
|
|
if (parsed.mode === "rpc" && parsed.fileArgs.length > 0) {
|
|
console.error(chalk.red("Error: @file arguments are not supported in RPC mode"));
|
|
process.exit(1);
|
|
}
|
|
|
|
validateForkFlags(parsed);
|
|
validateSessionIdFlags(parsed);
|
|
|
|
// Run migrations (pass cwd for project-local migrations)
|
|
const { migratedAuthProviders: migratedProviders, deprecationWarnings } = runMigrations(process.cwd());
|
|
time("runMigrations");
|
|
|
|
const cwd = process.cwd();
|
|
const agentDir = getAgentDir();
|
|
const startupSettingsManager = SettingsManager.create(cwd, agentDir);
|
|
reportDiagnostics(collectSettingsDiagnostics(startupSettingsManager, "startup session lookup"));
|
|
|
|
// 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
|
|
// the target session cwd is known. The startup-cwd settings manager is used only for
|
|
// sessionDir lookup during session selection.
|
|
const envSessionDir = process.env[ENV_SESSION_DIR];
|
|
const sessionDir =
|
|
(parsed.sessionDir ? normalizePath(parsed.sessionDir) : undefined) ??
|
|
(envSessionDir ? expandTildePath(envSessionDir) : undefined) ??
|
|
startupSettingsManager.getSessionDir();
|
|
let sessionManager = await createSessionManager(parsed, cwd, sessionDir, startupSettingsManager);
|
|
const missingSessionCwdIssue = getMissingSessionCwdIssue(sessionManager, cwd);
|
|
if (missingSessionCwdIssue) {
|
|
if (appMode === "interactive") {
|
|
const selectedCwd = await promptForMissingSessionCwd(missingSessionCwdIssue, startupSettingsManager);
|
|
if (!selectedCwd) {
|
|
process.exit(0);
|
|
}
|
|
sessionManager = SessionManager.open(missingSessionCwdIssue.sessionFile!, sessionDir, selectedCwd);
|
|
} else {
|
|
console.error(chalk.red(new MissingSessionCwdError(missingSessionCwdIssue).message));
|
|
process.exit(1);
|
|
}
|
|
}
|
|
if (parsed.name !== undefined) {
|
|
const name = parsed.name.trim();
|
|
if (!name) {
|
|
console.error(chalk.red("Error: --name requires a non-empty value"));
|
|
process.exit(1);
|
|
}
|
|
sessionManager.appendSessionInfo(name);
|
|
}
|
|
time("createSessionManager");
|
|
|
|
const trustStore = new ProjectTrustStore(agentDir);
|
|
const sessionCwd = sessionManager.getCwd();
|
|
const autoTrustOnReloadCwd =
|
|
parsed.projectTrustOverride === undefined && !hasProjectTrustInputs(sessionCwd) ? sessionCwd : undefined;
|
|
const trustPromptMode: AppMode = parsed.help || parsed.listModels !== undefined ? "print" : appMode;
|
|
const projectTrustByCwd = new Map<string, boolean>();
|
|
|
|
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: CreateAgentSessionRuntimeFactory = async ({
|
|
cwd,
|
|
agentDir,
|
|
sessionManager,
|
|
sessionStartEvent,
|
|
projectTrustContext,
|
|
}) => {
|
|
const isInitialRuntime = sessionStartEvent === undefined;
|
|
const projectTrustDiagnostics: AgentSessionRuntimeDiagnostic[] = [];
|
|
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,
|
|
agentDir,
|
|
authStorage,
|
|
settingsManager: runtimeSettingsManager,
|
|
extensionFlagValues: parsed.unknownFlags,
|
|
resourceLoaderReloadOptions: shouldResolveProjectTrust
|
|
? {
|
|
resolveProjectTrust: async ({ extensionsResult }) => {
|
|
const trusted = await resolveProjectTrusted({
|
|
cwd,
|
|
trustStore,
|
|
trustOverride: parsed.projectTrustOverride,
|
|
appMode: isInitialRuntime ? trustPromptMode : "print",
|
|
settingsManagerForPrompt: startupSettingsManager,
|
|
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,
|
|
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: options?.extensionFactories,
|
|
},
|
|
});
|
|
const { settingsManager, modelRegistry, resourceLoader } = services;
|
|
const diagnostics: AgentSessionRuntimeDiagnostic[] = [
|
|
...projectTrustDiagnostics,
|
|
...services.diagnostics,
|
|
...collectSettingsDiagnostics(settingsManager, "runtime creation"),
|
|
...resourceLoader.getExtensions().errors.map(({ path, error }) => ({
|
|
type: "error" as const,
|
|
message: `Failed to load extension "${path}": ${error}`,
|
|
})),
|
|
];
|
|
|
|
const modelPatterns = parsed.models ?? settingsManager.getEnabledModels();
|
|
const scopedModels =
|
|
modelPatterns && modelPatterns.length > 0 ? await resolveModelScope(modelPatterns, modelRegistry) : [];
|
|
const {
|
|
options: sessionOptions,
|
|
cliThinkingFromModel,
|
|
diagnostics: sessionOptionDiagnostics,
|
|
} = buildSessionOptions(
|
|
parsed,
|
|
scopedModels,
|
|
sessionManager.buildSessionContext().messages.length > 0,
|
|
modelRegistry,
|
|
settingsManager,
|
|
);
|
|
diagnostics.push(...sessionOptionDiagnostics);
|
|
|
|
if (parsed.apiKey) {
|
|
if (!sessionOptions.model) {
|
|
diagnostics.push({
|
|
type: "error",
|
|
message: "--api-key requires a model to be specified via --model, --provider/--model, or --models",
|
|
});
|
|
} else {
|
|
authStorage.setRuntimeApiKey(sessionOptions.model.provider, parsed.apiKey);
|
|
}
|
|
}
|
|
|
|
const created = await createAgentSessionFromServices({
|
|
services,
|
|
sessionManager,
|
|
sessionStartEvent,
|
|
model: sessionOptions.model,
|
|
thinkingLevel: sessionOptions.thinkingLevel,
|
|
scopedModels: sessionOptions.scopedModels,
|
|
tools: sessionOptions.tools,
|
|
excludeTools: sessionOptions.excludeTools,
|
|
noTools: sessionOptions.noTools,
|
|
customTools: sessionOptions.customTools,
|
|
});
|
|
const cliThinkingOverride = parsed.thinking !== undefined || cliThinkingFromModel;
|
|
if (created.session.model && cliThinkingOverride) {
|
|
created.session.setThinkingLevel(created.session.thinkingLevel);
|
|
}
|
|
|
|
return {
|
|
...created,
|
|
services,
|
|
diagnostics,
|
|
};
|
|
};
|
|
time("createRuntime");
|
|
const runtime = await createAgentSessionRuntime(createRuntime, {
|
|
cwd: sessionManager.getCwd(),
|
|
agentDir,
|
|
sessionManager,
|
|
});
|
|
time("createAgentSessionRuntime");
|
|
const { services, session, modelFallbackMessage } = runtime;
|
|
const { settingsManager, modelRegistry, resourceLoader } = services;
|
|
configureHttpDispatcher(settingsManager.getHttpIdleTimeoutMs());
|
|
|
|
if (parsed.help) {
|
|
const extensionFlags = resourceLoader
|
|
.getExtensions()
|
|
.extensions.flatMap((extension) => Array.from(extension.flags.values()));
|
|
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: string | undefined;
|
|
if (appMode !== "rpc") {
|
|
stdinContent = await readPipedStdin();
|
|
if (stdinContent !== undefined && appMode === "interactive") {
|
|
appMode = "print";
|
|
}
|
|
}
|
|
time("readPipedStdin");
|
|
|
|
const { initialMessage, initialImages } = await prepareInitialMessage(
|
|
parsed,
|
|
settingsManager.getImageAutoResize(),
|
|
stdinContent,
|
|
);
|
|
time("prepareInitialMessage");
|
|
initTheme(settingsManager.getTheme(), appMode === "interactive");
|
|
time("initTheme");
|
|
|
|
// Show deprecation warnings in interactive mode
|
|
if (appMode === "interactive" && deprecationWarnings.length > 0) {
|
|
await showDeprecationWarnings(deprecationWarnings);
|
|
}
|
|
|
|
time("resolveModelScope");
|
|
reportDiagnostics(runtime.diagnostics);
|
|
if (runtime.diagnostics.some((diagnostic) => diagnostic.type === "error")) {
|
|
process.exit(1);
|
|
}
|
|
time("createAgentSession");
|
|
|
|
if (appMode !== "interactive" && !session.model) {
|
|
console.error(chalk.red(formatNoModelsAvailableMessage()));
|
|
process.exit(1);
|
|
}
|
|
|
|
const startupBenchmark = isTruthyEnvFlag(process.env.PI_STARTUP_BENCHMARK);
|
|
if (startupBenchmark && appMode !== "interactive") {
|
|
console.error(chalk.red("Error: PI_STARTUP_BENCHMARK only supports interactive mode"));
|
|
process.exit(1);
|
|
}
|
|
|
|
if (appMode === "rpc") {
|
|
printTimings();
|
|
await runRpcMode(runtime);
|
|
} else if (appMode === "interactive") {
|
|
const interactiveMode = new InteractiveMode(runtime, {
|
|
migratedProviders,
|
|
modelFallbackMessage,
|
|
autoTrustOnReloadCwd,
|
|
initialMessage,
|
|
initialImages,
|
|
initialMessages: parsed.messages,
|
|
verbose: parsed.verbose,
|
|
});
|
|
if (startupBenchmark) {
|
|
await interactiveMode.init();
|
|
time("interactiveMode.init");
|
|
printTimings();
|
|
interactiveMode.stop();
|
|
stopThemeWatcher();
|
|
if (process.stdout.writableLength > 0) {
|
|
await new Promise<void>((resolve) => process.stdout.once("drain", resolve));
|
|
}
|
|
if (process.stderr.writableLength > 0) {
|
|
await new Promise<void>((resolve) => process.stderr.once("drain", resolve));
|
|
}
|
|
return;
|
|
}
|
|
|
|
printTimings();
|
|
await interactiveMode.run();
|
|
} else {
|
|
printTimings();
|
|
const exitCode = await runPrintMode(runtime, {
|
|
mode: toPrintOutputMode(appMode),
|
|
messages: parsed.messages,
|
|
initialMessage,
|
|
initialImages,
|
|
});
|
|
stopThemeWatcher();
|
|
restoreStdout();
|
|
if (exitCode !== 0) {
|
|
process.exitCode = exitCode;
|
|
}
|
|
return;
|
|
}
|
|
}
|