gsd-pi 2.33.1-dev.235d83a → 2.33.1-dev.29a8268

package/dist/resources/extensions/async-jobs/await-tool.ts

@@ -0,0 +1,103 @@
+/**
+ * await_job tool — wait for one or more background jobs to complete.
+ *
+ * If specific job IDs are provided, waits for those jobs.
+ * If omitted, waits for any running job to complete.
+ */
+
+import type { ToolDefinition } from "@gsd/pi-coding-agent";
+import { Type } from "@sinclair/typebox";
+import type { AsyncJobManager, Job } from "./job-manager.js";
+
+const schema = Type.Object({
+	jobs: Type.Optional(
+		Type.Array(Type.String(), {
+			description: "Job IDs to wait for. Omit to wait for any running job.",
+		}),
+	),
+});
+
+export function createAwaitTool(getManager: () => AsyncJobManager): ToolDefinition<typeof schema> {
+	return {
+		name: "await_job",
+		label: "Await Background Job",
+		description:
+			"Wait for background jobs to complete. Provide specific job IDs or omit to wait for the next job that finishes. Returns results of completed jobs.",
+		parameters: schema,
+		async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+			const manager = getManager();
+			const { jobs: jobIds } = params;
+
+			let watched: Job[];
+			if (jobIds && jobIds.length > 0) {
+				watched = [];
+				const notFound: string[] = [];
+				for (const id of jobIds) {
+					const job = manager.getJob(id);
+					if (job) {
+						watched.push(job);
+					} else {
+						notFound.push(id);
+					}
+				}
+				if (notFound.length > 0 && watched.length === 0) {
+					return {
+						content: [{ type: "text", text: `No jobs found: ${notFound.join(", ")}` }],
+						details: undefined,
+					};
+				}
+			} else {
+				watched = manager.getRunningJobs();
+				if (watched.length === 0) {
+					return {
+						content: [{ type: "text", text: "No running background jobs." }],
+						details: undefined,
+					};
+				}
+			}
+
+			// If all watched jobs are already done, return immediately
+			const running = watched.filter((j) => j.status === "running");
+			if (running.length === 0) {
+				const result = formatResults(watched);
+				manager.acknowledgeDeliveries(watched.map((j) => j.id));
+				return { content: [{ type: "text", text: result }], details: undefined };
+			}
+
+			// Wait for at least one to complete
+			await Promise.race(running.map((j) => j.promise));
+
+			// Collect all completed results (more may have finished while waiting)
+			const completed = watched.filter((j) => j.status !== "running");
+			manager.acknowledgeDeliveries(completed.map((j) => j.id));
+
+			const stillRunning = watched.filter((j) => j.status === "running");
+			let result = formatResults(completed);
+			if (stillRunning.length > 0) {
+				result += `\n\n**Still running:** ${stillRunning.map((j) => `${j.id} (${j.label})`).join(", ")}`;
+			}
+
+			return { content: [{ type: "text", text: result }], details: undefined };
+		},
+	};
+}
+
+function formatResults(jobs: Job[]): string {
+	if (jobs.length === 0) return "No completed jobs.";
+
+	const parts: string[] = [];
+	for (const job of jobs) {
+		const elapsed = ((Date.now() - job.startTime) / 1000).toFixed(1);
+		const header = `### ${job.id} — ${job.label} (${job.status}, ${elapsed}s)`;
+
+		if (job.status === "completed") {
+			parts.push(`${header}\n\n${job.resultText ?? "(no output)"}`);
+		} else if (job.status === "failed") {
+			parts.push(`${header}\n\nError: ${job.errorText ?? "unknown error"}`);
+		} else if (job.status === "cancelled") {
+			parts.push(`${header}\n\nCancelled.`);
+		}
+	}
+
+	return parts.join("\n\n---\n\n");
+}

package/dist/resources/extensions/async-jobs/cancel-job-tool.ts

@@ -0,0 +1,35 @@
+/**
+ * cancel_job tool — cancel a running background job.
+ */
+
+import type { ToolDefinition } from "@gsd/pi-coding-agent";
+import { Type } from "@sinclair/typebox";
+import type { AsyncJobManager } from "./job-manager.js";
+
+const schema = Type.Object({
+	job_id: Type.String({ description: "The background job ID to cancel (e.g. bg_a1b2c3d4)" }),
+});
+
+export function createCancelJobTool(getManager: () => AsyncJobManager): ToolDefinition<typeof schema> {
+	return {
+		name: "cancel_job",
+		label: "Cancel Background Job",
+		description: "Cancel a running background job by its ID.",
+		parameters: schema,
+		async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+			const manager = getManager();
+			const result = manager.cancel(params.job_id);
+
+			const messages: Record<string, string> = {
+				cancelled: `Job ${params.job_id} has been cancelled.`,
+				not_found: `Job ${params.job_id} not found.`,
+				already_completed: `Job ${params.job_id} has already completed (or failed/cancelled).`,
+			};
+
+			return {
+				content: [{ type: "text", text: messages[result] ?? `Unknown result: ${result}` }],
+				details: undefined,
+			};
+		},
+	};
+}

