agentweaver 0.1.17 → 0.1.19

package/dist/interactive/web/index.js

@@ -0,0 +1,326 @@
+import process from "node:process";
+import { writeSync } from "node:fs";
+import { FlowInterruptedError } from "../../errors.js";
+import { listArtifactCatalog } from "../../runtime/artifact-catalog.js";
+import { createArtifactRegistry } from "../../runtime/artifact-registry.js";
+import { InteractiveSessionController } from "../controller.js";
+import { startWebServer, } from "./server.js";
+function actionId(action) {
+    return "actionId" in action ? action.actionId : undefined;
+}
+export function createWebInteractiveSession(options, webOptions = {}) {
+    const controller = new InteractiveSessionController(options);
+    let server = null;
+    let unsubscribe = null;
+    let mounted = false;
+    let shuttingDown = false;
+    let activeScopeKey = options.scopeKey;
+    let artifactRestoreGeneration = 0;
+    const artifactCatalogProvider = webOptions.getArtifactCatalog ?? ((input) => {
+        const explorerScopeKey = controller.getViewModel().artifactExplorer.scopeKey;
+        const requestedScopeKey = input?.scopeKey;
+        const scopeKey = requestedScopeKey && requestedScopeKey === explorerScopeKey ? requestedScopeKey : activeScopeKey;
+        return listArtifactCatalog({
+            scopeKey,
+            artifactRegistry: createArtifactRegistry(),
+        });
+    });
+    function snapshot() {
+        return { type: "snapshot", viewModel: controller.getViewModel() };
+    }
+    function sendError(client, message, id) {
+        const event = { type: "error", message, ...(id ? { actionId: id } : {}) };
+        if (client) {
+            client.send(event);
+        }
+        else {
+            server?.broadcast(event);
+        }
+    }
+    function uniqueStrings(values) {
+        return values.filter((value, index, allValues) => (typeof value === "string" && value.length > 0 && allValues.indexOf(value) === index));
+    }
+    function collectPublishedArtifactRunIds(executionState) {
+        const runIds = [];
+        for (const phase of executionState?.phases ?? []) {
+            for (const step of phase.steps) {
+                for (const artifact of step.publishedArtifacts ?? []) {
+                    const runId = artifact.manifest?.run_id;
+                    if (runId) {
+                        runIds.push(runId);
+                    }
+                }
+            }
+        }
+        return uniqueStrings(runIds);
+    }
+    function candidateRunIds() {
+        const executionState = controller.getCurrentFlowExecutionState();
+        return uniqueStrings([
+            executionState?.runId ?? null,
+            executionState?.publicationRunId ?? null,
+            ...collectPublishedArtifactRunIds(executionState),
+        ]);
+    }
+    async function resolveArtifactExplorerRunMetadata(scopeKey) {
+        const candidates = candidateRunIds();
+        const preferredRunId = candidates[0] ?? null;
+        try {
+            const catalog = await artifactCatalogProvider({
+                scopeKey,
+                ...(candidates.length === 1 && preferredRunId ? { runId: preferredRunId, runIds: candidates } : {}),
+                ...(candidates.length > 1 ? { runIds: candidates } : {}),
+            });
+            if (!catalog || catalog.scopeKey !== scopeKey) {
+                return { runId: preferredRunId };
+            }
+            if (candidates.length === 0) {
+                return {
+                    runId: null,
+                    artifactCount: catalog.items.filter((item) => item.scopeKey === scopeKey && item.kind === "markdown").length,
+                };
+            }
+            const matchingRunIds = candidates.filter((candidate) => (catalog.items.some((item) => item.scopeKey === scopeKey && item.runId === candidate && item.kind === "markdown")));
+            if (matchingRunIds.length > 0) {
+                const matchingRunIdSet = new Set(matchingRunIds);
+                return {
+                    runId: matchingRunIds[0] ?? preferredRunId,
+                    ...(matchingRunIds.length > 1 ? { runIds: matchingRunIds } : {}),
+                    artifactCount: catalog.items.filter((item) => (item.scopeKey === scopeKey
+                        && item.kind === "markdown"
+                        && item.runId !== null
+                        && matchingRunIdSet.has(item.runId))).length,
+                };
+            }
+            return {
+                runId: preferredRunId,
+                artifactCount: catalog.items.filter((item) => item.scopeKey === scopeKey && item.kind === "markdown" && item.runId === preferredRunId).length,
+            };
+        }
+        catch {
+            return { runId: preferredRunId };
+        }
+    }
+    async function markArtifactExplorerForCompletedRun(status) {
+        artifactRestoreGeneration += 1;
+        const scopeKey = activeScopeKey;
+        const { runId, runIds, artifactCount } = await resolveArtifactExplorerRunMetadata(scopeKey);
+        controller.setArtifactExplorerAvailability({
+            scopeKey,
+            runId,
+            ...(runIds ? { runIds } : {}),
+            status,
+            ...(artifactCount !== undefined ? { artifactCount } : {}),
+            open: !controller.hasActiveInput(),
+        });
+    }
+    async function restoreArtifactExplorerFromScope(scopeKey) {
+        const generation = ++artifactRestoreGeneration;
+        try {
+            const catalog = await artifactCatalogProvider({ scopeKey });
+            if (generation !== artifactRestoreGeneration || shuttingDown || activeScopeKey !== scopeKey) {
+                return;
+            }
+            if (!catalog || catalog.scopeKey !== scopeKey) {
+                controller.setArtifactExplorerUnavailable();
+                return;
+            }
+            const artifactCount = catalog.items.filter((item) => item.scopeKey === scopeKey && item.kind === "markdown").length;
+            if (artifactCount === 0) {
+                controller.setArtifactExplorerUnavailable("No markdown artifacts were found for the current scope.");
+                return;
+            }
+            controller.setArtifactExplorerAvailability({
+                scopeKey,
+                runId: null,
+                status: "completed",
+                artifactCount,
+                open: false,
+                label: "Artifacts available",
+                message: "Markdown artifacts from this scope are available for review.",
+            });
+        }
+        catch {
+            if (generation === artifactRestoreGeneration && !shuttingDown && activeScopeKey === scopeKey) {
+                controller.setArtifactExplorerUnavailable("Artifact Explorer could not inspect the current scope.");
+            }
+        }
+    }
+    async function dispatch(action, client) {
+        let acceptedRunConfirmation = false;
+        try {
+            if (action.type === "flow.select") {
+                if (action.key) {
+                    controller.selectFlowKey(action.key);
+                }
+                else {
+                    controller.selectFlowIndex(action.index ?? 0);
+                }
+                return;
+            }
+            if (action.type === "folder.toggle") {
+                controller.toggleFolderKey(action.key);
+                return;
+            }
+            if (action.type === "run.openConfirm") {
+                await controller.openRunConfirm(action.flowId, action.key);
+                return;
+            }
+            if (action.type === "confirm.select") {
+                controller.selectConfirmAction(action.action);
+                return;
+            }
+            if (action.type === "confirm.accept") {
+                const confirmation = controller.getViewModel().confirmation;
+                const acceptedAction = action.action ?? confirmation?.selectedAction;
+                acceptedRunConfirmation = confirmation?.kind === "run" && acceptedAction !== "cancel";
+                if (action.action) {
+                    controller.selectConfirmAction(action.action);
+                }
+                await controller.acceptConfirmation();
+                if (acceptedRunConfirmation) {
+                    await markArtifactExplorerForCompletedRun("completed");
+                }
+                return;
+            }
+            if (action.type === "confirm.cancel") {
+                controller.cancelConfirmation();
+                return;
+            }
+            if (action.type === "form.update") {
+                controller.updateActiveFormValues(action.values);
+                return;
+            }
+            if (action.type === "form.fieldUpdate") {
+                controller.updateFormField(action.fieldId, action.value);
+                return;
+            }
+            if (action.type === "form.submit") {
+                controller.submitForm(action.values);
+                return;
+            }
+            if (action.type === "form.cancel") {
+                controller.cancelForm();
+                return;
+            }
+            if (action.type === "flow.interrupt") {
+                await controller.interruptCurrentFlow(action.flowId);
+                return;
+            }
+            if (action.type === "interrupt.openConfirm") {
+                controller.openInterruptConfirm();
+                return;
+            }
+            if (action.type === "log.clear") {
+                controller.clearLog();
+                return;
+            }
+            if (action.type === "artifactExplorer.open") {
+                controller.openArtifactExplorer();
+                return;
+            }
+            if (action.type === "artifactExplorer.close") {
+                controller.closeArtifactExplorer();
+                return;
+            }
+            if (action.type === "help.toggle") {
+                controller.showHelp(action.visible ?? !controller.getViewModel().helpVisible);
+                return;
+            }
+            controller.scrollPane(action.pane, { ...(action.delta !== undefined ? { delta: action.delta } : {}), ...(action.offset !== undefined ? { offset: action.offset } : {}) });
+        }
+        catch (error) {
+            if (acceptedRunConfirmation) {
+                await markArtifactExplorerForCompletedRun("failed");
+            }
+            const message = error.message;
+            controller.appendLog(`Web action failed: ${message}`);
+            sendError(client, message, actionId(action));
+        }
+    }
+    return {
+        mount() {
+            if (mounted) {
+                return;
+            }
+            mounted = true;
+            controller.mount();
+            void restoreArtifactExplorerFromScope(activeScopeKey);
+            unsubscribe = controller.subscribe((event) => {
+                if (event.type === "log") {
+                    server?.broadcast({ type: "log.append", appendedLines: event.appendedLines });
+                    return;
+                }
+                server?.broadcast(snapshot());
+            });
+            void startWebServer({
+                ...(webOptions.noOpen !== undefined ? { noOpen: webOptions.noOpen } : {}),
+                ...(webOptions.host !== undefined ? { host: webOptions.host } : {}),
+                ...(webOptions.auth !== undefined ? { auth: webOptions.auth } : {}),
+                printInfo: (message) => {
+                    webOptions.printInfo?.(message);
+                    controller.appendLog(message);
+                },
+                ...(webOptions.openBrowser ? { openBrowser: webOptions.openBrowser } : {}),
+                getArtifactCatalog: (input) => artifactCatalogProvider(input),
+                onClientAction: (action, client) => {
+                    void dispatch(action, client);
+                },
+                onClientConnected: (client) => {
+                    client.send(snapshot());
+                },
+                onExitRequested: () => {
+                    options.onExit();
+                },
+            }).then((started) => {
+                if (shuttingDown) {
+                    void started.close().catch((error) => {
+                        process.stderr.write(`Failed to close Web UI server: ${error.message}\n`);
+                    });
+                    return;
+                }
+                server = started;
+                webOptions.onServerReady?.(started);
+            }).catch((error) => {
+                const message = `Web UI startup failed: ${error.message}`;
+                controller.appendLog(message);
+                writeSync(process.stderr.fd, `${message}\n`);
+                options.onExit();
+            });
+        },
+        destroy() {
+            if (shuttingDown) {
+                return;
+            }
+            shuttingDown = true;
+            controller.interruptActiveForm("Web UI session closed.");
+            unsubscribe?.();
+            unsubscribe = null;
+            const closePromise = server?.close();
+            server = null;
+            if (closePromise) {
+                void closePromise.catch((error) => {
+                    process.stderr.write(`Failed to close Web UI server: ${error.message}\n`);
+                });
+            }
+            controller.destroy();
+        },
+        requestUserInput: (form) => controller.requestUserInput(form),
+        setSummary: (markdown) => controller.setSummary(markdown),
+        clearSummary: () => controller.clearSummary(),
+        setScope: (scopeKey, jiraIssueKey, gitBranchName) => {
+            activeScopeKey = scopeKey;
+            controller.setScope(scopeKey, jiraIssueKey, gitBranchName);
+            controller.setArtifactExplorerUnavailable();
+            void restoreArtifactExplorerFromScope(scopeKey);
+        },
+        appendLog: (text) => controller.appendLog(text),
+        setFlowFailed: (flowId) => controller.setFlowFailed(flowId),
+        interruptActiveForm: (message = "Flow interrupted by user.") => {
+            controller.interruptActiveForm(message);
+            if (message) {
+                controller.appendLog(new FlowInterruptedError(message).message);
+            }
+        },
+    };
+}

