@oh-my-pi/pi-coding-agent 17.1.8 → 17.2.0

package/src/internal-urls/mcp-protocol.ts

@@ -97,7 +97,10 @@ function formatAvailableResources(mcpManager: MCPManager): string {
 		.getConnectedServers()
 		.flatMap(name => {
 			const serverResources = mcpManager.getServerResources(name);
-			return (serverResources?.resources ?? []).map(r => `  ${r.uri} (${name})`);
+			if (!serverResources) return [];
+			const concrete = serverResources.resources.map(r => `  ${r.uri} (${name})`);
+			const templates = serverResources.templates.map(t => `  ${t.uriTemplate} (${name}, template)`);
+			return [...concrete, ...templates];
 		})
 		.join("\n");
 	return available || "  (none)";

package/src/launch/terminal-output-worker-client.ts

@@ -0,0 +1,53 @@
+import { workerHostEntry } from "@oh-my-pi/pi-utils/worker-host";
+import type { TerminalOutputOptions } from "./terminal-output";
+import {
+	TERMINAL_OUTPUT_WORKER_ARG,
+	type TerminalOutputWorkerRequest,
+	type TerminalOutputWorkerResult,
+} from "./terminal-output-worker-protocol";
+
+/** Replay legacy broker PTY bytes without evaluating xterm in the client process. */
+export async function renderTerminalOutputIsolated(
+	output: string,
+	options: TerminalOutputOptions,
+): Promise<string[] | undefined> {
+	const hostEntry = workerHostEntry();
+	const worker = hostEntry
+		? new Worker(hostEntry, { type: "module", argv: [TERMINAL_OUTPUT_WORKER_ARG] })
+		: new Worker(new URL("./terminal-output-worker.ts", import.meta.url).href, { type: "module" });
+	const pending = Promise.withResolvers<string[] | undefined>();
+	const onMessage = (event: MessageEvent<TerminalOutputWorkerResult>): void => {
+		if (event.data.ok) pending.resolve(event.data.rows);
+		else pending.reject(new Error(event.data.error));
+	};
+	const onError = (event: ErrorEvent): void => {
+		pending.reject(event.error instanceof Error ? event.error : new Error(event.message));
+	};
+	const onClose = (): void => {
+		pending.reject(new Error("Terminal output worker exited before responding"));
+	};
+	worker.addEventListener("message", onMessage);
+	worker.addEventListener("error", onError);
+	worker.addEventListener("close", onClose);
+	try {
+		const request: TerminalOutputWorkerRequest = { output, options };
+		worker.postMessage(request);
+		return await pending.promise;
+	} finally {
+		worker.removeEventListener("message", onMessage);
+		worker.removeEventListener("error", onError);
+		worker.removeEventListener("close", onClose);
+		worker.terminate();
+	}
+}
+
+/** Distribution smoke for source, npm-bundle, and compiled worker routing. */
+export async function smokeTestTerminalOutputWorker(): Promise<void> {
+	const rows = await renderTerminalOutputIsolated("old\r\x1b[2K\x1b[1;32mready\x1b[0m", {
+		head: false,
+		maxRows: 10,
+	});
+	if (rows?.length !== 1 || rows[0] !== "\x1b[0m\x1b[1;38;5;2mready") {
+		throw new Error("terminal output worker smoke mismatch");
+	}
+}

package/src/launch/terminal-output-worker-protocol.ts

@@ -0,0 +1,11 @@
+import type { TerminalOutputOptions } from "./terminal-output";
+
+/** Hidden CLI selector for legacy PTY replay outside the client process. */
+export const TERMINAL_OUTPUT_WORKER_ARG = "__omp_worker_terminal_output";
+
+export interface TerminalOutputWorkerRequest {
+	output: string;
+	options: TerminalOutputOptions;
+}
+
+export type TerminalOutputWorkerResult = { ok: true; rows: string[] | undefined } | { ok: false; error: string };

package/src/launch/terminal-output-worker.ts

@@ -0,0 +1,23 @@
+import { parentPort } from "node:worker_threads";
+import { consumeWorkerInbox } from "@oh-my-pi/pi-utils/worker-host";
+import { renderTerminalOutput } from "./terminal-output";
+import type { TerminalOutputWorkerRequest, TerminalOutputWorkerResult } from "./terminal-output-worker-protocol";
+
+if (!parentPort) throw new Error("terminal-output-worker: missing parentPort");
+
+const port = parentPort;
+const inbox = consumeWorkerInbox();
+const handle = async (message: unknown): Promise<void> => {
+	const request = message as TerminalOutputWorkerRequest;
+	let result: TerminalOutputWorkerResult;
+	try {
+		result = { ok: true, rows: await renderTerminalOutput(request.output, request.options) };
+	} catch (error) {
+		result = { ok: false, error: error instanceof Error ? error.message : String(error) };
+	}
+	port.postMessage(result);
+	port.close();
+};
+
+if (inbox) inbox.bind(message => void handle(message));
+else port.on("message", message => void handle(message));

package/src/lsp/client.ts

@@ -27,6 +27,7 @@ const fileOperationLocks = new Map<string, Promise<void>>();
 /** Negative cache of recent init failures so a broken server fails fast instead of re-spawning per call. */
 const INIT_FAILURE_BACKOFF_MS = 3 * 60 * 1000;
 const initFailures = new Map<string, { at: number; message: string }>();
+const READER_EXIT_GRACE_MS = 100;
 
 // Idle timeout configuration (disabled by default)
 let idleTimeoutMs: number | null = null;
@@ -303,6 +304,7 @@ async function startMessageReader(client: LspClient): Promise<void> {
 
 	const framer = new MessageFramer(Buffer.from(client.messageBuffer));
 
+	let readerFailed = false;
 	try {
 		while (true) {
 			const { done, value } = await reader.read();
@@ -391,6 +393,7 @@ async function startMessageReader(client: LspClient): Promise<void> {
 			}
 		}
 	} catch (err) {
+		readerFailed = true;
 		// Connection closed or error - reject all pending requests
 		for (const pending of Array.from(client.pendingRequests.values())) {
 			pending.reject(new Error(`LSP connection closed: ${err}`));
@@ -401,6 +404,9 @@ async function startMessageReader(client: LspClient): Promise<void> {
 		client.messageBuffer = framer.remainder();
 		reader.releaseLock();
 		client.isReading = false;
+		if (!readerFailed && client.proc.exitCode === null) {
+			await waitForExit(client, READER_EXIT_GRACE_MS);
+		}
 		// Reader exited while the server process is still alive (unrecoverable
 		// read error or bad stream state): nothing will route responses anymore,
 		// so tear the client down — the next call respawns instead of timing out.
@@ -676,6 +682,15 @@ const PROJECT_LOAD_TIMEOUT_MS = 15_000;
 const SHUTDOWN_TIMEOUT_MS = 5_000;
 const EXIT_TIMEOUT_MS = 1_000;
 
+function clientKey(config: ServerConfig, cwd: string): string {
+	return `${config.command}:${cwd}`;
+}
+
+/** Allow an explicit user reload to retry a matching initialization failure immediately. */
+export function clearInitializationFailure(config: ServerConfig, cwd: string): void {
+	initFailures.delete(clientKey(config, cwd));
+}
+
 /**
  * Get or create an LSP client for the given server configuration and working directory.
  * @param config - Server configuration
@@ -692,7 +707,7 @@ export async function getOrCreateClient(
 	initTimeoutMs?: number,
 	signal?: AbortSignal,
 ): Promise<LspClient> {
-	const key = `${config.command}:${cwd}`;
+	const key = clientKey(config, cwd);
 
 	// Check if client already exists
 	const existingClient = clients.get(key);
@@ -865,13 +880,13 @@ export async function getActiveOrPendingClient(
 	signal?: AbortSignal,
 ): Promise<LspClient | undefined> {
 	throwIfAborted(signal);
-	const client = clients.get(`${config.command}:${cwd}`);
+	const client = clients.get(clientKey(config, cwd));
 	if (client) {
 		client.lastActivity = Date.now();
 		return client;
 	}
 
-	const pending = clientLocks.get(`${config.command}:${cwd}`);
+	const pending = clientLocks.get(clientKey(config, cwd));
 	if (!pending) return undefined;
 	try {
 		return await untilAborted(signal, pending);

package/src/lsp/index.ts

@@ -17,6 +17,7 @@ import { formatPathRelativeToCwd, resolveToCwd } from "../tools/path-utils";
 import { ToolAbortError, ToolError, throwIfAborted } from "../tools/tool-errors";
 import { clampTimeout } from "../tools/tool-timeouts";
 import {
+	clearInitializationFailure,
 	ensureFileOpen,
 	FileChangeType,
 	getActiveClients,
@@ -2345,6 +2346,7 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 			const outputs: string[] = [];
 			for (const [workspaceServerName, workspaceServerConfig] of servers) {
 				throwIfAborted(signal);
+				clearInitializationFailure(workspaceServerConfig, this.session.cwd);
 				try {
 					const workspaceClient = await getOrCreateClient(
 						workspaceServerConfig,
@@ -2377,6 +2379,8 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 
 		const [serverName, serverConfig] = serverInfo;
 
+		if (action === "reload") clearInitializationFailure(serverConfig, this.session.cwd);
+
 		try {
 			const client = await getOrCreateClient(serverConfig, this.session.cwd, undefined, signal);
 			const targetFile = resolvedFile;

package/src/lsp/render.ts

@@ -582,7 +582,7 @@ function renderGeneric(text: string, lines: string[], expanded: boolean, theme:
 		for (let i = 0; i < lines.length; i++) {
 			const isLast = i === lines.length - 1;
 			const branch = isLast ? theme.tree.last : theme.tree.branch;
-			output += `\n ${theme.fg("dim", branch)} ${lines[i]}`;
+			output += `\n ${theme.fg("dim", branch)} ${truncateToWidth(replaceTabs(lines[i]), TRUNCATE_LENGTHS.CONTENT)}`;
 		}
 		return output.split("\n");
 	}

package/src/main.ts

@@ -41,7 +41,7 @@ import {
 	type ScopedModel,
 } from "./config/model-resolver";
 import { ModelsConfigFile } from "./config/models-config";
-import { getDefault, type SettingPath, Settings, settings } from "./config/settings";
+import { getDefault, type SettingPath, Settings, type SettingValue, settings } from "./config/settings";
 import { initializeWithSettings } from "./discovery";
 import {
 	clearPluginRootsAndCaches,
@@ -74,6 +74,13 @@ import {
 import type { AgentSession } from "./session/agent-session";
 import type { AuthStorage } from "./session/auth-storage";
 import { describePendingToolCalls } from "./session/exit-diagnostics";
+import {
+	createForeignSessionStore,
+	foreignSessionInfoToSessionInfo,
+	foreignSessionSourceName,
+	persistForeignSession,
+} from "./session/foreign-session-import";
+import type { ForeignSessionInfo, ForeignSessionSource, ForeignSessionStore } from "./session/foreign-session-store";
 import { resolveResumableSession, type SessionInfo } from "./session/session-listing";
 import { SessionManager } from "./session/session-manager";
 import { executeBuiltinSlashCommand } from "./slash-commands/builtin-registry";
@@ -83,14 +90,7 @@ import { createPersistedSubagentReviverFactory } from "./task/persisted-revive";
 import { createTelemetryExportConfig, initTelemetryExport, isTelemetryExportEnabled } from "./telemetry-export";
 import { concreteThinkingLevel, parseConfiguredThinkingLevel } from "./thinking";
 import type { LspStartupServerInfo } from "./tools";
-import {
-	getChangelogPath,
-	parseChangelog,
-	parseChangelogVersion,
-	readLastChangelogVersion,
-	selectStartupChangelog,
-	writeLastChangelogVersion,
-} from "./utils/changelog";
+import { getChangelogPath, resolveStartupChangelogForDisplay, type StartupChangelogSelection } from "./utils/changelog";
 import { EventBus } from "./utils/event-bus";
 import { withTimeoutSignal } from "./utils/fetch-timeout";
 
@@ -408,7 +408,7 @@ export function createAcpSessionFactory(args: AcpSessionFactoryOptions): AcpSess
 async function runInteractiveMode(
 	session: AgentSession,
 	version: string,
-	changelogMarkdown: string | undefined,
+	startupChangelog: StartupChangelogSelection | undefined,
 	notifs: (InteractiveModeNotify | null)[],
 	versionCheckPromise: Promise<string | undefined>,
 	initialMessages: string[],
@@ -426,7 +426,7 @@ async function runInteractiveMode(
 	const mode = new InteractiveMode(
 		session,
 		version,
-		changelogMarkdown,
+		startupChangelog,
 		setExtensionUIContext,
 		lspServers,
 		mcpManager,
@@ -565,6 +565,27 @@ export class SessionResolutionError extends Error {
 	}
 }
 
+function resolveForeignSessionSource(
+	parsed: Pick<Args, "continue" | "fork" | "fromClaude" | "fromCodex" | "noSession" | "resume">,
+): ForeignSessionSource | undefined {
+	if (parsed.fromClaude && parsed.fromCodex) {
+		throw new SessionResolutionError("--from-claude and --from-codex cannot be used together");
+	}
+	const source = parsed.fromClaude ? "claude" : parsed.fromCodex ? "codex" : undefined;
+	if (!source) return undefined;
+	if (parsed.noSession) {
+		throw new SessionResolutionError(`--from-${source} requires session persistence`);
+	}
+	if (parsed.continue || parsed.resume || parsed.fork) {
+		throw new SessionResolutionError(`--from-${source} cannot be combined with --continue, --resume, or --fork`);
+	}
+	return source;
+}
+
+function isForeignSessionImport(parsed: Pick<Args, "fromClaude" | "fromCodex">): boolean {
+	return parsed.fromClaude === true || parsed.fromCodex === true;
+}
+
 type MissingCwdMoveResult =
 	| { status: "not-needed" }
 	| { status: "declined" }
@@ -651,33 +672,19 @@ async function resolveScopedModels(
 	);
 }
 
-async function getChangelogForDisplay(parsed: Args): Promise<string | undefined> {
-	if (parsed.continue || parsed.resume) {
-		return undefined;
-	}
-
-	const lastVersion = await readLastChangelogVersion();
-	const parsedLastVersion = parseChangelogVersion(lastVersion);
-	if (!parsedLastVersion) {
-		await writeLastChangelogVersion(VERSION);
-		return undefined;
-	}
-	if (lastVersion === VERSION) {
-		// Steady state: user already saw the current version's changelog. Skip the file read + parse.
+async function getChangelogForDisplay(
+	parsed: Args,
+	mode: SettingValue<"startup.changelogMode">,
+): Promise<StartupChangelogSelection | undefined> {
+	if (parsed.continue || parsed.resume || isForeignSessionImport(parsed)) {
 		return undefined;
 	}
 
-	const changelogPath = getChangelogPath();
-	const entries = await parseChangelog(changelogPath);
-	const startupChangelog = selectStartupChangelog(entries, lastVersion, VERSION);
-	if (startupChangelog.persistCurrentVersion) {
-		await writeLastChangelogVersion(VERSION);
-	}
-	if (startupChangelog.markdown) {
-		return startupChangelog.markdown;
-	}
-
-	return undefined;
+	return resolveStartupChangelogForDisplay({
+		mode,
+		currentVersion: VERSION,
+		changelogPath: getChangelogPath(),
+	});
 }
 
 const SESSION_ID_ARG_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
@@ -852,6 +859,7 @@ export async function buildSessionOptions(
 		cwd: parsed.cwd ?? getProjectDir(),
 		autoApprove: parsed.autoApprove ?? false,
 	};
+	const restoringSession = Boolean(parsed.continue || parsed.resume || isForeignSessionImport(parsed));
 	const cliDirs = parsed.addDir ?? [];
 	const settingsDirs = activeSettings.get("workspace.additionalDirectories");
 	if (cliDirs.length > 0 || settingsDirs.length > 0) {
@@ -882,7 +890,7 @@ export async function buildSessionOptions(
 		options.providerPromptCacheKeySource = "explicit";
 	} else {
 		const header = sessionManager?.getHeader();
-		const scopedModelOverride = scopedModels.length > 0 && !parsed.continue && !parsed.resume;
+		const scopedModelOverride = scopedModels.length > 0 && !restoringSession;
 		const forkCacheShapeChanged =
 			scopedModelOverride ||
 			parsed.model !== undefined ||
@@ -939,7 +947,7 @@ export async function buildSessionOptions(
 				options.thinkingLevel = resolved.thinkingLevel;
 			}
 		}
-	} else if (scopedModels.length > 0 && !parsed.continue && !parsed.resume) {
+	} else if (scopedModels.length > 0 && !restoringSession) {
 		const remembered = activeSettings.getModelRole("default");
 		if (remembered) {
 			const rememberedSpec = resolveModelRoleValue(
@@ -1042,8 +1050,7 @@ export async function buildSessionOptions(
 		// thinking suffix) after extensions register; seeding the fallback
 		// scoped model's level here would override it in createAgentSession.
 		!deferredDefaultRole &&
-		!parsed.continue &&
-		!parsed.resume
+		!restoringSession
 	) {
 		options.thinkingLevel = scopedModels[0].thinkingLevel;
 	}
@@ -1119,6 +1126,7 @@ interface RunRootCommandDependencies {
 	discoverAuthStorage?: typeof discoverAuthStorage;
 	selectSession?: typeof selectSession;
 	runAcpMode?: RunAcpMode;
+	createForeignSessionStore?: (source: ForeignSessionSource) => ForeignSessionStore;
 	settings?: Settings;
 	forceSetupWizard?: boolean;
 }
@@ -1282,19 +1290,77 @@ export async function runRootCommand(
 	// id from UUID-shaped values owned by later extension flags.
 	normalizeContinueSessionArgs(parsedArgs, rawArgs);
 
-	// Create session manager based on CLI flags. SessionResolutionError signals a
-	// user-facing failure (unknown --resume/--fork id, non-interactive fork
-	// prompt, --fork with --no-session): print + exit cleanly instead of letting
-	// it surface as `[Uncaught Exception]` (see issue #2084).
+	// Resolve native resume/fork flags or import one foreign transcript into a
+	// fresh persisted OMP session before constructing the AgentSession.
 	let sessionManager: SessionManager | undefined;
+	let foreignSource: ForeignSessionSource | undefined;
 	try {
-		sessionManager = await logger.time(
-			"createSessionManager",
-			createSessionManager,
-			parsedArgs,
-			cwd,
-			settingsInstance,
-		);
+		foreignSource = resolveForeignSessionSource(parsedArgs);
+		if (foreignSource) {
+			if (isProtocolMode) {
+				throw new SessionResolutionError(`--from-${foreignSource} is not supported in ${mode} mode`);
+			}
+			const sourceName = foreignSessionSourceName(foreignSource);
+			const store = (deps.createForeignSessionStore ?? createForeignSessionStore)(foreignSource);
+			let foreignSessions: ForeignSessionInfo[];
+			try {
+				foreignSessions = await logger.time(`list${sourceName}Sessions`, () => store.list());
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				throw new SessionResolutionError(`Failed to list ${sourceName} sessions: ${message}`);
+			}
+			if (foreignSessions.length === 0) {
+				writeStartupNotice(parsedArgs, `${chalk.dim(`No ${sourceName} sessions found`)}\n`);
+				stopStartupWatchdog();
+				process.exit(0);
+			}
+			const choices = foreignSessions.map(foreignSessionInfoToSessionInfo);
+			pauseStartupWatchdog();
+			let selected: SessionInfo | null;
+			try {
+				selected = await logger.time(`select${sourceName}Session`, deps.selectSession ?? selectSession, choices, {
+					title: `Import ${sourceName} Session`,
+					scopeLabel: false,
+					showCwd: true,
+					allowDelete: false,
+					allowGlobalScope: false,
+					historySearch: false,
+				});
+			} finally {
+				resumeStartupWatchdog();
+			}
+			if (!selected) {
+				writeStartupNotice(parsedArgs, `${chalk.dim(`No ${sourceName} session selected`)}\n`);
+				stopStartupWatchdog();
+				process.exit(0);
+			}
+			const foreignSession = foreignSessions.find(
+				session => session.id === selected.id && session.path === selected.path,
+			);
+			if (!foreignSession) {
+				throw new SessionResolutionError(`Selected ${sourceName} session is no longer available`);
+			}
+			try {
+				sessionManager = await logger.time(
+					`import${sourceName}Session`,
+					persistForeignSession,
+					store,
+					foreignSession,
+					{ fallbackCwd: cwd, sessionDir: parsedArgs.sessionDir },
+				);
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				throw new SessionResolutionError(`Failed to import ${sourceName} session: ${message}`);
+			}
+		} else {
+			sessionManager = await logger.time(
+				"createSessionManager",
+				createSessionManager,
+				parsedArgs,
+				cwd,
+				settingsInstance,
+			);
+		}
 	} catch (error: unknown) {
 		if (error instanceof SessionResolutionError) {
 			process.stderr.write(`${chalk.red(`Error: ${error.message}`)}\n`);
@@ -1306,7 +1372,7 @@ export async function runRootCommand(
 		throw error;
 	}
 
-	if (typeof parsedArgs.resume === "string" && sessionManager) {
+	if ((typeof parsedArgs.resume === "string" || foreignSource) && sessionManager) {
 		const previousCwd = cwd;
 		cwd = await switchToResumedProject(sessionManager.getCwd(), settingsInstance, pluginPreloadPromise);
 		if (cwd !== previousCwd) {
@@ -1372,7 +1438,7 @@ export async function runRootCommand(
 		sessionManager = await SessionManager.open(selected.path);
 	}
 
-	if (sessionManager && (parsedArgs.continue || parsedArgs.resume || parsedArgs.fork)) {
+	if (sessionManager && (parsedArgs.continue || parsedArgs.resume || parsedArgs.fork || foreignSource)) {
 		const pendingToolWarning = describePendingToolCalls(sessionManager.getBranch());
 		if (pendingToolWarning) {
 			logger.warn("Resumed session has pending tool calls", {
@@ -1515,7 +1581,7 @@ export async function runRootCommand(
 		const showStartupSplash = shouldShowStartupSplash({
 			configured: settingsInstance.get("startup.showSplash"),
 			isInteractive,
-			resuming: Boolean(parsedArgs.continue || parsedArgs.resume || parsedArgs.fork),
+			resuming: Boolean(parsedArgs.continue || parsedArgs.resume || parsedArgs.fork || foreignSource),
 			quiet: settingsInstance.get("startup.quiet"),
 			timing: Boolean($env.PI_TIMING),
 			stdinIsTTY: process.stdin.isTTY,
@@ -1580,7 +1646,12 @@ export async function runRootCommand(
 			await runRpcMode(session, mode === "rpc-ui" ? setToolUIContext : undefined, eventBus, rpcInput);
 		} else if (isInteractive) {
 			const versionCheckPromise = checkForNewVersion(VERSION).catch(() => undefined);
-			const changelogMarkdown = await logger.time("main:getChangelogForDisplay", getChangelogForDisplay, parsedArgs);
+			const startupChangelog = await logger.time(
+				"main:getChangelogForDisplay",
+				getChangelogForDisplay,
+				parsedArgs,
+				settingsInstance.get("startup.changelogMode"),
+			);
 
 			const modelScopeNotification = buildModelScopeNotification(
 				scopedModels,
@@ -1605,14 +1676,14 @@ export async function runRootCommand(
 			await runInteractiveMode(
 				session,
 				VERSION,
-				changelogMarkdown,
+				startupChangelog,
 				notifs,
 				versionCheckPromise,
 				initialArgs.messages,
 				setToolUIContext,
 				lspServers,
 				mcpManager,
-				Boolean(parsedArgs.continue || parsedArgs.resume || parsedArgs.fork),
+				Boolean(parsedArgs.continue || parsedArgs.resume || parsedArgs.fork || foreignSource),
 				deps.forceSetupWizard === true,
 				showStartupSplash,
 				eventBus,