package/dist/resources/extensions/async-jobs/index.ts

@@ -0,0 +1,141 @@
+/**
+ * Async Jobs Extension
+ *
+ * Allows bash commands to run in the background. The agent gets a job ID
+ * immediately and can continue working. Results are delivered via follow-up
+ * messages when jobs complete.
+ *
+ * Tools:
+ *   async_bash — run a command in the background, get a job ID
+ *   await_job  — wait for background jobs to complete, get results
+ *   cancel_job — cancel a running background job
+ *
+ * Commands:
+ *   /jobs — show running and recent background jobs
+ */
+
+import type { ExtensionAPI, ExtensionCommandContext } from "@gsd/pi-coding-agent";
+import { AsyncJobManager, type Job } from "./job-manager.js";
+import { createAsyncBashTool } from "./async-bash-tool.js";
+import { createAwaitTool } from "./await-tool.js";
+import { createCancelJobTool } from "./cancel-job-tool.js";
+
+export default function AsyncJobs(pi: ExtensionAPI) {
+	let manager: AsyncJobManager | null = null;
+	let latestCwd: string = process.cwd();
+
+	function getManager(): AsyncJobManager {
+		if (!manager) {
+			throw new Error("AsyncJobManager not initialized. Wait for session_start.");
+		}
+		return manager;
+	}
+
+	function getCwd(): string {
+		return latestCwd;
+	}
+
+	// ── Session lifecycle ──────────────────────────────────────────────────
+
+	pi.on("session_start", async (_event, ctx) => {
+		latestCwd = ctx.cwd;
+
+		manager = new AsyncJobManager({
+			onJobComplete: (job) => {
+				const statusEmoji = job.status === "completed" ? "done" : "error";
+				const elapsed = ((Date.now() - job.startTime) / 1000).toFixed(1);
+				const output = job.status === "completed"
+					? job.resultText ?? "(no output)"
+					: `Error: ${job.errorText ?? "unknown error"}`;
+
+				// Truncate output for the follow-up message
+				const maxLen = 2000;
+				const truncatedOutput = output.length > maxLen
+					? output.slice(0, maxLen) + "\n\n[... truncated, use await_job for full output]"
+					: output;
+
+				// Deliver as follow-up without triggering a new LLM turn (#875).
+				// When the agent is streaming: the message is queued and picked up
+				// by the agent loop's getFollowUpMessages() after the current turn.
+				// When the agent is idle: the message is appended to context so it's
+				// visible on the next user-initiated prompt. Previously triggerTurn:true
+				// caused spurious autonomous turns — the model would interpret completed
+				// job output as requiring action and cascade into unbounded self-reinforcing
+				// loops (running more commands, spawning more jobs, burning context).
+				pi.sendMessage(
+					{
+						customType: "async_job_result",
+						content: [
+							`**Background job ${statusEmoji}: ${job.id}** (${job.label}, ${elapsed}s)`,
+							"",
+							truncatedOutput,
+						].join("\n"),
+						display: true,
+					},
+					{ deliverAs: "followUp" },
+				);
+			},
+		});
+	});
+
+	pi.on("session_shutdown", async () => {
+		if (manager) {
+			manager.shutdown();
+			manager = null;
+		}
+	});
+
+	// ── Tools ──────────────────────────────────────────────────────────────
+
+	pi.registerTool(createAsyncBashTool(getManager, getCwd));
+	pi.registerTool(createAwaitTool(getManager));
+	pi.registerTool(createCancelJobTool(getManager));
+
+	// ── /jobs command ──────────────────────────────────────────────────────
+
+	pi.registerCommand("jobs", {
+		description: "Show running and recent background jobs",
+		handler: async (_args: string, _ctx: ExtensionCommandContext) => {
+			if (!manager) {
+				pi.sendMessage({
+					customType: "async_jobs_list",
+					content: "No async job manager active.",
+					display: true,
+				});
+				return;
+			}
+
+			const running = manager.getRunningJobs();
+			const recent = manager.getRecentJobs(10);
+			const completed = recent.filter((j) => j.status !== "running");
+
+			const lines: string[] = ["## Background Jobs"];
+
+			if (running.length === 0 && completed.length === 0) {
+				lines.push("", "No background jobs.");
+			} else {
+				if (running.length > 0) {
+					lines.push("", "### Running");
+					for (const job of running) {
+						const elapsed = ((Date.now() - job.startTime) / 1000).toFixed(0);
+						lines.push(`- **${job.id}** — ${job.label} (${elapsed}s)`);
+					}
+				}
+
+				if (completed.length > 0) {
+					lines.push("", "### Recent");
+					for (const job of completed) {
+						const elapsed = ((Date.now() - job.startTime) / 1000).toFixed(1);
+						lines.push(`- **${job.id}** — ${job.label} (${job.status}, ${elapsed}s)`);
+					}
+				}
+			}
+
+			pi.sendMessage({
+				customType: "async_jobs_list",
+				content: lines.join("\n"),
+				display: true,
+			});
+		},
+	});
+}