package/dist/interactive/web/protocol.js

@@ -0,0 +1,160 @@
+const ACTION_TYPES = new Set([
+    "flow.select",
+    "folder.toggle",
+    "run.openConfirm",
+    "confirm.select",
+    "confirm.accept",
+    "confirm.cancel",
+    "form.update",
+    "form.fieldUpdate",
+    "form.submit",
+    "form.cancel",
+    "interrupt.openConfirm",
+    "flow.interrupt",
+    "log.clear",
+    "artifactExplorer.open",
+    "artifactExplorer.close",
+    "help.toggle",
+    "scroll",
+]);
+const SCROLL_PANES = new Set(["flows", "progress", "summary", "log", "help"]);
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function optionalActionId(value) {
+    if (value.actionId === undefined) {
+        return undefined;
+    }
+    if (typeof value.actionId !== "string" || value.actionId.trim().length === 0) {
+        throw new Error("actionId must be a non-empty string when provided.");
+    }
+    return value.actionId;
+}
+function requireNonEmptyString(value, fieldName) {
+    const field = value[fieldName];
+    if (typeof field !== "string" || field.trim().length === 0) {
+        throw new Error(`${fieldName} must be a non-empty string.`);
+    }
+    return field;
+}
+function optionalNonEmptyString(value, fieldName) {
+    if (value[fieldName] === undefined) {
+        return undefined;
+    }
+    return requireNonEmptyString(value, fieldName);
+}
+function optionalInteger(value, fieldName) {
+    if (value[fieldName] === undefined) {
+        return undefined;
+    }
+    const field = value[fieldName];
+    if (typeof field !== "number" || !Number.isInteger(field)) {
+        throw new Error(`${fieldName} must be an integer.`);
+    }
+    return field;
+}
+function requireValues(value, fieldName = "values") {
+    const values = value[fieldName];
+    if (!isRecord(values)) {
+        throw new Error(`${fieldName} must be an object.`);
+    }
+    return values;
+}
+export function parseClientAction(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error("Protocol message must be valid JSON.");
+    }
+    if (!isRecord(parsed) || typeof parsed.type !== "string") {
+        throw new Error("Protocol message requires a string type.");
+    }
+    if (!ACTION_TYPES.has(parsed.type)) {
+        throw new Error(`Unknown protocol action: ${parsed.type}`);
+    }
+    const actionId = optionalActionId(parsed);
+    if (parsed.type === "flow.select") {
+        const index = optionalInteger(parsed, "index");
+        const key = optionalNonEmptyString(parsed, "key");
+        if (index === undefined && key === undefined) {
+            throw new Error("flow.select requires index or key.");
+        }
+        return { type: "flow.select", ...(index !== undefined ? { index } : {}), ...(key ? { key } : {}), ...(actionId ? { actionId } : {}) };
+    }
+    if (parsed.type === "folder.toggle") {
+        return { type: "folder.toggle", key: requireNonEmptyString(parsed, "key"), ...(actionId ? { actionId } : {}) };
+    }
+    if (parsed.type === "run.openConfirm") {
+        const flowId = optionalNonEmptyString(parsed, "flowId");
+        const key = optionalNonEmptyString(parsed, "key");
+        return { type: "run.openConfirm", ...(flowId ? { flowId } : {}), ...(key ? { key } : {}), ...(actionId ? { actionId } : {}) };
+    }
+    if (parsed.type === "confirm.select") {
+        return { type: "confirm.select", action: requireNonEmptyString(parsed, "action"), ...(actionId ? { actionId } : {}) };
+    }
+    if (parsed.type === "confirm.accept") {
+        const action = optionalNonEmptyString(parsed, "action");
+        return { type: "confirm.accept", ...(action ? { action } : {}), ...(actionId ? { actionId } : {}) };
+    }
+    if (parsed.type === "confirm.cancel"
+        || parsed.type === "form.cancel"
+        || parsed.type === "log.clear"
+        || parsed.type === "artifactExplorer.open"
+        || parsed.type === "artifactExplorer.close") {
+        return { type: parsed.type, ...(actionId ? { actionId } : {}) };
+    }
+    if (parsed.type === "form.update") {
+        return { type: "form.update", values: requireValues(parsed), ...(actionId ? { actionId } : {}) };
+    }
+    if (parsed.type === "form.fieldUpdate") {
+        const fieldId = requireNonEmptyString(parsed, "fieldId");
+        if (!("value" in parsed)) {
+            throw new Error("value is required.");
+        }
+        const value = parsed.value;
+        if (typeof value !== "string"
+            && typeof value !== "boolean"
+            && (!Array.isArray(value) || value.some((item) => typeof item !== "string"))) {
+            throw new Error("value must be a string, boolean, or string array.");
+        }
+        return { type: "form.fieldUpdate", fieldId, value, ...(actionId ? { actionId } : {}) };
+    }
+    if (parsed.type === "form.submit") {
+        return {
+            type: "form.submit",
+            ...(parsed.values !== undefined ? { values: requireValues(parsed) } : {}),
+            ...(actionId ? { actionId } : {}),
+        };
+    }
+    if (parsed.type === "interrupt.openConfirm") {
+        return { type: "interrupt.openConfirm", ...(actionId ? { actionId } : {}) };
+    }
+    if (parsed.type === "flow.interrupt") {
+        const flowId = optionalNonEmptyString(parsed, "flowId");
+        return { type: "flow.interrupt", ...(flowId ? { flowId } : {}), ...(actionId ? { actionId } : {}) };
+    }
+    if (parsed.type === "help.toggle") {
+        if (parsed.visible !== undefined && typeof parsed.visible !== "boolean") {
+            throw new Error("visible must be a boolean when provided.");
+        }
+        return { type: "help.toggle", ...(parsed.visible !== undefined ? { visible: parsed.visible } : {}), ...(actionId ? { actionId } : {}) };
+    }
+    const pane = requireNonEmptyString(parsed, "pane");
+    if (!SCROLL_PANES.has(pane)) {
+        throw new Error("scroll pane must be one of flows, progress, summary, log, or help.");
+    }
+    const delta = optionalInteger(parsed, "delta");
+    const offset = optionalInteger(parsed, "offset");
+    if (delta === undefined && offset === undefined) {
+        throw new Error("scroll requires delta or offset.");
+    }
+    return {
+        type: "scroll",
+        pane: pane,
+        ...(delta !== undefined ? { delta } : {}),
+        ...(offset !== undefined ? { offset } : {}),
+        ...(actionId ? { actionId } : {}),
+    };
+}