@hyperdreamer/pi-webui 1.14.1 → 1.15.0

package/dist/pi-webui-plugins/workspace-tasks/workspaceTasksClient.js

@@ -1,17 +1,103 @@
 // Generated from pi-webui-plugins/workspace-tasks/workspaceTasksClient.ts. Do not edit directly.
-import { TASKS_CONFIG_PATH, parseTasksConfigText } from "./config.js";
+import { TASKS_CONFIG_PATH, parseTasksConfigText, serializeWorkspaceTasksConfig, } from "./config.js";
 export const tasksConfigMissingMessage = "No workspace tasks configured here.";
 export const tasksConfigMissingHint = `${TASKS_CONFIG_PATH} is optional. Create it in this workspace if you want custom tasks.`;
+export const tasksConfigInvalidMessage = "Workspace tasks configuration is invalid.";
+export const tasksConfigInvalidHint = `Fix ${TASKS_CONFIG_PATH}, then click Refresh.`;
 export const tasksConfigUnavailableMessage = "Could not load workspace tasks.";
 export const tasksConfigRefreshHint = `Fix ${TASKS_CONFIG_PATH}, then click Refresh.`;
-const missingWorkspaceFileError = "Path does not exist";
-export async function loadWorkspaceTasksConfig(files) {
+const configCache = new Map();
+const workspaceRuntimes = new Map();
+const subscribers = new Set();
+let stateEpoch = 0;
+export function loadWorkspaceTasksConfig(files) {
+    return readCurrentWorkspaceTasksConfig(files);
+}
+export function getWorkspaceTasksCacheEntry(workspaceKey) {
+    return configCache.get(workspaceKey);
+}
+export function ensureWorkspaceTasksConfig(files, workspaceKey) {
+    const cached = configCache.get(workspaceKey);
+    if (cached !== undefined)
+        return cached;
+    const runtime = getWorkspaceRuntime(workspaceKey);
+    const loadingEntry = {
+        state: { kind: "loading" },
+        refreshRequired: runtime.refreshRequired,
+    };
+    configCache.set(workspaceKey, loadingEntry);
+    void enqueueWorkspaceOperation(workspaceKey, async (operation) => {
+        const state = await loadWorkspaceTasksConfigSafely(files);
+        if (state.kind === "unavailable")
+            operation.runtime.refreshRequired = true;
+        publishState(operation, state, operation.runtime.refreshRequired);
+    }).catch(() => undefined);
+    return loadingEntry;
+}
+export function refreshWorkspaceTasksConfig(files, workspaceKey) {
+    return enqueueWorkspaceOperation(workspaceKey, async (operation) => {
+        const state = await loadWorkspaceTasksConfigSafely(files);
+        operation.runtime.refreshRequired = state.kind === "unavailable";
+        publishState(operation, state, operation.runtime.refreshRequired);
+        return state;
+    }, (operation) => {
+        if (!isCurrentOperation(operation))
+            return;
+        configCache.set(workspaceKey, {
+            state: { kind: "loading" },
+            refreshRequired: operation.runtime.refreshRequired,
+        });
+    });
+}
+export function guardedWriteWorkspaceTasksConfig(files, workspaceKey, sourceSnapshot, nextConfig) {
+    return enqueueWorkspaceOperation(workspaceKey, async (operation) => {
+        if (operation.runtime.refreshRequired) {
+            return blockMutation(operation, "A successful Refresh is required before another workspace task mutation.");
+        }
+        const preflight = await loadWorkspaceTasksConfigSafely(files);
+        if (preflight.kind === "unavailable") {
+            return blockMutation(operation, unavailableDetail(preflight));
+        }
+        const currentSnapshot = preflight.snapshot;
+        if (!snapshotsEqual(sourceSnapshot, currentSnapshot)) {
+            return blockMutation(operation, `The ${TASKS_CONFIG_PATH} file changed outside this panel. Refresh before trying again.`, "conflict");
+        }
+        const payload = serializeWorkspaceTasksConfig(nextConfig);
+        try {
+            await files.writeFile(TASKS_CONFIG_PATH, payload);
+        }
+        catch (error) {
+            return blockMutation(operation, `Unable to write ${TASKS_CONFIG_PATH}: ${formatUnknownError(error)}`, "write-failed");
+        }
+        const postWrite = await loadWorkspaceTasksConfigSafely(files);
+        if (postWrite.kind === "loaded" && postWrite.snapshot.content === payload) {
+            operation.runtime.refreshRequired = false;
+            publishState(operation, postWrite, false);
+            return { kind: "written", state: postWrite };
+        }
+        const detail = postWriteReloadDetail(postWrite);
+        blockMutation(operation, detail, undefined, postWrite);
+        return { kind: "written-but-unreloaded", detail };
+    });
+}
+export function subscribeWorkspaceTasksConfig(listener) {
+    subscribers.add(listener);
+    return () => {
+        subscribers.delete(listener);
+    };
+}
+export function clearWorkspaceTasksStateForTesting() {
+    stateEpoch += 1;
+    configCache.clear();
+    workspaceRuntimes.clear();
+}
+async function readCurrentWorkspaceTasksConfig(files) {
     let file;
     try {
         file = await files.readFile(TASKS_CONFIG_PATH);
     }
     catch (error) {
-        if (errorMessage(error) === missingWorkspaceFileError)
+        if (isMissingWorkspaceFileError(error))
             return missing();
         return unavailable(`Unable to read ${TASKS_CONFIG_PATH}: ${formatUnknownError(error)}`);
     }
@@ -20,15 +106,107 @@ export async function loadWorkspaceTasksConfig(files) {
     if (file.truncated)
         return unavailable(`${TASKS_CONFIG_PATH} is too large and was truncated`);
     const result = parseTasksConfigText(file.content);
-    if (!result.ok)
-        return unavailable(result.error);
-    return { kind: "loaded", config: result.config, path: TASKS_CONFIG_PATH };
+    if (!result.ok) {
+        return {
+            kind: "invalid",
+            message: tasksConfigInvalidMessage,
+            hint: tasksConfigInvalidHint,
+            detail: result.error,
+            snapshot: { kind: "text", content: file.content },
+        };
+    }
+    return {
+        kind: "loaded",
+        config: result.config,
+        path: TASKS_CONFIG_PATH,
+        snapshot: { kind: "text", content: file.content },
+    };
+}
+async function loadWorkspaceTasksConfigSafely(files) {
+    try {
+        return await readCurrentWorkspaceTasksConfig(files);
+    }
+    catch (error) {
+        return unavailable(`Unable to read ${TASKS_CONFIG_PATH}: ${formatUnknownError(error)}`);
+    }
+}
+function enqueueWorkspaceOperation(workspaceKey, operation, onRequest) {
+    const runtime = getWorkspaceRuntime(workspaceKey);
+    const context = {
+        key: workspaceKey,
+        runtime,
+        generation: runtime.requestGeneration + 1,
+        epoch: stateEpoch,
+    };
+    runtime.requestGeneration = context.generation;
+    onRequest?.(context);
+    const result = runtime.tail.then(() => operation(context));
+    runtime.tail = result.then(() => undefined, () => undefined);
+    return result;
+}
+function getWorkspaceRuntime(workspaceKey) {
+    const existing = workspaceRuntimes.get(workspaceKey);
+    if (existing !== undefined)
+        return existing;
+    const runtime = {
+        requestGeneration: 0,
+        refreshRequired: false,
+        tail: Promise.resolve(),
+    };
+    workspaceRuntimes.set(workspaceKey, runtime);
+    return runtime;
+}
+function publishState(operation, state, refreshRequired) {
+    if (!isCurrentOperation(operation))
+        return;
+    configCache.set(operation.key, { state, refreshRequired });
+    notifySubscribers(operation.key);
+}
+function blockMutation(operation, detail, kind = "preflight-unavailable", postWriteState) {
+    operation.runtime.refreshRequired = true;
+    if (isCurrentOperation(operation)) {
+        const existing = configCache.get(operation.key);
+        if (postWriteState !== undefined) {
+            configCache.set(operation.key, { state: postWriteState, refreshRequired: true });
+        }
+        else if (existing !== undefined) {
+            configCache.set(operation.key, { ...existing, refreshRequired: true });
+        }
+        notifySubscribers(operation.key);
+    }
+    return { kind, detail };
+}
+function isCurrentOperation(operation) {
+    return operation.epoch === stateEpoch
+        && workspaceRuntimes.get(operation.key) === operation.runtime
+        && operation.runtime.requestGeneration === operation.generation;
+}
+function notifySubscribers(workspaceKey) {
+    for (const listener of subscribers)
+        listener(workspaceKey);
+}
+function snapshotsEqual(left, right) {
+    if (left.kind !== right.kind)
+        return false;
+    if (left.kind === "missing" || right.kind === "missing")
+        return true;
+    return left.content === right.content;
+}
+function postWriteReloadDetail(result) {
+    if (result.kind === "loaded")
+        return `Unable to reload ${TASKS_CONFIG_PATH}: the post-write snapshot did not match the canonical payload.`;
+    if (result.kind === "missing")
+        return `Unable to reload ${TASKS_CONFIG_PATH}: the file is missing after the write.`;
+    if (result.kind === "invalid")
+        return `Unable to reload ${TASKS_CONFIG_PATH}: ${result.detail}`;
+    return `Unable to reload ${TASKS_CONFIG_PATH}: ${unavailableDetail(result)}`;
 }
 function missing() {
     return {
         kind: "missing",
         message: tasksConfigMissingMessage,
         hint: tasksConfigMissingHint,
+        snapshot: { kind: "missing" },
     };
 }
 function unavailable(detail) {
@@ -39,8 +217,25 @@ function unavailable(detail) {
         detail,
     };
 }
-function errorMessage(error) {
-    return error instanceof Error ? error.message : undefined;
+function unavailableDetail(result) {
+    return result.detail ?? tasksConfigUnavailableMessage;
+}
+function isMissingWorkspaceFileError(error) {
+    const message = errorField(error, "message");
+    const code = errorField(error, "code");
+    return message === "Path does not exist"
+        || code?.toLowerCase() === "enoent"
+        || message?.toLowerCase() === "enoent"
+        || message?.toLowerCase().includes("no such file or directory") === true
+        || code?.toLowerCase().includes("no such file or directory") === true;
+}
+function errorField(error, field) {
+    if (typeof error === "object" && error !== null && hasStringField(error, field))
+        return error[field];
+    return error instanceof Error && field === "message" ? error.message : undefined;
+}
+function hasStringField(value, field) {
+    return field in value && typeof Reflect.get(value, field) === "string";
 }
 function formatUnknownError(error) {
     return error instanceof Error ? error.message : String(error);

package/docs/plugins.md

@@ -301,8 +301,6 @@ Configure workspace tasks in `.pi-webui/tasks.json`:
 }
 ```
 
-Open a workspace, choose the **Tasks** tab, and click **Run** next to a task. Commands run in the workspace root because PI WEBUI creates the terminal for that workspace.
-
 Task fields:
 
 - `version`: must be `1`.
@@ -314,6 +312,48 @@ Task fields:
 - `group`: optional group heading.
 - `confirm`: optional boolean. When true, the browser asks before dispatching the command.
 
+Open a workspace, choose the **Tasks** tab, and use the editor to manage tasks in the browser:
+
+- **Add** creates a task and appends it to the task array.
+- **Edit** updates the task at its existing position in the array.
+- **Delete** removes the selected task without reordering the remaining tasks.
+- **Reset** is offered only for a complete, readable task-file snapshot whose text is invalid, including parse- or schema-invalid text. It is unavailable for binary, truncated, or otherwise unavailable files. After confirmation, it replaces the file with the canonical empty version-1 configuration `{"version":1,"tasks":[]}`.
+
+Browser saves write canonical JSON for the supported task fields. They preserve supported task values and task-array order, but canonicalize whitespace and key order and drop unsupported fields; original JSON formatting is not preserved.
+
+For a multiline script, encode line feeds as `\n` in JSON:
+
+```json
+{
+  "version": 1,
+  "tasks": [
+    {
+      "id": "verify",
+      "title": "Build and test",
+      "command": "set -e\nnpm run build\nnpm test"
+    }
+  ]
+}
+```
+
+Click **Run** next to a task to send one terminal request. The server starts one dedicated terminal in the workspace root with `$SHELL -lc`, so lines in a multiline script share shell state such as variables and the current directory. The shell's final exit status determines whether the run succeeds or fails. For POSIX-compatible fail-fast behavior, use syntax such as:
+
+```sh
+set -e
+npm run build
+npm test
+```
+
+or:
+
+```sh
+npm run build && npm test
+```
+
+These are POSIX-compatible examples, not shell-neutral guarantees.
+
+If the task file changed after the browser loaded it, the editor refuses the stale save as a best-effort conflict guard instead of merging the changes. Use **Refresh** to load the latest file, review it, and retry. This protects against sequential stale browser edits; it is not an atomic cross-tab or cross-process compare-and-swap guarantee.
+
 Review task configs before running them, especially in shared projects. Workspace Tasks runs trusted shell commands from your repositories.
 
 ## Discovery and packaging

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperdreamer/pi-webui",
-  "version": "1.14.1",
+  "version": "1.15.0",
   "description": "Web UI for persistent Pi Coding Agent sessions in real workspaces.",
   "license": "MIT",
   "author": "Federico Jaramillo Martinez and HyperDreamer",