package/dist/resources/extensions/async-jobs/job-manager.ts

@@ -0,0 +1,211 @@
+/**
+ * AsyncJobManager — manages background tool call jobs.
+ *
+ * Each job runs asynchronously and delivers its result via a callback
+ * when complete. Jobs are evicted after a configurable TTL.
+ */
+
+import { randomUUID } from "node:crypto";
+
+// ── Types ──────────────────────────────────────────────────────────────────
+
+export type JobStatus = "running" | "completed" | "failed" | "cancelled";
+export type JobType = "bash";
+
+export interface Job {
+	id: string;
+	type: JobType;
+	status: JobStatus;
+	startTime: number;
+	label: string;
+	abortController: AbortController;
+	promise: Promise<void>;
+	resultText?: string;
+	errorText?: string;
+}
+
+export interface JobManagerOptions {
+	maxRunning?: number;       // default 15
+	maxTotal?: number;         // default 100
+	evictionMs?: number;       // default 5 minutes
+	onJobComplete?: (job: Job) => void;
+}
+
+// ── Manager ────────────────────────────────────────────────────────────────
+
+export class AsyncJobManager {
+	private jobs = new Map<string, Job>();
+	private evictionTimers = new Map<string, ReturnType<typeof setTimeout>>();
+
+	private maxRunning: number;
+	private maxTotal: number;
+	private evictionMs: number;
+	private onJobComplete?: (job: Job) => void;
+
+	constructor(options: JobManagerOptions = {}) {
+		this.maxRunning = options.maxRunning ?? 15;
+		this.maxTotal = options.maxTotal ?? 100;
+		this.evictionMs = options.evictionMs ?? 5 * 60 * 1000;
+		this.onJobComplete = options.onJobComplete;
+	}
+
+	/**
+	 * Register a new background job.
+	 * @returns job ID (prefixed with `bg_`)
+	 */
+	register(
+		type: JobType,
+		label: string,
+		runFn: (signal: AbortSignal) => Promise<string>,
+	): string {
+		// Enforce limits
+		const running = this.getRunningJobs();
+		if (running.length >= this.maxRunning) {
+			throw new Error(
+				`Maximum concurrent background jobs reached (${this.maxRunning}). ` +
+				`Use await_job or cancel_job to free a slot.`,
+			);
+		}
+		if (this.jobs.size >= this.maxTotal) {
+			// Evict oldest completed job
+			this.evictOldest();
+			if (this.jobs.size >= this.maxTotal) {
+				throw new Error(
+					`Maximum total background jobs reached (${this.maxTotal}). ` +
+					`Use cancel_job to remove jobs.`,
+				);
+			}
+		}
+
+		const id = `bg_${randomUUID().slice(0, 8)}`;
+		const abortController = new AbortController();
+
+		// Declare job first so the promise callbacks can close over it safely.
+		const job: Job = {
+			id,
+			type,
+			status: "running",
+			startTime: Date.now(),
+			label,
+			abortController,
+			// promise assigned below
+			promise: undefined as unknown as Promise<void>,
+		};
+
+		job.promise = runFn(abortController.signal)
+			.then((resultText) => {
+				job.status = "completed";
+				job.resultText = resultText;
+				this.scheduleEviction(id);
+				this.deliverResult(job);
+			})
+			.catch((err) => {
+				if (job.status === "cancelled") {
+					// Already cancelled — don't overwrite
+					this.scheduleEviction(id);
+					return;
+				}
+				job.status = "failed";
+				job.errorText = err instanceof Error ? err.message : String(err);
+				this.scheduleEviction(id);
+				this.deliverResult(job);
+			});
+
+		this.jobs.set(id, job);
+		return id;
+	}
+
+	/**
+	 * Cancel a running job.
+	 */
+	cancel(id: string): "cancelled" | "not_found" | "already_completed" {
+		const job = this.jobs.get(id);
+		if (!job) return "not_found";
+		if (job.status !== "running") return "already_completed";
+
+		job.status = "cancelled";
+		job.errorText = "Cancelled by user";
+		job.abortController.abort();
+		this.scheduleEviction(id);
+		return "cancelled";
+	}
+
+	getJob(id: string): Job | undefined {
+		return this.jobs.get(id);
+	}
+
+	getRunningJobs(): Job[] {
+		return [...this.jobs.values()].filter((j) => j.status === "running");
+	}
+
+	getRecentJobs(limit = 10): Job[] {
+		return [...this.jobs.values()]
+			.sort((a, b) => b.startTime - a.startTime)
+			.slice(0, limit);
+	}
+
+	getAllJobs(): Job[] {
+		return [...this.jobs.values()];
+	}
+
+	/**
+	 * No-op. Retained for API compatibility with await_job tool.
+	 */
+	acknowledgeDeliveries(_jobIds: string[]): void {
+		// Delivery is fire-once; no retries to cancel.
+	}
+
+	/**
+	 * Cleanup all timers and resources.
+	 */
+	shutdown(): void {
+		for (const timer of this.evictionTimers.values()) {
+			clearTimeout(timer);
+		}
+		this.evictionTimers.clear();
+
+		// Abort all running jobs
+		for (const job of this.jobs.values()) {
+			if (job.status === "running") {
+				job.status = "cancelled";
+				job.abortController.abort();
+			}
+		}
+	}
+
+	// ── Private ────────────────────────────────────────────────────────────
+
+	private deliverResult(job: Job): void {
+		if (!this.onJobComplete) return;
+		this.onJobComplete(job);
+	}
+
+	private scheduleEviction(id: string): void {
+		const existing = this.evictionTimers.get(id);
+		if (existing) clearTimeout(existing);
+
+		const timer = setTimeout(() => {
+			this.evictionTimers.delete(id);
+			this.jobs.delete(id);
+		}, this.evictionMs);
+
+		this.evictionTimers.set(id, timer);
+	}
+
+	private evictOldest(): void {
+		let oldest: Job | undefined;
+		for (const job of this.jobs.values()) {
+			if (job.status !== "running") {
+				if (!oldest || job.startTime < oldest.startTime) {
+					oldest = job;
+				}
+			}
+		}
+		if (oldest) {
+			const timer = this.evictionTimers.get(oldest.id);
+			if (timer) clearTimeout(timer);
+			this.evictionTimers.delete(oldest.id);
+			this.jobs.delete(oldest.id);
+		}
+	}
+}

