gsd-pi 2.33.1 → 2.34.0-dev.0150ae9

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

@@ -0,0 +1,90 @@
+/**
+ * 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 } from "@sinclair/typebox";
+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) {
+    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;
+            if (jobIds && jobIds.length > 0) {
+                watched = [];
+                const notFound = [];
+                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) {
+    if (jobs.length === 0)
+        return "No completed jobs.";
+    const parts = [];
+    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.js

@@ -0,0 +1,28 @@
+/**
+ * cancel_job tool — cancel a running background job.
+ */
+import { Type } from "@sinclair/typebox";
+const schema = Type.Object({
+    job_id: Type.String({ description: "The background job ID to cancel (e.g. bg_a1b2c3d4)" }),
+});
+export function createCancelJobTool(getManager) {
+    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 = {
+                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.js

@@ -0,0 +1,119 @@
+/**
+ * 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 { AsyncJobManager } 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) {
+    let manager = null;
+    let latestCwd = process.cwd();
+    function getManager() {
+        if (!manager) {
+            throw new Error("AsyncJobManager not initialized. Wait for session_start.");
+        }
+        return manager;
+    }
+    function getCwd() {
+        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, _ctx) => {
+            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 = ["## 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.js

@@ -0,0 +1,159 @@
+/**
+ * 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";
+// ── Manager ────────────────────────────────────────────────────────────────
+export class AsyncJobManager {
+    jobs = new Map();
+    evictionTimers = new Map();
+    maxRunning;
+    maxTotal;
+    evictionMs;
+    onJobComplete;
+    constructor(options = {}) {
+        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, label, runFn) {
+        // 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 = {
+            id,
+            type,
+            status: "running",
+            startTime: Date.now(),
+            label,
+            abortController,
+            // promise assigned below
+            promise: undefined,
+        };
+        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) {
+        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) {
+        return this.jobs.get(id);
+    }
+    getRunningJobs() {
+        return [...this.jobs.values()].filter((j) => j.status === "running");
+    }
+    getRecentJobs(limit = 10) {
+        return [...this.jobs.values()]
+            .sort((a, b) => b.startTime - a.startTime)
+            .slice(0, limit);
+    }
+    getAllJobs() {
+        return [...this.jobs.values()];
+    }
+    /**
+     * No-op. Retained for API compatibility with await_job tool.
+     */
+    acknowledgeDeliveries(_jobIds) {
+        // Delivery is fire-once; no retries to cancel.
+    }
+    /**
+     * Cleanup all timers and resources.
+     */
+    shutdown() {
+        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 ────────────────────────────────────────────────────────────
+    deliverResult(job) {
+        if (!this.onJobComplete)
+            return;
+        this.onJobComplete(job);
+    }
+    scheduleEviction(id) {
+        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);
+    }
+    evictOldest() {
+        let oldest;
+        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.js

@@ -0,0 +1,138 @@
+/**
+ * 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";
+/** 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() {
+    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, notify) {
+    notify("Refreshing AWS credentials...", "info");
+    try {
+        await new Promise((resolve, reject) => {
+            const child = exec(command, { timeout: 120_000, env: { ...process.env } });
+            const onData = (data) => {
+                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) {
+    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();
+    });
+}