@walkeros/mcp 3.4.1-next-1776790594143 → 3.4.2

package/dist/index.js

@@ -156,7 +156,7 @@ function registerFlowBundleTool(server2) {
       inputSchema: {
         ...schemas2.BundleInputShape,
         remote: z2.boolean().optional().describe(
-          "Use remote cloud bundling (requires WALKEROS_TOKEN). Default: false (local)"
+          "Use remote cloud bundling (requires authentication). Default: false (local)"
         ),
         content: z2.record(z2.string(), z2.unknown()).optional().describe("Flow.Config JSON content (required when remote: true)")
       },
@@ -182,7 +182,7 @@ function registerFlowBundleTool(server2) {
             {
               next: [
                 "Use flow_simulate to test",
-                "Use api({ action: 'deploy' }) to publish"
+                'Use deploy_manage with action "deploy" to publish'
               ]
             }
           );
@@ -209,7 +209,7 @@ function registerFlowBundleTool(server2) {
           {
             next: [
               "Use flow_simulate to test",
-              "Use api({ action: 'deploy' }) to publish"
+              'Use deploy_manage with action "deploy" to publish'
             ]
           }
         );
@@ -863,7 +863,11 @@ function registerFlowLoadTool(server2) {
 
 // src/tools/feedback.ts
 import { z as z8 } from "zod";
-import { feedback, readConfig, writeConfig } from "@walkeros/cli";
+import {
+  feedback,
+  getFeedbackPreference,
+  setFeedbackPreference
+} from "@walkeros/cli";
 import { mcpResult as mcpResult8, mcpError as mcpError8 } from "@walkeros/core";
 function registerFeedbackTool(server2) {
   server2.registerTool(
@@ -887,8 +891,7 @@ function registerFeedbackTool(server2) {
     async (params) => {
       try {
         const { text, anonymous: explicitAnonymous } = params;
-        const config = readConfig();
-        let anonymous = config?.anonymousFeedback;
+        let anonymous = getFeedbackPreference();
         if (anonymous === void 0 && explicitAnonymous === void 0) {
           return mcpResult8(
             { needsConsent: true },
@@ -902,11 +905,10 @@ function registerFeedbackTool(server2) {
         }
         if (anonymous === void 0 && explicitAnonymous !== void 0) {
           anonymous = explicitAnonymous;
-          const base = config ?? { token: "", email: "", appUrl: "" };
-          writeConfig({ ...base, anonymousFeedback: anonymous });
+          setFeedbackPreference(anonymous);
         }
         const isAnonymous = explicitAnonymous ?? anonymous ?? true;
-        await feedback(text, { anonymous: isAnonymous, version: "3.4.1-next-1776790594143" });
+        await feedback(text, { anonymous: isAnonymous, version: "3.4.2" });
         return mcpResult8({ ok: true });
       } catch (error) {
         return mcpError8(error);
@@ -915,102 +917,332 @@ function registerFeedbackTool(server2) {
   );
 }
 
-// src/tools/api.ts
+// src/tools/auth.ts
+import { z as z9 } from "zod";
+import {
+  resolveToken,
+  deleteConfig,
+  requestDeviceCode,
+  pollForToken,
+  whoami
+} from "@walkeros/cli";
+import { mcpResult as mcpResult9, mcpError as mcpError9 } from "@walkeros/core";
+function registerAuthTool(server2) {
+  server2.registerTool(
+    "auth",
+    {
+      title: "Authentication",
+      description: "Manage walkerOS authentication. Check login status, log in via device code flow, or log out. No terminal or browser required \u2014 the MCP client handles the authorization URL.",
+      inputSchema: {
+        action: z9.enum(["status", "login", "logout"]).describe("Authentication action to perform"),
+        deviceCode: z9.string().optional().describe(
+          "Device code from a previous pending login attempt. Provide to resume polling without requesting a new code."
+        )
+      },
+      // No outputSchema: action-dispatched tool — each action returns a different shape
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: true
+      }
+    },
+    async ({ action, deviceCode }) => {
+      try {
+        switch (action) {
+          case "status": {
+            const resolved = resolveToken();
+            if (!resolved) {
+              return mcpResult9(
+                { authenticated: false },
+                { next: ['Use auth with action "login" to authenticate'] }
+              );
+            }
+            const user = await whoami();
+            return mcpResult9({ authenticated: true, ...user });
+          }
+          case "login": {
+            if (deviceCode) {
+              const pollResult = await pollForToken(deviceCode, {
+                timeoutMs: 6e4
+              });
+              if (pollResult.success) {
+                return mcpResult9(
+                  { authenticated: true, email: pollResult.email },
+                  {
+                    next: [
+                      'Use project_manage with action "list" to see your projects'
+                    ]
+                  }
+                );
+              }
+              if (pollResult.status === "pending") {
+                return mcpResult9({
+                  authenticated: false,
+                  status: "pending",
+                  message: "Still waiting for authorization. Try again shortly.",
+                  deviceCode
+                });
+              }
+              return mcpError9(
+                new Error(pollResult.error || "Authorization failed")
+              );
+            }
+            const code = await requestDeviceCode();
+            const loginUrl = code.verificationUriComplete || code.verificationUri;
+            return mcpResult9({
+              authenticated: false,
+              status: "awaiting_authorization",
+              loginUrl,
+              message: `Open this link to authorize: ${loginUrl}`,
+              deviceCode: code.deviceCode
+            });
+          }
+          case "logout": {
+            const deleted = deleteConfig();
+            const hadEnvToken = typeof process.env.WALKEROS_TOKEN === "string" && process.env.WALKEROS_TOKEN.length > 0;
+            delete process.env.WALKEROS_TOKEN;
+            let message;
+            if (deleted && hadEnvToken) {
+              message = "Logged out. Config removed and WALKEROS_TOKEN cleared from process environment.";
+            } else if (deleted) {
+              message = "Logged out and config removed.";
+            } else if (hadEnvToken) {
+              message = "No config found. WALKEROS_TOKEN cleared from process environment.";
+            } else {
+              message = "No config found \u2014 already logged out.";
+            }
+            return mcpResult9({
+              loggedOut: true,
+              message
+            });
+          }
+          default:
+            throw new Error(
+              `Unknown action: ${action}. Use one of: status, login, logout`
+            );
+        }
+      } catch (error) {
+        return mcpError9(error);
+      }
+    }
+  );
+}
+
+// src/tools/project-manage.ts
 import { z as z10 } from "zod";
 import {
-  whoami,
   listProjects,
   getProject,
   createProject,
   updateProject,
   deleteProject,
+  setDefaultProject
+} from "@walkeros/cli";
+import { mcpResult as mcpResult10, mcpError as mcpError10 } from "@walkeros/core";
+
+// src/types.ts
+function isAuthError(error) {
+  if (!(error instanceof Error)) return false;
+  const msg = error.message.toLowerCase();
+  if (msg.includes("unauthorized") || msg.includes("forbidden") || msg.includes("invalid token") || msg.includes("token expired") || msg.includes("not authenticated")) {
+    return true;
+  }
+  const code = error.code;
+  if (!code) return false;
+  const upperCode = code.toUpperCase();
+  return upperCode === "UNAUTHORIZED" || upperCode === "FORBIDDEN" || upperCode === "401" || upperCode === "403" || upperCode.startsWith("AUTH_");
+}
+var AUTH_HINT = 'Are you logged in? Use auth(action: "status") to check.';
+
+// src/tools/project-manage.ts
+function registerProjectManageTool(server2) {
+  server2.registerTool(
+    "project_manage",
+    {
+      title: "Project Management",
+      description: "Manage walkerOS projects. List, create, update, delete projects, or set a default project for CLI operations.",
+      inputSchema: {
+        action: z10.enum(["list", "get", "create", "update", "delete", "set_default"]).describe("Project management action to perform"),
+        projectId: z10.string().optional().describe(
+          "Project ID. Required for get, update, delete, and set_default actions."
+        ),
+        name: z10.string().optional().describe(
+          "Project name. Required for create. Optional for update (to rename)."
+        )
+      },
+      // No outputSchema: action-dispatched tool — each action returns a different shape
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: true
+      }
+    },
+    async ({ action, projectId, name }) => {
+      try {
+        switch (action) {
+          case "list": {
+            const projects = await listProjects();
+            const items = Array.isArray(projects) ? projects : projects?.projects || [];
+            if (items.length === 0) {
+              return mcpResult10(
+                { projects: [] },
+                {
+                  next: [
+                    'Use project_manage with action "create" to create your first project',
+                    'Use project_manage with action "set_default" after creating to set it as default'
+                  ]
+                }
+              );
+            }
+            return mcpResult10(projects);
+          }
+          case "get": {
+            if (!projectId) {
+              return mcpError10(
+                new Error(
+                  'projectId is required for get action. Use action "list" to see available projects.'
+                )
+              );
+            }
+            const project = await getProject({ projectId });
+            return mcpResult10(project);
+          }
+          case "create": {
+            if (!name) {
+              return mcpError10(new Error("name is required for create action."));
+            }
+            const created = await createProject({ name });
+            return mcpResult10(created, {
+              next: [
+                'Use project_manage with action "set_default" to make this your active project'
+              ]
+            });
+          }
+          case "update": {
+            if (!projectId) {
+              return mcpError10(
+                new Error(
+                  'projectId is required for update action. Use action "list" to see available projects.'
+                )
+              );
+            }
+            if (!name) {
+              return mcpError10(new Error("name is required for update action."));
+            }
+            const updated = await updateProject({ projectId, name });
+            return mcpResult10(updated);
+          }
+          case "delete": {
+            if (!projectId) {
+              return mcpError10(
+                new Error(
+                  'projectId is required for delete action. Use action "list" to see available projects.'
+                )
+              );
+            }
+            const deleted = await deleteProject({ projectId });
+            return mcpResult10(deleted);
+          }
+          case "set_default": {
+            if (!projectId) {
+              return mcpError10(
+                new Error(
+                  'projectId is required for set_default action. Use action "list" to see available projects.'
+                )
+              );
+            }
+            setDefaultProject(projectId);
+            return mcpResult10(
+              { defaultProjectId: projectId },
+              {
+                next: [
+                  'Use flow_manage with action "list" to see flows in this project'
+                ]
+              }
+            );
+          }
+          default:
+            throw new Error(
+              `Unknown action: ${action}. Use one of: list, get, create, update, delete, set_default`
+            );
+        }
+      } catch (error) {
+        return mcpError10(error, isAuthError(error) ? AUTH_HINT : void 0);
+      }
+    }
+  );
+}
+
+// src/tools/flow-manage.ts
+import { z as z11 } from "zod";
+import {
+  listAllFlows,
   listFlows,
   getFlow,
   createFlow,
   updateFlow,
   deleteFlow,
   duplicateFlow,
-  deploy,
-  getDeployment,
-  listDeployments,
-  getDeploymentBySlug,
-  createDeployment as createDep,
-  deleteDeployment as deleteDep,
-  listPreviews as listPreviewsApi,
-  getPreview as getPreviewApi,
-  createPreview as createPreviewApi,
-  deletePreview as deletePreviewApi
+  listPreviews,
+  getPreview,
+  createPreview,
+  deletePreview
 } from "@walkeros/cli";
-import { mcpResult as mcpResult9, mcpError as mcpError9 } from "@walkeros/core";
-
-// src/schemas/api-output.ts
-import { z as z9 } from "zod";
-var ApiOutputShape = {
-  action: z9.string().describe("Action that was executed"),
-  ok: z9.boolean().describe("Whether the action succeeded"),
-  data: z9.unknown().describe("Action-specific result data")
-};
-
-// src/tools/api.ts
-var ACTIONS = [
-  "whoami",
-  "project.list",
-  "project.get",
-  "project.create",
-  "project.update",
-  "project.delete",
-  "flow.list",
-  "flow.get",
-  "flow.create",
-  "flow.update",
-  "flow.delete",
-  "flow.duplicate",
-  "deploy",
-  "deployment.get",
-  "deployment.list",
-  "deployment.create",
-  "deployment.delete",
-  "preview.list",
-  "preview.get",
-  "preview.create",
-  "preview.delete"
-];
-function registerApiTool(server2) {
+import { mcpResult as mcpResult11, mcpError as mcpError11 } from "@walkeros/core";
+function registerFlowManageTool(server2) {
   server2.registerTool(
-    "api",
+    "flow_manage",
     {
-      title: "walkerOS Cloud API",
-      description: "Manage walkerOS cloud projects, flows, and deployments. Requires WALKEROS_TOKEN env var.\n\nActions:\n- whoami \u2014 verify token, get user info\n- project.list/get/create/update/delete \u2014 manage projects\n- flow.list/get/create/update/delete/duplicate \u2014 manage flow configs\n- deploy \u2014 deploy a flow (auto-detects web/server)\n- deployment.get/list/create/delete \u2014 manage deployments\n- preview.list/get/create/delete \u2014 manage preview bundles for testing flow changes on live sites\n\nParameters vary by action. content = Flow.Config JSON for flow.create/update.\n\nFor preview.create:\n- Ask the user for their site URL BEFORE creating (pass as siteUrl).\n- After creation, tell the user to open the returned activationUrl to activate preview mode.\n- Tell them to open the returned deactivationUrl to exit preview mode.\n- The activation URL is first-party on THEIR site (not walkeros.io); the preview only affects their domain.\n- Show the URLs verbatim; do not paraphrase them.\n",
+      title: "Flow Management",
+      description: "Manage walkerOS flows and their previews. List/get/create/update/delete/duplicate flows, or create/inspect/delete preview bundles for testing flow changes on live sites.",
       inputSchema: {
-        action: z10.enum(ACTIONS).describe("API action to perform"),
-        projectId: z10.string().optional().describe(
-          "Project ID (proj_...). Required for: project.get/update/delete, flow.create, flow.list. Falls back to WALKEROS_PROJECT_ID env var."
+        action: z11.enum([
+          "list",
+          "get",
+          "create",
+          "update",
+          "delete",
+          "duplicate",
+          "preview_list",
+          "preview_get",
+          "preview_create",
+          "preview_delete"
+        ]).describe("Flow management action to perform"),
+        flowId: z11.string().optional().describe(
+          "Flow ID (flow_...) or config ID (cfg_...). Required for get, update, delete, duplicate."
+        ),
+        projectId: z11.string().optional().describe(
+          "Project ID. Optional filter for list (omit to list all projects). Required for create if no default project set."
         ),
-        flowId: z10.string().optional().describe(
-          "Flow ID (flow_...) or config ID (cfg_...). Required for: flow.get, flow.update, flow.delete, flow.duplicate, deploy. For deployment.get/delete: can be a deployment slug."
+        name: z11.string().optional().describe(
+          "Flow name. Required for create. Optional for update (to rename) and duplicate."
         ),
-        name: z10.string().optional().describe("Name for create/update operations"),
-        content: z10.record(z10.string(), z10.unknown()).optional().describe("Flow.Config JSON for flow operations"),
-        patch: z10.boolean().optional().describe("Use merge-patch for flow.update (default: true)"),
-        wait: z10.boolean().optional().describe("Wait for deploy to complete (default: true)"),
-        flowName: z10.string().optional().describe("Flow name for multi-settings flows"),
-        fields: z10.array(z10.string()).optional().describe("Dot-path field selectors for flow.get"),
-        type: z10.enum(["web", "server"]).optional().describe("Deployment type for deployment.create"),
-        sort: z10.string().optional().describe("Sort field for list operations"),
-        order: z10.enum(["asc", "desc"]).optional().describe("Sort order"),
-        status: z10.string().optional().describe("Status filter for deployment.list"),
-        includeDeleted: z10.boolean().optional().describe("Include deleted items in lists"),
-        previewId: z10.string().optional().describe(
-          "Preview ID (e.g., prv_abc123). Required for preview.get/delete."
+        content: z11.record(z11.string(), z11.unknown()).optional().describe("Flow.Config JSON content. Used for create and update."),
+        patch: z11.boolean().optional().describe(
+          "Merge-patch for update (default true). When true, only provided fields are updated."
         ),
-        flowSettingsId: z10.string().optional().describe(
-          "Flow settings ID. Used by preview.create as an alternative to flowName."
+        fields: z11.array(z11.string()).optional().describe(
+          "Dot-path selectors for get to return only specific fields."
         ),
-        siteUrl: z10.string().optional().describe(
-          "Optional site URL for preview.create. When provided, the response includes a full activationUrl the user can click to activate preview mode on their site."
+        sort: z11.enum(["name", "updated_at", "created_at"]).optional().describe("Sort field for list."),
+        order: z11.enum(["asc", "desc"]).optional().describe("Sort order for list."),
+        includeDeleted: z11.boolean().optional().describe("Include soft-deleted flows in list results."),
+        previewId: z11.string().optional().describe(
+          "Preview ID (prv_...). Required for preview_get and preview_delete."
+        ),
+        flowName: z11.string().optional().describe(
+          "Flow settings name. Used by preview_create as an alternative to flowSettingsId."
+        ),
+        flowSettingsId: z11.string().optional().describe(
+          "Flow settings ID. Used by preview_create as an alternative to flowName."
+        ),
+        siteUrl: z11.string().optional().describe(
+          "Optional site URL for preview_create. When provided, the response includes full activationUrl and deactivationUrl the user can click."
         )
       },
-      outputSchema: ApiOutputShape,
+      // No outputSchema: action-dispatched tool — each action returns a different shape
       annotations: {
         readOnlyHint: false,
         destructiveHint: true,
@@ -1018,249 +1250,152 @@ function registerApiTool(server2) {
         openWorldHint: true
       }
     },
-    async (params, extra) => {
-      const {
-        action,
-        projectId,
-        flowId,
-        name,
-        content,
-        patch,
-        wait,
-        flowName,
-        fields,
-        type,
-        sort,
-        order,
-        status,
-        includeDeleted,
-        previewId,
-        flowSettingsId,
-        siteUrl
-      } = params;
+    async ({
+      action,
+      flowId,
+      projectId,
+      name,
+      content,
+      patch,
+      fields,
+      sort,
+      order,
+      includeDeleted,
+      previewId,
+      flowName,
+      flowSettingsId,
+      siteUrl
+    }) => {
       try {
-        let data;
         switch (action) {
-          // Auth
-          case "whoami": {
-            data = await whoami();
-            break;
-          }
-          // Projects
-          case "project.list": {
-            data = await listProjects();
-            break;
-          }
-          case "project.get": {
-            data = await getProject({ projectId });
-            break;
-          }
-          case "project.create": {
-            if (!name) throw new Error("name required for project.create");
-            data = await createProject({ name });
-            break;
-          }
-          case "project.update": {
-            if (!name) throw new Error("name required for project.update");
-            data = await updateProject({ projectId, name });
-            break;
-          }
-          case "project.delete": {
-            data = await deleteProject({ projectId });
-            break;
+          case "list": {
+            if (projectId) {
+              const data2 = await listFlows({
+                projectId,
+                sort,
+                order,
+                includeDeleted
+              });
+              return mcpResult11(data2);
+            }
+            const data = await listAllFlows({ sort, order, includeDeleted });
+            return mcpResult11(
+              { projects: data },
+              {
+                next: [
+                  'Use flow_manage with action "get" and a flowId to inspect a specific flow',
+                  "Use flow_load to open a flow for editing"
+                ]
+              }
+            );
           }
-          // Flows
-          case "flow.list": {
-            data = await listFlows({
-              projectId,
-              sort,
-              order,
-              includeDeleted
+          case "get": {
+            if (!flowId) {
+              return mcpError11(
+                new Error(
+                  'flowId is required for get action. Use action "list" to see available flows.'
+                )
+              );
+            }
+            const flow = await getFlow({ flowId, projectId, fields });
+            return mcpResult11(flow, {
+              next: [
+                "Use flow_load to open this flow for editing and validation"
+              ]
             });
-            break;
           }
-          case "flow.get": {
-            if (!flowId) throw new Error("flowId required for flow.get");
-            data = await getFlow({ flowId, projectId, fields });
-            break;
-          }
-          case "flow.create": {
-            if (!name) throw new Error("name required for flow.create");
-            if (!content) throw new Error("content required for flow.create");
-            data = await createFlow({ name, content, projectId });
-            break;
+          case "create": {
+            if (!name) {
+              return mcpError11(new Error("name is required for create action."));
+            }
+            const created = await createFlow({
+              name,
+              content: content ?? {},
+              projectId
+            });
+            return mcpResult11(created, {
+              next: [
+                "Use flow_load to open this flow for editing and validation"
+              ]
+            });
           }
-          case "flow.update": {
-            if (!flowId) throw new Error("flowId required for flow.update");
-            data = await updateFlow({
+          case "update": {
+            if (!flowId) {
+              return mcpError11(
+                new Error(
+                  'flowId is required for update action. Use action "list" to see available flows.'
+                )
+              );
+            }
+            const updated = await updateFlow({
               flowId,
+              projectId,
               name,
               content,
-              projectId,
               mergePatch: patch ?? true
             });
-            break;
+            return mcpResult11(updated);
           }
-          case "flow.delete": {
-            if (!flowId) throw new Error("flowId required for flow.delete");
-            data = await deleteFlow({ flowId, projectId });
-            break;
-          }
-          case "flow.duplicate": {
-            if (!flowId) throw new Error("flowId required for flow.duplicate");
-            data = await duplicateFlow({ flowId, name, projectId });
-            break;
-          }
-          // Deploy
-          case "deploy": {
-            if (!flowId) throw new Error("flowId required for deploy");
-            const progressToken = extra._meta?.progressToken;
-            const DEPLOY_TIMEOUT_MS = 9e4;
-            const timeoutSignal = AbortSignal.timeout(DEPLOY_TIMEOUT_MS);
-            const combinedAbort = new AbortController();
-            const onAbort = () => combinedAbort.abort();
-            timeoutSignal.addEventListener("abort", onAbort);
-            extra.signal?.addEventListener("abort", onAbort);
-            data = await deploy({
-              flowId,
-              projectId,
-              wait: wait ?? true,
-              flowName,
-              timeout: DEPLOY_TIMEOUT_MS,
-              onStatus: (s, sub) => {
-                if (!progressToken) return;
-                const key = sub ? `${s}:${sub}` : s;
-                const stages = {
-                  "bundling:building": {
-                    progress: 20,
-                    label: "Building bundle..."
-                  },
-                  "deploying:publishing": {
-                    progress: 60,
-                    label: "Publishing to CDN..."
-                  },
-                  "deploying:provisioning": {
-                    progress: 60,
-                    label: "Provisioning container..."
-                  },
-                  "deploying:starting": {
-                    progress: 80,
-                    label: "Starting container..."
-                  },
-                  published: { progress: 100, label: "Published" },
-                  active: { progress: 100, label: "Active" },
-                  failed: { progress: 100, label: "Failed" }
-                };
-                const stage = stages[key] ?? stages[s] ?? { progress: 10, label: key };
-                extra.sendNotification({
-                  method: "notifications/progress",
-                  params: {
-                    progressToken,
-                    progress: stage.progress,
-                    total: 100,
-                    message: stage.label
-                  }
-                });
-              },
-              signal: combinedAbort.signal
-            });
-            timeoutSignal.removeEventListener("abort", onAbort);
-            extra.signal?.removeEventListener("abort", onAbort);
-            const st = data.status;
-            const deployData = data;
-            if (st === "failed") {
-              return mcpResult9(
-                { action, ok: false, data },
-                {
-                  next: ["Run flow_validate to check your configuration"]
-                }
+          case "delete": {
+            if (!flowId) {
+              return mcpError11(
+                new Error(
+                  'flowId is required for delete action. Use action "list" to see available flows.'
+                )
               );
-            } else {
-              const publicUrl = deployData.publicUrl;
-              const containerUrl = deployData.containerUrl;
-              const deployType = deployData.type;
-              const nextHints = [];
-              if (deployType === "web" && publicUrl) {
-                nextHints.push(`Bundle at ${publicUrl}`);
-                nextHints.push(`Add <script src='${publicUrl}'></script>`);
-              } else if (deployType === "server" && containerUrl) {
-                nextHints.push(`Container at ${containerUrl}`);
-                nextHints.push(`Test: curl ${containerUrl}/health`);
-              }
-              if (nextHints.length > 0) {
-                return mcpResult9(
-                  { action, ok: true, data },
-                  {
-                    next: nextHints
-                  }
-                );
-              }
             }
-            break;
+            const deleted = await deleteFlow({ flowId, projectId });
+            return mcpResult11(deleted);
           }
-          // Deployments
-          case "deployment.get": {
-            if (!flowId)
-              throw new Error(
-                "flowId (flowId or slug) required for deployment.get"
+          case "duplicate": {
+            if (!flowId) {
+              return mcpError11(
+                new Error(
+                  'flowId is required for duplicate action. Use action "list" to see available flows.'
+                )
               );
-            try {
-              data = await getDeployment({ flowId, flowName });
-            } catch {
-              data = await getDeploymentBySlug({ slug: flowId });
             }
-            break;
-          }
-          case "deployment.list": {
-            data = await listDeployments({
-              projectId,
-              type,
-              status
+            const duplicated = await duplicateFlow({
+              flowId,
+              name,
+              projectId
             });
-            break;
+            return mcpResult11(duplicated);
           }
-          case "deployment.create": {
-            if (!type)
-              throw new Error(
-                "type (web/server) required for deployment.create"
+          case "preview_list": {
+            if (!flowId) {
+              return mcpError11(
+                new Error(
+                  'flowId is required for preview_list. Use action "list" to see available flows.'
+                )
               );
-            data = await createDep({ type, label: name, projectId });
-            break;
-          }
-          case "deployment.delete": {
-            if (!flowId)
-              throw new Error("flowId (slug) required for deployment.delete");
-            data = await deleteDep({ slug: flowId });
-            break;
-          }
-          // Previews
-          case "preview.list": {
-            if (!flowId) throw new Error("flowId required for preview.list");
-            data = await listPreviewsApi({ projectId, flowId });
-            break;
+            }
+            const data = await listPreviews({ projectId, flowId });
+            return mcpResult11(data);
           }
-          case "preview.get": {
+          case "preview_get": {
             if (!flowId || !previewId) {
-              throw new Error("flowId and previewId required for preview.get");
+              return mcpError11(
+                new Error("flowId and previewId are required for preview_get.")
+              );
             }
-            data = await getPreviewApi({ projectId, flowId, previewId });
-            break;
+            const data = await getPreview({ projectId, flowId, previewId });
+            return mcpResult11(data);
           }
-          case "preview.create": {
-            if (!flowId) throw new Error("flowId required for preview.create");
-            if (!flowName && !flowSettingsId) {
-              throw new Error(
-                "flowName or flowSettingsId required for preview.create"
+          case "preview_create": {
+            if (!flowId) {
+              return mcpError11(
+                new Error("flowId is required for preview_create.")
               );
             }
-            if (siteUrl) {
-              try {
-                new URL(siteUrl);
-              } catch {
-                throw new Error(`Invalid siteUrl: ${siteUrl}`);
-              }
+            if (!flowName && !flowSettingsId) {
+              return mcpError11(
+                new Error(
+                  "flowName or flowSettingsId is required for preview_create."
+                )
+              );
             }
-            const preview = await createPreviewApi({
+            const preview = await createPreview({
               projectId,
               flowId,
               flowName,
@@ -1281,52 +1416,155 @@ function registerApiTool(server2) {
             } else {
               delete enriched.activationUrl;
             }
-            data = enriched;
-            break;
+            return mcpResult11(enriched, {
+              next: siteUrl ? [
+                "Open activationUrl to activate preview mode; open deactivationUrl to exit."
+              ] : [
+                "Append activationParam to any URL on your site to activate preview mode."
+              ]
+            });
           }
-          case "preview.delete": {
+          case "preview_delete": {
             if (!flowId || !previewId) {
-              throw new Error(
-                "flowId and previewId required for preview.delete"
+              return mcpError11(
+                new Error(
+                  "flowId and previewId are required for preview_delete."
+                )
               );
             }
-            data = await deletePreviewApi({ projectId, flowId, previewId });
-            break;
+            const data = await deletePreview({
+              projectId,
+              flowId,
+              previewId
+            });
+            return mcpResult11(data);
           }
           default:
             throw new Error(
-              `Unknown action: ${action}. Use one of: ${ACTIONS.join(", ")}`
+              `Unknown action: ${action}. Use one of: list, get, create, update, delete, duplicate, preview_list, preview_get, preview_create, preview_delete`
             );
         }
-        return mcpResult9({ action, ok: true, data });
       } catch (error) {
-        const msg = error instanceof Error ? error.message : "";
-        const name2 = error instanceof Error ? error.name : "";
-        if (action === "deploy" && (name2 === "AbortError" || name2 === "TimeoutError" || msg.includes("abort"))) {
-          return mcpResult9(
-            {
-              action,
-              ok: true,
-              data: { status: "deploying", flowId }
-            },
-            {
+        return mcpError11(error, isAuthError(error) ? AUTH_HINT : void 0);
+      }
+    }
+  );
+}
+
+// src/tools/deploy-manage.ts
+import { z as z12 } from "zod";
+import {
+  deploy as deployFlow,
+  listDeployments,
+  getDeployment,
+  getDeploymentBySlug,
+  deleteDeployment
+} from "@walkeros/cli";
+import { mcpResult as mcpResult12, mcpError as mcpError12 } from "@walkeros/core";
+function registerDeployTool(server2) {
+  server2.registerTool(
+    "deploy_manage",
+    {
+      title: "Deploy Management",
+      description: 'Deploy walkerOS flows and manage deployments. Deploy a flow, list deployments, get deployment details, or delete deployments. Note: the "get" and "delete" actions accept a deployment slug (e.g. "dep_..."), not a flow ID. If you only have a flowId, resolve the latest deployment slug first via flow_manage with action "get".',
+      inputSchema: {
+        action: z12.enum(["deploy", "list", "get", "delete"]).describe("Deployment action to perform"),
+        flowId: z12.string().optional().describe("Flow ID. Required for deploy action."),
+        id: z12.string().optional().describe(
+          'Deployment slug (e.g. "dep_..."). Required for get and delete actions. This is the deployment slug, not a flow ID \u2014 if you only have a flowId, use flow_manage action "get" to resolve the latest deployment slug.'
+        ),
+        projectId: z12.string().optional().describe("Project ID. Optional filter for list."),
+        type: z12.enum(["web", "server"]).optional().describe("Deployment type filter for list."),
+        status: z12.string().optional().describe("Status filter for list."),
+        wait: z12.boolean().optional().describe(
+          "Wait for deploy to complete (default true). Only used with deploy action."
+        ),
+        flowName: z12.string().optional().describe(
+          "Flow name for multi-settings flows. Only used with deploy action."
+        )
+      },
+      // No outputSchema: action-dispatched tool — each action returns a different shape
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: true
+      }
+    },
+    async ({ action, flowId, id, projectId, type, status, wait, flowName }) => {
+      try {
+        switch (action) {
+          case "deploy": {
+            if (!flowId) {
+              return mcpError12(
+                new Error(
+                  'flowId is required for deploy action. Use flow_manage with action "list" to see available flows.'
+                )
+              );
+            }
+            const result = await deployFlow({
+              flowId,
+              wait: wait ?? true,
+              flowName
+            });
+            return mcpResult12(result, {
               next: [
-                'Use api(action: "deployment.list") to check current status'
+                'Use deploy_manage with action "get" to check deployment status'
               ]
+            });
+          }
+          case "list": {
+            const data = await listDeployments({ projectId, type, status });
+            return mcpResult12(data);
+          }
+          case "get": {
+            if (!id) {
+              return mcpError12(
+                new Error(
+                  'id is required for get action. Use deploy_manage with action "list" to see available deployments.'
+                )
+              );
             }
-          );
+            try {
+              const data = await getDeploymentBySlug({ slug: id, projectId });
+              return mcpResult12(data);
+            } catch {
+              const data = await getDeployment({ flowId: id, projectId });
+              return mcpResult12(data);
+            }
+          }
+          case "delete": {
+            if (!id) {
+              return mcpError12(
+                new Error(
+                  'id is required for delete action. Use deploy_manage with action "list" to see available deployments.'
+                )
+              );
+            }
+            try {
+              const data = await deleteDeployment({ slug: id, projectId });
+              return mcpResult12({ deleted: true, ...data });
+            } catch (error) {
+              if (isAuthError(error)) {
+                return mcpError12(error, AUTH_HINT);
+              }
+              const message = error instanceof Error ? error.message : String(error);
+              if (/not[\s_-]?found|404/i.test(message)) {
+                return mcpError12(
+                  error,
+                  'Deployment not found. The "delete" action expects a deployment slug (e.g. "dep_..."), not a flow ID. If you only have a flowId, use flow_manage with action "get" to resolve the latest deployment slug first.'
+                );
+              }
+              return mcpError12(error);
+            }
+          }
+          default:
+            throw new Error(
+              `Unknown action: ${action}. Use one of: deploy, list, get, delete`
+            );
         }
-        if (msg.includes("401") || msg.includes("403") || msg.includes("Unauthorized"))
-          return mcpError9(
-            error,
-            "Set WALKEROS_TOKEN env var or check token expiry"
-          );
-        if (msg.includes("required"))
-          return mcpError9(
-            error,
-            `See api tool description for ${action} parameters.`
-          );
-        return mcpError9(error);
+      } catch (error) {
+        return mcpError12(error, isAuthError(error) ? AUTH_HINT : void 0);
       }
     }
   );
@@ -1554,8 +1792,8 @@ function registerReferenceResources(server2) {
     }
   );
   server2.resource(
-    "api",
-    "walkeros://reference/api",
+    "openapi",
+    "walkeros://reference/openapi",
     {
       description: "walkerOS cloud API \u2014 OpenAPI 3.1 specification",
       mimeType: "application/json"
@@ -1574,7 +1812,7 @@ function registerReferenceResources(server2) {
       return {
         contents: [
           {
-            uri: "walkeros://reference/api",
+            uri: "walkeros://reference/openapi",
             text: openApiSpec,
             mimeType: "application/json"
           }
@@ -1605,17 +1843,17 @@ function registerReferenceResources(server2) {
 }
 
 // src/prompts/add-step.ts
-import { z as z11 } from "zod";
+import { z as z13 } from "zod";
 function registerAddStepPrompt(server2) {
   server2.registerPrompt(
     "add-step",
     {
       description: "Add a source, destination, transformer, or store step to a flow configuration. Guides through package selection, config scaffolding, and wiring.",
       argsSchema: {
-        stepType: z11.string().optional().describe(
+        stepType: z13.string().optional().describe(
           "Type of step to add: source, destination, transformer, or store"
         ),
-        flowPath: z11.string().optional().describe("Path to the flow.json file to modify")
+        flowPath: z13.string().optional().describe("Path to the flow.json file to modify")
       }
     },
     async ({ stepType, flowPath }) => ({
@@ -1656,14 +1894,14 @@ function registerAddStepPrompt(server2) {
 }
 
 // src/prompts/setup-mapping.ts
-import { z as z12 } from "zod";
+import { z as z14 } from "zod";
 function registerSetupMappingPrompt(server2) {
   server2.registerPrompt(
     "setup-mapping",
     {
       description: "Set up event mapping for any step in a flow. Teaches mapping syntax and uses package examples as templates.",
       argsSchema: {
-        stepName: z12.string().optional().describe('Step name in the flow (e.g., "gtag", "meta", "express")')
+        stepName: z14.string().optional().describe('Step name in the flow (e.g., "gtag", "meta", "express")')
       }
     },
     async ({ stepName }) => ({
@@ -1701,14 +1939,14 @@ function registerSetupMappingPrompt(server2) {
 }
 
 // src/prompts/manage-contract.ts
-import { z as z13 } from "zod";
+import { z as z15 } from "zod";
 function registerManageContractPrompt(server2) {
   server2.registerPrompt(
     "manage-contract",
     {
       description: "Create or update event contracts for a flow. Can generate contracts from existing mappings or scaffold mappings from contracts.",
       argsSchema: {
-        direction: z13.string().optional().describe(
+        direction: z15.string().optional().describe(
           'Direction: "from-mappings" (extract contract from existing mappings), "from-scratch" (create new contract), or "to-mappings" (scaffold mappings from contract)'
         )
       }
@@ -1746,14 +1984,14 @@ function registerManageContractPrompt(server2) {
 }
 
 // src/prompts/use-definitions.ts
-import { z as z14 } from "zod";
+import { z as z16 } from "zod";
 function registerUseDefinitionsPrompt(server2) {
   server2.registerPrompt(
     "use-definitions",
     {
       description: "Extract shared patterns into definitions and variables for DRY, environment-aware flow configurations.",
       argsSchema: {
-        flowPath: z14.string().optional().describe("Path to the flow.json file to analyze")
+        flowPath: z16.string().optional().describe("Path to the flow.json file to analyze")
       }
     },
     async ({ flowPath }) => ({
@@ -1794,11 +2032,11 @@ function registerUseDefinitionsPrompt(server2) {
 }
 
 // src/index.ts
-setClientContext({ type: "mcp", version: "3.4.1-next-1776790594143" });
+setClientContext({ type: "mcp", version: "3.4.2" });
 var server = new McpServer(
   {
     name: "walkeros-flow",
-    version: "3.4.1-next-1776790594143"
+    version: "3.4.2"
   },
   {
     instructions: `walkerOS is an open-source, privacy-first event data collection platform. Define event pipelines as code using JSON flow configurations.
@@ -1812,15 +2050,18 @@ var server = new McpServer(
 
 ## Workflow
 
-1. \`flow_load({ platform: "web" })\` or \`flow_load({ source: "./flow.json" })\` \u2014 create or load
-2. \`package_search({ type: "destination", platform: "web" })\` \u2014 discover packages
-3. \`package_get({ package: "..." })\` \u2014 read schemas, hints, examples
-4. Use the \`add-step\` prompt \u2014 guided step addition
-5. Use the \`setup-mapping\` prompt \u2014 event transformation config
-6. \`flow_validate({ type: "flow", input: "flow.json" })\` \u2014 verify
-7. \`flow_simulate({ configPath: "flow.json", event: "..." })\` \u2014 test
-8. \`flow_bundle({ configPath: "flow.json" })\` \u2014 build
-9. \`api({ action: "deploy", id: "cfg_..." })\` \u2014 deploy (requires WALKEROS_TOKEN)
+1. \`auth({ action: "status" })\` \u2014 check if logged in, or \`auth({ action: "login" })\` to connect
+2. \`project_manage({ action: "list" })\` \u2014 see your projects
+3. \`flow_manage({ action: "list" })\` \u2014 see all flows across projects
+4. \`flow_load({ platform: "web" })\` or \`flow_load({ source: "./flow.json" })\` \u2014 create or load
+5. \`package_search({ type: "destination", platform: "web" })\` \u2014 discover packages
+6. \`package_get({ package: "..." })\` \u2014 read schemas, hints, examples
+7. Use the \`add-step\` prompt \u2014 guided step addition
+8. Use the \`setup-mapping\` prompt \u2014 event transformation config
+9. \`flow_validate({ type: "flow", input: "flow.json" })\` \u2014 verify
+10. \`flow_simulate({ configPath: "flow.json", event: "..." })\` \u2014 test
+11. \`flow_manage({ action: "update", flowId: "...", content: {...} })\` \u2014 save to cloud
+12. \`deploy_manage({ action: "deploy", flowId: "..." })\` \u2014 deploy
 
 ## Architecture: Source \u2192 Collector \u2192 Destination(s)
 
@@ -1874,15 +2115,16 @@ registerPackageSearchTool(server);
 registerGetPackageSchemaTool(server);
 registerFlowLoadTool(server);
 registerFeedbackTool(server);
+registerAuthTool(server);
+registerProjectManageTool(server);
+registerFlowManageTool(server);
+registerDeployTool(server);
 registerPackageSchemaResources(server);
 registerReferenceResources(server);
 registerAddStepPrompt(server);
 registerSetupMappingPrompt(server);
 registerManageContractPrompt(server);
 registerUseDefinitionsPrompt(server);
-if (process.env.WALKEROS_TOKEN) {
-  registerApiTool(server);
-}
 async function main() {
   const transport = new StdioServerTransport();
   await server.connect(transport);