package/dist/resources/extensions/aws-auth/index.ts

@@ -0,0 +1,144 @@
+/**
+ * AWS Auth Refresh Extension
+ *
+ * Automatically refreshes AWS credentials when Bedrock API requests fail
+ * with authentication/token errors, then retries the user's message.
+ *
+ * ## How it works
+ *
+ * Hooks into `agent_end` to check if the last assistant message failed with
+ * an AWS auth error (expired SSO token, missing credentials, etc.). If so:
+ *
+ *   1. Runs the configured `awsAuthRefresh` command (e.g. `aws sso login`)
+ *   2. Streams the SSO auth URL and verification code to the TUI so users
+ *      can copy/paste if the browser doesn't auto-open
+ *   3. Calls `retryLastTurn()` which removes the failed assistant response
+ *      and re-runs the agent from the user's original message
+ *
+ * ## Activation
+ *
+ * This extension is completely inert unless BOTH conditions are met:
+ *   1. A Bedrock API request fails with a recognized AWS auth error
+ *   2. `awsAuthRefresh` is configured in settings.json
+ *
+ * Non-Bedrock users and Bedrock users without `awsAuthRefresh` configured
+ * are not affected in any way.
+ *
+ * ## Setup
+ *
+ * Add to ~/.gsd/agent/settings.json (or project-level .gsd/settings.json):
+ *
+ *   { "awsAuthRefresh": "aws sso login --profile my-profile" }
+ *
+ * ## Matched error patterns
+ *
+ * The extension recognizes errors from the AWS SDK, Bedrock, and SSO
+ * credential providers including:
+ *   - ExpiredTokenException / ExpiredToken
+ *   - The security token included in the request is expired
+ *   - The SSO session associated with this profile has expired or is invalid
+ *   - Unable to locate credentials / Could not load credentials
+ *   - UnrecognizedClientException
+ *   - Error loading SSO Token / Token does not exist
+ *   - SSOTokenProviderFailure
+ */
+
+import { exec } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import type { ExtensionAPI } from "@gsd/pi-coding-agent";
+
+/** Matches AWS SDK / Bedrock / SSO credential and token errors. */
+const AWS_AUTH_ERROR_RE =
+	/ExpiredToken|security token.*expired|unable to locate credentials|SSO.*(?:session|token).*(?:expired|not found|invalid)|UnrecognizedClient|Could not load credentials|Invalid identity token|token is expired|credentials.*(?:could not|cannot|failed to).*(?:load|resolve|find)|The.*token.*is.*not.*valid|token has expired|SSOTokenProviderFailure|Error loading SSO Token|Token.*does not exist/i;
+
+/**
+ * Reads the `awsAuthRefresh` command from settings.json.
+ * Checks project-level first, then global (~/.gsd/agent/settings.json).
+ */
+function getAwsAuthRefreshCommand(): string | undefined {
+	const configDir = process.env.PI_CONFIG_DIR || ".gsd";
+	const paths = [
+		join(process.cwd(), configDir, "settings.json"),
+		join(homedir(), configDir, "agent", "settings.json"),
+	];
+	for (const settingsPath of paths) {
+		if (!existsSync(settingsPath)) continue;
+		try {
+			const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+			if (settings.awsAuthRefresh) return settings.awsAuthRefresh;
+		} catch {}
+	}
+	return undefined;
+}
+
+/**
+ * Runs the refresh command with a 2-minute timeout (for SSO browser flows).
+ * Streams stdout/stderr to capture and display the SSO auth URL and
+ * verification code in real-time via TUI notifications.
+ */
+async function runRefresh(
+	command: string,
+	notify: (msg: string, level: "info" | "warning" | "error") => void,
+): Promise<boolean> {
+	notify("Refreshing AWS credentials...", "info");
+	try {
+		await new Promise<void>((resolve, reject) => {
+			const child = exec(command, { timeout: 120_000, env: { ...process.env } });
+			const onData = (data: Buffer | string) => {
+				const text = data.toString();
+				const urlMatch = text.match(/https?:\/\/\S+/);
+				if (urlMatch) {
+					notify(`Open this URL if the browser didn't launch: ${urlMatch[0]}`, "warning");
+				}
+				const codeMatch = text.match(/code[:\s]+([A-Z]{4}-[A-Z]{4})/i);
+				if (codeMatch) {
+					notify(`Verification code: ${codeMatch[1]}`, "info");
+				}
+			};
+			child.stdout?.on("data", onData);
+			child.stderr?.on("data", onData);
+			child.on("close", (code) => {
+				if (code === 0) resolve();
+				else reject(new Error(`Refresh command exited with code ${code}`));
+			});
+			child.on("error", reject);
+		});
+		notify("AWS credentials refreshed successfully ✓", "info");
+		return true;
+	} catch (error) {
+		const msg = error instanceof Error ? error.message : String(error);
+		const isTimeout = /timed out|ETIMEDOUT|killed/i.test(msg);
+		if (isTimeout) {
+			notify("AWS credential refresh timed out. The SSO login may have been cancelled or the browser window was closed.", "error");
+		} else {
+			notify(`AWS credential refresh failed: ${msg}`, "error");
+		}
+		return false;
+	}
+}
+
+export default function (pi: ExtensionAPI) {
+	pi.on("agent_end", async (event, ctx) => {
+		const refreshCommand = getAwsAuthRefreshCommand();
+		if (!refreshCommand) return;
+
+		const messages = event.messages;
+		const lastAssistant = messages[messages.length - 1];
+		if (
+			!lastAssistant ||
+			lastAssistant.role !== "assistant" ||
+			!("errorMessage" in lastAssistant) ||
+			!lastAssistant.errorMessage ||
+			!AWS_AUTH_ERROR_RE.test(lastAssistant.errorMessage)
+		) {
+			return;
+		}
+
+		const refreshed = await runRefresh(refreshCommand, (m, level) => ctx.ui.notify(m, level));
+		if (!refreshed) return;
+
+		pi.retryLastTurn();
+	});
+}