agentweaver 0.1.18 → 0.1.20

package/dist/interactive/web/protocol.js

@@ -12,6 +12,27 @@ const ACTION_TYPES = new Set([
     "interrupt.openConfirm",
     "flow.interrupt",
     "log.clear",
+    "artifactExplorer.open",
+    "artifactExplorer.close",
+    "autoFlow.selectPreset",
+    "autoFlow.loadConfig",
+    "autoFlow.save",
+    "autoFlow.reset",
+    "autoFlow.toggleBlock",
+    "autoFlow.updateParam",
+    "autoFlow.insertBlock",
+    "autoFlow.removeBlock",
+    "git.refresh",
+    "git.createBranch",
+    "git.checkout",
+    "git.fetch",
+    "git.pullFfOnly",
+    "git.stage",
+    "git.unstage",
+    "git.updateCommitMessage",
+    "git.commit",
+    "git.push",
+    "settings.update",
     "help.toggle",
     "scroll",
 ]);
@@ -51,6 +72,62 @@ function optionalInteger(value, fieldName) {
     }
     return field;
 }
+function optionalBoolean(value, fieldName) {
+    if (value[fieldName] === undefined) {
+        return undefined;
+    }
+    const field = value[fieldName];
+    if (typeof field !== "boolean") {
+        throw new Error(`${fieldName} must be a boolean.`);
+    }
+    return field;
+}
+function requireSettingsPatch(value) {
+    const settings = value.settings;
+    if (!isRecord(settings)) {
+        throw new Error("settings must be an object.");
+    }
+    const allowed = new Set(["theme", "autoFlowHeight", "workspaceSplit", "logAutoscroll"]);
+    for (const key of Object.keys(settings)) {
+        if (!allowed.has(key)) {
+            throw new Error(`Unsupported settings key: ${key}`);
+        }
+    }
+    const patch = {};
+    if ("theme" in settings) {
+        const theme = settings.theme;
+        if (theme !== "dark" && theme !== "light") {
+            throw new Error("settings.theme must be light or dark.");
+        }
+        patch.theme = theme;
+    }
+    if ("autoFlowHeight" in settings) {
+        const autoFlowHeight = settings.autoFlowHeight;
+        if (autoFlowHeight !== null
+            && (typeof autoFlowHeight !== "number" || !Number.isFinite(autoFlowHeight))) {
+            throw new Error("settings.autoFlowHeight must be a finite number or null.");
+        }
+        patch.autoFlowHeight = autoFlowHeight;
+    }
+    if ("workspaceSplit" in settings) {
+        const workspaceSplit = settings.workspaceSplit;
+        if (typeof workspaceSplit !== "number" || !Number.isFinite(workspaceSplit)) {
+            throw new Error("settings.workspaceSplit must be a finite number.");
+        }
+        patch.workspaceSplit = workspaceSplit;
+    }
+    if ("logAutoscroll" in settings) {
+        const logAutoscroll = settings.logAutoscroll;
+        if (typeof logAutoscroll !== "boolean") {
+            throw new Error("settings.logAutoscroll must be a boolean.");
+        }
+        patch.logAutoscroll = logAutoscroll;
+    }
+    if (Object.keys(patch).length === 0) {
+        throw new Error("settings.update requires at least one setting.");
+    }
+    return patch;
+}
 function requireValues(value, fieldName = "values") {
     const values = value[fieldName];
     if (!isRecord(values)) {
@@ -58,6 +135,26 @@ function requireValues(value, fieldName = "values") {
     }
     return values;
 }
+function requireStringArray(value, fieldName) {
+    const field = value[fieldName];
+    if (!Array.isArray(field) || field.some((item) => typeof item !== "string" || item.length === 0)) {
+        throw new Error(`${fieldName} must be an array of non-empty strings.`);
+    }
+    return field;
+}
+function optionalStringArray(value, fieldName) {
+    if (value[fieldName] === undefined) {
+        return undefined;
+    }
+    return requireStringArray(value, fieldName);
+}
+function requireCommitMessage(value) {
+    const message = value.message;
+    if (typeof message !== "string" || message.trim().length === 0) {
+        throw new Error("message must be a non-empty string.");
+    }
+    return message;
+}
 export function parseClientAction(raw) {
     let parsed;
     try {
@@ -96,7 +193,15 @@ export function parseClientAction(raw) {
         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") {
+    if (parsed.type === "confirm.cancel"
+        || parsed.type === "form.cancel"
+        || parsed.type === "log.clear"
+        || parsed.type === "artifactExplorer.open"
+        || parsed.type === "artifactExplorer.close"
+        || parsed.type === "git.refresh"
+        || parsed.type === "git.fetch"
+        || parsed.type === "git.pullFfOnly"
+        || parsed.type === "git.push") {
         return { type: parsed.type, ...(actionId ? { actionId } : {}) };
     }
     if (parsed.type === "form.update") {
@@ -129,12 +234,128 @@ export function parseClientAction(raw) {
         const flowId = optionalNonEmptyString(parsed, "flowId");
         return { type: "flow.interrupt", ...(flowId ? { flowId } : {}), ...(actionId ? { actionId } : {}) };
     }
+    if (parsed.type === "autoFlow.selectPreset") {
+        const preset = requireNonEmptyString(parsed, "preset");
+        if (preset !== "simple" && preset !== "standard") {
+            throw new Error("preset must be simple or standard.");
+        }
+        return { type: "autoFlow.selectPreset", preset, ...(actionId ? { actionId } : {}) };
+    }
+    if (parsed.type === "autoFlow.loadConfig") {
+        const flowId = optionalNonEmptyString(parsed, "flowId");
+        return {
+            type: "autoFlow.loadConfig",
+            name: requireNonEmptyString(parsed, "name"),
+            ...(flowId ? { flowId } : {}),
+            ...(actionId ? { actionId } : {}),
+        };
+    }
+    if (parsed.type === "autoFlow.save") {
+        const flowId = optionalNonEmptyString(parsed, "flowId");
+        const name = optionalNonEmptyString(parsed, "name");
+        const location = optionalNonEmptyString(parsed, "location");
+        if (location !== undefined && location !== "project" && location !== "user") {
+            throw new Error("location must be project or user.");
+        }
+        return {
+            type: "autoFlow.save",
+            ...(flowId ? { flowId } : {}),
+            ...(name ? { name } : {}),
+            ...(location ? { location } : {}),
+            ...(actionId ? { actionId } : {}),
+        };
+    }
+    if (parsed.type === "autoFlow.reset") {
+        const flowId = optionalNonEmptyString(parsed, "flowId");
+        return { type: "autoFlow.reset", ...(flowId ? { flowId } : {}), ...(actionId ? { actionId } : {}) };
+    }
+    if (parsed.type === "autoFlow.toggleBlock") {
+        const flowId = optionalNonEmptyString(parsed, "flowId");
+        const slotId = optionalNonEmptyString(parsed, "slotId");
+        const enabled = optionalBoolean(parsed, "enabled");
+        return {
+            type: "autoFlow.toggleBlock",
+            ...(flowId ? { flowId } : {}),
+            ...(slotId ? { slotId } : {}),
+            blockId: requireNonEmptyString(parsed, "blockId"),
+            ...(enabled !== undefined ? { enabled } : {}),
+            ...(actionId ? { actionId } : {}),
+        };
+    }
+    if (parsed.type === "autoFlow.updateParam") {
+        const flowId = optionalNonEmptyString(parsed, "flowId");
+        const slotId = optionalNonEmptyString(parsed, "slotId");
+        return {
+            type: "autoFlow.updateParam",
+            ...(flowId ? { flowId } : {}),
+            ...(slotId ? { slotId } : {}),
+            blockId: requireNonEmptyString(parsed, "blockId"),
+            paramName: requireNonEmptyString(parsed, "paramName"),
+            value: optionalInteger(parsed, "value") ?? (() => {
+                throw new Error("value must be an integer.");
+            })(),
+            ...(actionId ? { actionId } : {}),
+        };
+    }
+    if (parsed.type === "autoFlow.insertBlock") {
+        const flowId = optionalNonEmptyString(parsed, "flowId");
+        return {
+            type: "autoFlow.insertBlock",
+            ...(flowId ? { flowId } : {}),
+            slotId: requireNonEmptyString(parsed, "slotId"),
+            blockId: requireNonEmptyString(parsed, "blockId"),
+            ...(actionId ? { actionId } : {}),
+        };
+    }
+    if (parsed.type === "autoFlow.removeBlock") {
+        const flowId = optionalNonEmptyString(parsed, "flowId");
+        return {
+            type: "autoFlow.removeBlock",
+            ...(flowId ? { flowId } : {}),
+            slotId: requireNonEmptyString(parsed, "slotId"),
+            blockId: requireNonEmptyString(parsed, "blockId"),
+            ...(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 } : {}) };
     }
+    if (parsed.type === "git.createBranch") {
+        if ("selectedBase" in parsed || "base" in parsed || "baseBranch" in parsed) {
+            throw new Error("git.createBranch does not accept a selected base in the MVP.");
+        }
+        return { type: "git.createBranch", branchName: requireNonEmptyString(parsed, "branchName"), ...(actionId ? { actionId } : {}) };
+    }
+    if (parsed.type === "git.checkout") {
+        return { type: "git.checkout", branchName: requireNonEmptyString(parsed, "branchName"), ...(actionId ? { actionId } : {}) };
+    }
+    if (parsed.type === "git.stage") {
+        return { type: "git.stage", paths: requireStringArray(parsed, "paths"), ...(actionId ? { actionId } : {}) };
+    }
+    if (parsed.type === "git.unstage") {
+        return { type: "git.unstage", paths: requireStringArray(parsed, "paths"), ...(actionId ? { actionId } : {}) };
+    }
+    if (parsed.type === "git.updateCommitMessage") {
+        if (typeof parsed.message !== "string") {
+            throw new Error("message must be a string.");
+        }
+        return { type: "git.updateCommitMessage", message: parsed.message, ...(actionId ? { actionId } : {}) };
+    }
+    if (parsed.type === "git.commit") {
+        const paths = optionalStringArray(parsed, "paths");
+        return {
+            type: "git.commit",
+            message: requireCommitMessage(parsed),
+            ...(paths !== undefined ? { paths } : {}),
+            ...(actionId ? { actionId } : {}),
+        };
+    }
+    if (parsed.type === "settings.update") {
+        return { type: "settings.update", settings: requireSettingsPatch(parsed), ...(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.");