gsd-pi 2.33.1-dev.29a8268 → 2.33.1-dev.b1c6556

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();
+    });
+}

package/dist/resources/extensions/bg-shell/bg-shell-command.js

@@ -0,0 +1,182 @@
+/**
+ * /bg slash command registration — interactive process manager overlay and CLI subcommands.
+ */
+import { Key } from "@gsd/pi-tui";
+import { shortcutDesc } from "../shared/terminal.js";
+import { processes, killProcess, getGroupStatus, cleanupAll, } from "./process-manager.js";
+import { generateDigest, getOutput, formatDigestText, } from "./output-formatter.js";
+import { formatUptime } from "./utilities.js";
+import { BgManagerOverlay } from "./overlay.js";
+export function registerBgShellCommand(pi, state) {
+    pi.registerCommand("bg", {
+        description: "Manage background processes: /bg [list|output|kill|killall|groups] [id]",
+        getArgumentCompletions: (prefix) => {
+            const subcommands = ["list", "output", "kill", "killall", "groups", "digest"];
+            const parts = prefix.trim().split(/\s+/);
+            if (parts.length <= 1) {
+                return subcommands
+                    .filter(cmd => cmd.startsWith(parts[0] ?? ""))
+                    .map(cmd => ({ value: cmd, label: cmd }));
+            }
+            if (parts[0] === "output" || parts[0] === "kill" || parts[0] === "digest") {
+                const idPrefix = parts[1] ?? "";
+                return Array.from(processes.values())
+                    .filter(p => p.id.startsWith(idPrefix))
+                    .map(p => ({
+                    value: `${parts[0]} ${p.id}`,
+                    label: `${p.id} — ${p.label}`,
+                }));
+            }
+            return [];
+        },
+        handler: async (args, ctx) => {
+            const parts = args.trim().split(/\s+/);
+            const sub = parts[0] || "list";
+            if (sub === "list" || sub === "") {
+                if (processes.size === 0) {
+                    ctx.ui.notify("No background processes.", "info");
+                    return;
+                }
+                if (!ctx.hasUI) {
+                    const lines = Array.from(processes.values()).map(p => {
+                        const statusIcon = p.alive
+                            ? (p.status === "ready" ? "✓" : p.status === "error" ? "✗" : "⋯")
+                            : "○";
+                        const uptime = formatUptime(Date.now() - p.startedAt);
+                        const portInfo = p.ports.length > 0 ? ` :${p.ports.join(",")}` : "";
+                        return `${p.id}  ${statusIcon} ${p.status}  ${uptime}  ${p.label}  [${p.processType}]${portInfo}`;
+                    });
+                    ctx.ui.notify(lines.join("\n"), "info");
+                    return;
+                }
+                await ctx.ui.custom((tui, theme, _kb, done) => {
+                    return new BgManagerOverlay(tui, theme, () => {
+                        done();
+                        state.refreshWidget();
+                    });
+                }, {
+                    overlay: true,
+                    overlayOptions: {
+                        width: "60%",
+                        minWidth: 50,
+                        maxHeight: "70%",
+                        anchor: "center",
+                    },
+                });
+                return;
+            }
+            if (sub === "output" || sub === "digest") {
+                const id = parts[1];
+                if (!id) {
+                    ctx.ui.notify(`Usage: /bg ${sub} <id>`, "error");
+                    return;
+                }
+                const bg = processes.get(id);
+                if (!bg) {
+                    ctx.ui.notify(`No process with id '${id}'`, "error");
+                    return;
+                }
+                if (!ctx.hasUI) {
+                    if (sub === "digest") {
+                        const digest = generateDigest(bg);
+                        ctx.ui.notify(formatDigestText(bg, digest), "info");
+                    }
+                    else {
+                        const output = getOutput(bg, { stream: "both", tail: 50 });
+                        ctx.ui.notify(output || "(no output)", "info");
+                    }
+                    return;
+                }
+                await ctx.ui.custom((tui, theme, _kb, done) => {
+                    const overlay = new BgManagerOverlay(tui, theme, () => {
+                        done();
+                        state.refreshWidget();
+                    });
+                    const procs = Array.from(processes.values());
+                    const idx = procs.findIndex(p => p.id === id);
+                    if (idx >= 0)
+                        overlay.selectAndView(idx);
+                    return overlay;
+                }, {
+                    overlay: true,
+                    overlayOptions: {
+                        width: "60%",
+                        minWidth: 50,
+                        maxHeight: "70%",
+                        anchor: "center",
+                    },
+                });
+                return;
+            }
+            if (sub === "kill") {
+                const id = parts[1];
+                if (!id) {
+                    ctx.ui.notify("Usage: /bg kill <id>", "error");
+                    return;
+                }
+                const bg = processes.get(id);
+                if (!bg) {
+                    ctx.ui.notify(`No process with id '${id}'`, "error");
+                    return;
+                }
+                killProcess(id, "SIGTERM");
+                await new Promise(r => setTimeout(r, 300));
+                if (bg.alive) {
+                    killProcess(id, "SIGKILL");
+                    await new Promise(r => setTimeout(r, 200));
+                }
+                if (!bg.alive)
+                    processes.delete(id);
+                ctx.ui.notify(`Killed process ${id} (${bg.label})`, "info");
+                return;
+            }
+            if (sub === "killall") {
+                const count = processes.size;
+                cleanupAll();
+                ctx.ui.notify(`Killed ${count} background process(es)`, "info");
+                return;
+            }
+            if (sub === "groups") {
+                const groups = new Set();
+                for (const p of processes.values()) {
+                    if (p.group)
+                        groups.add(p.group);
+                }
+                if (groups.size === 0) {
+                    ctx.ui.notify("No process groups defined.", "info");
+                    return;
+                }
+                const lines = Array.from(groups).map(g => {
+                    const gs = getGroupStatus(g);
+                    const icon = gs.healthy ? "✓" : "✗";
+                    const procs = gs.processes.map(p => `${p.id}(${p.status})`).join(", ");
+                    return `${icon} ${g}: ${procs}`;
+                });
+                ctx.ui.notify(lines.join("\n"), "info");
+                return;
+            }
+            ctx.ui.notify("Usage: /bg [list|output|digest|kill|killall|groups] [id]", "info");
+        },
+    });
+    // ── Ctrl+Alt+B shortcut ──────────────────────────────────────────────
+    pi.registerShortcut(Key.ctrlAlt("b"), {
+        description: shortcutDesc("Open background process manager", "/bg"),
+        handler: async (ctx) => {
+            state.latestCtx = ctx;
+            await ctx.ui.custom((tui, theme, _kb, done) => {
+                return new BgManagerOverlay(tui, theme, () => {
+                    done();
+                    state.refreshWidget();
+                });
+            }, {
+                overlay: true,
+                overlayOptions: {
+                    width: "60%",
+                    minWidth: 50,
+                    maxHeight: "70%",
+                    anchor: "center",
+                },
+            });
+        },
+    });
+}