agentweaver 0.1.19 → 0.1.20

package/dist/interactive/web/protocol.js

@@ -14,6 +14,25 @@ const ACTION_TYPES = new Set([
     "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",
 ]);
@@ -53,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)) {
@@ -60,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 {
@@ -102,7 +197,11 @@ export function parseClientAction(raw) {
         || parsed.type === "form.cancel"
         || parsed.type === "log.clear"
         || parsed.type === "artifactExplorer.open"
-        || parsed.type === "artifactExplorer.close") {
+        || 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") {
@@ -135,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.");

package/dist/interactive/web/server.js

@@ -7,6 +7,7 @@ import process from "node:process";
 import { fileURLToPath } from "node:url";
 import { parseArtifactReference } from "../../artifact-manifest.js";
 import { scopeArtifactsDir, scopeWorkspaceDir } from "../../artifacts.js";
+import { GitDiffError } from "../../git/git-service.js";
 import { groupArtifactCatalog, inferArtifactRenderKind, inferArtifactRole, inferArtifactTitle, } from "../../runtime/artifact-catalog.js";
 import { createArtifactRegistry } from "../../runtime/artifact-registry.js";
 import { parseClientAction } from "./protocol.js";
@@ -22,6 +23,17 @@ const CONTENT_TYPES = new Map([
 ]);
 const BASIC_AUTH_REALM = "AgentWeaver Web UI";
 const ARTIFACT_API_PREFIX = "/__agentweaver/api/artifacts";
+const GIT_DIFF_API_PATH = "/__agentweaver/api/git/diff";
+const GIT_DIFF_ERROR_STATUSES = {
+    missing_path: 400,
+    invalid_path: 403,
+    invalid_mode: 400,
+    missing_provider: 503,
+    repository_unavailable: 503,
+    forbidden_path: 403,
+    read_failed: 500,
+    git_failed: 500,
+};
 const ARTIFACT_ERROR_STATUSES = {
     invalid_id: 400,
     missing_scope: 400,
@@ -136,6 +148,9 @@ function writeArtifactApiError(response, code, message, artifact) {
         ...(artifact ? { artifact } : {}),
     });
 }
+function writeGitDiffApiError(response, code, message) {
+    writeJson(response, GIT_DIFF_ERROR_STATUSES[code], { code, message });
+}
 function safeArtifactMetadata(item) {
     return {
         id: item.id,
@@ -195,13 +210,9 @@ function parseArtifactApiRoute(requestUrl) {
     }
     return { kind: "content", artifactId: "", action: "preview", scopeKey, runIds };
 }
-function filterCatalog(catalog, scopeKey, runIds) {
-    const runIdSet = new Set(runIds);
-    let items = catalog.items.filter((item) => item.scopeKey === scopeKey && item.kind === "markdown");
-    if (runIdSet.size > 0) {
-        items = items.filter((item) => item.runId !== null && runIdSet.has(item.runId));
-    }
-    const sortedItems = items.slice();
+function filterCatalog(catalog, scopeKey) {
+    const markdownItems = catalog.items.filter((item) => item.scopeKey === scopeKey && item.kind === "markdown");
+    const sortedItems = markdownItems.slice();
     return {
         scopeKey,
         items: sortedItems,
@@ -460,11 +471,8 @@ function handleArtifactApiRequest(request, response, options, auth) {
             writeArtifactApiError(response, "missing_scope", "A scope query parameter is required.");
             return true;
         }
-        const primaryRunId = route.runIds[0];
         void loadArtifactCatalog(options, {
             scopeKey: route.scopeKey,
-            ...(route.runIds.length === 1 && primaryRunId ? { runId: primaryRunId, runIds: route.runIds } : {}),
-            ...(route.runIds.length > 1 ? { runIds: route.runIds } : {}),
         })
             .then((catalog) => {
             if (!catalog) {
@@ -475,7 +483,7 @@ function handleArtifactApiRequest(request, response, options, auth) {
                 writeArtifactApiError(response, "scope_mismatch", "Requested scope does not match the active Web UI scope.");
                 return;
             }
-            writeJson(response, 200, filterCatalog(catalog, route.scopeKey, route.runIds));
+            writeJson(response, 200, filterCatalog(catalog, route.scopeKey));
         })
             .catch(() => {
             writeArtifactApiError(response, "read_failed", "Artifact catalog could not be loaded.");
@@ -486,11 +494,8 @@ function handleArtifactApiRequest(request, response, options, auth) {
         writeArtifactApiError(response, "invalid_id", "Artifact identifier is invalid.");
         return true;
     }
-    const primaryRunId = route.runIds[0];
     void loadArtifactCatalog(options, {
         ...(route.scopeKey ? { scopeKey: route.scopeKey } : {}),
-        ...(route.runIds.length === 1 && primaryRunId ? { runId: primaryRunId, runIds: route.runIds } : {}),
-        ...(route.runIds.length > 1 ? { runIds: route.runIds } : {}),
     })
         .then((catalog) => {
         if (!catalog) {
@@ -521,6 +526,56 @@ function handleArtifactApiRequest(request, response, options, auth) {
     });
     return true;
 }
+function isGitDiffMode(value) {
+    return value === "head" || value === "staged" || value === "worktree";
+}
+function gitDiffErrorCode(error) {
+    if (error instanceof GitDiffError && error.code in GIT_DIFF_ERROR_STATUSES) {
+        return error.code;
+    }
+    return "git_failed";
+}
+function handleGitDiffApiRequest(request, response, options, auth) {
+    const parsed = new URL(request.url ?? "/", "http://agentweaver.local");
+    if (parsed.pathname !== GIT_DIFF_API_PATH) {
+        return false;
+    }
+    if (request.method !== "GET") {
+        return false;
+    }
+    if (!isAuthorized(request, auth)) {
+        writeAuthRequired(response);
+        return true;
+    }
+    if (!options.gitService || !options.getGitWorkspaceSnapshot) {
+        writeGitDiffApiError(response, "missing_provider", "Git diff provider is not configured.");
+        return true;
+    }
+    const filePath = parsed.searchParams.get("path");
+    const mode = parsed.searchParams.get("mode");
+    if (!filePath) {
+        writeGitDiffApiError(response, "missing_path", "A path query parameter is required.");
+        return true;
+    }
+    if (!isGitDiffMode(mode)) {
+        writeGitDiffApiError(response, "invalid_mode", "Mode must be head, staged, or worktree.");
+        return true;
+    }
+    const snapshot = options.getGitWorkspaceSnapshot();
+    if (!snapshot || !snapshot.available || !snapshot.repositoryRoot) {
+        writeGitDiffApiError(response, "repository_unavailable", snapshot?.error ?? "Git repository is not available.");
+        return true;
+    }
+    void options.gitService.diffFile(filePath, mode, snapshot)
+        .then((diff) => {
+        writeJson(response, 200, diff);
+    })
+        .catch((error) => {
+        const code = gitDiffErrorCode(error);
+        writeGitDiffApiError(response, code, error.message || "Git diff request failed.");
+    });
+    return true;
+}
 function htmlShell() {
     return `<!doctype html>
 <html lang="en">
@@ -843,6 +898,9 @@ export async function startWebServer(options) {
             writeJson(response, 200, { ok: true });
             return;
         }
+        if (handleGitDiffApiRequest(request, response, options, auth)) {
+            return;
+        }
         if (handleArtifactApiRequest(request, response, options, auth)) {
             return;
         }