@firstpick/pi-package-webui 0.5.5 → 0.5.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/bin/pi-webui.mjs CHANGED
@@ -4,7 +4,7 @@ import { createHash, randomInt, randomUUID, timingSafeEqual } from "node:crypto"
4
4
  import { createReadStream } from "node:fs";
5
5
  import { createServer } from "node:http";
6
6
  import { createRequire } from "node:module";
7
- import { access, copyFile, mkdir, readFile, readdir, realpath, rename, stat, writeFile } from "node:fs/promises";
7
+ import { access, copyFile, mkdir, readFile, readdir, realpath, rename, rm, stat, writeFile } from "node:fs/promises";
8
8
  import { homedir, networkInterfaces, tmpdir } from "node:os";
9
9
  import path from "node:path";
10
10
  import { StringDecoder } from "node:string_decoder";
@@ -36,6 +36,15 @@ import {
36
36
  nativeSlashCommandEntries,
37
37
  parseSlashCommand as parseNativeSlashCommand,
38
38
  } from "../lib/native-command-adapter.mjs";
39
+ import {
40
+ WORKTREE_ERROR_CODES,
41
+ createGitWorktree,
42
+ gitWorktreeErrorPayload,
43
+ listGitWorktrees,
44
+ openGitWorktree,
45
+ pathInside,
46
+ removeGitWorktree,
47
+ } from "../lib/git-worktrees.mjs";
39
48
 
40
49
  const __dirname = path.dirname(fileURLToPath(import.meta.url));
41
50
  const require = createRequire(import.meta.url);
@@ -53,7 +62,7 @@ try {
53
62
  } catch {
54
63
  piPackageJson = {};
55
64
  }
56
- const nativeParityMatrix = JSON.parse(await readFile(path.join(packageRoot, "dev", "docs", "WEBUI_TUI_NATIVE_PARITY.json"), "utf8"));
65
+ const nativeParityMatrix = JSON.parse(await readFile(path.join(packageRoot, "lib", "WEBUI_TUI_NATIVE_PARITY.json"), "utf8"));
57
66
  const webuiDevServer = isTruthyEnv(process.env.PI_WEBUI_DEV) || isSourceCheckout(packageRoot);
58
67
  let remoteQrCorePromise = null;
59
68
 
@@ -180,6 +189,8 @@ const APP_RUNNER_COMMAND_CACHE_TTL_MS = 30_000;
180
189
  const APP_RUNNER_OUTPUT_LINE_LIMIT = 1_000;
181
190
  const APP_RUNNER_OUTPUT_MAX_CHARS = 240_000;
182
191
  const APP_RUNNER_INPUT_MAX_CHARS = 16_000;
192
+ const APP_RUNNER_CONTEXT_DEFAULT_LINES = 80;
193
+ const APP_RUNNER_CONTEXT_MAX_LINES = APP_RUNNER_OUTPUT_LINE_LIMIT;
183
194
  const APP_RUNNER_STOP_GRACE_MS = 2_500;
184
195
  const APP_RUNNER_PYTHON_ENTRIES = ["Main.py", "main.py", "src/main.py", "src/Main.py", "app.py", "src/app.py"];
185
196
  const APP_RUNNER_JS_ENTRIES = ["main.js", "src/main.js", "index.js", "src/index.js", "server.js", "src/server.js", "app.js", "src/app.js"];
@@ -421,6 +432,10 @@ function truncateLongText(value, maxLength = 8000) {
421
432
  return `${text.slice(0, Math.max(0, maxLength - 1))}…`;
422
433
  }
423
434
 
