@jmfederico/pi-web 1.202610.1 → 1.202610.3

package/dist/pi-web-plugins/git/browser/git-panel.js

@@ -346,7 +346,6 @@ function createGitPanel(html, svg, controller) {
       </svg>
     `,
         order: 20,
-        routeAliases: ["git", "core:workspace.git"],
         visible: (context) => controller.isOwnedWorkspace(context.workspace),
         onInvalidate: (context) => controller.invalidate(context),
         render: (context) => renderGitPanel(html, controller, context),

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

@@ -1,14 +1,23 @@
 // 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";
+import { createWorkspaceDiscoveryHooks } from "./workspaceDiscoveryHooks.js";
 const GIT_LOCAL_ENV_VARS = Object.freeze([
     "GIT_ALTERNATE_OBJECT_DIRECTORIES",
     "GIT_COMMON_DIR",
+    "GIT_CONFIG",
+    "GIT_CONFIG_COUNT",
+    "GIT_CONFIG_PARAMETERS",
     "GIT_DIR",
+    "GIT_GRAFT_FILE",
+    "GIT_IMPLICIT_WORK_TREE",
     "GIT_INDEX_FILE",
+    "GIT_NO_REPLACE_OBJECTS",
     "GIT_OBJECT_DIRECTORY",
     "GIT_PREFIX",
     "GIT_QUARANTINE_PATH",
+    "GIT_REPLACE_REF_BASE",
+    "GIT_SHALLOW_FILE",
     "GIT_WORK_TREE",
 ]);
 const plugin = {
@@ -16,15 +25,16 @@ const plugin = {
     name: "Git",
     activate(context) {
         return {
-            workspaceProvider: createGitWorkspaceProvider(context),
+            workspaceProvider: createGitWorkspaceProvider(context, process.env["PI_WEB_INSTANCE_NAMESPACE"] ?? ""),
             peer: { request: (request) => requestGitBackend(context, request) },
         };
     },
 };
 export default plugin;
-export function createGitWorkspaceProvider(context) {
+export function createGitWorkspaceProvider(context, instanceNamespace = "") {
     return Object.freeze({
         fallback: true,
+        integration: createWorkspaceDiscoveryHooks(context, (cwd, args, signal) => runGit(context, cwd, args, signal), process.execPath, instanceNamespace),
         async probe(project, signal) {
             const result = await runGit(context, project.path, ["rev-parse", "--is-inside-work-tree"], signal);
             if (result.signal !== null)
@@ -161,6 +171,7 @@ async function runGit(context, cwd, args, signal) {
         file: "git",
         args: ["-C", cwd, ...args],
         unsetEnv: GIT_LOCAL_ENV_VARS,
+        timeoutMs: 10_000,
         signal,
     });
     if (result.stdoutTruncated || result.stderrTruncated) {

package/dist/pi-web-plugins/git/workspace-discovery-notify.cjs

@@ -0,0 +1,14 @@
+// Packaged with PI WEB: best-effort discovery hint, never Git authority.
+const { spawnSync } = require("node:child_process");
+const [notification, ...args] = process.argv.slice(2);
+
+// Initial worktree checkout has a null previous OID and branch flag 1.
+// --no-checkout skips this hook; ordinary catalog access still discovers it.
+if (args.length === 3 && /^(?:0{40}|0{64})$/.test(args[0]) && args[2] === "1") {
+  try {
+    const command = JSON.parse(notification);
+    if (Array.isArray(command) && command.length > 0 && command.every((value) => typeof value === "string")) {
+      spawnSync(command[0], command.slice(1), { stdio: "ignore", timeout: 2000, killSignal: "SIGKILL" });
+    }
+  } catch { /* Invalid arguments, missing commands, and daemon failures must not affect Git. */ }
+}

package/dist/pi-web-plugins/git/workspaceDiscoveryHooks.js

@@ -0,0 +1,186 @@
+// Generated from pi-web-plugins/git/workspaceDiscoveryHooks.ts. Do not edit directly.
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+const EVENT = "post-checkout";
+/** Git owns the hook policy; the host owns settings snapshots and notification attribution/transport. */
+export function createWorkspaceDiscoveryHooks(context, runGit, nodeExecutable = process.execPath, instanceNamespace = "") {
+    if (instanceNamespace !== "" && !/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,31}$/u.test(instanceNamespace)) {
+        throw new Error("PI_WEB_INSTANCE_NAMESPACE must be 1–32 letters, digits, underscores or hyphens, starting with a letter or digit");
+    }
+    if (!isAbsolute(nodeExecutable))
+        throw new Error("Git hook runtime must be an absolute executable path");
+    // Serialize this activation's config edits, including registrations sharing a
+    // common Git config. Git itself locks writes from other processes.
+    let pending = Promise.resolve();
+    return Object.freeze({
+        reconcile(project, signal) {
+            const operation = pending.then(() => reconcile(project, signal));
+            pending = operation.catch(() => { });
+            return operation;
+        },
+        async acceptNotification(project, signal) {
+            return await enabled(project, signal) && (context.workspaceNotifications?.command(project.id).length ?? 0) > 0;
+        },
+    });
+    async function enabled(project, signal) {
+        signal.throwIfAborted();
+        const settings = context.resolveProjectSettings === undefined
+            ? context.settings
+            : await context.resolveProjectSettings(project, signal);
+        const value = settings["workspaceDiscoveryHooks"];
+        if (value === undefined)
+            return true;
+        if (typeof value !== "boolean")
+            throw new Error("Git setting workspaceDiscoveryHooks must be a boolean");
+        return value;
+    }
+    async function reconcile(project, signal) {
+        const isEnabled = await enabled(project, signal);
+        // Separate projects/instances may share Git config. This identity belongs
+        // to the packaged-helper implementation; older generated helpers are untouched.
+        const identity = createHash("sha256")
+            .update(JSON.stringify(["packaged-helper", context.pluginId, resolve(context.dataDirectory), project.id]))
+            .digest("hex");
+        // Keep the unnamespaced production identity byte-for-byte compatible.
+        // The name also scopes ownership records; never adopt another instance's hook.
+        const prefix = instanceNamespace === "" ? "" : `${instanceNamespace}-`;
+        const name = `pi-web-workspace-discovery-${prefix}${identity}`;
+        const helper = join(context.packageRoot, "workspace-discovery-notify.cjs");
+        const registration = join(context.dataDirectory, "workspace-discovery", `${name}.registration.json`);
+        const notifier = context.workspaceNotifications?.command(project.id);
+        const command = registrationCommand(helper, nodeExecutable, notifier ?? []);
+        const ownedCommands = new Set([command, ...await readRegistrationCommands(registration, signal)]);
+        const install = isEnabled && notifier !== undefined && notifier.length > 0;
+        if (install && !await supportsNamedHooks(project, signal))
+            return;
+        const commandKey = `hook.${name}.command`;
+        const eventKey = `hook.${name}.event`;
+        const commands = await readConfig(project, commandKey, signal);
+        const events = await readConfig(project, eventKey, signal);
+        if (commands.some((entry) => entry.scope !== "local" || !ownedCommands.has(entry.value))
+            || events.some((entry) => entry.scope !== "local" || (entry.value !== EVENT && commands.length === 0))) {
+            // We only install local keys. A same-name global/worktree registration is
+            // external even if its values happen to match ours; never override it or
+            // remove the local command on which its inherited event might depend.
+            throw new Error(`Git workspace discovery hook conflict: ${name} has unexpected configuration`);
+        }
+        if (!install) {
+            // Disconnect the event first: an event without a command makes Git fail.
+            // Installation uses the reverse order for the same reason.
+            await unsetLocal(project, eventKey, events, signal);
+            await unsetLocal(project, commandKey, commands, signal);
+            signal.throwIfAborted();
+            await rm(registration, { force: true });
+            return;
+        }
+        // Routing/runtime arguments live in Git config, not generated executable
+        // files. Preserve exact ownership before changing config, including either
+        // side of a failed update, then compact after installation succeeds.
+        await writeRegistration([...new Set([...commands.map((entry) => entry.value), command])]);
+        await setLocal(project, commandKey, command, commands, signal);
+        await setLocal(project, eventKey, EVENT, events, signal);
+        await writeRegistration([command]);
+        async function writeRegistration(owned) {
+            await writeOwnedFileIfChanged(registration, `${JSON.stringify({ version: 1, commands: owned })}\n`, signal);
+        }
+    }
+    async function supportsNamedHooks(project, signal) {
+        // Detect Git's advertised named-config facility, not its version. `hook
+        // list` is unsuitable here: a missing command in an existing registration
+        // makes it fail, preventing precisely the repair we need to perform.
+        const result = await runGit(project.path, ["help", "--config"], signal);
+        if (result.signal !== null)
+            throw new Error(`Git named-hook detection ended from signal ${result.signal}`);
+        const keys = result.stdout.split(/\r?\n/u);
+        const supported = result.exitCode === 0
+            && keys.includes("hook.<friendly-name>.command") && keys.includes("hook.<friendly-name>.event");
+        if (!supported)
+            context.logger.debug("Git named configuration hooks unavailable; workspace discovery remains on catalog access", { projectId: project.id });
+        return supported;
+    }
+    async function readConfig(project, key, signal) {
+        const result = await runGit(project.path, ["config", "--null", "--show-scope", "--get-all", key], signal);
+        if (result.signal === null && result.exitCode === 1)
+            return [];
+        requireSuccess(result, `read ${key}`);
+        const fields = result.stdout.split("\0");
+        if (fields.pop() !== "" || fields.length % 2 !== 0)
+            throw new Error(`Malformed Git config output for ${key}`);
+        const entries = [];
+        for (let index = 0; index < fields.length; index += 2) {
+            entries.push({ scope: fields[index] ?? "", value: fields[index + 1] ?? "" });
+        }
+        return entries;
+    }
+    async function setLocal(project, key, value, entries, signal) {
+        const local = entries.filter((entry) => entry.scope === "local");
+        if (local.length === 1 && local[0]?.value === value)
+            return;
+        requireSuccess(await runGit(project.path, ["config", "--local", "--replace-all", key, value], signal), `set ${key}`);
+    }
+    async function unsetLocal(project, key, entries, signal) {
+        if (!entries.some((entry) => entry.scope === "local"))
+            return;
+        requireSuccess(await runGit(project.path, ["config", "--local", "--unset-all", key], signal), `remove ${key}`);
+    }
+}
+function requireSuccess(result, action) {
+    if (result.signal === null && result.exitCode === 0)
+        return;
+    const outcome = result.signal === null ? `exit ${String(result.exitCode)}` : `signal ${result.signal}`;
+    throw new Error(`Unable to ${action} (${outcome}): ${result.stderr.trim()}`);
+}
+function shellQuote(value) {
+    return `'${value.replaceAll("'", "'\\''")}'`;
+}
+function registrationCommand(helper, nodeExecutable, notificationCommand) {
+    // Git itself supplies the shell and appends quoted hook argv to the function
+    // call. No extra `sh` executable is required on the user's PATH. The final
+    // return preserves best-effort behavior even when our helper/runtime is gone.
+    const shellHelper = process.platform === "win32" ? helper.replaceAll("\\", "/") : helper;
+    const shellNode = process.platform === "win32" ? nodeExecutable.replaceAll("\\", "/") : nodeExecutable;
+    return `pi_web_workspace_notify () { if test -r ${shellQuote(shellHelper)}; then ${shellQuote(shellNode)} ${shellQuote(shellHelper)} ${shellQuote(JSON.stringify(notificationCommand))} "$@" >/dev/null 2>&1; fi; return 0; }; pi_web_workspace_notify`;
+}
+async function readRegistrationCommands(path, signal) {
+    let source;
+    try {
+        source = await readFile(path, { encoding: "utf8", signal });
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+    const value = JSON.parse(source);
+    if (typeof value !== "object" || value === null || Array.isArray(value)
+        || Reflect.get(value, "version") !== 1)
+        throw new Error(`Invalid PI WEB Git hook registration record: ${path}`);
+    const commands = Reflect.get(value, "commands");
+    if (!Array.isArray(commands) || !commands.every((command) => typeof command === "string" && command.length > 0)) {
+        throw new Error(`Invalid PI WEB Git hook command record: ${path}`);
+    }
+    return commands;
+}
+async function writeOwnedFileIfChanged(path, source, signal) {
+    signal.throwIfAborted();
+    try {
+        if (await readFile(path, { encoding: "utf8", signal }) === source)
+            return;
+    }
+    catch (error) {
+        if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT")
+            throw error;
+    }
+    await mkdir(dirname(path), { recursive: true });
+    // Atomic per-project ownership records never contain executable code.
+    const temporary = `${path}.${randomUUID()}.tmp`;
+    try {
+        await writeFile(temporary, source, { flag: "wx", mode: 0o600, signal });
+        signal.throwIfAborted();
+        await rename(temporary, path);
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+}

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

@@ -198,7 +198,7 @@ function renderWorkspaceSection(html, workspace) {
     </section>
   `;
 }
-/** Panel body: render the Info tab for the current workspace panel context. */
+/** Panel body: machine status is useful even without a selected workspace. */
 export function renderInfoPanel(html, context) {
     return html `
     <style>
@@ -214,9 +214,9 @@ export function renderInfoPanel(html, context) {
     </style>
     <section class="toolbar"><strong>Info</strong></section>
     <section class="viewer info-status">
-      ${renderStatusSection(html, context.state?.piWebStatus)}
+      ${renderStatusSection(html, context.state.piWebStatus)}
       ${renderMachineSection(html, context.machine)}
-      ${renderWorkspaceSection(html, context.workspace)}
+      ${context.workspace === undefined ? null : renderWorkspaceSection(html, context.workspace)}
     </section>
   `;
 }

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

@@ -27,7 +27,7 @@ const plugin = {
                     items: (context) => [{ type: "text", text: context.workspace.provider?.pluginId ?? "folder", title: context.workspace.path }],
                 },
             ],
-            workspacePanels: [
+            applicationPanels: [
                 {
                     id: "workspace.info",
                     title: "Info",