@firstpick/pi-package-webui 0.6.9 → 0.7.0
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/README.md +6 -2
- package/bin/pi-webui.mjs +407 -31
- package/index.ts +7 -91
- package/package.json +5 -4
- package/public/app.js +676 -70
- package/public/aur-review-payload.mjs +108 -0
- package/public/guided-git-command-state.mjs +34 -0
- package/public/guided-git-review-state.mjs +137 -0
- package/public/index.html +4 -1
- package/public/styles.css +92 -2
- package/tests/aur-review-payload.test.mjs +57 -0
- package/tests/aur-review-widget-static.test.mjs +38 -0
- package/tests/compaction-resume-harness.test.mjs +55 -3
- package/tests/compaction-static.test.mjs +3 -3
- package/tests/fixtures/compacting-pi.mjs +10 -5
- package/tests/fixtures/fake-pi.mjs +46 -0
- package/tests/guided-git-aur-review.test.mjs +183 -0
- package/tests/http-endpoints-harness.test.mjs +92 -0
- package/tests/mobile-static.test.mjs +59 -6
- package/tests/staged-content-hash-contract.test.mjs +174 -0
- package/tests/subagents-helper.test.mjs +83 -4
- package/tests/transport-hardening-harness.test.mjs +157 -0
- package/webui-rpc-helper.mjs +108 -25
package/README.md
CHANGED
|
@@ -158,7 +158,7 @@ Optional Natural Conversation server-side voice fallback variables:
|
|
|
158
158
|
- Side-panel theme picker backed by optional `@firstpick/pi-themes-bundle` themes when loaded.
|
|
159
159
|
- Per-tab cwd changes, a clickable footer cwd picker, directory creation/search in the picker, saved path fast picks, server-persisted fast picks, and restart-safe restoration of open tabs.
|
|
160
160
|
- Detected app runner dropdown for the active tab cwd, including Cargo, Bun, npm/npx/pnpm, Python/uv, Go/Golang, Zig, C/C++, Docker Compose, root/dev/scripts shell scripts, and other common project runners with live output pinned at the top of the terminal. Running app runners expose line-oriented stdin in the widget for interactive scripts. Projects can add browseable custom runners in `.pi-webui-runners.json` with a command (default `./`) plus a relative path to the file to run.
|
|
161
|
-
- Guided Git workflow for existing repos and new repos with persistent model/reasoning preferences, review-first staging, generated or typed commit messages, explicit push/PR confirmation, and optional PR worktrees.
|
|
161
|
+
- Guided Git workflow for existing repos and new repos with persistent model/reasoning preferences, review-first staging, an optional manual staged repository-review gate from `aur-review`, generated or typed commit messages, explicit push/PR confirmation, and optional PR worktrees. When the review extension is loaded/enabled, both `git add .` and accepting the current staged set send `/aur-review start --scope staged --origin guided-git` to the same tab. Only its matching approval advances to message generation. The browser and server recheck the approved domain-separated staged-content hash before message generation, commit, and PR-worktree transfer; drift, missing hashes, or hash-check errors return to Stage and require a new review. A decline returns to staging and rejects an unchanged declined staged hash until corrected content is restaged. Guided Git never stages, commits, or pushes remediation automatically. The extension remains the decision authority; direct API callers are not granted an approval by this browser workflow.
|
|
162
162
|
- Browser support for Pi extension UI prompts, widgets, status updates, `/btw` side-question output widgets with optional context transfer/live steering, browser notifications when a tab needs an extension UI response, and an optional side-panel toggle for agent-done notifications.
|
|
163
163
|
- Localhost-only Pi/Web UI update checks with a top-right update notification and confirmed restart actions: **Update Pi & restart** runs `pi update --self` for Pi-only updates, while **Update Pi + Packages & Restart** first checks the selected Pi executable's `pi update --help`. It uses `pi update --all` when advertised, otherwise falls back to `pi update --self` followed by `pi update --extensions`, then updates detected Web UI/Optional Feature package roots for configured, local agent, project, global npm, and global Bun installs.
|
|
164
164
|
- Feedback reactions (`👍`, `👎`, `?`) on final assistant output plus tool/bash action cards, which can ask Pi to create or update a LEARNING.
|
|
@@ -338,6 +338,7 @@ Useful browser endpoints exposed by the local server include:
|
|
|
338
338
|
- `POST /api/action-feedback?tab=<tabId>` for feedback on final assistant output and action cards.
|
|
339
339
|
- `GET /api/optional-features` for optional companion package install/update status.
|
|
340
340
|
- `POST /api/optional-feature-install` for installing or updating known optional companion packages from the side panel.
|
|
341
|
+
- `GET /api/git-workflow/staged-content?tab=<tabId>` for the read-only bounded staged-content hash used by Guided Git approval binding.
|
|
341
342
|
- `GET /api/update-status`, localhost-only `POST /api/restart`, and localhost-only `POST /api/update` for checking Pi/Web UI updates and restarting the Web UI. `POST /api/update?all=1` probes the selected Pi executable for `pi update --all`, uses the split `pi update --self` plus `pi update --extensions` fallback when unavailable, and then updates detected Web UI/Optional Feature package roots for configured, local agent, project, global npm, and global Bun installs.
|
|
342
343
|
- `GET /api/network`, localhost-only `POST /api/network/open`, localhost-only `POST /api/network/close`, `GET /api/remote-auth`, `POST /api/remote-auth`, and localhost-only `POST /api/remote-auth/settings` for trusted-LAN exposure and optional 4-digit PIN authentication when serving non-local browser clients.
|
|
343
344
|
|
|
@@ -353,7 +354,9 @@ Run `../dev/scripts/sync-pi-package-symlinks.sh` first when developing companion
|
|
|
353
354
|
|
|
354
355
|
## Optional companion packages
|
|
355
356
|
|
|
356
|
-
A normal Pi/npm install includes the optional companion packages unless optional dependencies are disabled. Each Web UI tab curates Pi resources from the Web UI package that started the server, while preserving unrelated user/project resources. Companion packages installed as global/npm-prefix siblings of the started Web UI package are reused when the Web UI package does not have its own nested optional dependency copy, avoiding duplicate loads while keeping global `pi-webui` launches working. Startup checks loaded Pi capabilities directly through RPC-visible commands and live widget events, then the side panel shows each optional feature as enabled, disabled, installed-but-not-loaded, update-available, or install-needed. Installing or updating a feature is an explicit, warned action with running/failure feedback in the row and activity log; it is localhost-only, limited to known packages, and requires reloading the active Pi tab after installation.
|
|
357
|
+
A normal Pi/npm install includes the published optional companion packages unless optional dependencies are disabled. Each Web UI tab curates Pi resources from the Web UI package that started the server, while preserving unrelated user/project resources. Companion packages installed as global/npm-prefix siblings of the started Web UI package are reused when the Web UI package does not have its own nested optional dependency copy, avoiding duplicate loads while keeping global `pi-webui` launches working. Startup checks loaded Pi capabilities directly through RPC-visible commands and live widget events, then the side panel shows each optional feature as enabled, disabled, installed-but-not-loaded, update-available, or install-needed. Installing or updating a feature is an explicit, warned action with running/failure feedback in the row and activity log; it is localhost-only, limited to known packages, and requires reloading the active Pi tab after installation.
|
|
358
|
+
|
|
359
|
+
`@firstpick/pi-extension-aur-review` is intentionally not bundled with this WebUI release until it is published. From this workspace, install it locally with `pi install /home/firstpick/npm-packages/pi-extension-aur-review`, then reload the affected Pi/WebUI tab. `pi install npm:@firstpick/pi-extension-aur-review` becomes valid only after that package is published to npm.
|
|
357
360
|
|
|
358
361
|
When the standalone global `pi-webui` launcher is used, optional companion installs target the npm prefix containing the Web UI package when that prefix is safe, otherwise the Pi agent npm root if it contains Web UI. Override the target explicitly with `PI_WEBUI_OPTIONAL_FEATURE_INSTALL_ROOT=/path/to/package-root` when needed.
|
|
359
362
|
|
|
@@ -366,6 +369,7 @@ Optional companions:
|
|
|
366
369
|
- `@firstpick/pi-prompts-git-pr` — guided Git commit/push workflow.
|
|
367
370
|
- `@firstpick/pi-extension-release-npm` — NPM publish menu and release widgets.
|
|
368
371
|
- `@firstpick/pi-extension-release-aur` — AUR publish menu and release widgets.
|
|
372
|
+
- `@firstpick/pi-extension-aur-review` — Deterministic manual repository/Git review with working-tree standalone snapshots, staged Guided Git snapshots, and a specialized browser card. Install from `/home/firstpick/npm-packages/pi-extension-aur-review` locally for now; npm installation is valid only after publication.
|
|
369
373
|
- `@firstpick/pi-extension-workflows` — `/workflow` runtime with non-blocking Web UI subprocess-output widgets.
|
|
370
374
|
- `@firstpick/pi-extension-safety-guard` — configurable guardrails for dangerous bash commands and protected file edits, with native `/safety-guard-setup` controls.
|
|
371
375
|
- `@firstpick/pi-extension-setup-skills` — TUI `/skills` setup command alongside WebUI-native skill toggles.
|
package/bin/pi-webui.mjs
CHANGED
|
@@ -4,7 +4,7 @@ import { createHash, randomInt, randomUUID, timingSafeEqual } from "node:crypto"
|
|
|
4
4
|
import { createReadStream, readFileSync, realpathSync, statSync } 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, rm, stat, writeFile } from "node:fs/promises";
|
|
7
|
+
import { access, copyFile, lstat, mkdir, open, readFile, readdir, realpath, rename, rm, stat, writeFile } from "node:fs/promises";
|
|
8
8
|
import { homedir, networkInterfaces, platform, tmpdir } from "node:os";
|
|
9
9
|
import path from "node:path";
|
|
10
10
|
import { StringDecoder } from "node:string_decoder";
|
|
@@ -154,6 +154,9 @@ const ATTACHMENT_UPLOAD_MAX_FILE_BYTES = 64 * 1024 * 1024;
|
|
|
154
154
|
const ATTACHMENT_UPLOAD_MAX_TOTAL_BYTES = 64 * 1024 * 1024;
|
|
155
155
|
const INLINE_IMAGE_MAX_BYTES = 8 * 1024 * 1024;
|
|
156
156
|
const INLINE_IMAGE_TOTAL_MAX_BYTES = 16 * 1024 * 1024;
|
|
157
|
+
// Keep enough headroom for base64-encoded inline images plus their RPC envelope.
|
|
158
|
+
// Pi RPC output is JSONL, so this caps one physical line rather than a response.
|
|
159
|
+
const PI_RPC_JSONL_LINE_MAX_BYTES = 32 * 1024 * 1024;
|
|
157
160
|
const RPC_IMAGE_MIME_TYPES = new Set(["image/png", "image/jpeg", "image/webp", "image/gif"]);
|
|
158
161
|
const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
|
|
159
162
|
const SETTINGS_TRANSPORT_CHOICES = ["sse", "websocket", "websocket-cached", "auto"];
|
|
@@ -310,6 +313,7 @@ const OPTIONAL_FEATURE_PACKAGES = new Map([
|
|
|
310
313
|
["gitWorkflow", "@firstpick/pi-prompts-git-pr"],
|
|
311
314
|
["releaseNpm", "@firstpick/pi-extension-release-npm"],
|
|
312
315
|
["releaseAur", "@firstpick/pi-extension-release-aur"],
|
|
316
|
+
["aurReview", "@firstpick/pi-extension-aur-review"],
|
|
313
317
|
["workflows", "@firstpick/pi-extension-workflows"],
|
|
314
318
|
["safetyGuard", "@firstpick/pi-extension-safety-guard"],
|
|
315
319
|
["tuiSkillsCommand", "@firstpick/pi-extension-setup-skills"],
|
|
@@ -634,6 +638,47 @@ async function installedPiReleaseNotes() {
|
|
|
634
638
|
return piReleaseNotesCache;
|
|
635
639
|
}
|
|
636
640
|
|
|
641
|
+
const stderrMirrorFailureListeners = new Set();
|
|
642
|
+
const stderrMirrorErrorHandlers = new WeakSet();
|
|
643
|
+
|
|
644
|
+
function ensureStderrMirrorErrorHandler(stream) {
|
|
645
|
+
if (stderrMirrorErrorHandlers.has(stream)) return;
|
|
646
|
+
stderrMirrorErrorHandlers.add(stream);
|
|
647
|
+
stream.on("error", (error) => {
|
|
648
|
+
// Do not log from this handler: stderr is the failing sink and recursive
|
|
649
|
+
// diagnostics can otherwise terminate the process. Active writers report
|
|
650
|
+
// the failure through their normal Web UI event path instead.
|
|
651
|
+
for (const reportFailure of [...stderrMirrorFailureListeners]) reportFailure(error);
|
|
652
|
+
});
|
|
653
|
+
}
|
|
654
|
+
|
|
655
|
+
function mirrorPiStderr(text, onFailure) {
|
|
656
|
+
const stream = process.stderr;
|
|
657
|
+
let reported = false;
|
|
658
|
+
const reportFailure = (error) => {
|
|
659
|
+
if (reported) return;
|
|
660
|
+
reported = true;
|
|
661
|
+
stderrMirrorFailureListeners.delete(reportFailure);
|
|
662
|
+
onFailure(error);
|
|
663
|
+
};
|
|
664
|
+
|
|
665
|
+
if (!stream?.writable || stream.destroyed || stream.writableEnded) {
|
|
666
|
+
reportFailure(new Error("Web UI stderr sink is not writable"));
|
|
667
|
+
return;
|
|
668
|
+
}
|
|
669
|
+
|
|
670
|
+
ensureStderrMirrorErrorHandler(stream);
|
|
671
|
+
stderrMirrorFailureListeners.add(reportFailure);
|
|
672
|
+
try {
|
|
673
|
+
stream.write(text, (error) => {
|
|
674
|
+
stderrMirrorFailureListeners.delete(reportFailure);
|
|
675
|
+
if (error) reportFailure(error);
|
|
676
|
+
});
|
|
677
|
+
} catch (error) {
|
|
678
|
+
reportFailure(error);
|
|
679
|
+
}
|
|
680
|
+
}
|
|
681
|
+
|
|
637
682
|
class PiRpcProcess {
|
|
638
683
|
constructor({ command, args, displayCommand, cwd, env = process.env }) {
|
|
639
684
|
this.command = command;
|
|
@@ -645,6 +690,16 @@ class PiRpcProcess {
|
|
|
645
690
|
this.pending = new Map();
|
|
646
691
|
this.listeners = new Set();
|
|
647
692
|
this.startedAt = new Date().toISOString();
|
|
693
|
+
this.stderrMirrorFailureReported = false;
|
|
694
|
+
}
|
|
695
|
+
|
|
696
|
+
reportStderrMirrorFailure(error) {
|
|
697
|
+
if (this.stderrMirrorFailureReported) return;
|
|
698
|
+
this.stderrMirrorFailureReported = true;
|
|
699
|
+
this.emit({
|
|
700
|
+
type: "pi_stderr_sink_error",
|
|
701
|
+
error: `Pi RPC stderr could not be mirrored to the Web UI server log: ${sanitizeError(error)}`,
|
|
702
|
+
});
|
|
648
703
|
}
|
|
649
704
|
|
|
650
705
|
start() {
|
|
@@ -669,8 +724,10 @@ class PiRpcProcess {
|
|
|
669
724
|
this.attachJsonlReader(this.child.stdout, (line) => this.handleStdoutLine(line));
|
|
670
725
|
this.attachTextReader(this.child.stderr, (text) => {
|
|
671
726
|
if (text.length > 0) {
|
|
672
|
-
|
|
727
|
+
// Publish before attempting the optional terminal mirror so a closed
|
|
728
|
+
// stderr sink cannot hide Pi diagnostics from browser clients.
|
|
673
729
|
this.emit({ type: "pi_stderr", text });
|
|
730
|
+
mirrorPiStderr(text, (error) => this.reportStderrMirrorFailure(error));
|
|
674
731
|
}
|
|
675
732
|
});
|
|
676
733
|
|
|
@@ -699,24 +756,56 @@ class PiRpcProcess {
|
|
|
699
756
|
attachJsonlReader(stream, onLine) {
|
|
700
757
|
const decoder = new StringDecoder("utf8");
|
|
701
758
|
let buffer = "";
|
|
759
|
+
let bufferBytes = 0;
|
|
760
|
+
let discardingOversizedLine = false;
|
|
761
|
+
|
|
762
|
+
const emitOversizedLine = () => this.emit({
|
|
763
|
+
type: "pi_stdout_line_too_large",
|
|
764
|
+
error: `Discarded a Pi RPC JSONL line larger than ${PI_RPC_JSONL_LINE_MAX_BYTES} bytes`,
|
|
765
|
+
maxBytes: PI_RPC_JSONL_LINE_MAX_BYTES,
|
|
766
|
+
});
|
|
767
|
+
const consume = (chunk) => {
|
|
768
|
+
let input = chunk;
|
|
769
|
+
while (input.length > 0) {
|
|
770
|
+
if (discardingOversizedLine) {
|
|
771
|
+
const newlineIndex = input.indexOf("\n");
|
|
772
|
+
if (newlineIndex === -1) return;
|
|
773
|
+
discardingOversizedLine = false;
|
|
774
|
+
input = input.slice(newlineIndex + 1);
|
|
775
|
+
continue;
|
|
776
|
+
}
|
|
702
777
|
|
|
703
|
-
|
|
704
|
-
|
|
705
|
-
|
|
706
|
-
|
|
707
|
-
|
|
708
|
-
|
|
709
|
-
|
|
778
|
+
const newlineIndex = input.indexOf("\n");
|
|
779
|
+
const segment = newlineIndex === -1 ? input : input.slice(0, newlineIndex);
|
|
780
|
+
const segmentBytes = Buffer.byteLength(segment);
|
|
781
|
+
if (bufferBytes + segmentBytes > PI_RPC_JSONL_LINE_MAX_BYTES) {
|
|
782
|
+
buffer = "";
|
|
783
|
+
bufferBytes = 0;
|
|
784
|
+
emitOversizedLine();
|
|
785
|
+
if (newlineIndex === -1) {
|
|
786
|
+
discardingOversizedLine = true;
|
|
787
|
+
return;
|
|
788
|
+
}
|
|
789
|
+
input = input.slice(newlineIndex + 1);
|
|
790
|
+
continue;
|
|
791
|
+
}
|
|
792
|
+
|
|
793
|
+
buffer += segment;
|
|
794
|
+
bufferBytes += segmentBytes;
|
|
795
|
+
if (newlineIndex === -1) return;
|
|
796
|
+
let line = buffer;
|
|
797
|
+
buffer = "";
|
|
798
|
+
bufferBytes = 0;
|
|
710
799
|
if (line.endsWith("\r")) line = line.slice(0, -1);
|
|
711
800
|
onLine(line);
|
|
801
|
+
input = input.slice(newlineIndex + 1);
|
|
712
802
|
}
|
|
713
|
-
}
|
|
803
|
+
};
|
|
714
804
|
|
|
805
|
+
stream.on("data", (chunk) => consume(typeof chunk === "string" ? chunk : decoder.write(chunk)));
|
|
715
806
|
stream.on("end", () => {
|
|
716
|
-
|
|
717
|
-
if (buffer.length > 0)
|
|
718
|
-
onLine(buffer.endsWith("\r") ? buffer.slice(0, -1) : buffer);
|
|
719
|
-
}
|
|
807
|
+
consume(decoder.end());
|
|
808
|
+
if (!discardingOversizedLine && buffer.length > 0) onLine(buffer.endsWith("\r") ? buffer.slice(0, -1) : buffer);
|
|
720
809
|
});
|
|
721
810
|
}
|
|
722
811
|
|
|
@@ -2009,6 +2098,9 @@ async function restoreGitWorkflowGenerationProfile(tab) {
|
|
|
2009
2098
|
|
|
2010
2099
|
async function startGitWorkflowGeneration(tab, body = {}) {
|
|
2011
2100
|
if (tab.gitWorkflowGenerationRestore) throw makeHttpError(409, "A guided Git generation request is already active in this tab");
|
|
2101
|
+
// Browser state is untrusted. When it claims an approved content token,
|
|
2102
|
+
// verify the exact current index again at this server action boundary.
|
|
2103
|
+
await assertExpectedStagedContentHash(tab, body);
|
|
2012
2104
|
const preferences = await readGitWorkflowPreferences();
|
|
2013
2105
|
if (!isGitWorkflowSetupComplete(preferences)) throw makeHttpError(409, "Run /git-workflow-setup or open Guided Git Setup before generating Git text");
|
|
2014
2106
|
|
|
@@ -4391,6 +4483,15 @@ let activeGitWorkflowProcess = null;
|
|
|
4391
4483
|
const GIT_CHANGES_COMMAND_TIMEOUT_MS = 5000;
|
|
4392
4484
|
const GIT_CHANGES_DIFF_MAX_OUTPUT = 500_000;
|
|
4393
4485
|
const GIT_PULL_TIMEOUT_MS = 15 * 60 * 1000;
|
|
4486
|
+
// Must remain byte-for-byte aligned with pi-extension-aur-review/src/git.ts.
|
|
4487
|
+
const STAGED_CONTENT_HASH_DOMAIN = "firstpick/aur-review/staged-content/v1\0";
|
|
4488
|
+
const STAGED_CONTENT_HASH_TIMEOUT_MS = 10_000;
|
|
4489
|
+
const STAGED_CONTENT_HASH_OUTPUT_LIMIT = 4 * 1024 * 1024;
|
|
4490
|
+
const STAGED_CONTENT_HASH_ARGS = [
|
|
4491
|
+
"-c", "core.quotepath=false",
|
|
4492
|
+
"-c", "diff.external=",
|
|
4493
|
+
"diff", "--cached", "--binary", "--full-index", "--no-ext-diff", "--no-textconv", "--no-renames", "--",
|
|
4494
|
+
];
|
|
4394
4495
|
const GIT_STATUS_KIND_RANK = Object.freeze({ changed: 0, untracked: 1, modified: 2, staged: 3, conflicted: 4 });
|
|
4395
4496
|
|
|
4396
4497
|
async function getGitRoot(cwd) {
|
|
@@ -4417,6 +4518,103 @@ async function runGitReadCommand(root, args, options = {}) {
|
|
|
4417
4518
|
return (await runGitReadCommandDetailed(root, args, options)).output;
|
|
4418
4519
|
}
|
|
4419
4520
|
|
|
4521
|
+
/**
|
|
4522
|
+
* Read binary cached-diff bytes without decoding them. This is intentionally
|
|
4523
|
+
* separate from runCommand(), whose string buffering is appropriate for UI
|
|
4524
|
+
* output but would corrupt the staged-content approval token.
|
|
4525
|
+
*/
|
|
4526
|
+
function runGitStagedContentHashCommand(root) {
|
|
4527
|
+
return new Promise((resolve, reject) => {
|
|
4528
|
+
const child = spawn("git", STAGED_CONTENT_HASH_ARGS, {
|
|
4529
|
+
cwd: root,
|
|
4530
|
+
stdio: ["ignore", "pipe", "pipe"],
|
|
4531
|
+
windowsHide: true,
|
|
4532
|
+
env: { ...process.env, GIT_OPTIONAL_LOCKS: "0", GIT_CONFIG_NOSYSTEM: "1", LC_ALL: "C" },
|
|
4533
|
+
});
|
|
4534
|
+
const stdout = [];
|
|
4535
|
+
const stderr = [];
|
|
4536
|
+
let stdoutBytes = 0;
|
|
4537
|
+
let stderrBytes = 0;
|
|
4538
|
+
let settled = false;
|
|
4539
|
+
const finish = (error, result) => {
|
|
4540
|
+
if (settled) return;
|
|
4541
|
+
settled = true;
|
|
4542
|
+
clearTimeout(timeout);
|
|
4543
|
+
if (error) reject(error);
|
|
4544
|
+
else resolve(result);
|
|
4545
|
+
};
|
|
4546
|
+
const stop = (message) => {
|
|
4547
|
+
try { child.kill("SIGKILL"); } catch { /* process already exited */ }
|
|
4548
|
+
finish(makeUserFacingError(message));
|
|
4549
|
+
};
|
|
4550
|
+
const timeout = setTimeout(() => stop(`git diff --cached timed out after ${STAGED_CONTENT_HASH_TIMEOUT_MS / 1000} seconds`), STAGED_CONTENT_HASH_TIMEOUT_MS);
|
|
4551
|
+
child.stdout.on("data", (chunk) => {
|
|
4552
|
+
const bytes = Buffer.from(chunk);
|
|
4553
|
+
stdoutBytes += bytes.length;
|
|
4554
|
+
if (stdoutBytes > STAGED_CONTENT_HASH_OUTPUT_LIMIT) {
|
|
4555
|
+
stop(`git diff --cached output exceeded the ${STAGED_CONTENT_HASH_OUTPUT_LIMIT / 1024 / 1024} MiB staged-content safety limit`);
|
|
4556
|
+
return;
|
|
4557
|
+
}
|
|
4558
|
+
stdout.push(bytes);
|
|
4559
|
+
});
|
|
4560
|
+
child.stderr.on("data", (chunk) => {
|
|
4561
|
+
const bytes = Buffer.from(chunk);
|
|
4562
|
+
stderrBytes += bytes.length;
|
|
4563
|
+
if (stderrBytes <= 64 * 1024) stderr.push(bytes);
|
|
4564
|
+
});
|
|
4565
|
+
child.on("error", (error) => finish(makeUserFacingError(formatCommandSpawnError("git", error))));
|
|
4566
|
+
child.on("close", (exitCode) => {
|
|
4567
|
+
if (exitCode !== 0) {
|
|
4568
|
+
const detail = Buffer.concat(stderr).toString("utf8").trim().slice(0, 1200);
|
|
4569
|
+
finish(makeUserFacingError(detail ? `git diff --cached failed: ${detail}` : `git diff --cached failed with exit code ${exitCode ?? "unknown"}`));
|
|
4570
|
+
return;
|
|
4571
|
+
}
|
|
4572
|
+
finish(null, Buffer.concat(stdout));
|
|
4573
|
+
});
|
|
4574
|
+
});
|
|
4575
|
+
}
|
|
4576
|
+
|
|
4577
|
+
function stagedContentHashFromDiff(stagedDiff) {
|
|
4578
|
+
return createHash("sha256").update(STAGED_CONTENT_HASH_DOMAIN).update(stagedDiff).digest("hex");
|
|
4579
|
+
}
|
|
4580
|
+
|
|
4581
|
+
async function readStagedContentHash(root) {
|
|
4582
|
+
// `git diff --cached` correctly compares the index to the empty tree when
|
|
4583
|
+
// HEAD is unborn, so no HEAD lookup is needed (or allowed) here.
|
|
4584
|
+
const stagedDiff = await runGitStagedContentHashCommand(root);
|
|
4585
|
+
return {
|
|
4586
|
+
stagedDiff,
|
|
4587
|
+
hasStagedChanges: stagedDiff.length > 0,
|
|
4588
|
+
stagedContentHash: stagedDiff.length > 0 ? stagedContentHashFromDiff(stagedDiff) : null,
|
|
4589
|
+
};
|
|
4590
|
+
}
|
|
4591
|
+
|
|
4592
|
+
/** Read-only same-tab digest of the exact staged content git can commit. */
|
|
4593
|
+
async function stagedContentHashForTab(tab) {
|
|
4594
|
+
const root = await getGitRoot(tab.cwd);
|
|
4595
|
+
const staged = await readStagedContentHash(root);
|
|
4596
|
+
return { root, hasStagedChanges: staged.hasStagedChanges, stagedContentHash: staged.stagedContentHash };
|
|
4597
|
+
}
|
|
4598
|
+
|
|
4599
|
+
function expectedStagedContentHashFromBody(body = {}) {
|
|
4600
|
+
const expected = body?.expectedStagedContentHash;
|
|
4601
|
+
if (expected === undefined) return ""; // Legacy Guided Git flow: no review was required.
|
|
4602
|
+
if (typeof expected !== "string" || !/^[a-f0-9]{64}$/i.test(expected)) {
|
|
4603
|
+
throw makeHttpError(400, "expectedStagedContentHash must be a SHA-256 hex digest");
|
|
4604
|
+
}
|
|
4605
|
+
return expected;
|
|
4606
|
+
}
|
|
4607
|
+
|
|
4608
|
+
async function assertExpectedStagedContentHash(tab, body = {}) {
|
|
4609
|
+
const expected = expectedStagedContentHashFromBody(body);
|
|
4610
|
+
if (!expected) return "";
|
|
4611
|
+
const current = await stagedContentHashForTab(tab);
|
|
4612
|
+
if (!current.hasStagedChanges || current.stagedContentHash !== expected) {
|
|
4613
|
+
throw makeHttpError(409, "Staged content changed after manual approval. Return to Stage and request a new manual review before continuing.");
|
|
4614
|
+
}
|
|
4615
|
+
return expected;
|
|
4616
|
+
}
|
|
4617
|
+
|
|
4420
4618
|
function gitBranchFromPorcelainStatus(statusText) {
|
|
4421
4619
|
for (const line of String(statusText || "").split(/\r?\n/)) {
|
|
4422
4620
|
if (!line.startsWith("# branch.head ")) continue;
|
|
@@ -5952,18 +6150,17 @@ async function readGitWorkflowMessageFilesForTransfer(root, messageCwd = root) {
|
|
|
5952
6150
|
return files;
|
|
5953
6151
|
}
|
|
5954
6152
|
|
|
5955
|
-
async function snapshotGitWorkflowBranchState(root, cwd = root) {
|
|
6153
|
+
async function snapshotGitWorkflowBranchState(root, cwd = root, expectedStagedContentHash = "") {
|
|
5956
6154
|
const messageCwd = gitWorkflowMessageCwd(root, cwd);
|
|
5957
|
-
|
|
5958
|
-
|
|
5959
|
-
|
|
5960
|
-
|
|
5961
|
-
|
|
5962
|
-
if (diffResult.exitCode !== 0 || diffResult.timedOut || diffResult.cancelled || diffResult.error) {
|
|
5963
|
-
throw new Error((diffResult.stderr || diffResult.stdout || diffResult.error || "Unable to read staged changes for the PR worktree").trim());
|
|
6155
|
+
// Preserve raw patch bytes: string decoding would corrupt binary staged
|
|
6156
|
+
// changes before `git apply --index` can copy them to the PR worktree.
|
|
6157
|
+
const staged = await readStagedContentHash(root);
|
|
6158
|
+
if (expectedStagedContentHash && (!staged.hasStagedChanges || staged.stagedContentHash !== expectedStagedContentHash)) {
|
|
6159
|
+
throw makeHttpError(409, "Staged content changed after manual approval. Return to Stage and request a new manual review before creating a PR worktree.");
|
|
5964
6160
|
}
|
|
5965
6161
|
return {
|
|
5966
|
-
stagedPatch:
|
|
6162
|
+
stagedPatch: staged.stagedDiff,
|
|
6163
|
+
stagedContentHash: staged.stagedContentHash,
|
|
5967
6164
|
messageFiles: await readGitWorkflowMessageFilesForTransfer(root, messageCwd),
|
|
5968
6165
|
};
|
|
5969
6166
|
}
|
|
@@ -5971,10 +6168,10 @@ async function snapshotGitWorkflowBranchState(root, cwd = root) {
|
|
|
5971
6168
|
async function applyGitWorkflowBranchStateToWorktree(snapshot, worktreePath) {
|
|
5972
6169
|
const copiedMessageFiles = [];
|
|
5973
6170
|
let appliedStagedPatch = false;
|
|
5974
|
-
const
|
|
5975
|
-
if (
|
|
6171
|
+
const patchBytes = Buffer.isBuffer(snapshot?.stagedPatch) ? snapshot.stagedPatch : Buffer.alloc(0);
|
|
6172
|
+
if (patchBytes.length > 0) {
|
|
5976
6173
|
const patchPath = path.join(tmpdir(), `pi-webui-staged-worktree-${process.pid}-${Date.now()}-${randomUUID()}.patch`);
|
|
5977
|
-
await writeFile(patchPath,
|
|
6174
|
+
await writeFile(patchPath, patchBytes);
|
|
5978
6175
|
try {
|
|
5979
6176
|
const applyResult = await runGitWorkflowCommand(["apply", "--index", "--whitespace=nowarn", patchPath], {
|
|
5980
6177
|
cwd: worktreePath,
|
|
@@ -6020,7 +6217,8 @@ async function createGitWorkflowBranchWorktree(tab, body = {}) {
|
|
|
6020
6217
|
const root = await getGitRoot(tab.cwd);
|
|
6021
6218
|
const branch = cleanGitBranchName(body.branch || body.branchName);
|
|
6022
6219
|
await validateGitBranchName(root, branch);
|
|
6023
|
-
const
|
|
6220
|
+
const expectedStagedContentHash = expectedStagedContentHashFromBody(body);
|
|
6221
|
+
const snapshot = await snapshotGitWorkflowBranchState(root, tab.cwd, expectedStagedContentHash);
|
|
6024
6222
|
let createdResult = null;
|
|
6025
6223
|
try {
|
|
6026
6224
|
createdResult = await createGitWorktree(tab.cwd, { ...body, branchName: branch });
|
|
@@ -6225,6 +6423,7 @@ function gitWorkflowCommandPayload(result) {
|
|
|
6225
6423
|
// guard are enforced at the router before dispatch — never dispatch on path
|
|
6226
6424
|
// alone, or cross-origin GETs (image/script tags) could drive git mutations.
|
|
6227
6425
|
const GIT_WORKFLOW_READONLY_PATHS = new Set([
|
|
6426
|
+
"/api/git-workflow/staged-content",
|
|
6228
6427
|
"/api/git-workflow/message",
|
|
6229
6428
|
"/api/git-workflow/default-commit-message",
|
|
6230
6429
|
"/api/git-workflow/branch-name",
|
|
@@ -6252,6 +6451,9 @@ async function handleGitWorkflowRequest(pathname, body = {}, tabOrCwd = options.
|
|
|
6252
6451
|
const cwd = tab?.cwd || tabOrCwd || options.cwd;
|
|
6253
6452
|
try {
|
|
6254
6453
|
switch (pathname) {
|
|
6454
|
+
case "/api/git-workflow/staged-content":
|
|
6455
|
+
if (!tab) throw new Error("Staged-content lookup requires a Web UI tab");
|
|
6456
|
+
return { ok: true, data: await stagedContentHashForTab(tab) };
|
|
6255
6457
|
case "/api/git-workflow/message":
|
|
6256
6458
|
return { ok: true, data: await readGitWorkflowMessages(cwd) };
|
|
6257
6459
|
case "/api/git-workflow/default-commit-message":
|
|
@@ -6303,6 +6505,9 @@ async function handleGitWorkflowRequest(pathname, body = {}, tabOrCwd = options.
|
|
|
6303
6505
|
case "/api/git-workflow/commit": {
|
|
6304
6506
|
const variant = String(body.variant || "").trim();
|
|
6305
6507
|
if (!["short", "long", "input"].includes(variant)) throw new Error("variant must be 'short', 'long', or 'input'");
|
|
6508
|
+
// Recheck here as well as in the browser. A staged index can change
|
|
6509
|
+
// between the browser's read-only check and this mutating request.
|
|
6510
|
+
await assertExpectedStagedContentHash(tab || { cwd }, body);
|
|
6306
6511
|
if (variant === "input") {
|
|
6307
6512
|
const root = await getGitRoot(cwd);
|
|
6308
6513
|
const message = cleanGitCommitMessageInput(body.message);
|
|
@@ -6455,7 +6660,7 @@ async function readBundledThemes() {
|
|
|
6455
6660
|
function normalizeStaticPath(urlPath) {
|
|
6456
6661
|
if (urlPath === "/") return "index.html";
|
|
6457
6662
|
const name = urlPath.startsWith("/") ? urlPath.slice(1) : urlPath;
|
|
6458
|
-
if (!["index.html", "app.js", "voice-conversation.mjs", "styles.css", "favicon.svg", "apple-touch-icon.png", "icon-192.png", "icon-512.png", "catppuccin-mocha-background.png", "matrix-background.webp", "manifest.webmanifest", "service-worker.js"].includes(name)) return undefined;
|
|
6663
|
+
if (!["index.html", "app.js", "voice-conversation.mjs", "aur-review-payload.mjs", "guided-git-command-state.mjs", "guided-git-review-state.mjs", "styles.css", "favicon.svg", "apple-touch-icon.png", "icon-192.png", "icon-512.png", "catppuccin-mocha-background.png", "matrix-background.webp", "manifest.webmanifest", "service-worker.js"].includes(name)) return undefined;
|
|
6459
6664
|
return name;
|
|
6460
6665
|
}
|
|
6461
6666
|
|
|
@@ -6892,9 +7097,11 @@ async function workspacePackageRootForName(packageName) {
|
|
|
6892
7097
|
return null;
|
|
6893
7098
|
}
|
|
6894
7099
|
for (const entry of entries) {
|
|
7100
|
+
// Workspace package directories use the pi-* convention. Confirm every
|
|
7101
|
+
// eligible sibling by its manifest name, never the folder prefix alone.
|
|
6895
7102
|
if (!entry.isDirectory() || !entry.name.startsWith("pi-")) continue;
|
|
6896
7103
|
const candidate = path.join(root, entry.name);
|
|
6897
|
-
if ((await packageNameForResourcePath(path.join(candidate, "
|
|
7104
|
+
if ((await packageNameForResourcePath(path.join(candidate, "package.json"))) === packageName) return candidate;
|
|
6898
7105
|
}
|
|
6899
7106
|
return null;
|
|
6900
7107
|
}
|
|
@@ -7495,7 +7702,7 @@ async function flushCompactionQueue(tab, event = {}) {
|
|
|
7495
7702
|
let startedPrompt = false;
|
|
7496
7703
|
while (remaining.length) {
|
|
7497
7704
|
const item = remaining[0];
|
|
7498
|
-
const command = startedPrompt ?
|
|
7705
|
+
const command = startedPrompt ? queuedRetryCommand(item) : queuedPromptCommand(item);
|
|
7499
7706
|
if (!startedPrompt) {
|
|
7500
7707
|
const pendingThinkingResponse = await applyPendingThinkingBeforePrompt(tab);
|
|
7501
7708
|
if (pendingThinkingResponse?.success === false) throw new Error(pendingThinkingResponse.error || "failed to apply queued thinking level");
|
|
@@ -7833,7 +8040,7 @@ function attachRpcToTab(tab, rpc) {
|
|
|
7833
8040
|
scopedEvent = { ...scopedEvent, tabActivity: tabActivitySnapshot(tab), pendingExtensionUiRequestCount: pendingExtensionUiRequests(tab).length };
|
|
7834
8041
|
recordEvent(scopedEvent);
|
|
7835
8042
|
for (const client of tab.sseClients) sendSse(client, scopedEvent);
|
|
7836
|
-
if (event?.type === "compaction_end"
|
|
8043
|
+
if (event?.type === "compaction_end") void flushCompactionQueue(tab, event);
|
|
7837
8044
|
if (event?.type === "agent_settled") void restoreGitWorkflowGenerationProfile(tab);
|
|
7838
8045
|
});
|
|
7839
8046
|
}
|
|
@@ -7962,6 +8169,79 @@ function webuiSubagentsData() {
|
|
|
7962
8169
|
};
|
|
7963
8170
|
}
|
|
7964
8171
|
|
|
8172
|
+
function normalizeWebuiSubagentTranscriptValue(value, maxLength = WEBUI_SUBAGENT_OUTPUT_LINE_LENGTH) {
|
|
8173
|
+
return String(value ?? "").replace(/\r/g, "").slice(0, maxLength);
|
|
8174
|
+
}
|
|
8175
|
+
|
|
8176
|
+
function normalizeWebuiSubagentTranscriptLines(value) {
|
|
8177
|
+
return String(value ?? "").replace(/\r/g, "").split("\n").map((line) => line.slice(0, WEBUI_SUBAGENT_OUTPUT_LINE_LENGTH));
|
|
8178
|
+
}
|
|
8179
|
+
|
|
8180
|
+
function normalizeWebuiSubagentTranscript(value) {
|
|
8181
|
+
const messages = [];
|
|
8182
|
+
let remainingParts = WEBUI_SUBAGENT_OUTPUT_LINE_LIMIT;
|
|
8183
|
+
const rawMessages = Array.isArray(value) ? value : [];
|
|
8184
|
+
for (let messageIndex = rawMessages.length - 1; messageIndex >= 0 && remainingParts > 0; messageIndex -= 1) {
|
|
8185
|
+
const rawMessage = rawMessages[messageIndex];
|
|
8186
|
+
const role = rawMessage?.role;
|
|
8187
|
+
if (role !== "assistant" && role !== "toolResult") continue;
|
|
8188
|
+
const rawContent = Array.isArray(rawMessage.content) ? rawMessage.content : [{ type: "text", text: rawMessage.content }];
|
|
8189
|
+
const content = [];
|
|
8190
|
+
for (let partIndex = rawContent.length - 1; partIndex >= 0 && remainingParts > 0; partIndex -= 1) {
|
|
8191
|
+
const rawPart = rawContent[partIndex];
|
|
8192
|
+
if (role === "assistant" && rawPart?.type === "toolCall") {
|
|
8193
|
+
const name = normalizeWebuiSubagentText(rawPart.name || rawPart.toolName || rawPart.toolCall?.name, 120) || "tool";
|
|
8194
|
+
let argumentsText = "{}";
|
|
8195
|
+
try {
|
|
8196
|
+
const argumentsValue = rawPart.arguments ?? rawPart.args ?? rawPart.input ?? rawPart.toolCall?.arguments ?? {};
|
|
8197
|
+
argumentsText = normalizeWebuiSubagentTranscriptValue(typeof argumentsValue === "string" ? argumentsValue.replace(/\n/g, "\\n") : JSON.stringify(argumentsValue));
|
|
8198
|
+
} catch {
|
|
8199
|
+
// Keep the bounded placeholder when the helper received a cyclic value.
|
|
8200
|
+
}
|
|
8201
|
+
content.unshift({
|
|
8202
|
+
type: "toolCall",
|
|
8203
|
+
name,
|
|
8204
|
+
arguments: argumentsText,
|
|
8205
|
+
...(normalizeWebuiSubagentText(rawPart.id || rawPart.toolCallId || rawPart.tool_call_id, 240) ? { id: normalizeWebuiSubagentText(rawPart.id || rawPart.toolCallId || rawPart.tool_call_id, 240) } : {}),
|
|
8206
|
+
});
|
|
8207
|
+
remainingParts -= 1;
|
|
8208
|
+
continue;
|
|
8209
|
+
}
|
|
8210
|
+
const type = role === "assistant" && rawPart?.type === "thinking" ? "thinking" : "text";
|
|
8211
|
+
if (rawPart?.type !== "text" && typeof rawPart !== "string" && type !== "thinking") continue;
|
|
8212
|
+
const rawText = typeof rawPart === "string"
|
|
8213
|
+
? rawPart
|
|
8214
|
+
: type === "thinking" ? rawPart.thinking ?? rawPart.text ?? rawPart.content : rawPart.text ?? rawPart.content;
|
|
8215
|
+
if (typeof rawText !== "string") continue;
|
|
8216
|
+
const property = type === "thinking" ? "thinking" : "text";
|
|
8217
|
+
const lines = normalizeWebuiSubagentTranscriptLines(rawText);
|
|
8218
|
+
for (let lineIndex = lines.length - 1; lineIndex >= 0 && remainingParts > 0; lineIndex -= 1) {
|
|
8219
|
+
const line = lines[lineIndex];
|
|
8220
|
+
if (line.trim().toLowerCase() === "(no output)") continue;
|
|
8221
|
+
const previous = content[0];
|
|
8222
|
+
if (previous?.type === type) previous[property] = `${line}\n${previous[property]}`;
|
|
8223
|
+
else content.unshift({ type, [property]: line });
|
|
8224
|
+
remainingParts -= 1;
|
|
8225
|
+
}
|
|
8226
|
+
}
|
|
8227
|
+
if (!content.length) continue;
|
|
8228
|
+
const timestamp = Number.isFinite(rawMessage.timestamp)
|
|
8229
|
+
? rawMessage.timestamp
|
|
8230
|
+
: normalizeWebuiSubagentText(rawMessage.timestamp, 128) || undefined;
|
|
8231
|
+
messages.unshift({
|
|
8232
|
+
role,
|
|
8233
|
+
...(timestamp ? { timestamp } : {}),
|
|
8234
|
+
...(role === "toolResult" ? {
|
|
8235
|
+
...(normalizeWebuiSubagentText(rawMessage.toolCallId || rawMessage.tool_call_id, 240) ? { toolCallId: normalizeWebuiSubagentText(rawMessage.toolCallId || rawMessage.tool_call_id, 240) } : {}),
|
|
8236
|
+
...(normalizeWebuiSubagentText(rawMessage.toolName || rawMessage.name, 120) ? { toolName: normalizeWebuiSubagentText(rawMessage.toolName || rawMessage.name, 120) } : {}),
|
|
8237
|
+
...(rawMessage.isError === true ? { isError: true } : {}),
|
|
8238
|
+
} : {}),
|
|
8239
|
+
content,
|
|
8240
|
+
});
|
|
8241
|
+
}
|
|
8242
|
+
return messages;
|
|
8243
|
+
}
|
|
8244
|
+
|
|
7965
8245
|
function normalizeWebuiSubagentOutput(value, selection) {
|
|
7966
8246
|
if (!value || typeof value !== "object" || value.version !== 1) throw makeHttpError(502, "Invalid subagent output response from Web UI helper");
|
|
7967
8247
|
const rawAgent = value.agent && typeof value.agent === "object" ? value.agent : {};
|
|
@@ -7973,6 +8253,7 @@ function normalizeWebuiSubagentOutput(value, selection) {
|
|
|
7973
8253
|
args: normalizeWebuiSubagentText(entry?.args, 500),
|
|
7974
8254
|
endMs: Number.isFinite(entry?.endMs) ? entry.endMs : undefined,
|
|
7975
8255
|
})).filter((entry) => entry.tool);
|
|
8256
|
+
const transcript = normalizeWebuiSubagentTranscript(rawAgent.transcript);
|
|
7976
8257
|
return {
|
|
7977
8258
|
version: 1,
|
|
7978
8259
|
runId: normalizeWebuiSubagentText(value.runId, 160) || selection.run.id,
|
|
@@ -7995,6 +8276,7 @@ function normalizeWebuiSubagentOutput(value, selection) {
|
|
|
7995
8276
|
tokens: Number.isFinite(rawAgent.tokens) ? rawAgent.tokens : undefined,
|
|
7996
8277
|
recentTools,
|
|
7997
8278
|
recentOutput,
|
|
8279
|
+
transcript,
|
|
7998
8280
|
error: normalizeWebuiSubagentText(rawAgent.error, 1000) || undefined,
|
|
7999
8281
|
},
|
|
8000
8282
|
};
|
|
@@ -9896,6 +10178,88 @@ async function getFileContentData(tab, requestedPath = "") {
|
|
|
9896
10178
|
};
|
|
9897
10179
|
}
|
|
9898
10180
|
|
|
10181
|
+
function aurReviewReportPathSegments(value = "") {
|
|
10182
|
+
const requested = String(value || "").trim();
|
|
10183
|
+
if (!requested || requested.length > 1024 || requested.includes("\0")) throw makeHttpError(400, "Report path must be a non-empty repo-root-relative path");
|
|
10184
|
+
if (path.isAbsolute(requested) || path.win32.isAbsolute(requested) || requested.includes("\\")) {
|
|
10185
|
+
throw makeHttpError(400, "Report path must be a repo-root-relative path");
|
|
10186
|
+
}
|
|
10187
|
+
const segments = requested.split("/");
|
|
10188
|
+
if (segments.some((segment) => !segment || segment === "." || segment === "..")) {
|
|
10189
|
+
throw makeHttpError(400, "Report path cannot contain traversal segments");
|
|
10190
|
+
}
|
|
10191
|
+
return segments;
|
|
10192
|
+
}
|
|
10193
|
+
|
|
10194
|
+
async function canonicalGitRootForTab(tab) {
|
|
10195
|
+
const root = await getGitRoot(tab.cwd);
|
|
10196
|
+
try {
|
|
10197
|
+
return await realpath(root);
|
|
10198
|
+
} catch {
|
|
10199
|
+
throw makeHttpError(404, "Git repository root is no longer accessible");
|
|
10200
|
+
}
|
|
10201
|
+
}
|
|
10202
|
+
|
|
10203
|
+
async function readBoundedAurReviewReport(targetPath) {
|
|
10204
|
+
const handle = await open(targetPath, "r");
|
|
10205
|
+
try {
|
|
10206
|
+
const info = await handle.stat();
|
|
10207
|
+
if (!info.isFile()) throw makeHttpError(400, "Report path is not a regular file");
|
|
10208
|
+
if (info.size > FILE_VIEWER_MAX_BYTES) throw makeHttpError(413, `Report is too large to open in WebUI (limit ${formatBytes(FILE_VIEWER_MAX_BYTES)})`);
|
|
10209
|
+
const chunks = [];
|
|
10210
|
+
let total = 0;
|
|
10211
|
+
while (true) {
|
|
10212
|
+
const remaining = FILE_VIEWER_MAX_BYTES + 1 - total;
|
|
10213
|
+
if (remaining <= 0) throw makeHttpError(413, `Report is too large to open in WebUI (limit ${formatBytes(FILE_VIEWER_MAX_BYTES)})`);
|
|
10214
|
+
const chunk = Buffer.allocUnsafe(Math.min(64 * 1024, remaining));
|
|
10215
|
+
const { bytesRead } = await handle.read(chunk, 0, chunk.length, total);
|
|
10216
|
+
if (bytesRead === 0) break;
|
|
10217
|
+
chunks.push(chunk.subarray(0, bytesRead));
|
|
10218
|
+
total += bytesRead;
|
|
10219
|
+
}
|
|
10220
|
+
return { buffer: Buffer.concat(chunks, total), info };
|
|
10221
|
+
} finally {
|
|
10222
|
+
await handle.close().catch(() => {});
|
|
10223
|
+
}
|
|
10224
|
+
}
|
|
10225
|
+
|
|
10226
|
+
/** Read-only AUR-review report access rooted at the tab's canonical Git root. */
|
|
10227
|
+
async function getAurReviewReportContentData(tab, { path: requestedPath = "", repoRoot = "" } = {}) {
|
|
10228
|
+
if (typeof repoRoot !== "string" || !repoRoot || repoRoot.includes("\0")) {
|
|
10229
|
+
throw makeHttpError(400, "repoRoot is required for an AUR review report");
|
|
10230
|
+
}
|
|
10231
|
+
const root = await canonicalGitRootForTab(tab);
|
|
10232
|
+
if (repoRoot !== root) throw makeHttpError(403, "Report repoRoot does not match this tab's canonical Git root");
|
|
10233
|
+
const segments = aurReviewReportPathSegments(requestedPath);
|
|
10234
|
+
let targetPath = root;
|
|
10235
|
+
let info;
|
|
10236
|
+
for (const [index, segment] of segments.entries()) {
|
|
10237
|
+
targetPath = path.join(targetPath, segment);
|
|
10238
|
+
try {
|
|
10239
|
+
info = await lstat(targetPath);
|
|
10240
|
+
} catch (error) {
|
|
10241
|
+
throw makeHttpError(error?.code === "ENOENT" ? 404 : 400, `Report path not found: ${segments.join("/")}`);
|
|
10242
|
+
}
|
|
10243
|
+
if (info.isSymbolicLink()) throw makeHttpError(403, "Report path cannot contain symlinks");
|
|
10244
|
+
if (index < segments.length - 1 && !info.isDirectory()) throw makeHttpError(400, "Report path contains a non-directory component");
|
|
10245
|
+
}
|
|
10246
|
+
if (!info?.isFile()) throw makeHttpError(400, "Report path is not a regular file");
|
|
10247
|
+
const realTarget = await realpath(targetPath).catch(() => "");
|
|
10248
|
+
if (!realTarget || !pathInside(root, realTarget)) throw makeHttpError(403, "Resolved report path escapes the canonical Git root");
|
|
10249
|
+
const opened = await readBoundedAurReviewReport(targetPath);
|
|
10250
|
+
assertTextFileBuffer(opened.buffer);
|
|
10251
|
+
return {
|
|
10252
|
+
root,
|
|
10253
|
+
path: segments.join("/"),
|
|
10254
|
+
name: path.basename(targetPath),
|
|
10255
|
+
content: opened.buffer.toString("utf8"),
|
|
10256
|
+
size: opened.buffer.length,
|
|
10257
|
+
mtimeMs: opened.info.mtimeMs,
|
|
10258
|
+
extension: path.extname(targetPath).toLowerCase(),
|
|
10259
|
+
language: fileViewerLanguage(targetPath),
|
|
10260
|
+
};
|
|
10261
|
+
}
|
|
10262
|
+
|
|
9899
10263
|
async function saveFileContentData(tab, body = {}) {
|
|
9900
10264
|
if (typeof body.content !== "string") throw makeHttpError(400, "File content must be a string");
|
|
9901
10265
|
if (body.content.includes("\0")) throw makeHttpError(400, "File content cannot contain null bytes");
|
|
@@ -11678,6 +12042,18 @@ const server = createServer(async (req, res) => {
|
|
|
11678
12042
|
return;
|
|
11679
12043
|
}
|
|
11680
12044
|
|
|
12045
|
+
if (url.pathname === "/api/aur-review/report-content" && req.method === "GET") {
|
|
12046
|
+
const tab = getRequestedTab(req, url);
|
|
12047
|
+
sendJson(res, 200, {
|
|
12048
|
+
ok: true,
|
|
12049
|
+
data: await getAurReviewReportContentData(tab, {
|
|
12050
|
+
path: url.searchParams.get("path") || "",
|
|
12051
|
+
repoRoot: url.searchParams.get("repoRoot") || "",
|
|
12052
|
+
}),
|
|
12053
|
+
});
|
|
12054
|
+
return;
|
|
12055
|
+
}
|
|
12056
|
+
|
|
11681
12057
|
if (url.pathname === "/api/files/content" && req.method === "GET") {
|
|
11682
12058
|
const tab = getRequestedTab(req, url);
|
|
11683
12059
|
sendJson(res, 200, { ok: true, data: await getFileContentData(tab, url.searchParams.get("path") || "") });
|