435
+ function stripAnsi(text) {
436
+ return String(text ?? "").replace(/(?:\x1B|\u241B)(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, "");
437
+ }
438
+
424
439
  function parsePackageVersion(version) {
425
440
  const match = String(version || "").trim().match(/^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+.*)?$/);
426
441
  if (!match) return undefined;
@@ -2556,6 +2571,59 @@ function clearAppRunnerForTab(tab) {
2556
2571
  return true;
2557
2572
  }
2558
2573
 
2574
+ function normalizeAppRunnerContextLineCount(value) {
2575
+ const number = Number.parseInt(String(value ?? ""), 10);
2576
+ if (!Number.isFinite(number)) return APP_RUNNER_CONTEXT_DEFAULT_LINES;
2577
+ return Math.max(1, Math.min(APP_RUNNER_CONTEXT_MAX_LINES, number));
2578
+ }
2579
+
2580
+ function appRunnerOutputLinesForContext(run) {
2581
+ const lines = Array.isArray(run?.lines) ? [...run.lines] : [];
2582
+ const pendingLine = appRunnerPendingLine(run);
2583
+ if (pendingLine) lines.push(pendingLine);
2584
+ return lines.map((line) => stripAnsi(line).replace(/\r\n?/g, "\n"));
2585
+ }
2586
+
2587
+ function formatAppRunnerContextContent(tab, run, { requestedLineCount, lines, totalAvailableLines }) {
2588
+ const status = appRunnerStatusLabel(run);
2589
+ const capturedAt = new Date().toISOString();
2590
+ const header = [
2591
+ "App runner output transferred from Pi Web UI.",
2592
+ `Command: ${stripAnsi(run?.displayCommand || run?.command || "app runner")}`,
2593
+ `Cwd: ${stripAnsi(run?.cwd || tab?.cwd || "")}`,
2594
+ `Status: ${status}`,
2595
+ `Captured: last ${lines.length} of ${totalAvailableLines} available line${totalAvailableLines === 1 ? "" : "s"} (requested ${requestedLineCount})`,
2596
+ run?.truncated ? "Note: earlier app runner output had already been truncated before this capture." : "",
2597
+ `Captured at: ${capturedAt}`,
2598
+ ].filter(Boolean);
2599
+ return `${header.join("\n")}\n\n\`\`\`\`text\n${lines.join("\n").trimEnd()}\n\`\`\`\``;
2600
+ }
2601
+
2602
+ async function transferAppRunnerContext(tab, body = {}) {
2603
+ const run = tab?.appRunner;
2604
+ if (!run) throw makeHttpError(409, "No app runner output is available in this tab");
2605
+ const requestedLineCount = normalizeAppRunnerContextLineCount(body.lineCount ?? body.lines ?? body.count);
2606
+ const allLines = appRunnerOutputLinesForContext(run);
2607
+ const lines = allLines.slice(-requestedLineCount);
2608
+ if (!lines.some((line) => stripAnsi(line).trim())) throw makeHttpError(400, "App runner output is empty");
2609
+ const details = {
2610
+ runId: run.id,
2611
+ runnerId: run.runnerId,
2612
+ command: run.displayCommand || run.command || "",
2613
+ cwd: run.cwd || tab.cwd,
2614
+ status: run.status || "running",
2615
+ requestedLineCount,
2616
+ lineCount: lines.length,
2617
+ totalAvailableLines: allLines.length,
2618
+ truncated: run.truncated === true,
2619
+ capturedAt: new Date().toISOString(),
2620
+ };
2621
+ const content = formatAppRunnerContextContent(tab, run, { requestedLineCount, lines, totalAvailableLines: allLines.length });
2622
+ const helperData = await sendWebuiHelperCommand(tab, "app-runner-context", { content, details });
2623
+ recordEvent({ type: "webui_app_runner_context", tabId: tab.id, tabTitle: tab.title, command: details.command, lineCount: lines.length, requestedLineCount, delivery: helperData?.delivery || "context" });
2624
+ return { ...details, delivery: helperData?.delivery || "context", activeRun: publicAppRunnerState(run) };
2625
+ }
2626
+
2559
2627
  function firstDefined(...values) {
2560
2628
  return values.find((value) => value !== undefined && value !== null);
2561
2629
  }
@@ -3707,16 +3775,31 @@ function normalizeGitBranchList(branchText, current = "") {
3707
3775
 
3708
3776
  async function readGitBranches(cwd) {
3709
3777
  const root = await getGitRoot(cwd);
3710
- const [current, branchText] = await Promise.all([
3778
+ const [current, branchText, worktreeData] = await Promise.all([
3711
3779
  currentGitBranchForPicker(root),
3712
3780
  runGitReadCommand(root, ["branch", "--format=%(refname:short)"], { timeoutMs: 5000, maxOutputLength: 120_000 }),
3781
+ listGitWorktrees(cwd).catch(() => null),
3713
3782
  ]);
3783
+ const occupiedByBranch = new Map();
3784
+ for (const item of worktreeData?.occupiedBranches || []) {
3785
+ if (!item?.branch || occupiedByBranch.has(item.branch)) continue;
3786
+ occupiedByBranch.set(item.branch, item);
3787
+ }
3714
3788
  return {
3715
3789
  cwd,
3716
3790
  root,
3791
+ repoRoot: worktreeData?.repoRoot || root,
3792
+ commonGitDir: worktreeData?.commonGitDir || "",
3793
+ currentWorktreePath: worktreeData?.currentWorktreePath || root,
3794
+ defaultWorktreesRoot: worktreeData?.defaultWorktreesRoot || "",
3717
3795
  current,
3718
3796
  generatedAt: new Date().toISOString(),
3719
- branches: normalizeGitBranchList(branchText, current),
3797
+ branches: normalizeGitBranchList(branchText, current).map((branch) => {
3798
+ const occupied = occupiedByBranch.get(branch.name);
3799
+ return occupied ? { ...branch, occupied: true, worktreePath: occupied.path, worktreeCurrent: occupied.current === true, mainWorktree: occupied.isMainWorktree === true } : branch;
3800
+ }),
3801
+ worktrees: worktreeData?.worktrees || [],
3802
+ occupiedBranches: worktreeData?.occupiedBranches || [],
3720
3803
  };
3721
3804
  }
3722
3805
 
@@ -3728,6 +3811,15 @@ async function switchGitBranch(cwd, branch, { create = false } = {}) {
3728
3811
  const branchExists = branches.branches.some((item) => item.name === targetBranch);
3729
3812
  if (create && branchExists) throw new Error(`Local git branch already exists: ${targetBranch}`);
3730
3813
  if (!create && !branchExists) throw new Error(`Unknown local git branch: ${targetBranch}`);
3814
+ const occupied = branches.branches.find((item) => item.name === targetBranch && item.occupied && !item.worktreeCurrent);
3815
+ if (!create && occupied?.worktreePath) {
3816
+ return {
3817
+ ok: false,
3818
+ code: WORKTREE_ERROR_CODES.BRANCH_CHECKED_OUT_ELSEWHERE,
3819
+ error: `Branch ${targetBranch} is already checked out at ${occupied.worktreePath}. Open that worktree instead of switching this checkout.`,
3820
+ data: { branch: targetBranch, root, worktreePath: occupied.worktreePath },
3821
+ };
3822
+ }
3731
3823
  if (!create && branches.current === targetBranch) {
3732
3824
  return { ok: true, data: { command: `git switch ${targetBranch}`, stdout: "", stderr: "", exitCode: 0, branch: targetBranch, root, switched: false, created: false } };
3733
3825
  }
@@ -3744,6 +3836,271 @@ async function switchGitBranch(cwd, branch, { create = false } = {}) {
3744
3836
  return payload;
3745
3837
  }
3746
3838
 
3839
+ function normalizeWorktreeSessionMode(value) {
3840
+ const mode = String(value || "fork-current").trim().toLowerCase();
3841
+ if (!mode || mode === "fork" || mode === "fork-current") return "fork-current";
3842
+ if (mode === "empty" || mode === "new") return "empty";
3843
+ if (mode === "clone-current" || mode === "parent-only") {
3844
+ throw makeHttpError(400, `sessionMode ${mode} is not supported yet; use fork-current or empty.`);
3845
+ }
3846
+ throw makeHttpError(400, "sessionMode must be fork-current or empty");
3847
+ }
3848
+
3849
+ async function createEmptySessionFileForCwd(cwd) {
3850
+ const manager = SessionManager.create(cwd, configuredSessionDir());
3851
+ const sessionFile = manager.getSessionFile();
3852
+ const header = manager.getHeader();
3853
+ if (!sessionFile || !header) return undefined;
3854
+ await mkdir(path.dirname(sessionFile), { recursive: true });
3855
+ await writeFile(sessionFile, `${JSON.stringify(header)}\n`, { encoding: "utf8", flag: "wx" });
3856
+ return sessionFile;
3857
+ }
3858
+
3859
+ async function prepareWorktreeSessionFile(sourceTab, targetCwd, requestedMode = "fork-current") {
3860
+ if (options.noSession) return { mode: "none", requestedMode: "none", sessionFile: undefined, warning: "Web UI was started with --no-session." };
3861
+ const mode = normalizeWorktreeSessionMode(requestedMode);
3862
+ if (mode === "empty") {
3863
+ return { mode, requestedMode: mode, sessionFile: await createEmptySessionFileForCwd(targetCwd) };
3864
+ }
3865
+
3866
+ const state = await currentSessionState(sourceTab).catch(() => sourceTab?.lastState || {});
3867
+ const sourceSessionFile = state.sessionFile || tabRestorableSessionFile(sourceTab);
3868
+ if (sourceSessionFile) {
3869
+ requireAllowedSessionPath(sourceSessionFile);
3870
+ const sourceInfo = await stat(sourceSessionFile).catch(() => null);
3871
+ if (sourceInfo?.isFile()) {
3872
+ const manager = SessionManager.forkFrom(sourceSessionFile, targetCwd, configuredSessionDir());
3873
+ return { mode, requestedMode: mode, sessionFile: manager.getSessionFile(), parentSession: sourceSessionFile };
3874
+ }
3875
+ }
3876
+
3877
+ return {
3878
+ mode: "empty",
3879
+ requestedMode: mode,
3880
+ sessionFile: await createEmptySessionFileForCwd(targetCwd),
3881
+ warning: "Current session is not persisted yet; opened an empty session rooted at the worktree.",
3882
+ };
3883
+ }
3884
+
3885
+ function gitWorkspaceFromWorktreeResult(result, worktree = result?.worktree) {
3886
+ if (!worktree?.path) return null;
3887
+ return {
3888
+ repoRoot: result.repoRoot || worktree.repoRoot || "",
3889
+ commonGitDir: result.commonGitDir || worktree.commonGitDir || "",
3890
+ worktreePath: worktree.path,
3891
+ branch: worktree.branch || result.branch || null,
3892
+ worktreeCount: Array.isArray(result.worktrees) ? result.worktrees.length : undefined,
3893
+ isMainWorktree: worktree.isMainWorktree === true,
3894
+ };
3895
+ }
3896
+
3897
+ async function openWorktreeResultForTab(sourceTab, result, body = {}) {
3898
+ const worktree = result?.worktree;
3899
+ const worktreePath = worktree?.path || result?.path;
3900
+ if (!worktreePath) throw makeHttpError(500, "Git worktree operation did not return a path");
3901
+ if (body.openTab === false) return { ...result, session: null, tab: null, tabs: listTabs(), openedTab: false };
3902
+
3903
+ if (sameResolvedPath(worktreePath, sourceTab.cwd)) {
3904
+ sourceTab.gitWorkspace = gitWorkspaceFromWorktreeResult(result, worktree);
3905
+ return { ...result, session: null, tab: tabMeta(sourceTab), tabs: listTabs(), openedTab: false, openedCurrent: true };
3906
+ }
3907
+
3908
+ const existingTab = [...tabs.values()].find((item) => sameResolvedPath(item.cwd, worktreePath));
3909
+ if (existingTab) {
3910
+ existingTab.gitWorkspace = gitWorkspaceFromWorktreeResult(result, worktree);
3911
+ return { ...result, session: null, tab: tabMeta(existingTab), tabs: listTabs(), openedTab: false, openedExistingTab: true };
3912
+ }
3913
+
3914
+ const session = await prepareWorktreeSessionFile(sourceTab, worktreePath, body.sessionMode || "fork-current");
3915
+ const tab = await createTab({
3916
+ title: body.title,
3917
+ titleSource: body.title ? "explicit" : undefined,
3918
+ cwd: worktreePath,
3919
+ sessionFile: session.sessionFile,
3920
+ gitWorkspace: gitWorkspaceFromWorktreeResult(result, worktree),
3921
+ });
3922
+ recordEvent({ type: "webui_worktree_opened", tabId: tab.id, tabTitle: tab.title, cwd: tab.cwd, branch: worktree.branch || result.branch || "", sessionMode: session.mode });
3923
+ return {
3924
+ ...result,
3925
+ session,
3926
+ tab: tabMeta(tab),
3927
+ tabs: listTabs(),
3928
+ openedTab: true,
3929
+ dependencyHint: "Git worktrees do not share ignored dependency directories such as node_modules or .venv; install/bootstrap dependencies manually if needed.",
3930
+ };
3931
+ }
3932
+
3933
+ async function cleanupCreatedWorktreeAfterFailure(sourceCwd, worktreePath) {
3934
+ try {
3935
+ return await removeGitWorktree(sourceCwd, worktreePath, { force: true });
3936
+ } catch (error) {
3937
+ return { ok: false, error: sanitizeError(error), code: error?.code || WORKTREE_ERROR_CODES.GIT_COMMAND_FAILED };
3938
+ }
3939
+ }
3940
+
3941
+ async function readGitWorkflowMessageFilesForTransfer(root) {
3942
+ const { shortPath, longPath } = commitMessagePaths(root);
3943
+ const files = [];
3944
+ for (const sourcePath of [shortPath, longPath]) {
3945
+ try {
3946
+ const content = await readFile(sourcePath, "utf8");
3947
+ files.push({ relativePath: path.relative(root, sourcePath).split(path.sep).join("/"), content });
3948
+ } catch (error) {
3949
+ if (error?.code !== "ENOENT") throw error;
3950
+ }
3951
+ }
3952
+ return files;
3953
+ }
3954
+
3955
+ async function snapshotGitWorkflowBranchState(root) {
3956
+ const diffResult = await runGitWorkflowCommand(["diff", "--cached", "--binary", "--full-index"], {
3957
+ cwd: root,
3958
+ label: "git diff --cached --binary --full-index",
3959
+ timeoutMs: 60 * 1000,
3960
+ });
3961
+ if (diffResult.exitCode !== 0 || diffResult.timedOut || diffResult.cancelled || diffResult.error) {
3962
+ throw new Error((diffResult.stderr || diffResult.stdout || diffResult.error || "Unable to read staged changes for the PR worktree").trim());
3963
+ }
3964
+ return {
3965
+ stagedPatch: diffResult.stdout || "",
3966
+ messageFiles: await readGitWorkflowMessageFilesForTransfer(root),
3967
+ };
3968
+ }
3969
+
3970
+ async function applyGitWorkflowBranchStateToWorktree(snapshot, worktreePath) {
3971
+ const copiedMessageFiles = [];
3972
+ let appliedStagedPatch = false;
3973
+ const patchText = String(snapshot?.stagedPatch || "");
3974
+ if (patchText.trim()) {
3975
+ const patchPath = path.join(tmpdir(), `pi-webui-staged-worktree-${process.pid}-${Date.now()}-${randomUUID()}.patch`);
3976
+ await writeFile(patchPath, patchText, "utf8");
3977
+ try {
3978
+ const applyResult = await runGitWorkflowCommand(["apply", "--index", "--whitespace=nowarn", patchPath], {
3979
+ cwd: worktreePath,
3980
+ label: "git apply --index <staged diff>",
3981
+ timeoutMs: 5 * 60 * 1000,
3982
+ });
3983
+ if (applyResult.exitCode !== 0 || applyResult.timedOut || applyResult.cancelled || applyResult.error) {
3984
+ throw new Error((applyResult.stderr || applyResult.stdout || applyResult.error || "Unable to apply staged changes in the PR worktree").trim());
3985
+ }
3986
+ appliedStagedPatch = true;
3987
+ } finally {
3988
+ await rm(patchPath, { force: true }).catch(() => {});
3989
+ }
3990
+ }
3991
+
3992
+ for (const file of snapshot?.messageFiles || []) {
3993
+ const relativePath = String(file.relativePath || "").replace(/\\/g, "/");
3994
+ const targetPath = path.resolve(worktreePath, relativePath);
3995
+ if (!relativePath || !pathInside(worktreePath, targetPath)) throw new Error(`Refusing to copy Git workflow file outside the worktree: ${relativePath}`);
3996
+ await mkdir(path.dirname(targetPath), { recursive: true });
3997
+ await writeFile(targetPath, file.content, "utf8");
3998
+ copiedMessageFiles.push(relativePath);
3999
+ }
4000
+
4001
+ return { appliedStagedPatch, copiedMessageFiles };
4002
+ }
4003
+
4004
+ function gitWorkflowBranchWorktreeStdout({ branch, worktreePath, createdResult, opened, transfer }) {
4005
+ const lines = [];
4006
+ if (createdResult?.created) lines.push(`Created branch worktree ${branch} at ${worktreePath}.`);
4007
+ else if (createdResult?.openedExisting) lines.push(`Opened existing branch worktree ${branch} at ${worktreePath}.`);
4008
+ else lines.push(`Opened branch worktree ${branch} at ${worktreePath}.`);
4009
+ if (transfer?.appliedStagedPatch) lines.push("Copied the source checkout's staged changes into the worktree index.");
4010
+ else if (createdResult?.openedExisting) lines.push("Existing worktree was reused; source staged changes were not copied automatically.");
4011
+ else lines.push("No staged changes were copied because the source index was clean.");
4012
+ if (transfer?.copiedMessageFiles?.length) lines.push(`Copied ${transfer.copiedMessageFiles.join(", ")} for commit message selection.`);
4013
+ if (opened?.tab?.id) lines.push(`Continue the guided Git workflow in Web UI tab ${opened.tab.title || opened.tab.id}.`);
4014
+ lines.push("The source checkout was left on its current branch.");
4015
+ return lines.join("\n");
4016
+ }
4017
+
4018
+ async function createGitWorkflowBranchWorktree(tab, body = {}) {
4019
+ const root = await getGitRoot(tab.cwd);
4020
+ const branch = cleanGitBranchName(body.branch || body.branchName);
4021
+ await validateGitBranchName(root, branch);
4022
+ const snapshot = await snapshotGitWorkflowBranchState(root);
4023
+ let createdResult = null;
4024
+ try {
4025
+ createdResult = await createGitWorktree(tab.cwd, { ...body, branchName: branch });
4026
+ const worktreePath = createdResult.worktree?.path || createdResult.path;
4027
+ if (!worktreePath) throw makeHttpError(500, "Git workflow worktree creation did not return a path");
4028
+ const transfer = createdResult.created
4029
+ ? await applyGitWorkflowBranchStateToWorktree(snapshot, worktreePath)
4030
+ : { appliedStagedPatch: false, copiedMessageFiles: [] };
4031
+ const opened = await openWorktreeResultForTab(tab, createdResult, { openTab: body.openTab !== false, sessionMode: body.sessionMode || "fork-current", ...body });
4032
+ if (createdResult.created) {
4033
+ recordEvent({ type: "webui_worktree_created", tabId: opened.tab?.id || tab.id, cwd: opened.worktree?.path || opened.path, branch });
4034
+ }
4035
+ recordEvent({ type: "webui_git_workflow_worktree", tabId: opened.tab?.id || tab.id, cwd: worktreePath, branch, transferredStagedChanges: transfer.appliedStagedPatch });
4036
+ return {
4037
+ ...opened,
4038
+ command: createdResult.created ? formatGitCommand(["worktree", "add", "-b", branch, worktreePath]) : formatGitCommand(["worktree", "list", "--porcelain"]),
4039
+ stdout: gitWorkflowBranchWorktreeStdout({ branch, worktreePath, createdResult, opened, transfer }),
4040
+ stderr: "",
4041
+ exitCode: 0,
4042
+ branch: opened.branch || branch,
4043
+ carriedStagedChanges: transfer.appliedStagedPatch,
4044
+ copiedMessageFiles: transfer.copiedMessageFiles,
4045
+ };
4046
+ } catch (error) {
4047
+ let cleanup = null;
4048
+ const createdPath = createdResult?.created && !createdResult?.openedExisting ? createdResult.worktree?.path || createdResult.path : "";
4049
+ if (createdPath) cleanup = await cleanupCreatedWorktreeAfterFailure(tab.cwd, createdPath);
4050
+ recordEvent({ type: "webui_git_workflow_worktree_failed", tabId: tab.id, cwd: createdPath || tab.cwd, branch, error: sanitizeError(error), cleanup });
4051
+ throw error;
4052
+ }
4053
+ }
4054
+
4055
+ async function createGitWorktreeTab(tab, body = {}) {
4056
+ let createdResult = null;
4057
+ try {
4058
+ createdResult = await createGitWorktree(tab.cwd, body);
4059
+ const opened = await openWorktreeResultForTab(tab, createdResult, { openTab: body.openTab !== false, ...body });
4060
+ if (createdResult.created) {
4061
+ recordEvent({ type: "webui_worktree_created", tabId: opened.tab?.id || tab.id, cwd: opened.worktree?.path || opened.path, branch: opened.branch || body.branchName || "" });
4062
+ }
4063
+ return opened;
4064
+ } catch (error) {
4065
+ let cleanup = null;
4066
+ const createdPath = createdResult?.created && !createdResult?.openedExisting ? createdResult.worktree?.path || createdResult.path : "";
4067
+ if (createdPath) cleanup = await cleanupCreatedWorktreeAfterFailure(tab.cwd, createdPath);
4068
+ recordEvent({ type: "webui_worktree_create_failed", tabId: tab.id, cwd: createdPath || tab.cwd, branch: body.branchName || body.branch || "", error: sanitizeError(error), cleanup });
4069
+ throw error;
4070
+ }
4071
+ }
4072
+
4073
+ async function openExistingGitWorktreeTab(tab, body = {}) {
4074
+ const requestedPath = String(body.path || body.worktreePath || "").trim();
4075
+ if (!requestedPath) throw makeHttpError(400, "worktree path is required");
4076
+ const result = await openGitWorktree(tab.cwd, requestedPath);
4077
+ return openWorktreeResultForTab(tab, result, { openTab: body.openTab !== false, ...body });
4078
+ }
4079
+
4080
+ function openTabsInsideWorktree(worktreePath) {
4081
+ return [...tabs.values()].filter((tab) => pathInside(worktreePath, tab.cwd));
4082
+ }
4083
+
4084
+ async function removeGitWorktreeForTab(tab, body = {}) {
4085
+ if (body.confirmed !== true) throw makeHttpError(409, "Removing a worktree requires confirmed: true because it deletes files under the worktree path.");
4086
+ const requestedPath = String(body.path || body.worktreePath || "").trim();
4087
+ if (!requestedPath) throw makeHttpError(400, "worktree path is required");
4088
+ const activeTabs = openTabsInsideWorktree(requestedPath);
4089
+ if (activeTabs.length) {
4090
+ const error = makeHttpError(409, `Refusing to remove a worktree that is open in ${activeTabs.length} Web UI tab${activeTabs.length === 1 ? "" : "s"}.`);
4091
+ error.code = WORKTREE_ERROR_CODES.WORKTREE_BUSY;
4092
+ error.details = { path: requestedPath, tabIds: activeTabs.map((item) => item.id) };
4093
+ throw error;
4094
+ }
4095
+ const result = await removeGitWorktree(tab.cwd, requestedPath, { force: body.force === true });
4096
+ recordEvent({ type: "webui_worktree_removed", tabId: tab.id, cwd: result.path || requestedPath, branch: result.branch || "" });
4097
+ return { ...result, tabs: listTabs() };
4098
+ }
4099
+
4100
+ function sendGitWorktreeFailure(res, error) {
4101
+ sendJson(res, 200, gitWorktreeErrorPayload(error));
4102
+ }
4103
+
3747
4104
  async function defaultGitRemote(root) {
3748
4105
  const result = await runGitWorkflowCommand(["remote"], { cwd: root, timeoutMs: 5000 });
3749
4106
  if (result.exitCode !== 0) throw new Error((result.stderr || result.stdout || "Cannot list git remotes").trim());
@@ -3855,7 +4212,9 @@ function gitWorkflowCommandPayload(result) {
3855
4212
  };
3856
4213
  }
3857
4214
 
3858
- async function handleGitWorkflowRequest(pathname, body = {}, cwd = options.cwd) {
4215
+ async function handleGitWorkflowRequest(pathname, body = {}, tabOrCwd = options.cwd) {
4216
+ const tab = tabOrCwd && typeof tabOrCwd === "object" ? tabOrCwd : null;
4217
+ const cwd = tab?.cwd || tabOrCwd || options.cwd;
3859
4218
  try {
3860
4219
  switch (pathname) {
3861
4220
  case "/api/git-workflow/message":
@@ -3904,12 +4263,8 @@ async function handleGitWorkflowRequest(pathname, body = {}, cwd = options.cwd)
3904
4263
  await getGitRoot(cwd);
3905
4264
  return gitWorkflowCommandPayload(await runGitWorkflowCommand(["add", "."], { cwd }));
3906
4265
  case "/api/git-workflow/branch": {
3907
- const root = await getGitRoot(cwd);
3908
- const branch = cleanGitBranchName(body.branch);
3909
- await validateGitBranchName(root, branch);
3910
- const payload = gitWorkflowCommandPayload(await runGitWorkflowCommand(["switch", "-c", branch], { cwd: root }));
3911
- if (payload.ok) payload.data.branch = branch;
3912
- return payload;
4266
+ if (!tab) throw new Error("Git workflow branch worktree requires a Web UI tab");
4267
+ return { ok: true, data: await createGitWorkflowBranchWorktree(tab, body) };
3913
4268
  }
3914
4269
  case "/api/git-workflow/commit": {
3915
4270
  const variant = String(body.variant || "").trim();
@@ -4706,6 +5061,11 @@ function extensionStatusMap(tab) {
4706
5061
  return tab.extensionStatuses;
4707
5062
  }
4708
5063
 
5064
+ function extensionWidgetMap(tab) {
5065
+ if (!tab.extensionWidgets) tab.extensionWidgets = new Map();
5066
+ return tab.extensionWidgets;
5067
+ }
5068
+
4709
5069
  function rememberExtensionStatusEvent(tab, event) {
4710
5070
  if (event?.type !== "extension_ui_request" || event.method !== "setStatus" || !event.statusKey) return;
4711
5071
  const statuses = extensionStatusMap(tab);
@@ -4713,10 +5073,23 @@ function rememberExtensionStatusEvent(tab, event) {
4713
5073
  else statuses.delete(String(event.statusKey));
4714
5074
  }
4715
5075
 
5076
+ function rememberExtensionWidgetEvent(tab, event) {
5077
+ if (event?.type !== "extension_ui_request" || event.method !== "setWidget") return;
5078
+ const widgetKey = event.widgetKey || event.id;
5079
+ if (!widgetKey) return;
5080
+ const widgets = extensionWidgetMap(tab);
5081
+ if (Array.isArray(event.widgetLines)) widgets.set(String(widgetKey), { ...event, widgetKey: String(widgetKey), widgetLines: event.widgetLines.map((line) => String(line)) });
5082
+ else widgets.delete(String(widgetKey));
5083
+ }
5084
+
4716
5085
  function clearExtensionStatuses(tab) {
4717
5086
  tab?.extensionStatuses?.clear();
4718
5087
  }
4719
5088
 
5089
+ function clearExtensionWidgets(tab) {
5090
+ tab?.extensionWidgets?.clear();
5091
+ }
5092
+
4720
5093
  function replayExtensionStatuses(tab, res) {
4721
5094
  for (const [statusKey, statusText] of extensionStatusMap(tab)) {
4722
5095
  sendSse(res, {
@@ -4734,6 +5107,24 @@ function replayExtensionStatuses(tab, res) {
4734
5107
  }
4735
5108
  }
4736
5109
 
5110
+ function replayExtensionWidgets(tab, res) {
5111
+ const pendingExtensionUiRequestCount = pendingExtensionUiRequests(tab).length;
5112
+ for (const [widgetKey, request] of extensionWidgetMap(tab)) {
5113
+ sendSse(res, {
5114
+ ...request,
5115
+ type: "extension_ui_request",
5116
+ id: randomUUID(),
5117
+ method: "setWidget",
5118
+ widgetKey,
5119
+ tabId: tab.id,
5120
+ tabTitle: tab.title,
5121
+ replayed: true,
5122
+ tabActivity: tabActivitySnapshot(tab),
5123
+ pendingExtensionUiRequestCount,
5124
+ });
5125
+ }
5126
+ }
5127
+
4737
5128
  function bashQueueForTab(tab) {
4738
5129
  if (!tab.bashQueue) tab.bashQueue = [];
4739
5130
  return tab.bashQueue;
@@ -5030,8 +5421,10 @@ function attachRpcToTab(tab, rpc) {
5030
5421
  if (event?.type === "pi_process_exit" || event?.type === "pi_process_error") {
5031
5422
  clearPendingExtensionUiRequests(tab);
5032
5423
  clearExtensionStatuses(tab);
5424
+ clearExtensionWidgets(tab);
5033
5425
  } else {
5034
5426
  rememberExtensionStatusEvent(tab, scopedEvent);
5427
+ rememberExtensionWidgetEvent(tab, scopedEvent);
5035
5428
  trackPendingExtensionUiRequest(tab, scopedEvent);
5036
5429
  }
5037
5430
  scopedEvent = { ...scopedEvent, tabActivity: tabActivitySnapshot(tab), pendingExtensionUiRequestCount: pendingExtensionUiRequests(tab).length };
@@ -5040,7 +5433,7 @@ function attachRpcToTab(tab, rpc) {
5040
5433
  });
5041
5434
  }
5042
5435
 
5043
- async function createTab({ id: requestedId, index, title, titleSource, conversationStarted, cwd, sessionFile } = {}) {
5436
+ async function createTab({ id: requestedId, index, title, titleSource, conversationStarted, cwd, sessionFile, gitWorkspace } = {}) {
5044
5437
  const tabIndex = Number.isInteger(index) && index > 0 ? index : nextTabIndex;
5045
5438
  nextTabIndex = Math.max(nextTabIndex, tabIndex + 1);
5046
5439
  const explicitTitle = String(title || "").trim();
@@ -5063,11 +5456,13 @@ async function createTab({ id: requestedId, index, title, titleSource, conversat
5063
5456
  cwd: tabCwd,
5064
5457
  createdAt,
5065
5458
  sessionFile: options.noSession ? undefined : normalizedRestoreString(sessionFile, 4096),
5459
+ gitWorkspace: gitWorkspace || null,
5066
5460
  lastState: null,
5067
5461
  pendingThinkingLevel: undefined,
5068
5462
  activity: createTabActivity(createdAt),
5069
5463
  pendingExtensionUiRequests: new Map(),
5070
5464
  extensionStatuses: new Map(),
5465
+ extensionWidgets: new Map(),
5071
5466
  webuiHelperRequests: new Map(),
5072
5467
  webuiHelperResponseIds: new Set(),
5073
5468
  bashQueue: [],
@@ -5108,6 +5503,7 @@ function tabMeta(tab) {
5108
5503
  conversationStarted: !!tab.conversationStarted,
5109
5504
  cwd: tab.cwd,
5110
5505
  sessionFile: tabRestorableSessionFile(tab),
5506
+ gitWorkspace: tab.gitWorkspace || null,
5111
5507
  pendingThinkingLevel: tab.pendingThinkingLevel || null,
5112
5508
  createdAt: tab.createdAt,
5113
5509
  startedAt: tab.rpc.startedAt,
@@ -5117,6 +5513,7 @@ function tabMeta(tab) {
5117
5513
  clientCount: tab.sseClients.size,
5118
5514
  pendingExtensionUiRequestCount: pendingExtensionUiRequests(tab).length,
5119
5515
  activity: tabActivitySnapshot(tab),
5516
+ appRunner: publicAppRunnerState(tab.appRunner),
5120
5517
  };
5121
5518
  }
5122
5519
 
@@ -5657,6 +6054,7 @@ async function updateTabCwd(id, cwd) {
5657
6054
  resetTabActivity(tab);
5658
6055
  clearPendingExtensionUiRequests(tab);
5659
6056
  clearExtensionStatuses(tab);
6057
+ clearExtensionWidgets(tab);
5660
6058
  const rpc = new PiRpcProcess({ ...piCommand, cwd: tab.cwd });
5661
6059
  attachRpcToTab(tab, rpc);
5662
6060
  rpc.start();
@@ -5694,6 +6092,7 @@ async function restartTabRpc(tab, reason = "reload") {
5694
6092
  resetTabActivity(tab);
5695
6093
  clearPendingExtensionUiRequests(tab);
5696
6094
  clearExtensionStatuses(tab);
6095
+ clearExtensionWidgets(tab);
5697
6096
  const rpc = new PiRpcProcess({ ...piCommand, cwd: tab.cwd });
5698
6097
  attachRpcToTab(tab, rpc);
5699
6098
  rpc.start();
@@ -7382,6 +7781,7 @@ const server = createServer(async (req, res) => {
7382
7781
  activeRun: publicAppRunnerState(tab.appRunner),
7383
7782
  });
7384
7783
  replayExtensionStatuses(tab, res);
7784
+ replayExtensionWidgets(tab, res);
7385
7785
  replayPendingExtensionUiRequests(tab, res);
7386
7786
  const keepAlive = setInterval(() => res.write(": keepalive\n\n"), 15000);
7387
7787
  req.on("close", () => {
@@ -7541,6 +7941,13 @@ const server = createServer(async (req, res) => {
7541
7941
  return;
7542
7942
  }
7543
7943
 
7944
+ if (url.pathname === "/api/app-runner/context" && req.method === "POST") {
7945
+ const body = await readJsonBody(req);
7946
+ const tab = getRequestedTab(req, url, body);
7947
+ sendJson(res, 200, { ok: true, data: await transferAppRunnerContext(tab, body) });
7948
+ return;
7949
+ }
7950
+
7544
7951
  if (url.pathname === "/api/app-runner/stop" && req.method === "POST") {
7545
7952
  const body = await readJsonBody(req);
7546
7953
  const tab = getRequestedTab(req, url, body);
@@ -7797,6 +8204,18 @@ const server = createServer(async (req, res) => {
7797
8204
  return;
7798
8205
  }
7799
8206
 
8207
+ if (url.pathname === "/api/queue/remove" && req.method === "POST") {
8208
+ const body = await readJsonBody(req);
8209
+ const tab = getRequestedTab(req, url, body);
8210
+ const data = await sendWebuiHelperCommand(tab, "queue-remove", {
8211
+ kind: body.kind || "followUp",
8212
+ index: body.index,
8213
+ message: body.message,
8214
+ });
8215
+ sendJson(res, 200, { ok: true, data });
8216
+ return;
8217
+ }
8218
+
7800
8219
  if (url.pathname === "/api/prompt" && req.method === "POST") {
7801
8220
  const body = await readJsonBody(req, { limitBytes: requestBodyLimitForPath(url.pathname) });
7802
8221
  const tab = getRequestedTab(req, url, body);
@@ -7853,6 +8272,50 @@ const server = createServer(async (req, res) => {
7853
8272
  return;
7854
8273
  }
7855
8274
 
8275
+ if (url.pathname === "/api/git-worktrees" && req.method === "GET") {
8276
+ const tab = getRequestedTab(req, url);
8277
+ try {
8278
+ sendJson(res, 200, { ok: true, data: await listGitWorktrees(tab.cwd) });
8279
+ } catch (error) {
8280
+ sendGitWorktreeFailure(res, error);
8281
+ }
8282
+ return;
8283
+ }
8284
+
8285
+ if (url.pathname === "/api/git-worktrees" && req.method === "POST") {
8286
+ const body = await readJsonBody(req);
8287
+ const tab = getRequestedTab(req, url, body);
8288
+ try {
8289
+ sendJson(res, 200, { ok: true, data: await createGitWorktreeTab(tab, body) });
8290
+ } catch (error) {
8291
+ sendGitWorktreeFailure(res, error);
8292
+ }
8293
+ return;
8294
+ }
8295
+
8296
+ if (url.pathname === "/api/git-worktrees/open" && req.method === "POST") {
8297
+ const body = await readJsonBody(req);
8298
+ const tab = getRequestedTab(req, url, body);
8299
+ try {
8300
+ sendJson(res, 200, { ok: true, data: await openExistingGitWorktreeTab(tab, body) });
8301
+ } catch (error) {
8302
+ sendGitWorktreeFailure(res, error);
8303
+ }
8304
+ return;
8305
+ }
8306
+
8307
+ if (url.pathname === "/api/git-worktrees" && req.method === "DELETE") {
8308
+ requireLocalhost(req, "Removing Git worktrees is only allowed from localhost");
8309
+ const body = await readJsonBody(req);
8310
+ const tab = getRequestedTab(req, url, body);
8311
+ try {
8312
+ sendJson(res, 200, { ok: true, data: await removeGitWorktreeForTab(tab, body) });
8313
+ } catch (error) {
8314
+ sendGitWorktreeFailure(res, error);
8315
+ }
8316
+ return;
8317
+ }
8318
+
7856
8319
  if (url.pathname === "/api/git-branches" && req.method === "GET") {
7857
8320
  const tab = getRequestedTab(req, url);
7858
8321
  try {
@@ -7877,7 +8340,7 @@ const server = createServer(async (req, res) => {
7877
8340
  if (url.pathname.startsWith("/api/git-workflow/")) {
7878
8341
  const body = req.method === "POST" ? await readJsonBody(req) : {};
7879
8342
  const tab = getRequestedTab(req, url, body);
7880
- const response = await handleGitWorkflowRequest(url.pathname, body, tab.cwd);
8343
+ const response = await handleGitWorkflowRequest(url.pathname, body, tab);
7881
8344
  if (response) {
7882
8345
  sendJson(res, 200, response);
7883
8346
  return;
@@ -7942,6 +8405,7 @@ const server = createServer(async (req, res) => {
7942
8405
  rememberTabState(tab, response.data);
7943
8406
  clearPendingExtensionUiRequests(tab);
7944
8407
  clearExtensionStatuses(tab);
8408
+ clearExtensionWidgets(tab);
7945
8409
  }
7946
8410
  sendJson(res, response.success === false ? 400 : 200, responseWithTab(response, tab));
7947
8411
  return;