@hyperdreamer/pi-webui 1.14.0 → 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/dist/server/sessions/piSessionService.js

@@ -564,7 +564,12 @@ export class PiSessionService {
             },
             onCompactionEnd: (session, result, detail) => {
                 this.endSessionEntryMutation(session);
-                this.publishActivity(session, result === "success" ? "compaction complete" : "compaction failed", result === "success" ? "idle" : "error", detail);
+                const activity = result === "success"
+                    ? { label: "compaction complete", phase: "idle" }
+                    : result === "cancelled"
+                        ? { label: "compaction cancelled", phase: "idle" }
+                        : { label: "compaction failed", phase: "error" };
+                this.publishActivity(session, activity.label, activity.phase, detail);
                 this.publishStatus(session);
             },
             reloadSession: (session) => this.reloadSessionRuntime(session),
@@ -2508,26 +2513,31 @@ export class PiSessionService {
         }
     }
     async abortSessionOperations(session) {
-        let branchSummaryAbortFailed = false;
-        let branchSummaryAbortError;
+        const failures = [];
+        try {
+            session.abortCompaction();
+            this.commandService.cancelManualCompaction(session.sessionId);
+        }
+        catch (error) {
+            failures.push(error);
+        }
         try {
             session.abortBranchSummary?.();
         }
         catch (error) {
-            branchSummaryAbortFailed = true;
-            branchSummaryAbortError = error;
+            failures.push(error);
         }
         try {
             await session.abort();
         }
-        catch (abortError) {
-            if (branchSummaryAbortFailed) {
-                throw new AggregateError([branchSummaryAbortError, abortError], "Failed to abort session operations", { cause: abortError });
-            }
-            throw abortError;
+        catch (error) {
+            failures.push(error);
+        }
+        if (failures.length === 1)
+            throw failures[0];
+        if (failures.length > 1) {
+            throw new AggregateError(failures, "Failed to abort session operations", { cause: failures[failures.length - 1] });
         }
-        if (branchSummaryAbortFailed)
-            throw branchSummaryAbortError;
     }
     async assertWritable(ref) {
         if ((await this.getArchived(ref)) !== undefined)