pi-ui-extend 0.1.9 → 0.1.13

package/dist/app/session/tabs-controller.js

@@ -7,7 +7,7 @@ import { isRecord } from "../guards.js";
 import { createId } from "../id.js";
 import { createStartupInfoMessage, isEmptyStartupSession } from "../cli/startup-info.js";
 import { tabPanelRows } from "../rendering/tab-line-renderer.js";
-const TAB_STATE_VERSION = 2;
+const TAB_STATE_VERSION = 3;
 const MAX_RESTORED_TABS = 8;
 const TAB_ATTENTION_BLINK_KEY = "tab-attention";
 export class AppTabsController {
@@ -16,6 +16,7 @@ export class AppTabsController {
     runtimesByTabId = new Map();
     runtimeSubscriptionsByTabId = new Map();
     inputStatesByTabId = new Map();
+    deferredUserMessagesByTabId = new Map();
     activeTabId;
     pendingActiveTabId;
     historyLoadGeneration = 0;
@@ -96,8 +97,13 @@ export class AppTabsController {
     async saveInputStateForQuit() {
         this.syncActiveTabFromRuntime({ save: false });
         this.storeActiveInputState();
+        this.storeActiveDeferredUserMessages();
         await this.saveTabs();
     }
+    persistActiveDeferredUserMessages() {
+        this.storeActiveDeferredUserMessages();
+        void this.saveTabs();
+    }
     syncActiveTabFromRuntime(options = {}) {
         if (this.pendingActiveTabId && options.force !== true)
             return;
@@ -108,14 +114,17 @@ export class AppTabsController {
         const active = this.activeTab();
         const existing = sessionPath ? this.findTabBySessionPath(sessionPath, active ? { excludeTabId: active.id } : {}) : undefined;
         if (existing) {
-            if (active)
+            if (active) {
                 this.storeActiveInputState();
+                this.storeActiveDeferredUserMessages();
+            }
             this.activeTabId = existing.id;
             this.clearTabAttention(existing);
             this.updateTabFromSession(existing, session);
             if (active)
                 this.deleteRuntimeForTab(active.id);
             this.storeActiveRuntime();
+            this.restoreDeferredUserMessages(existing.id);
             if (options.save !== false)
                 void this.saveTabs();
             return;
@@ -167,6 +176,7 @@ export class AppTabsController {
                 : restoredTabs[0]?.sessionPath;
         this.replaceTabs(restoredTabs, desiredPath);
         this.restorePersistedInputStates(saved);
+        this.restorePersistedDeferredUserMessages(saved);
         if (explicitSessionPath && currentPath)
             this.ensureCurrentSessionTab(runtime.session);
         if (!desiredPath) {
@@ -191,6 +201,8 @@ export class AppTabsController {
         }
         this.syncActiveTabFromRuntime({ save: false });
         this.host.resetSessionView();
+        if (this.activeTabId)
+            this.restoreDeferredUserMessages(this.activeTabId);
         this.host.loadSessionHistory();
         this.host.setSessionStatus(runtime.session);
         this.host.setSessionActivity(this.sessionActivity(runtime.session));
@@ -211,6 +223,7 @@ export class AppTabsController {
         this.cancelHistoryLoad();
         this.syncActiveTabFromRuntime();
         this.storeActiveInputState();
+        this.storeActiveDeferredUserMessages();
         this.host.setStatus("starting new tab");
         this.host.render();
         const newRuntime = await this.host.createRuntimeForNewSession();
@@ -233,6 +246,7 @@ export class AppTabsController {
         }
         void this.saveTabs();
         this.host.resetSessionView();
+        this.restoreDeferredUserMessages(tab.id);
         if (isEmptyStartupSession(newRuntime)) {
             this.host.addEntry({ id: createId("system"), kind: "system", text: createStartupInfoMessage(newRuntime) });
         }
@@ -270,6 +284,7 @@ export class AppTabsController {
         }
         this.cancelHistoryLoad();
         this.storeActiveInputState();
+        this.storeActiveDeferredUserMessages();
         const previousTabId = this.activeTabId;
         const previousRuntime = runtime;
         this.host.setStatus("opening session tab");
@@ -312,6 +327,8 @@ export class AppTabsController {
             void this.host.disposeRuntime(newRuntime);
             this.host.showToast("Could not open session tab", "warning");
             this.host.resetSessionView();
+            if (previousTabId)
+                this.restoreDeferredUserMessages(previousTabId);
             this.host.loadSessionHistory();
             this.host.setSessionStatus(this.host.runtime()?.session);
             this.host.setSessionActivity(this.sessionActivity(this.host.runtime()?.session));
@@ -353,12 +370,14 @@ export class AppTabsController {
         const previousTargetActivity = target.activity;
         this.storeActiveRuntime(runtime);
         this.storeActiveInputState();
+        this.storeActiveDeferredUserMessages();
         this.activeTabId = target.id;
         this.pendingActiveTabId = target.id;
         target.activity = "thinking";
         this.clearTabAttention(target);
         this.restoreInputState(target.id);
         this.host.resetSessionView();
+        this.restoreDeferredUserMessages(target.id);
         this.host.setStatus("switching tab");
         this.host.setSessionActivity("thinking");
         this.host.render();
@@ -388,6 +407,8 @@ export class AppTabsController {
             }
             this.host.showToast("Could not switch tab", "warning");
             this.host.resetSessionView();
+            if (previousTabId)
+                this.restoreDeferredUserMessages(previousTabId);
             this.host.loadSessionHistory();
             const activeSession = this.host.runtime()?.session;
             this.host.setSessionStatus(activeSession);
@@ -426,7 +447,9 @@ export class AppTabsController {
             this.tabItems.splice(index, 1);
             this.deleteRuntimeForTab(tabId);
             this.inputStatesByTabId.delete(tabId);
+            this.deferredUserMessagesByTabId.delete(tabId);
             this.storeActiveInputState();
+            this.storeActiveDeferredUserMessages();
             this.stopAttentionBlinkIfIdle();
             if (tabRuntime)
                 void this.host.disposeRuntime(tabRuntime);
@@ -451,6 +474,7 @@ export class AppTabsController {
         this.tabItems.splice(index, 1);
         this.deleteRuntimeForTab(tabId);
         this.inputStatesByTabId.delete(tabId);
+        this.deferredUserMessagesByTabId.delete(tabId);
         this.stopAttentionBlinkIfIdle();
         this.activeTabId = nextTab.id;
         this.clearTabAttention(nextTab);
@@ -483,9 +507,11 @@ export class AppTabsController {
         this.updateTabFromSession(tab, runtime.session);
         this.setRuntimeForTab(tab.id, runtime);
         this.inputStatesByTabId.delete(tab.id);
+        this.deferredUserMessagesByTabId.delete(tab.id);
         this.restoreInputState(tab.id);
         this.stopAttentionBlinkIfIdle();
         this.host.resetSessionView();
+        this.restoreDeferredUserMessages(tab.id);
         this.host.addEntry({ id: createId("system"), kind: "system", text: `Started a new session. cwd=${runtime.cwd}` });
         if (runtime.modelFallbackMessage)
             this.host.addEntry({ id: createId("system"), kind: "system", text: runtime.modelFallbackMessage });
@@ -502,6 +528,8 @@ export class AppTabsController {
         const generation = ++this.historyLoadGeneration;
         const isCancelled = () => generation !== this.historyLoadGeneration || this.host.runtime() !== runtime;
         this.host.resetSessionView();
+        if (this.activeTabId)
+            this.restoreDeferredUserMessages(this.activeTabId);
         this.host.setStatus("loading session history");
         this.host.setSessionActivity("thinking");
         this.host.render();
@@ -620,9 +648,31 @@ export class AppTabsController {
             cursor: state.cursor,
         });
     }
+    storeActiveDeferredUserMessages() {
+        if (!this.activeTabId || !this.host.captureDeferredUserMessages)
+            return;
+        const messages = this.host.captureDeferredUserMessages();
+        if (messages.length > 0) {
+            this.deferredUserMessagesByTabId.set(this.activeTabId, messages.map((message) => this.cloneSubmittedUserMessage(message)));
+        }
+        else {
+            this.deferredUserMessagesByTabId.delete(this.activeTabId);
+        }
+    }
     restoreInputState(tabId) {
         this.host.restoreInputState(this.inputStatesByTabId.get(tabId) ?? { text: "", cursor: 0 });
     }
+    restoreDeferredUserMessages(tabId) {
+        this.host.restoreDeferredUserMessages?.(this.deferredUserMessagesByTabId.get(tabId) ?? []);
+    }
+    cloneSubmittedUserMessage(message) {
+        return {
+            id: message.id,
+            promptText: message.promptText,
+            displayText: message.displayText,
+            images: message.images.map((image) => ({ ...image })),
+        };
+    }
     async runtimeForTab(tab) {
         const existing = this.runtimesByTabId.get(tab.id);
         if (existing)
@@ -650,6 +700,7 @@ export class AppTabsController {
         this.runtimesByTabId.clear();
         this.clearRuntimeSubscriptions();
         this.inputStatesByTabId.clear();
+        this.deferredUserMessagesByTabId.clear();
         const seen = new Set();
         for (const tab of tabs) {
             const sessionPath = tab.sessionPath ? resolve(tab.sessionPath) : undefined;
@@ -678,6 +729,7 @@ export class AppTabsController {
             this.tabItems.splice(index, 1);
         this.deleteRuntimeForTab(tabId);
         this.inputStatesByTabId.delete(tabId);
+        this.deferredUserMessagesByTabId.delete(tabId);
     }
     restorePersistedInputStates(saved) {
         const inputsByPath = new Map();
@@ -695,6 +747,22 @@ export class AppTabsController {
             this.inputStatesByTabId.set(tab.id, input);
         }
     }
+    restorePersistedDeferredUserMessages(saved) {
+        const messagesByPath = new Map();
+        for (const tab of saved.tabs) {
+            if (!tab.deferredUserMessages || tab.deferredUserMessages.length === 0)
+                continue;
+            messagesByPath.set(resolve(tab.path), tab.deferredUserMessages.map((message) => this.cloneSubmittedUserMessage(message)));
+        }
+        for (const tab of this.tabItems) {
+            if (!tab.sessionPath)
+                continue;
+            const messages = messagesByPath.get(resolve(tab.sessionPath));
+            if (!messages || messages.length === 0)
+                continue;
+            this.deferredUserMessagesByTabId.set(tab.id, messages);
+        }
+    }
     ensureCurrentSessionTab(session) {
         const currentPath = session.sessionFile ? resolve(session.sessionFile) : undefined;
         if (!currentPath)
@@ -783,7 +851,8 @@ export class AppTabsController {
         for (const tab of saved.tabs) {
             const sessionPath = resolve(tab.path);
             const hasDraftInput = (tab.input?.text.length ?? 0) > 0;
-            if (seen.has(sessionPath) || (!existsSync(sessionPath) && !hasDraftInput))
+            const hasDeferredQueue = (tab.deferredUserMessages?.length ?? 0) > 0;
+            if (seen.has(sessionPath) || (!existsSync(sessionPath) && !hasDraftInput && !hasDeferredQueue))
                 continue;
             seen.add(sessionPath);
             const title = titles.get(sessionPath) ?? tab.title?.trim();
@@ -802,21 +871,23 @@ export class AppTabsController {
         try {
             const raw = await readFile(this.filePath(), "utf8");
             const parsed = JSON.parse(raw);
-            if (!isRecord(parsed) || (parsed.version !== 1 && parsed.version !== TAB_STATE_VERSION) || !Array.isArray(parsed.tabs))
+            if (!isRecord(parsed) || (parsed.version !== 1 && parsed.version !== 2 && parsed.version !== TAB_STATE_VERSION) || !Array.isArray(parsed.tabs))
                 return undefined;
             const tabs = [];
             for (const value of parsed.tabs) {
                 if (!isRecord(value) || typeof value.path !== "string")
                     continue;
                 const input = this.parsePersistedInputState(value.input);
+                const deferredUserMessages = this.parsePersistedSubmittedUserMessages(value.deferredUserMessages);
                 tabs.push({
                     path: value.path,
                     ...(typeof value.title === "string" ? { title: value.title } : {}),
                     ...(input ? { input } : {}),
+                    ...(deferredUserMessages.length > 0 ? { deferredUserMessages } : {}),
                 });
             }
             return {
-                version: parsed.version === 1 ? 1 : TAB_STATE_VERSION,
+                version: parsed.version === 1 ? 1 : parsed.version === 2 ? 2 : TAB_STATE_VERSION,
                 cwd: typeof parsed.cwd === "string" ? parsed.cwd : this.host.options.cwd,
                 tabs,
                 ...(typeof parsed.activePath === "string" ? { activePath: parsed.activePath } : {}),
@@ -836,6 +907,27 @@ export class AppTabsController {
             : value.text.length;
         return { text: value.text, cursor };
     }
+    parsePersistedSubmittedUserMessages(value) {
+        if (!Array.isArray(value))
+            return [];
+        const messages = [];
+        for (const item of value) {
+            if (!isRecord(item) || typeof item.promptText !== "string" || typeof item.displayText !== "string")
+                continue;
+            const images = Array.isArray(item.images)
+                ? item.images.flatMap((image) => (isRecord(image) && typeof image.data === "string" && typeof image.mimeType === "string"
+                    ? [{ type: "image", data: image.data, mimeType: image.mimeType }]
+                    : []))
+                : [];
+            messages.push({
+                id: typeof item.id === "string" ? item.id : createId("queued-user"),
+                promptText: item.promptText,
+                displayText: item.displayText,
+                images,
+            });
+        }
+        return messages;
+    }
     async saveTabs() {
         if (this.host.options.noSession)
             return;
@@ -857,6 +949,10 @@ export class AppTabsController {
                         cursor: Math.max(0, Math.min(input.text.length, Math.trunc(input.cursor))),
                     };
                 }
+                const deferredUserMessages = this.deferredUserMessagesByTabId.get(tab.id);
+                if (deferredUserMessages && deferredUserMessages.length > 0) {
+                    persistedTab.deferredUserMessages = deferredUserMessages.map((message) => this.cloneSubmittedUserMessage(message));
+                }
                 tabs.push(persistedTab);
             }
             if (tabs.length === 0)

package/dist/app/terminal/nerd-font-controller.d.ts

@@ -1,3 +1,18 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { mkdir, readdir, writeFile } from "node:fs/promises";
+import { commandExists, runProcess } from "../process.js";
+type NerdFontControllerDeps = {
+    commandExists: typeof commandExists;
+    existsSync: typeof existsSync;
+    fetch: typeof fetch;
+    mkdir: typeof mkdir;
+    readdir: typeof readdir;
+    runProcess: typeof runProcess;
+    spawn: typeof spawn;
+    writeFile: typeof writeFile;
+};
+export declare function setNerdFontControllerTestDeps(overrides: Partial<NerdFontControllerDeps>): () => void;
 export type NerdFontInstallHost = {
     showToast(message: string, kind: "success" | "error" | "warning" | "info"): void;
     render(): void;
@@ -15,3 +30,4 @@ export declare class NerdFontController {
 export declare function isJetBrainsNerdFontInstalled(): Promise<boolean>;
 export declare function installJetBrainsNerdFont(): Promise<string>;
 export declare function userFontInstallPath(): string;
+export {};

package/dist/app/terminal/nerd-font-controller.js

@@ -1,8 +1,17 @@
-import { spawn, spawnSync } from "node:child_process";
+import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
 import { mkdir, readdir, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
+import { commandExists, runProcess } from "../process.js";
+let deps = { commandExists, existsSync, fetch, mkdir, readdir, runProcess, spawn, writeFile };
+export function setNerdFontControllerTestDeps(overrides) {
+    const previous = deps;
+    deps = { ...deps, ...overrides };
+    return () => {
+        deps = previous;
+    };
+}
 const CASK_NAME = "font-jetbrains-mono-nerd-font";
 export const FONT_FAMILY_NAME = "JetBrainsMono Nerd Font Mono";
 export const FONT_FILE_NAME = "JetBrainsMonoNerdFontMono-Regular.ttf";
@@ -42,10 +51,13 @@ export class NerdFontController {
     }
 }
 export async function isJetBrainsNerdFontInstalled() {
-    if (commandExists("brew") && spawnSync("brew", ["list", "--cask", CASK_NAME], { stdio: "ignore" }).status === 0)
-        return true;
-    if (process.platform === "linux" && commandExists("fc-match")) {
-        const result = spawnSync("fc-match", ["-f", "%{family}", FONT_FAMILY_NAME], { encoding: "utf8" });
+    if (await deps.commandExists("brew")) {
+        const result = await deps.runProcess("brew", ["list", "--cask", CASK_NAME], { maxBufferBytes: 1024 });
+        if (result.status === 0)
+            return true;
+    }
+    if (process.platform === "linux" && await deps.commandExists("fc-match")) {
+        const result = await deps.runProcess("fc-match", ["-f", "%{family}", FONT_FAMILY_NAME], { maxBufferBytes: 1024 });
         if (result.status === 0 && /JetBrains.*Nerd/iu.test(result.stdout))
             return true;
     }
@@ -57,13 +69,13 @@ export async function isJetBrainsNerdFontInstalled() {
     return false;
 }
 export async function installJetBrainsNerdFont() {
-    if (process.platform === "darwin" && commandExists("brew")) {
+    if (process.platform === "darwin" && await deps.commandExists("brew")) {
         await runBrewInstall();
         return CASK_NAME;
     }
     const targetPath = userFontInstallPath();
-    await mkdir(dirname(targetPath), { recursive: true });
-    const response = await fetch(FONT_DOWNLOAD_URL, {
+    await deps.mkdir(dirname(targetPath), { recursive: true });
+    const response = await deps.fetch(FONT_DOWNLOAD_URL, {
         headers: { "User-Agent": "pix-font-installer" },
         signal: AbortSignal.timeout(30_000),
     });
@@ -72,11 +84,11 @@ export async function installJetBrainsNerdFont() {
     const bytes = new Uint8Array(await response.arrayBuffer());
     if (bytes.length < 100_000)
         throw new Error("downloaded font is unexpectedly small");
-    await writeFile(targetPath, bytes);
+    await deps.writeFile(targetPath, bytes);
     if (process.platform === "linux")
-        runOptionalCommand("fc-cache", ["-f", dirname(targetPath)]);
+        await runOptionalCommand("fc-cache", ["-f", dirname(targetPath)]);
     if (process.platform === "win32")
-        registerWindowsUserFont(targetPath);
+        await registerWindowsUserFont(targetPath);
     return targetPath;
 }
 export function userFontInstallPath() {
@@ -103,7 +115,7 @@ function platformFontDirs() {
     }
 }
 async function directoryContainsFont(root) {
-    if (!existsSync(root))
+    if (!deps.existsSync(root))
         return false;
     const pending = [{ dir: root, depth: 0 }];
     let scanned = 0;
@@ -113,7 +125,7 @@ async function directoryContainsFont(root) {
             continue;
         let entries;
         try {
-            entries = await readdir(current.dir, { withFileTypes: true });
+            entries = await deps.readdir(current.dir, { withFileTypes: true });
         }
         catch {
             continue;
@@ -130,7 +142,7 @@ async function directoryContainsFont(root) {
 }
 async function runBrewInstall() {
     await new Promise((resolve, reject) => {
-        const child = spawn("brew", ["install", "--cask", CASK_NAME], {
+        const child = deps.spawn("brew", ["install", "--cask", CASK_NAME], {
             env: { ...process.env, HOMEBREW_NO_AUTO_UPDATE: "1" },
             stdio: ["ignore", "ignore", "pipe"],
         });
@@ -147,10 +159,10 @@ async function runBrewInstall() {
         });
     });
 }
-function registerWindowsUserFont(fontPath) {
+async function registerWindowsUserFont(fontPath) {
     const escapedPath = fontPath.replaceAll("'", "''");
     const escapedName = `${FONT_FAMILY_NAME} (TrueType)`.replaceAll("'", "''");
-    runOptionalCommand("powershell.exe", [
+    await runOptionalCommand("powershell.exe", [
         "-NoProfile",
         "-ExecutionPolicy",
         "Bypass",
@@ -158,13 +170,8 @@ function registerWindowsUserFont(fontPath) {
         `New-Item -Path 'HKCU:\\Software\\Microsoft\\Windows NT\\CurrentVersion\\Fonts' -Force | Out-Null; New-ItemProperty -Path 'HKCU:\\Software\\Microsoft\\Windows NT\\CurrentVersion\\Fonts' -Name '${escapedName}' -Value '${escapedPath}' -PropertyType String -Force | Out-Null`,
     ]);
 }
-function runOptionalCommand(command, args) {
-    spawnSync(command, args, { stdio: "ignore" });
-}
-function commandExists(command) {
-    if (process.platform === "win32")
-        return spawnSync("where", [command], { stdio: "ignore" }).status === 0;
-    return spawnSync("sh", ["-lc", `command -v ${command}`], { stdio: "ignore" }).status === 0;
+async function runOptionalCommand(command, args) {
+    await deps.runProcess(command, args, { maxBufferBytes: 1024 });
 }
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);

package/dist/app/terminal/terminal-controller.d.ts

@@ -13,6 +13,7 @@ export type AppTerminalControllerHost = {
     stopSubagentsPolling(): void;
     stopModelUsagePolling(): void;
     stopVoiceInput(): Promise<void>;
+    stopAutocomplete(): void;
     stopShellCommand(): void;
     unsubscribeSession(): void;
     clearExtensionWidgets(): void;

package/dist/app/terminal/terminal-controller.js

@@ -104,6 +104,7 @@ export class AppTerminalController {
         this.host.stopSubagentsPolling();
         this.host.stopModelUsagePolling();
         await this.host.stopVoiceInput();
+        this.host.stopAutocomplete();
         this.host.stopShellCommand();
         process.stdin.off("data", this.onInputData);
         process.stdin.pause();

package/dist/app/types.d.ts

@@ -264,6 +264,7 @@ export type StatusLineLayout = {
     modelUsageLabel?: string;
     contextBarLabel?: string;
     userJumpWidget?: StatusUserJumpWidgetLayout;
+    draftQueueWidget?: StatusDraftQueueWidgetLayout;
     thinkingExpandWidget?: StatusThinkingExpandWidgetLayout;
     compactToolsWidget?: StatusCompactToolsWidgetLayout;
     terminalBellSoundWidget?: StatusTerminalBellSoundWidgetLayout;
@@ -274,6 +275,10 @@ export type StatusUserJumpWidgetLayout = {
     startColumn: number;
     endColumn: number;
 };
+export type StatusDraftQueueWidgetLayout = {
+    startColumn: number;
+    endColumn: number;
+};
 export type StatusThinkingExpandWidgetLayout = {
     startColumn: number;
     endColumn: number;
@@ -357,6 +362,10 @@ export type RenderedInput = {
         start: number;
         end: number;
     }[])[];
+    suggestionSpans: readonly (readonly {
+        start: number;
+        end: number;
+    }[])[];
 };
 export type ScrollBarMetrics = {
     top: number;
@@ -547,6 +556,11 @@ export type StatusUserJumpTarget = {
     startColumn: number;
     endColumn: number;
 };
+export type StatusDraftQueueTarget = {
+    row: number;
+    startColumn: number;
+    endColumn: number;
+};
 export type StatusThinkingExpandTarget = {
     row: number;
     startColumn: number;

package/dist/app/workspace/workspace-actions-controller.d.ts

@@ -28,7 +28,7 @@ export declare class AppWorkspaceActionsController {
     recordWorkspaceMutationForUserEntry(entryId: string, mutation: WorkspaceMutation): void;
     scheduleUserSessionEntryMetadataSync(): void;
     syncUserSessionEntryMetadata(): void;
-    copyUserMessage(entryId: string): void;
+    copyUserMessage(entryId: string): Promise<void>;
     forkFromUserMessage(entryId: string): Promise<void>;
     undoChangesFromUserMessage(entryId: string): Promise<void>;
     private resolveUserSessionEntryId;

package/dist/app/workspace/workspace-actions-controller.js

@@ -74,11 +74,11 @@ export class AppWorkspaceActionsController {
                 this.host.touchEntry(entry);
         }
     }
-    copyUserMessage(entryId) {
+    async copyUserMessage(entryId) {
         const entry = this.host.findUserEntry(entryId);
         if (!entry)
             throw new Error("User message is no longer available");
-        copyTextToClipboard(entry.text);
+        await copyTextToClipboard(entry.text);
         this.host.showToast("Message copied", "success");
         this.host.setSessionStatus(this.host.runtime()?.session);
     }
@@ -127,7 +127,7 @@ export class AppWorkspaceActionsController {
             this.host.setStatus("reverting recorded commands");
             this.host.render();
         }
-        const reverted = mutations.length === 0 ? { ok: true, changedFiles: 0, revertedChanges: 0 } : revertWorkspaceMutations(runtime.cwd, mutations);
+        const reverted = mutations.length === 0 ? { ok: true, changedFiles: 0, revertedChanges: 0 } : await revertWorkspaceMutations(runtime.cwd, mutations);
         if (!reverted.ok)
             throw new Error(reverted.error);
         this.host.setStatus("truncating session");

package/dist/app/workspace/workspace-undo.d.ts

@@ -41,4 +41,4 @@ export declare function loadWorkspaceUndoIndex(agentDir: string): WorkspaceUndoI
 export declare function saveWorkspaceUndoIndex(agentDir: string, index: WorkspaceUndoIndex): void;
 export declare function prepareWorkspaceMutation(cwd: string, toolName: string, args: unknown): WorkspaceMutationPreparation | undefined;
 export declare function workspaceMutationFromToolExecution(input: WorkspaceMutationFromToolInput): WorkspaceMutation | undefined;
-export declare function revertWorkspaceMutations(cwd: string, mutations: readonly WorkspaceMutation[]): WorkspaceRevertResult;
+export declare function revertWorkspaceMutations(cwd: string, mutations: readonly WorkspaceMutation[]): Promise<WorkspaceRevertResult>;

package/dist/app/workspace/workspace-undo.js

@@ -1,6 +1,7 @@
-import { spawnSync } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { runProcess } from "../process.js";
 const UNDO_INDEX_VERSION = 1;
 export function workspaceUndoIndexKey(_sessionFile, _sessionId, entryId) {
     return entryId;
@@ -63,13 +64,13 @@ export function workspaceMutationFromToolExecution(input) {
     }
     return undefined;
 }
-export function revertWorkspaceMutations(cwd, mutations) {
+export async function revertWorkspaceMutations(cwd, mutations) {
     const changedFiles = new Set();
     const applied = [];
     for (const mutation of [...mutations].reverse()) {
-        const result = applyMutation(cwd, mutation, "undo");
+        const result = await applyMutation(cwd, mutation, "undo");
         if (!result.ok) {
-            const rollback = rollbackMutations(cwd, applied);
+            const rollback = await rollbackMutations(cwd, applied);
             const rollbackText = rollback.ok ? "Rolled back already-applied undo steps." : `Rollback failed: ${rollback.error}`;
             return { ok: false, error: `${result.error}\n${rollbackText}` };
         }
@@ -79,30 +80,30 @@ export function revertWorkspaceMutations(cwd, mutations) {
     }
     return { ok: true, changedFiles: changedFiles.size, revertedChanges: applied.length };
 }
-function rollbackMutations(cwd, appliedUndoMutations) {
+async function rollbackMutations(cwd, appliedUndoMutations) {
     for (const mutation of [...appliedUndoMutations].reverse()) {
-        const result = applyMutation(cwd, mutation, "redo");
+        const result = await applyMutation(cwd, mutation, "redo");
         if (!result.ok)
             return { ok: false, error: result.error };
     }
     return { ok: true, changedFiles: 0, revertedChanges: appliedUndoMutations.length };
 }
-function applyMutation(cwd, mutation, direction) {
+async function applyMutation(cwd, mutation, direction) {
     if (mutation.type === "patch")
         return applyPatchMutation(cwd, mutation, direction);
     return applyWriteMutation(cwd, mutation, direction);
 }
-function applyPatchMutation(cwd, mutation, direction) {
+async function applyPatchMutation(cwd, mutation, direction) {
     const args = ["apply", ...(direction === "undo" ? ["--reverse"] : []), "--whitespace=nowarn"];
-    const check = runGitApply(cwd, [...args, "--check"], mutation.patch);
+    const check = await runGitApply(cwd, [...args, "--check"], mutation.patch);
     if (check.status !== 0)
         return { ok: false, error: commandError(`git ${args.join(" ")} --check`, check) };
-    const apply = runGitApply(cwd, args, mutation.patch);
+    const apply = await runGitApply(cwd, args, mutation.patch);
     if (apply.status !== 0)
         return { ok: false, error: commandError(`git ${args.join(" ")}`, apply) };
     return { ok: true, changedFiles: filesFromPatch(mutation.patch) };
 }
-function applyWriteMutation(cwd, mutation, direction) {
+async function applyWriteMutation(cwd, mutation, direction) {
     const safePath = safeRelativePath(cwd, mutation.path);
     if (!safePath)
         return { ok: false, error: `Refusing to modify path outside workspace: ${mutation.path}` };
@@ -110,17 +111,17 @@ function applyWriteMutation(cwd, mutation, direction) {
     const expectedContent = direction === "undo" ? mutation.afterContent : mutation.beforeContent;
     const nextContent = direction === "undo" ? mutation.beforeContent : mutation.afterContent;
     const currentExists = existsSync(absolutePath);
-    const currentContent = currentExists ? readFileSync(absolutePath, "utf8") : undefined;
+    const currentContent = currentExists ? await readFile(absolutePath, "utf8") : undefined;
     if (currentContent !== expectedContent) {
         return { ok: false, error: `Refusing to ${direction} write for ${safePath}: file content changed since the recorded command.` };
     }
     if (nextContent === undefined) {
         if (currentExists)
-            rmSync(absolutePath, { force: true });
+            await rm(absolutePath, { force: true });
     }
     else {
-        mkdirSync(dirname(absolutePath), { recursive: true });
-        writeFileSync(absolutePath, nextContent, "utf8");
+        await mkdir(dirname(absolutePath), { recursive: true });
+        await writeFile(absolutePath, nextContent, "utf8");
     }
     return { ok: true, changedFiles: [safePath] };
 }
@@ -138,17 +139,18 @@ function parseUndoIndex(value) {
 function workspaceUndoIndexPath(agentDir) {
     return join(agentDir, "pix", "workspace-undo", "index.json");
 }
-function runGitApply(cwd, args, input) {
-    return spawnSync("git", ["-c", "core.autocrlf=false", ...args], {
+async function runGitApply(cwd, args, input) {
+    return runProcess("git", ["-c", "core.autocrlf=false", ...args], {
         cwd,
         input,
-        encoding: "utf8",
-        maxBuffer: 20 * 1024 * 1024,
+        maxBufferBytes: 20 * 1024 * 1024,
     });
 }
 function commandError(command, result) {
     if (result.error)
         return `${command} failed: ${result.error.message}`;
+    if (result.timedOut)
+        return `${command} timed out`;
     const message = result.stderr?.trim() || result.stdout?.trim() || `exit code ${result.status ?? "unknown"}`;
     return `${command} failed: ${message}`;
 }