@oh-my-pi/pi-coding-agent 15.0.0 → 15.0.2

package/src/internal-urls/registry-helpers.ts

@@ -0,0 +1,25 @@
+/**
+ * Shared helpers for internal-url protocol handlers that resolve IDs against
+ * registered agent sessions.
+ */
+import { AgentRegistry } from "../registry/agent-registry";
+
+/**
+ * Snapshot of artifacts dirs for every registered session, deduped.
+ *
+ * Prefers `sessionManager.getArtifactsDir()` because subagents adopt their
+ * parent's `ArtifactManager` and report the parent's dir there; dedup then
+ * collapses parent + N subagents (the whole agent tree) to one entry. Falls
+ * back to the raw session file (with the `.jsonl` suffix stripped) when no
+ * live session reference is attached.
+ */
+export function artifactsDirsFromRegistry(): string[] {
+	const dirs: string[] = [];
+	for (const ref of AgentRegistry.global().list()) {
+		const dir =
+			ref.session?.sessionManager.getArtifactsDir() ?? (ref.sessionFile ? ref.sessionFile.slice(0, -6) : null);
+		if (!dir) continue;
+		if (!dirs.includes(dir)) dirs.push(dir);
+	}
+	return dirs;
+}

package/src/internal-urls/router.ts

@@ -50,6 +50,14 @@ export class InternalUrlRouter {
 		this.#handlers.set(handler.scheme.toLowerCase(), handler);
 	}
 
+	unregister(scheme: string): boolean {
+		return this.#handlers.delete(scheme.toLowerCase());
+	}
+
+	getHandler(scheme: string): ProtocolHandler | undefined {
+		return this.#handlers.get(scheme.toLowerCase());
+	}
+
 	canHandle(input: string): boolean {
 		const match = input.match(/^([a-z][a-z0-9+.-]*):\/\//i);
 		if (!match) return false;

package/src/internal-urls/types.ts

@@ -63,6 +63,18 @@ export interface ResolveContext {
 	signal?: AbortSignal;
 }
 
+/**
+ * Caller context for write operations dispatched to host-owned URI handlers.
+ * Mirrors {@link ResolveContext} so handlers that share read/write state can
+ * accept the same shape.
+ */
+export interface WriteContext {
+	/** Working directory of the calling session. */
+	cwd?: string;
+	/** Caller's abort signal. */
+	signal?: AbortSignal;
+}
+
 /**
  * Handler for a specific internal URL scheme (e.g., agent://, memory://, skill://, mcp://).
  */
@@ -86,4 +98,13 @@ export interface ProtocolHandler {
 	 * @throws Error with user-friendly message if resolution fails
 	 */
 	resolve(url: InternalUrl, context?: ResolveContext): Promise<InternalResource>;
+	/**
+	 * Optional write hook. When present, the write tool dispatches
+	 * `write(url, content)` to this handler instead of writing to a filesystem
+	 * path. The handler is responsible for any persistence and validation.
+	 *
+	 * Handlers that omit this method are treated as read-only; the write tool
+	 * surfaces a clear "not writable" error when invoked against them.
+	 */
+	write?(url: InternalUrl, content: string, context?: WriteContext): Promise<void>;
 }

package/src/lsp/config.ts

@@ -154,16 +154,25 @@ function applyRuntimeDefaults(servers: Record<string, ServerConfig>): Record<str
  * Check if any root marker file exists in the directory
  */
 export function hasRootMarkers(cwd: string, markers: string[]): boolean {
+	let entries: string[] | null = null;
 	for (const marker of markers) {
-		// Handle glob-like patterns (e.g., "*.cabal")
+		// Handle glob-like patterns (e.g., "*.cabal"). Root markers live at the
+		// project root, so a one-level readdir is sufficient — and avoids
+		// Bun.Glob descending into node_modules for patterns like "**/*.cabal".
 		if (marker.includes("*")) {
-			try {
-				const scan = new Bun.Glob(marker).scanSync({ cwd, onlyFiles: false });
-				for (const _ of scan) {
+			if (entries === null) {
+				try {
+					entries = fs.readdirSync(cwd);
+				} catch {
+					entries = [];
+					logger.warn("Failed to list directory for glob root marker.", { marker, cwd });
+				}
+			}
+			const glob = new Bun.Glob(marker);
+			for (const entry of entries) {
+				if (glob.match(entry)) {
 					return true;
 				}
-			} catch {
-				logger.warn("Failed to resolve glob root marker.", { marker, cwd });
 			}
 			continue;
 		}

package/src/lsp/defaults.json

@@ -5,7 +5,11 @@
 		"fileTypes": [".rs"],
 		"rootMarkers": ["Cargo.toml", "rust-analyzer.toml"],
 		"initOptions": {},
-		"settings": {},
+		"settings": {
+			"rust-analyzer": {
+				"checkOnSave": false
+			}
+		},
 		"capabilities": {
 			"flycheck": true,
 			"ssr": true,
@@ -424,7 +428,7 @@
 		"args": ["server"],
 		"fileTypes": [".md", ".markdown"],
 		"rootMarkers": [".marksman.toml", ".git"],
-		"warmupTimeoutMs": 15000
+		"warmupTimeoutMs": 2000
 	},
 	"texlab": {
 		"command": "texlab",

package/src/main.ts

@@ -129,7 +129,7 @@ export async function submitInteractiveInput(
 		InteractiveMode,
 		"markPendingSubmissionStarted" | "finishPendingSubmission" | "showError" | "checkShutdownRequested"
 	>,
-	session: Pick<AgentSession, "prompt">,
+	session: Pick<AgentSession, "prompt" | "promptCustomMessage">,
 	input: SubmittedUserInput,
 ): Promise<void> {
 	if (input.cancelled) {
@@ -141,7 +141,16 @@ export async function submitInteractiveInput(
 		if (!input.started && !mode.markPendingSubmissionStarted(input)) {
 			return;
 		}
-		await session.prompt(input.text, { images: input.images });
+		if (input.customType) {
+			await session.promptCustomMessage({
+				customType: input.customType,
+				content: input.text,
+				display: input.display ?? false,
+				attribution: "agent",
+			});
+		} else {
+			await session.prompt(input.text, { images: input.images });
+		}
 	} catch (error: unknown) {
 		const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
 		mode.showError(errorMessage);

package/src/mcp/oauth-flow.ts

@@ -133,6 +133,26 @@ export class MCPOAuthFlow extends OAuthCallbackFlow {
 		this.#resolvedClientId = this.#resolveClientId(config);
 	}
 
+	/**
+	 * Client id used during the authorization request. Returns the value supplied
+	 * via {@link MCPOAuthConfig.clientId} or, when the server required dynamic
+	 * client registration, the id issued during registration. `undefined` until
+	 * {@link generateAuthUrl} (or {@link login}) has run for a server that needs
+	 * a client id.
+	 */
+	get resolvedClientId(): string | undefined {
+		return this.#resolvedClientId;
+	}
+
+	/**
+	 * Client secret issued by dynamic client registration, if any. Always
+	 * `undefined` for PKCE-only/public clients and when the caller supplies the
+	 * client id via config.
+	 */
+	get registeredClientSecret(): string | undefined {
+		return this.#registeredClientSecret;
+	}
+
 	async generateAuthUrl(state: string, redirectUri: string): Promise<{ url: string; instructions?: string }> {
 		if (!this.#resolvedClientId) {
 			await this.#tryRegisterClient(redirectUri);