@jmfederico/pi-web 1.202607.3 → 1.202608.1

package/dist/{server/git/gitService.js → pi-web-plugins/git/git-backend.js}

@@ -1,16 +1,41 @@
+// Generated from pi-web-plugins/git/git-backend.ts. Do not edit directly.
 import { createHash } from "node:crypto";
-import { spawn } from "node:child_process";
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-import { normalizeRelativePath } from "../workspaces/pathSafety.js";
-import { sanitizedGitEnv } from "./gitEnv.js";
-const MAX_OUTPUT = 2 * 1024 * 1024;
-export async function gitStatus(cwd) {
+import { realpath } from "node:fs/promises";
+import { isAbsolute, join, relative, sep } from "node:path";
+import { GIT_DIFF_OPERATION, GIT_STATUS_OPERATION, } from "./browser/git-contract.js";
+export { GIT_DIFF_OPERATION, GIT_STATUS_OPERATION } from "./browser/git-contract.js";
+const GIT_COMMAND_TIMEOUT_MS = 10_000;
+const GIT_LOCAL_ENV_VARS = Object.freeze([
+    "GIT_ALTERNATE_OBJECT_DIRECTORIES",
+    "GIT_COMMON_DIR",
+    "GIT_DIR",
+    "GIT_INDEX_FILE",
+    "GIT_OBJECT_DIRECTORY",
+    "GIT_PREFIX",
+    "GIT_QUARANTINE_PATH",
+    "GIT_WORK_TREE",
+]);
+/** Dispatch the Git-owned status/diff schema through the provider's public request seam. */
+export async function requestGitBackend(activationContext, request) {
+    const runGit = createGitRunner(activationContext, request.signal);
+    if (request.operation === GIT_STATUS_OPERATION) {
+        requireStatusInput(request.input);
+        return statusProviderResponse(await gitStatusWithRunner(runGit, request.workspace.path));
+    }
+    if (request.operation === GIT_DIFF_OPERATION) {
+        return diffProviderResponse(await gitDiffWithRunner(runGit, request.workspace.path, parseDiffInput(request.input)));
+    }
+    throw new Error(`Unsupported Git workspace backend operation: ${request.operation}`);
+}
+export async function gitStatus(context, cwd, signal) {
+    return gitStatusWithRunner(createGitRunner(context, signal), cwd);
+}
+async function gitStatusWithRunner(runGit, cwd) {
     const result = await runGit(cwd, ["status", "--porcelain=v2", "--branch", "--untracked-files=all", "-z"]);
     if (result.code !== 0)
         return { isGitRepo: false, hash: hash(result.stdout + result.stderr), files: [], submodules: [] };
     const parsed = parseStatus(result.stdout, { deferSubmodules: true });
-    return expandSubmodules(cwd, parsed, result.stdout);
+    return expandSubmodules(runGit, cwd, parsed, result.stdout);
 }
 /**
  * Merge each dirty submodule's own changes into the flat file list. A moved
@@ -19,11 +44,17 @@ export async function gitStatus(cwd) {
  * entries under `<submodule>/<inner path>`. A plain `-dirty` pointer (commit
  * unchanged) is intentionally not surfaced as a pointer entry.
  */
-async function expandSubmodules(cwd, parsed, topRaw) {
+async function expandSubmodules(runGit, cwd, parsed, topRaw) {
     // Fan out concurrently — one `git status` per dirty submodule plus one
     // `git rev-parse` per unstaged pointer move — then concatenate in input
     // order so the file list and hash are identical to a serial pass.
-    const expanded = await Promise.all(parsed.submodules.map(async (sub) => ({ path: sub.path, ...(await expandSubmodule(cwd, sub)) })));
+    const canonicalRoot = parsed.submodules.length === 0 ? undefined : await canonicalPath(cwd);
+    const expanded = await Promise.all(parsed.submodules.map(async (sub) => {
+        const location = canonicalRoot === undefined
+            ? undefined
+            : await validatedSubmodule(runGit, cwd, canonicalRoot, sub.path);
+        return { path: sub.path, ...(await expandSubmodule(runGit, sub, location)) };
+    }));
     const files = [...parsed.files];
     const dirtySubmodulePaths = [];
     let extraForHash = "";
@@ -44,7 +75,7 @@ async function expandSubmodules(cwd, parsed, topRaw) {
     };
 }
 /** Expand one dirty submodule: the pointer entry first, then its inner files. */
-async function expandSubmodule(cwd, sub) {
+async function expandSubmodule(runGit, sub, location) {
     const files = [];
     let extraForHash = "";
     if (sub.commitChanged) {
@@ -53,11 +84,11 @@ async function expandSubmodule(cwd, sub) {
             index: sub.index,
             workingTree: sub.workingTree,
             submoduleFromCommit: displayFromCommit(sub.headOid),
-            submoduleToCommit: short(await resolveSubmoduleToCommit(cwd, sub)),
+            submoduleToCommit: short(await resolveSubmoduleToCommit(runGit, location?.cwd, sub)),
         });
     }
-    if (sub.hasModifiedContent || sub.hasUntrackedContent) {
-        const inner = await runGit(join(cwd, sub.path), ["status", "--porcelain=v2", "--untracked-files=all", "-z"]);
+    if ((sub.hasModifiedContent || sub.hasUntrackedContent) && location !== undefined) {
+        const inner = await runGit(location.cwd, ["status", "--porcelain=v2", "--untracked-files=all", "-z"]);
         if (inner.code === 0) {
             extraForHash = `\0${sub.path}\0${inner.stdout}`;
             const innerFiles = parseStatus(inner.stdout, { deferSubmodules: false }).files;
@@ -73,24 +104,28 @@ async function expandSubmodule(cwd, sub) {
     }
     return { files, extraForHash };
 }
-async function resolveSubmoduleToCommit(cwd, sub) {
+async function resolveSubmoduleToCommit(runGit, cwd, sub) {
     // Staged pointer moves already expose the new commit as the index OID; an
-    // unstaged move only records the old OID, so read the submodule's HEAD.
-    if (sub.indexOid !== sub.headOid)
+    // unstaged move only records the old OID, so read the validated submodule's
+    // HEAD. An unavailable checkout cannot safely supply a different pointer.
+    if (sub.indexOid !== sub.headOid || cwd === undefined)
         return sub.indexOid;
-    const head = await runGit(join(cwd, sub.path), ["rev-parse", "HEAD"]);
+    const head = await runGit(cwd, ["rev-parse", "HEAD"]);
     const resolved = head.stdout.trim();
     return head.code === 0 && resolved !== "" ? resolved : sub.indexOid;
 }
-export async function gitDiff(cwd, options) {
+export async function gitDiff(context, cwd, options, signal) {
+    return gitDiffWithRunner(createGitRunner(context, signal), cwd, options);
+}
+async function gitDiffWithRunner(runGit, cwd, options) {
     const staged = options.staged === true;
     let path;
     if (options.path !== undefined && options.path !== "")
         path = normalizeRelativePath(options.path);
     if (path !== undefined) {
-        const owner = await submoduleForPath(cwd, path);
+        const owner = await submoduleForPath(runGit, cwd, path);
         if (owner !== undefined)
-            return submoduleDiff(cwd, owner, path, staged);
+            return submoduleDiff(runGit, owner, path, staged);
     }
     const args = ["diff", "--no-ext-diff", "--color=never"];
     if (staged)
@@ -100,7 +135,7 @@ export async function gitDiff(cwd, options) {
     const result = await runGit(cwd, args);
     if (result.code !== 0)
         throw new Error(result.stderr.trim() || "git diff failed");
-    if (!staged && path !== undefined && result.stdout === "" && await isUntracked(cwd, path)) {
+    if (!staged && path !== undefined && result.stdout === "" && await isUntracked(runGit, cwd, path)) {
         const untracked = await runGit(cwd, ["diff", "--no-ext-diff", "--color=never", "--no-index", "/dev/null", "--", path]);
         if (untracked.code !== 0 && untracked.code !== 1)
             throw new Error(untracked.stderr.trim() || "git diff failed");
@@ -114,9 +149,9 @@ export async function gitDiff(cwd, options) {
  * The response path stays the full superproject-relative path so the viewer and
  * the selected row line up.
  */
-async function submoduleDiff(cwd, owner, path, staged) {
-    const subCwd = join(cwd, owner);
-    const rel = normalizeRelativePath(path.slice(owner.length + 1));
+async function submoduleDiff(runGit, owner, path, staged) {
+    const subCwd = owner.cwd;
+    const rel = normalizeRelativePath(path.slice(owner.path.length + 1));
     const args = ["diff", "--no-ext-diff", "--color=never"];
     if (staged)
         args.push("--cached");
@@ -124,7 +159,7 @@ async function submoduleDiff(cwd, owner, path, staged) {
     const result = await runGit(subCwd, args);
     if (result.code !== 0)
         throw new Error(result.stderr.trim() || "git diff failed");
-    if (!staged && result.stdout === "" && await isUntracked(subCwd, rel)) {
+    if (!staged && result.stdout === "" && await isUntracked(runGit, subCwd, rel)) {
         const untracked = await runGit(subCwd, ["diff", "--no-ext-diff", "--color=never", "--no-index", "/dev/null", "--", rel]);
         if (untracked.code !== 0 && untracked.code !== 1)
             throw new Error(untracked.stderr.trim() || "git diff failed");
@@ -132,12 +167,12 @@ async function submoduleDiff(cwd, owner, path, staged) {
     }
     return { path, staged, hash: hash(result.stdout), diff: result.stdout, truncated: result.truncated };
 }
-async function isUntracked(cwd, path) {
+async function isUntracked(runGit, cwd, path) {
     const result = await runGit(cwd, ["ls-files", "--others", "--exclude-standard", "-z", "--", path]);
     return result.code === 0 && result.stdout.split("\0").includes(path);
 }
 /** Configured direct-submodule paths (depth 1), read from `.gitmodules`. */
-async function configuredSubmodulePaths(cwd) {
+async function configuredSubmodulePaths(runGit, cwd) {
     // `-z` emits `<key>\n<value>\0` records; keys may themselves contain spaces
     // (`submodule.my sub.path`), so splitting lines at the first space mangles
     // paths with spaces in them.
@@ -151,26 +186,73 @@ async function configuredSubmodulePaths(cwd) {
         const newlineAt = record.indexOf("\n");
         if (newlineAt === -1)
             continue;
-        paths.push(record.slice(newlineAt + 1));
+        try {
+            const path = normalizeRelativePath(record.slice(newlineAt + 1));
+            if (path !== "")
+                paths.push(path);
+        }
+        catch {
+            // A malformed repository path is not eligible for submodule routing.
+        }
     }
-    return paths;
+    return [...new Set(paths)];
 }
-/** The submodule that strictly contains `path`, if any (longest match wins). */
-async function submoduleForPath(cwd, path) {
-    // Cheap bail-outs before spawning `git config`: a path strictly inside a
-    // submodule always contains `/`, and without `.gitmodules` there are no
-    // configured submodules to look up (every diff call used to pay this spawn).
+/** The validated gitlink that strictly contains `path`, if any (longest match wins). */
+async function submoduleForPath(runGit, cwd, path) {
     if (!path.includes("/"))
         return undefined;
-    if (!existsSync(join(cwd, ".gitmodules")))
+    const candidates = (await configuredSubmodulePaths(runGit, cwd))
+        .filter((sub) => path.startsWith(`${sub}/`))
+        .sort((left, right) => right.length - left.length);
+    if (candidates.length === 0)
+        return undefined;
+    const canonicalRoot = await canonicalPath(cwd);
+    if (canonicalRoot === undefined)
+        return undefined;
+    for (const candidate of candidates) {
+        const validated = await validatedSubmodule(runGit, cwd, canonicalRoot, candidate);
+        if (validated !== undefined)
+            return validated;
+    }
+    return undefined;
+}
+/**
+ * Confirm that repository-controlled `.gitmodules` data names an index
+ * gitlink and that its checkout resolves strictly below the workspace root.
+ * Commands use the resolved checkout rather than following the configured
+ * path as a symlink.
+ */
+async function validatedSubmodule(runGit, cwd, canonicalRoot, path) {
+    const index = await runGit(cwd, ["ls-files", "--stage", "-z", "--", path]);
+    if (index.code !== 0 || !hasGitlink(index.stdout, path))
+        return undefined;
+    const candidate = await canonicalPath(join(cwd, path));
+    if (candidate === undefined || !isStrictDescendant(canonicalRoot, candidate))
+        return undefined;
+    return { path, cwd: candidate };
+}
+function hasGitlink(raw, path) {
+    return raw.split("\0").some((record) => {
+        const separator = record.indexOf("\t");
+        if (separator === -1 || record.slice(separator + 1) !== path)
+            return false;
+        return record.slice(0, separator).split(" ")[0] === "160000";
+    });
+}
+async function canonicalPath(path) {
+    try {
+        return await realpath(path);
+    }
+    catch {
         return undefined;
-    const subs = await configuredSubmodulePaths(cwd);
-    let best;
-    for (const sub of subs) {
-        if (sub !== "" && path.startsWith(`${sub}/`) && (best === undefined || sub.length > best.length))
-            best = sub;
     }
-    return best;
+}
+function isStrictDescendant(root, candidate) {
+    const relation = relative(root, candidate);
+    return relation !== ""
+        && relation !== ".."
+        && !relation.startsWith(`..${sep}`)
+        && !isAbsolute(relation);
 }
 function parseStatus(raw, options) {
     const records = raw.split("\0").filter((record) => record !== "");
@@ -269,22 +351,89 @@ function displayFromCommit(headOid) {
 function hash(value) {
     return createHash("sha1").update(value).digest("hex");
 }
-async function runGit(cwd, args) {
-    return new Promise((resolve, reject) => {
-        const child = spawn("git", args, { cwd, env: sanitizedGitEnv(), stdio: ["ignore", "pipe", "pipe"] });
-        const timer = setTimeout(() => { child.kill("SIGKILL"); }, 10000);
-        let stdout = Buffer.alloc(0);
-        let stderr = Buffer.alloc(0);
-        let truncated = false;
-        child.stdout.on("data", (chunk) => {
-            if (stdout.length + chunk.length > MAX_OUTPUT)
-                truncated = true;
-            if (stdout.length < MAX_OUTPUT)
-                stdout = Buffer.concat([stdout, chunk]).subarray(0, MAX_OUTPUT);
-        });
-        child.stderr.on("data", (chunk) => { stderr = Buffer.concat([stderr, chunk]).subarray(0, 64 * 1024); });
-        child.on("error", (error) => { clearTimeout(timer); reject(error); });
-        child.on("close", (code) => { clearTimeout(timer); resolve({ code: code ?? 1, stdout: stdout.toString("utf8"), stderr: stderr.toString("utf8"), truncated }); });
-    });
+function statusProviderResponse(status) {
+    return {
+        isGitRepo: status.isGitRepo,
+        hash: status.hash,
+        ...(status.branch === undefined ? {} : { branch: status.branch }),
+        ...(status.upstream === undefined ? {} : { upstream: status.upstream }),
+        ...(status.ahead === undefined ? {} : { ahead: status.ahead }),
+        ...(status.behind === undefined ? {} : { behind: status.behind }),
+        files: status.files.map((file) => ({
+            path: file.path,
+            ...(file.oldPath === undefined ? {} : { oldPath: file.oldPath }),
+            index: file.index,
+            workingTree: file.workingTree,
+            ...(file.submoduleFromCommit === undefined ? {} : { submoduleFromCommit: file.submoduleFromCommit }),
+            ...(file.submoduleToCommit === undefined ? {} : { submoduleToCommit: file.submoduleToCommit }),
+        })),
+        submodules: status.submodules,
+    };
+}
+function diffProviderResponse(diff) {
+    return {
+        ...(diff.path === undefined ? {} : { path: diff.path }),
+        staged: diff.staged,
+        hash: diff.hash,
+        diff: diff.diff,
+        truncated: diff.truncated,
+    };
+}
+function createGitRunner(context, signal) {
+    return async (cwd, args) => commandResult(await context.execFile({
+        file: "git",
+        args,
+        cwd,
+        unsetEnv: GIT_LOCAL_ENV_VARS,
+        timeoutMs: GIT_COMMAND_TIMEOUT_MS,
+        signal,
+    }), args);
+}
+function commandResult(result, args) {
+    const command = `git ${args.join(" ")}`;
+    if (result.signal !== null)
+        throw new Error(`${command} ended from signal ${result.signal}`);
+    if (result.exitCode === null)
+        throw new Error(`${command} ended without an exit code`);
+    return {
+        code: result.exitCode,
+        stdout: result.stdout,
+        stderr: result.stderr,
+        truncated: result.stdoutTruncated,
+    };
+}
+function requireStatusInput(input) {
+    if (input !== null)
+        throw new Error("Git status input must be null");
+}
+function parseDiffInput(input) {
+    if (!isRecord(input))
+        throw new Error("Git diff input must be an object");
+    const unsupported = Object.keys(input).find((key) => key !== "path" && key !== "staged");
+    if (unsupported !== undefined)
+        throw new Error(`Git diff input contains an unsupported field: ${unsupported}`);
+    const path = input["path"];
+    const staged = input["staged"];
+    if (path !== undefined && typeof path !== "string")
+        throw new Error("Git diff input path must be a string");
+    if (staged !== undefined && typeof staged !== "boolean")
+        throw new Error("Git diff input staged must be a boolean");
+    return {
+        ...(path === undefined ? {} : { path }),
+        ...(staged === undefined ? {} : { staged }),
+    };
+}
+function normalizeRelativePath(input) {
+    const value = input ?? "";
+    if (value === "" || value === ".")
+        return "";
+    if (isAbsolute(value))
+        throw new Error("Absolute paths are not allowed");
+    const parts = value.split(/[\\/]+/u).filter((part) => part !== "" && part !== ".");
+    if (parts.some((part) => part === ".."))
+        throw new Error("Path traversal is not allowed");
+    return parts.join("/");
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-//# sourceMappingURL=gitService.js.map

package/dist/pi-web-plugins/git/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@pi-web/git-plugin",
+  "private": true,
+  "type": "module",
+  "piWeb": {
+    "plugins": [
+      {
+        "id": "git",
+        "browserRoot": "browser",
+        "module": "browser/pi-web-plugin.js",
+        "serverModule": "server-plugin.js",
+        "machineSpecific": true
+      }
+    ]
+  }
+}

package/dist/pi-web-plugins/git/server-plugin.js

@@ -0,0 +1,176 @@
+// Generated from pi-web-plugins/git/server-plugin.ts. Do not edit directly.
+import { basename, resolve } from "node:path";
+import { requestGitBackend } from "./git-backend.js";
+const GIT_LOCAL_ENV_VARS = Object.freeze([
+    "GIT_ALTERNATE_OBJECT_DIRECTORIES",
+    "GIT_COMMON_DIR",
+    "GIT_DIR",
+    "GIT_INDEX_FILE",
+    "GIT_OBJECT_DIRECTORY",
+    "GIT_PREFIX",
+    "GIT_QUARANTINE_PATH",
+    "GIT_WORK_TREE",
+]);
+const plugin = {
+    apiVersion: 1,
+    name: "Git",
+    activate(context) {
+        return { workspaceProvider: createGitWorkspaceProvider(context) };
+    },
+};
+export default plugin;
+export function createGitWorkspaceProvider(context) {
+    return Object.freeze({
+        fallback: true,
+        async probe(project, signal) {
+            const result = await runGit(context, project.path, ["rev-parse", "--is-inside-work-tree"], signal);
+            if (result.signal !== null)
+                throw new Error(`git repository probe ended from signal ${result.signal}`);
+            if (result.exitCode !== 0)
+                return "pass";
+            return result.stdout.trim() === "true" ? "claim" : "pass";
+        },
+        async list(project, signal) {
+            const rootResult = await requireGit(runGit(context, project.path, ["rev-parse", "--show-toplevel"], signal), "resolve the Git worktree root");
+            const mainRootOutput = rootResult.stdout.trim();
+            if (mainRootOutput === "")
+                throw new Error("Git returned an empty worktree root");
+            const mainRoot = resolve(mainRootOutput);
+            const commonDirectoryResult = await requireGit(runGit(context, project.path, ["rev-parse", "--git-common-dir"], signal), "resolve the Git common directory");
+            const commonDirectoryOutput = commonDirectoryResult.stdout.trim();
+            if (commonDirectoryOutput === "")
+                throw new Error("Git returned an empty common directory");
+            const commonDirectory = resolve(project.path, commonDirectoryOutput);
+            const listResult = await requireGit(runGit(context, project.path, ["worktree", "list", "--porcelain", "-z"], signal), "list Git worktrees");
+            const worktrees = parseGitWorktreeList(listResult.stdout)
+                .filter((worktree) => worktree.bare !== true)
+                .map((worktree) => {
+                const path = resolve(worktree.path);
+                return { worktree: { ...worktree, path }, path };
+            });
+            // Prefer the checkout Git identifies for the registered project. A
+            // submodule is the exception: its sole worktree record points at common
+            // storage under the superproject instead of at --show-toplevel.
+            const mainWorkspacePath = worktrees.some(({ path }) => path === mainRoot)
+                ? mainRoot
+                : commonDirectory;
+            const selectable = worktrees
+                .map(({ worktree, path }) => ({ worktree, path, isMain: path === mainWorkspacePath }))
+                .filter(({ worktree, path, isMain }) => worktree.prunable !== true || isMain || path === project.path);
+            if (selectable.length === 0)
+                return [singleGitWorkspace(project)];
+            return selectable.map(({ worktree, path, isMain }) => {
+                const label = worktree.branch ?? (worktree.detached === true ? "detached" : basename(worktree.path) || worktree.path);
+                return {
+                    key: path,
+                    path,
+                    label,
+                    isMain,
+                    data: {
+                        worktreePath: worktree.path,
+                        ...(worktree.branch === undefined ? {} : { branch: worktree.branch }),
+                    },
+                    publicMetadata: {
+                        isGitRepo: true,
+                        isGitWorktree: true,
+                        ...(worktree.branch === undefined ? {} : { branch: worktree.branch }),
+                        ...(worktree.detached === undefined ? {} : { detached: worktree.detached }),
+                    },
+                    ...(isMain ? {} : { removal: gitRemovalPresentation(label, path) }),
+                };
+            });
+        },
+        request: (request) => requestGitBackend(context, request),
+        async prepareRemove({ project, workspace, signal }) {
+            const privatePath = gitPrivateWorktreePath(workspace);
+            if (resolve(privatePath) !== workspace.path) {
+                throw new Error("Git workspace removal data no longer matches the current workspace path");
+            }
+            const listResult = await requireGit(runGit(context, project.path, ["worktree", "list", "--porcelain", "-z"], signal), "validate the Git worktree before removal");
+            const current = parseGitWorktreeList(listResult.stdout)
+                .find((worktree) => resolve(worktree.path) === workspace.path);
+            if (current === undefined || current.prunable === true) {
+                throw new Error("Git worktree is no longer available for removal");
+            }
+            if (current.bare === true)
+                throw new Error("A bare Git workspace cannot be removed as a linked worktree");
+            return {
+                title: `Delete workspace: ${workspace.label}`,
+                command: `git worktree remove ${shellQuote(workspace.path)}`,
+            };
+        },
+    });
+}
+/** Parse `git worktree list --porcelain -z` without path quoting or space loss. */
+export function parseGitWorktreeList(stdout) {
+    return stdout.split("\0\0").flatMap((record) => {
+        if (record === "")
+            return [];
+        const info = { path: "" };
+        for (const field of record.split("\0")) {
+            const separator = field.indexOf(" ");
+            const key = separator === -1 ? field : field.slice(0, separator);
+            const value = separator === -1 ? "" : field.slice(separator + 1);
+            if (key === "worktree")
+                info.path = value;
+            else if (key === "branch")
+                info.branch = value.replace(/^refs\/heads\//u, "");
+            else if (key === "bare")
+                info.bare = true;
+            else if (key === "detached")
+                info.detached = true;
+            else if (key === "prunable")
+                info.prunable = true;
+        }
+        return info.path === "" ? [] : [info];
+    });
+}
+function singleGitWorkspace(project) {
+    return {
+        key: project.path,
+        path: project.path,
+        label: project.name,
+        isMain: true,
+        data: { worktreePath: project.path },
+        publicMetadata: { isGitRepo: true, isGitWorktree: false },
+    };
+}
+function gitRemovalPresentation(label, path) {
+    return {
+        actionLabel: "Delete workspace",
+        confirmation: `Delete workspace ${label}?\n\nThis will run git worktree remove and delete:\n${path}\n\nThe Git branch will not be deleted.`,
+    };
+}
+function gitPrivateWorktreePath(workspace) {
+    const data = workspace.data;
+    if (typeof data !== "object" || data === null || Array.isArray(data)) {
+        throw new Error("Git workspace removal data is unavailable");
+    }
+    const path = Reflect.get(data, "worktreePath");
+    if (typeof path !== "string" || path === "")
+        throw new Error("Git worktree path is unavailable for removal");
+    return path;
+}
+function shellQuote(value) {
+    return `'${value.replaceAll("'", "'\\''")}'`;
+}
+async function runGit(context, cwd, args, signal) {
+    const result = await context.execFile({
+        file: "git",
+        args: ["-C", cwd, ...args],
+        unsetEnv: GIT_LOCAL_ENV_VARS,
+        signal,
+    });
+    if (result.stdoutTruncated || result.stderrTruncated) {
+        throw new Error(`git ${args.join(" ")} exceeded the host output limit`);
+    }
+    return result;
+}
+async function requireGit(resultPromise, action) {
+    const result = await resultPromise;
+    if (result.signal === null && result.exitCode === 0)
+        return result;
+    const detail = result.stderr.trim();
+    const outcome = result.signal === null ? `exit ${String(result.exitCode)}` : `signal ${result.signal}`;
+    throw new Error(`Unable to ${action} (${outcome})${detail === "" ? "" : `: ${detail}`}`);
+}

package/dist/pi-web-plugins/info/infoInternals.js

@@ -62,8 +62,7 @@ export function componentDetails(component) {
 }
 export function workspaceFlags(workspace) {
     return [
-        workspace.branch === undefined || workspace.branch === "" ? undefined : `branch ${workspace.branch}`,
-        workspace.isGitWorktree ? "git worktree" : workspace.isGitRepo ? "git repo" : "not a git repo",
+        workspace.provider === undefined ? "folder workspace" : `provider: ${workspace.provider.pluginId}`,
         workspace.isMain ? "main workspace" : undefined,
     ].filter((flag) => flag !== undefined);
 }

package/dist/pi-web-plugins/info/package.json

@@ -3,7 +3,7 @@
   "private": true,
   "piWeb": {
     "plugins": [
-      { "id": "info", "module": "pi-web-plugin.js" }
+      { "id": "info", "browserRoot": ".", "module": "pi-web-plugin.js" }
     ]
   }
 }

package/dist/pi-web-plugins/info/pi-web-plugin.js

@@ -7,7 +7,7 @@
 // the internals for your own.
 import { copyDiagnostics, renderInfoPanel } from "./infoInternals.js";
 const plugin = {
-    apiVersion: 1,
+    apiVersion: 2,
     name: "Info Plugin",
     activate: ({ html, svg }) => ({
         contributions: {
@@ -24,7 +24,7 @@ const plugin = {
                 {
                     id: "workspace.kind-label",
                     order: 100,
-                    items: (context) => [{ type: "text", text: context.workspace.isGitRepo ? "git" : "folder", title: context.workspace.path }],
+                    items: (context) => [{ type: "text", text: context.workspace.provider?.pluginId ?? "folder", title: context.workspace.path }],
                 },
             ],
             workspacePanels: [

package/dist/pi-web-plugins/relays/package.json

@@ -3,7 +3,7 @@
   "private": true,
   "piWeb": {
     "plugins": [
-      { "id": "relays", "module": "pi-web-plugin.js" }
+      { "id": "relays", "browserRoot": ".", "module": "pi-web-plugin.js" }
     ]
   }
 }

package/dist/pi-web-plugins/relays/pi-web-plugin.js

@@ -2,9 +2,9 @@
 import { RELAYS_ROOT } from "./relayDiscovery.js";
 import { defineRelaysPanelElement } from "./relaysPanelElement.js";
 const plugin = {
-    apiVersion: 1,
+    apiVersion: 2,
     name: "Relays",
-    activate: ({ pluginId, html, svg }) => {
+    activate: ({ runtimePluginId, html, svg }) => {
         defineRelaysPanelElement();
         return {
             contributions: {
@@ -18,7 +18,7 @@ const plugin = {
                         run: (context) => {
                             if (context.state.selectedWorkspace === undefined)
                                 return;
-                            context.selectWorkspaceTool(`${pluginId}:workspace.relays`);
+                            context.selectWorkspaceTool(`${runtimePluginId}:workspace.relays`);
                         },
                     },
                 ],