@deepseek-ai/dsh-experimental-client-ui-forge 0.2.2-alpha.2 → 0.2.2-alpha.3

package/lib/index.js

@@ -101,7 +101,7 @@ function remoteOrder(upstream, remotes) {
 }
 //#endregion
 //#region lib/types/git.js
-/** Read-only Git inspection of a Session's current directory in the Session's execution world. */
+/** Git queries in a Session's current directory, using its permissions and execution world. */
 var __addDisposableResource$1 = function(env, value, async) {
 	if (value !== null && value !== void 0) {
 		if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
@@ -203,9 +203,9 @@ const GIT_PREFIX = [
 const NOT_A_CHECKOUT = /not a git repository|must be run in a work tree/i;
 /**
 * Inspect the checkout containing `directory`. Every command runs through the
-* mounted subprocess provider under a read-only confinement of the Session's
-* sandbox policy and reads refs and configuration only, never the working
-* tree. The top-level and shared Git directories Git prints are resolved
+* mounted subprocess provider under the Session's sandbox policy and reads
+* refs and configuration only, never the working tree.
+* The top-level and shared Git directories Git prints are resolved
 * through `ctx.fs` into canonical process paths, the form the
 * working-directory service records.
 * @param ctx - context that provides `fs`, `subprocess`, `sandbox`, and `sandboxPolicy`.
@@ -265,7 +265,7 @@ async function inspectCheckout(ctx, config, session, directory, signal) {
 }
 /**
 * List the local branches that can start a worktree of the checkout containing
-* `directory`, under the same confinement as {@link inspectCheckout}.
+* `directory`, using the Session's permissions as in {@link inspectCheckout}.
 * @param ctx - context that provides `subprocess`, `sandbox`, and `sandboxPolicy`.
 * @param config - executable and process limits.
 * @param session - Session whose sandbox policy and execution world apply.
@@ -304,7 +304,7 @@ async function together(signal, start) {
 	}
 }
 /**
-* Report whether a local branch exists, under the same confinement as {@link inspectCheckout}.
+* Report whether a local branch exists, using the Session's permissions as in {@link inspectCheckout}.
 * @param ctx - context that provides `subprocess`, `sandbox`, and `sandboxPolicy`.
 * @param config - executable and process limits.
 * @param session - Session whose sandbox policy and execution world apply.
@@ -323,8 +323,8 @@ async function hasBranch(ctx, config, session, repositoryRoot, branch, signal) {
 	], [0, 1])).exitCode === 0;
 }
 /**
-* Bind the confined Git runner to one Session and directory: every command
-* runs under a read-only confinement of the Session's sandbox policy with the
+* Bind the Git runner to one Session and directory: every command
+* runs under the Session's sandbox policy with the
 * scrubbed environment, the fixed command prefix, and `config`'s limits.
 * @param ctx - context that provides `subprocess`, `sandbox`, and `sandboxPolicy`.
 * @param config - executable and process limits.
@@ -334,14 +334,8 @@ async function hasBranch(ctx, config, session, repositoryRoot, branch, signal) {
 * @returns the runner.
 */
 function gitIn(ctx, config, session, directory, signal) {
-	const policy = {
-		...ctx.sandboxPolicy.resolve({
-			session,
-			mode: "read-only"
-		}),
-		mode: "read-only"
-	};
-	return (name, args, allowedExitCodes = [0]) => runGit(ctx, config, policy, directory, name, args, signal, allowedExitCodes);
+	const policy = ctx.sandboxPolicy.resolve({ session });
+	return (name, args, allowedExitCodes = [0], configOverrides = {}) => runGit(ctx, config, policy, directory, name, args, signal, allowedExitCodes, configOverrides);
 }
 /** Read the checked-out branch, including an unborn one; null when HEAD is detached. */
 async function currentBranch(git) {
@@ -362,7 +356,7 @@ async function headCommit(git) {
 	], [0, 128]);
 	return head.exitCode === 0 ? parseName(head.stdout) : null;
 }
-async function runGit(ctx, config, policy, cwd, name, args, signal, allowedExitCodes) {
+async function runGit(ctx, config, policy, cwd, name, args, signal, allowedExitCodes, configOverrides) {
 	const env_1 = {
 		stack: [],
 		error: void 0,
@@ -370,17 +364,25 @@ async function runGit(ctx, config, policy, cwd, name, args, signal, allowedExitC
 	};
 	try {
 		const timeout = __addDisposableResource$1(env_1, deadline(signal, config.gitTimeoutMs, "FORGE_PANEL_GIT_TIMEOUT"), false);
-		const program = await ctx.subprocess.resolveExecutable(config.gitCommand, void 0, timeout.signal);
-		const confined = await ctx.sandbox.confine([
-			program,
+		const command = [
+			await ctx.subprocess.resolveExecutable(config.gitCommand, void 0, timeout.signal),
 			...GIT_PREFIX,
 			...args
-		], policy, timeout.signal);
+		];
+		const argv = policy.mode === "danger-full-access" ? command : (await ctx.sandbox.confine(command, {
+			...policy,
+			mode: policy.mode
+		}, timeout.signal)).argv;
 		timeout.signal.throwIfAborted();
+		const overrides = Object.entries(configOverrides);
 		const child = ctx.subprocess.spawn({
-			argv: confined.argv,
+			argv,
 			cwd,
-			env: GIT_ENV,
+			env: {
+				...GIT_ENV,
+				GIT_CONFIG_COUNT: String(overrides.length),
+				...Object.fromEntries(overrides.flatMap(([key, value], index) => [[`GIT_CONFIG_KEY_${index}`, key], [`GIT_CONFIG_VALUE_${index}`, value]]))
+			},
 			signal: timeout.signal,
 			graceMs: config.graceMs,
 			stdio: {
@@ -557,29 +559,59 @@ function pathOf(name, prefix) {
 * Local changes of a Session's checkout: where the `branch` scope forks, the
 * patch of one scope with its untracked files, the new-side text of one file,
 * and the size of the `branch` scope for the panel's card. Git runs through
-* the confined runner; untracked and working-tree files are read through
+* the Session's Git runner; untracked and working-tree files are read through
 * `ctx.fs`, both within `maxDiffBytes`.
 */
 /** Thrown when a patch, a file list, or a file exceeds `maxDiffBytes`. */
 var DiffTooLarge = class extends Error {
 	name = "DiffTooLarge";
 };
+/** Thrown when filter configuration cannot be read completely; no comparison has run. */
+var FilterConfigError = class extends Error {
+	name = "FilterConfigError";
+};
 /** Thrown for the `branch` scope of a checkout without a fork point. */
 var NoForkPoint = class extends Error {
 	name = "NoForkPoint";
 };
-/** Literal paths, no external diff driver or text conversion, rename detection, and fixed `a/` and `b/` prefixes. */
+/** No executable diff helpers or submodule working-tree inspection; preserve recorded submodule commit changes. */
 const DIFF = [
 	"-c",
 	"core.quotePath=false",
 	"diff",
 	"--no-ext-diff",
 	"--no-textconv",
+	"--submodule=short",
+	"--ignore-submodules=dirty",
 	"--no-color",
 	"-M",
 	"--src-prefix=a/",
 	"--dst-prefix=b/"
 ];
+/** Disable enumerated clean/process filters for one diff without modifying Git configuration. */
+async function diffFilterOverrides(git) {
+	let configured;
+	try {
+		configured = await git("filters", [
+			"config",
+			"--null",
+			"--name-only",
+			"--get-regexp",
+			"^filter\\."
+		], [0, 1]);
+	} catch (error) {
+		throw new FilterConfigError("Cannot read complete Git filter configuration; comparison was not run", { cause: error });
+	}
+	const overrides = {};
+	for (const key of configured.stdout.split("\0")) {
+		if (!key.endsWith(".clean") && !key.endsWith(".process")) continue;
+		const driver = key.slice(0, key.lastIndexOf("."));
+		overrides[`${driver}.clean`] = "";
+		overrides[`${driver}.process`] = "";
+		overrides[`${driver}.required`] = "false";
+	}
+	return overrides;
+}
 /** Characters Git inspects for a NUL character before it calls content binary. */
 const BINARY_PROBE = 8e3;
 /**
@@ -628,7 +660,8 @@ async function forkPoint(git, inspection, created) {
 	return null;
 }
 /**
-* Read the changes one scope covers in the checkout at `root`.
+* Read changes at `root` with command-local clean/process filter overrides and without
+* submodule working-tree inspection. Git's built-in newline, ident, and encoding conversions still apply.
 * @param ctx - context that provides `fs`, `subprocess`, `sandbox`, and `sandboxPolicy`.
 * @param config - Git and size limits.
 * @param session - Session whose sandbox policy and execution world apply.
@@ -637,7 +670,8 @@ async function forkPoint(git, inspection, created) {
 * @param scope - which changes to read.
 * @param signal - cancellation of every command and read.
 * @returns tracked files in Git's order, then untracked files unless the scope is `staged`.
-* @throws NoForkPoint for the `branch` scope without `fork`; DiffTooLarge over `maxDiffBytes`; an Error when Git fails.
+* @throws NoForkPoint for the `branch` scope without `fork`; FilterConfigError when filter configuration
+* cannot be read within `maxDiffBytes`; DiffTooLarge for oversized comparison output; an Error when Git fails.
 */
 async function localDiff(ctx, config, session, root, fork, scope, signal) {
 	const git = gitIn(ctx, {
@@ -662,11 +696,12 @@ async function localDiff(ctx, config, session, root, fork, scope, signal) {
 		/* v8 ignore next -- closed ForgeLocalScope union exhaustiveness guard */
 		default: return assertNever(scope, "ForgeLocalScope.kind");
 	}
+	const overrides = await diffFilterOverrides(git);
 	const tracked = parseDiff((await bounded(git("diff", [
 		...DIFF,
 		...range,
 		"--"
-	]))).stdout);
+	], void 0, overrides))).stdout);
 	if (scope.kind === "staged") return {
 		base: null,
 		files: tracked,
@@ -714,25 +749,22 @@ async function localText(ctx, config, session, root, scope, path, signal) {
 * @param created - worktree the Session created, or null.
 * @param signal - cancellation of every command and read.
 * @returns the base and the changed files, or null without a fork point.
-* @throws DiffTooLarge when the untracked file list exceeds `maxDiffBytes`; an Error when Git fails.
+* @throws FilterConfigError when filter configuration cannot be read within `maxOutputBytes`;
+* DiffTooLarge when the untracked file list exceeds `maxDiffBytes`; an Error when Git fails.
 */
 async function localChanges(ctx, config, session, inspection, created, signal) {
 	const root = inspection.checkout.root;
 	const git = gitIn(ctx, config, session, root, signal);
 	const fork = await forkPoint(git, inspection, created);
 	if (fork === null) return null;
+	const overrides = await diffFilterOverrides(git);
 	const numstat = await git("numstat", [
-		"-c",
-		"core.quotePath=false",
-		"diff",
-		"--no-ext-diff",
-		"--no-textconv",
+		...DIFF,
 		"--numstat",
 		"-z",
-		"-M",
 		fork.commit,
 		"--"
-	]);
+	], void 0, overrides);
 	const untracked = await untrackedFiles(ctx, config, gitIn(ctx, {
 		...config,
 		maxOutputBytes: config.maxDiffBytes
@@ -2050,7 +2082,7 @@ var Reader = class {
 var Run = class {
 	sources;
 	readers;
-	table;
+	storage;
 	states = /* @__PURE__ */ new Map();
 	sessionsOf = /* @__PURE__ */ new Map();
 	urlsOf = /* @__PURE__ */ new Map();
@@ -2060,11 +2092,11 @@ var Run = class {
 	starting = true;
 	writes = /* @__PURE__ */ new Set();
 	stopped = false;
-	constructor(sources, readers, table) {
+	constructor(sources, readers, storage) {
 		this.sources = sources;
 		this.readers = readers;
-		this.table = table;
-		for (const [, state] of table.entries()) this.states.set(state.url, state);
+		this.storage = storage;
+		for (const [, state] of storage.table.entries()) this.states.set(state.url, state);
 		this.stopBindings = sources.onBindings((id, urls) => {
 			if (this.starting) this.startupBindings.set(id, urls);
 			else this.bind(id, urls);
@@ -2085,7 +2117,7 @@ var Run = class {
 		for (const [url] of this.states) {
 			if (this.sessionsOf.has(url)) continue;
 			this.states.delete(url);
-			this.write(() => this.table.delete(storedKey(url)));
+			this.write(() => this.storage.table.delete(storedKey(url)));
 		}
 	}
 	/** The known states of every change request that some Session the reader may read binds. */
@@ -2102,7 +2134,11 @@ var Run = class {
 		this.stopBindings();
 		for (const stop of this.polls.values()) stop();
 		this.polls.clear();
-		await Promise.all(this.writes);
+		try {
+			await Promise.all(this.writes);
+		} finally {
+			await this.storage.close();
+		}
 	}
 	bind(id, urls) {
 		const next = new Set(urls);
@@ -2143,7 +2179,7 @@ var Run = class {
 	settle(url, ids, state) {
 		if (this.stopped || sameState(this.states.get(url), state)) return;
 		this.states.set(url, state);
-		this.write(() => this.table.put(storedKey(url), state));
+		this.write(() => this.storage.table.put(storedKey(url), state));
 		for (const reader of this.readers) if ([...ids].some(reader.allowed)) reader.push(state);
 	}
 	write(operation) {
@@ -2195,7 +2231,7 @@ var ChangeRequestStates = class {
 		}
 	}
 	/**
-	* End every stream, stop polling, and wait for initialization and accepted storage writes.
+	* End every stream, stop polling, and wait for initialization, accepted writes, and storage closure.
 	* @returns settles after all owned work stops; subsequent streams end without starting work.
 	*/
 	async dispose() {
@@ -2210,14 +2246,16 @@ var ChangeRequestStates = class {
 		const started = (async () => {
 			await preceding;
 			aborter.signal.throwIfAborted();
-			const table = await this.sources.open();
-			aborter.signal.throwIfAborted();
-			const run = new Run(this.sources, this.readers, table);
+			const storage = await this.sources.open();
+			let run;
 			try {
+				aborter.signal.throwIfAborted();
+				run = new Run(this.sources, this.readers, storage);
 				await run.start(aborter.signal);
 				return run;
 			} catch (error) {
-				await run.stop();
+				if (run === void 0) await storage.close();
+				else await run.stop();
 				throw error;
 			}
 		})();
@@ -2279,7 +2317,7 @@ var __esDecorate = function(ctor, descriptorIn, decorators, contextIn, initializ
 };
 /**
 * Serves the forge panel. Following a Session inspects the checkout of its
-* current directory read-only in the Session's execution world, recognizes the
+* current directory using the Session's permissions and execution world, recognizes the
 * code host of the upstream remote or `origin`, probes sign-in for that host,
 * and polls the Session's bound change requests through `ctx.forge` until the
 * last follower of that Session leaves. A worktree request makes the panel
@@ -2303,8 +2341,10 @@ let ForgePanelController = (() => {
 	let _refresh_decorators;
 	let _localDiff_decorators;
 	let _localText_decorators;
+	let _changeRequestChecks_decorators;
 	let _changeRequestDiff_decorators;
 	let _changeRequestText_decorators;
+	let _submitReview_decorators;
 	let _markReady_decorators;
 	let _merge_decorators;
 	let _requestWorktree_decorators;
@@ -2324,8 +2364,10 @@ let ForgePanelController = (() => {
 			_refresh_decorators = [Remote];
 			_localDiff_decorators = [Remote];
 			_localText_decorators = [Remote];
+			_changeRequestChecks_decorators = [Remote];
 			_changeRequestDiff_decorators = [Remote];
 			_changeRequestText_decorators = [Remote];
+			_submitReview_decorators = [Remote];
 			_markReady_decorators = [Remote];
 			_merge_decorators = [Remote];
 			_requestWorktree_decorators = [Remote];
@@ -2422,6 +2464,17 @@ let ForgePanelController = (() => {
 				},
 				metadata: _metadata
 			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _changeRequestChecks_decorators, {
+				kind: "method",
+				name: "changeRequestChecks",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "changeRequestChecks" in obj,
+					get: (obj) => obj.changeRequestChecks
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
 			__esDecorate(this, null, _changeRequestDiff_decorators, {
 				kind: "method",
 				name: "changeRequestDiff",
@@ -2444,6 +2497,17 @@ let ForgePanelController = (() => {
 				},
 				metadata: _metadata
 			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _submitReview_decorators, {
+				kind: "method",
+				name: "submitReview",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "submitReview" in obj,
+					get: (obj) => obj.submitReview
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
 			__esDecorate(this, null, _markReady_decorators, {
 				kind: "method",
 				name: "markReady",
@@ -2712,13 +2776,14 @@ let ForgePanelController = (() => {
 		}
 		/**
 		* Read the changes one scope covers in the checkout of the Session's
-		* current directory, with Git confined to the Session's read-only sandbox.
+		* current directory, with Git using the Session's sandbox policy.
 		* @param session - Session whose checkout is read.
 		* @param scope - which changes to read.
 		* @param signal - request cancellation.
 		* @returns the files, the base of the `branch` scope, and the untracked files left out.
 		* @throws `forgePanel/not-a-checkout` outside a checkout; `forgePanel/no-fork-point` for the `branch`
-		* scope of a checkout without one; `forgePanel/diff-too-large` over `maxDiffBytes`; the Git error when Git fails.
+		* scope of a checkout without one; `forgePanel/filter-config-failed` when filter configuration cannot be read
+		* completely, before any comparison; `forgePanel/diff-too-large` over `maxDiffBytes`; the Git error when Git fails.
 		*/
 		async localDiff(session, scope, signal) {
 			signal.throwIfAborted();
@@ -2744,6 +2809,24 @@ let ForgePanelController = (() => {
 			return await diffing(localText(this.home, this.config, session, inspection.checkout.root, scope, path, signal));
 		}
 		/**
+		* Load complete checks for the change request whose list the user opened.
+		* @param session - Session retaining the visible binding.
+		* @param url - binding URL.
+		* @param headSha - commit displayed by the card; a different head rejects the result.
+		* @param signal - cancellation when the list closes.
+		* @returns the complete snapshot at the displayed head.
+		* @throws `forgePanel/not-bound` for an invisible binding, `forgePanel/stale-head` for a moved head,
+		* or `forgePanel/checks-failed` when the provider cannot complete the read.
+		*/
+		async changeRequestChecks(session, url, headSha, signal) {
+			signal.throwIfAborted();
+			const result = await this.home.forge.fetchChecks(this.bound(session, url).ref, signal);
+			this.bound(session, url);
+			if ("code" in result) throw new RemoteError("forgePanel/checks-failed", result.message, {});
+			if (result.headSha !== headSha) throw new RemoteError("forgePanel/stale-head", "The change request head changed; refresh its status", {});
+			return result;
+		}
+		/**
 		* Read the changes of a change request of a Session as its code host
 		* computes them, at the head commit of its latest status. A patch already
 		* read at the same head commit and base branch is reused from memory, for
@@ -2804,6 +2887,23 @@ let ForgePanelController = (() => {
 			return text;
 		}
 		/**
+		* Publish a line comment or completed review for a visible Session binding.
+		* @param session - Session retaining the change request.
+		* @param url - visible binding URL.
+		* @param request - reviewed head, ranges, plain text, and explicit review decision.
+		* @param signal - request cancellation.
+		* @returns confirmed publication or a typed failure; unknown outcomes require reconciliation on the host.
+		*/
+		async submitReview(session, url, request, signal) {
+			signal.throwIfAborted();
+			const { ref } = this.bound(session, url);
+			if (!/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/i.test(request.headSha)) throw new Error("Invalid review commit");
+			const comments = request.kind === "comment" ? [request.comment] : request.comments;
+			if (comments.some((comment) => comment.path === "" || comment.body.trim() === "" || !Number.isSafeInteger(comment.startLine) || comment.startLine < 1 || !Number.isSafeInteger(comment.endLine) || comment.endLine < comment.startLine)) throw new Error("Invalid review comment");
+			if (request.kind === "review" && request.event !== "approve" && request.body.trim() === "" && comments.length === 0) throw new Error("Empty review");
+			return await this.home.forge.submitReview(ref, request, signal);
+		}
+		/**
 		* Mark a draft change request of a Session ready for review; the change
 		* request is polled again once the host answers.
 		* @param session - Session the change request is bound to.
@@ -3061,7 +3161,13 @@ let ForgePanelController = (() => {
 				}),
 				refOf: (url) => ctx.forge.changeRequestFromUrl(url),
 				watch: (ref, listener) => ctx.forge.watch(ref, listener),
-				open: async () => (await storage.open(changeRequestStatesDomain)).table("states"),
+				open: async () => {
+					const domain = await storage.open(changeRequestStatesDomain);
+					return {
+						table: domain.table("states"),
+						close: () => domain.close()
+					};
+				},
 				report: (error) => {
 					ctx.logger.warn(`forge-panel: storing a change request state failed: ${String(error)}`);
 				}
@@ -3100,6 +3206,7 @@ async function diffing(reading) {
 	try {
 		return await reading;
 	} catch (error) {
+		if (error instanceof FilterConfigError) throw new RemoteError("forgePanel/filter-config-failed", error.message, {}, { cause: error });
 		if (error instanceof DiffTooLarge) throw new RemoteError("forgePanel/diff-too-large", error.message, {}, { cause: error });
 		if (error instanceof NoForkPoint) throw new RemoteError("forgePanel/no-fork-point", error.message, {}, { cause: error });
 		throw error;