@mtreeai/msapling-cli 2.3.6-beta.27 → 2.3.6-beta.28

package/dist/index.js

@@ -356,6 +356,98 @@ var init_src = __esm({
       async disableOllama() {
         return await this.request("/api/ollama/disable", { method: "POST" });
       }
+      // Parity Task Card implementations
+      // Card 1: Usage Tracking (synced from /api/usage/sync-offline)
+      async syncOfflineUsage() {
+        return await this.request("/api/usage/sync-offline", { method: "POST" });
+      }
+      // Card 2: Budget Buckets (7 bucket types)
+      async getBillingBuckets() {
+        return await this.request("/api/billing/buckets");
+      }
+      // Card 4: Image Generation
+      async generateImage(prompt4, model) {
+        return await this.request("/api/image/generate", {
+          method: "POST",
+          body: JSON.stringify({ prompt: prompt4, model })
+        });
+      }
+      // Card 5: Voice/Audio Operations
+      async listVoices() {
+        return await this.request("/api/audio/voices");
+      }
+      async speak(text, voice) {
+        return await this.request("/api/audio/speak", {
+          method: "POST",
+          body: JSON.stringify({ text, voice })
+        });
+      }
+      // Card 8: Chat Sharing
+      async shareChat(chatId, expiryDays) {
+        return await this.request(`/api/share/chat/${encodeURIComponent(chatId)}/share`, {
+          method: "POST",
+          body: JSON.stringify({ expiry_days: expiryDays })
+        });
+      }
+      async listShares() {
+        return await this.request("/api/share");
+      }
+      async fetchSharedChat(token) {
+        return await this.request(`/api/shared/${encodeURIComponent(token)}`);
+      }
+      // Card 9: Notifications (preferences only)
+      async getNotificationPreferences() {
+        return await this.request("/api/notifications/preferences");
+      }
+      async setNotificationPreferences(prefs) {
+        return await this.request("/api/notifications/preferences", {
+          method: "PATCH",
+          body: JSON.stringify(prefs)
+        });
+      }
+      // Card 10: MLineage Events List
+      async listMLineageEvents() {
+        return await this.request("/api/mlineage/events");
+      }
+      // Card 11: Per-Project Model Config
+      async setProjectModel(projectId, model) {
+        return await this.request(`/api/projects/${encodeURIComponent(projectId)}`, {
+          method: "PATCH",
+          body: JSON.stringify({ default_model: model })
+        });
+      }
+      // Card 12: MFA/TOTP
+      async enrollMFA(method) {
+        return await this.request("/api/mfa/enroll", {
+          method: "POST",
+          body: JSON.stringify({ method })
+        });
+      }
+      async verifyMFA(code) {
+        return await this.request("/api/mfa/verify", {
+          method: "POST",
+          body: JSON.stringify({ code })
+        });
+      }
+      // Card 13: MCP Client Surface
+      async mcpConnect(serverUrl) {
+        return await this.request("/api/mcp/connect", {
+          method: "POST",
+          body: JSON.stringify({ server_url: serverUrl })
+        });
+      }
+      async mcpTools() {
+        return await this.request("/api/mcp/tools");
+      }
+      async mcpInvoke(method, args2) {
+        return await this.request("/api/mcp/invoke", {
+          method: "POST",
+          body: JSON.stringify({ method, args: args2 })
+        });
+      }
+      async mcpDisconnect() {
+        return await this.request("/api/mcp/disconnect", { method: "POST" });
+      }
       // CLI-KEYS-BYOK-01 (Iter 35): BYOK provider-key management. Per LAB
       // routers/keys.py — /api/keys/{status,save,{provider}}.
       async getProviderKeys() {
@@ -732,6 +824,32 @@ var init_src = __esm({
       async getActiveTasks() {
         return this.request("/api/task-monitor/active");
       }
+      /**
+       * Webhook Management (LAB-WEBHOOK-CRUD-01)
+       */
+      async listWebhooks() {
+        return this.request("/api/webhooks");
+      }
+      async createWebhook(url, events) {
+        return this.request("/api/webhooks", {
+          method: "POST",
+          body: JSON.stringify({ url, events })
+        });
+      }
+      async deleteWebhook(id) {
+        await this.request(`/api/webhooks/${encodeURIComponent(id)}`, {
+          method: "DELETE"
+        });
+      }
+      async listWebhookDeliveries(webhookId) {
+        const path2 = webhookId ? `/api/webhooks/deliveries?webhook_id=${encodeURIComponent(webhookId)}` : "/api/webhooks/deliveries";
+        return this.request(path2);
+      }
+      async retryWebhookDelivery(deliveryId) {
+        return this.request(`/api/webhooks/deliveries/${encodeURIComponent(deliveryId)}/retry`, {
+          method: "POST"
+        });
+      }
       /**
        * Wakeup Management (LAB-CHAT-PARITY-04)
        */
@@ -9575,11 +9693,19 @@ var init_usage = __esm({
     init_esm_shims();
     usageCommand = {
       name: "usage",
-      description: "Show detailed usage, fuel balance, and daily quota",
+      args: "[--json] [--since DATE]",
+      description: "Show detailed usage, fuel balance, and daily quota; sync offline usage",
       category: "chat",
       handler: async (args2, context) => {
         try {
+          const isJson = args2.includes("--json");
           const user = await context.client.getLiveUsage();
+          await context.client.syncOfflineUsage().catch(() => {
+          });
+          if (isJson) {
+            context.addMessage("system", JSON.stringify(user, null, 2));
+            return;
+          }
           context.addMessage("system", "MSapling Usage Dashboard:");
           context.addMessage("system", `  - Fuel Credits: $${user.fuel_credits.toFixed(4)}`);
           context.addMessage("system", `  - Daily Spending Limit: ${user.monthly_spending_limit ? "$" + user.monthly_spending_limit : "Unlimited"}`);
@@ -9680,12 +9806,31 @@ var init_project = __esm({
     LETTERS2 = "abcdefghijklmnopqrstuvwxyz";
     projectCommand = {
       name: "project",
-      args: "[number|letter|name|id]",
-      description: "List or switch active project",
+      args: "[number|letter|name|id|config]",
+      description: "List or switch active project, or set per-project config",
       category: "project",
       handler: async (args2, context) => {
         const arg = args2.join(" ").trim();
         const currentId = context.getProjectId() || null;
+        if (args2[0] === "config") {
+          const modelIdx = args2.indexOf("--model");
+          const model = modelIdx >= 0 ? args2[modelIdx + 1] : void 0;
+          if (!model) {
+            context.addMessage("system", "Usage: /project config --model <MODEL>");
+            return;
+          }
+          if (!currentId) {
+            context.addMessage("error", "No active project. Use /project <id> first.");
+            return;
+          }
+          try {
+            await context.client.setProjectModel(currentId, model);
+            context.addMessage("system", `Project default model set to: ${model}`);
+          } catch (e) {
+            context.addMessage("error", `Failed to set model: ${e.message}`);
+          }
+          return;
+        }
         if (args2[0] === "new" || args2[0] === "create") {
           const name = args2.slice(1).join(" ").trim();
           if (!name) {
@@ -10632,7 +10777,7 @@ var init_version = __esm({
       description: "Show version information for CLI and core packages",
       category: "debug",
       handler: async (_args, context) => {
-        const cliVersion = true ? "2.3.6-beta.27" : "(dev)";
+        const cliVersion = true ? "2.3.6-beta.28" : "(dev)";
         const coreVersion = true ? "2.3.2" : "(dev)";
         const runtime = process.version;
         context.addMessage("system", "MSapling Version Info");
@@ -10641,7 +10786,7 @@ var init_version = __esm({
         context.addMessage("system", row2("Core (@msapling/core)", coreVersion));
         context.addMessage("system", row2("Runtime (Node/Bun)", runtime));
         try {
-          const ts = "2026-05-29T00:38:48.242Z";
+          const ts = "2026-05-29T17:03:26.902Z";
           if (ts && ts !== "__BUILD_TIMESTAMP__") {
             context.addMessage("system", row2("Build Timestamp", ts));
           }
@@ -11359,6 +11504,529 @@ var init_totp = __esm({
   }
 });
 
+// src/commands/budget.ts
+var budgetCommand;
+var init_budget = __esm({
+  "src/commands/budget.ts"() {
+    "use strict";
+    init_esm_shims();
+    budgetCommand = {
+      name: "budget",
+      description: "Show budget buckets (lifetime, sub, top_up, free, guest, byok, ollama)",
+      category: "config",
+      handler: async (args2, context) => {
+        try {
+          const data = await context.client.getBillingBuckets();
+          context.addMessage("system", "Budget Buckets:");
+          if (data && typeof data === "object") {
+            for (const [key, val] of Object.entries(data)) {
+              const bucket = val;
+              const remaining = bucket.remaining ?? bucket.balance ?? 0;
+              const limit = bucket.limit ?? bucket.cap ?? 0;
+              context.addMessage("system", `  - ${key}: $${remaining.toFixed(4)} / $${limit.toFixed(4)}`);
+            }
+          } else {
+            context.addMessage("system", JSON.stringify(data, null, 2));
+          }
+        } catch (e) {
+          context.addMessage("error", `Failed to fetch budget: ${e.message}`);
+        }
+      }
+    };
+  }
+});
+
+// src/commands/image.ts
+var imageCommand;
+var init_image = __esm({
+  "src/commands/image.ts"() {
+    "use strict";
+    init_esm_shims();
+    imageCommand = {
+      name: "image",
+      args: "<prompt> [--model MODEL] [--output FILE]",
+      description: "Generate an image from a text prompt",
+      category: "chat",
+      handler: async (args2, context) => {
+        let prompt4 = "";
+        let model = "dall-e-3";
+        let outputFile = null;
+        for (let i = 0; i < args2.length; i++) {
+          if (args2[i] === "--model" && i + 1 < args2.length) {
+            model = args2[++i];
+            continue;
+          }
+          if (args2[i] === "--output" && i + 1 < args2.length) {
+            outputFile = args2[++i];
+            continue;
+          }
+          prompt4 += (prompt4 ? " " : "") + args2[i];
+        }
+        if (!prompt4) {
+          context.addMessage("system", "Usage: /image <prompt> [--model MODEL] [--output FILE]");
+          return;
+        }
+        try {
+          const result = await context.client.generateImage(prompt4, model);
+          context.addMessage("system", `Image generated: ${result.url ?? result.image_url ?? "processing"}`);
+        } catch (e) {
+          context.addMessage("error", `Image generation failed: ${e.message}`);
+        }
+      }
+    };
+  }
+});
+
+// src/commands/voice.ts
+var voiceCommand;
+var init_voice = __esm({
+  "src/commands/voice.ts"() {
+    "use strict";
+    init_esm_shims();
+    voiceCommand = {
+      name: "voice",
+      args: "[list|speak|transcribe] [args...]",
+      description: "Voice operations: list, speak, or transcribe audio",
+      category: "chat",
+      handler: async (args2, context) => {
+        const sub = (args2[0] ?? "list").toLowerCase();
+        const rest = args2.slice(1);
+        try {
+          if (sub === "list") {
+            const voices = await context.client.listVoices();
+            context.addMessage("system", "Available voices:");
+            if (Array.isArray(voices)) {
+              for (const voice of voices) {
+                context.addMessage("system", `  - ${voice.id ?? voice.name}: ${voice.name ?? voice.id}`);
+              }
+            } else if (typeof voices === "object") {
+              for (const [key, val] of Object.entries(voices)) {
+                context.addMessage("system", `  - ${key}`);
+              }
+            }
+            return;
+          }
+          if (sub === "speak") {
+            const text = rest.join(" ").trim();
+            if (!text) {
+              context.addMessage("system", "Usage: /voice speak --text <TEXT> --voice <VOICE>");
+              return;
+            }
+            const voiceIdx = rest.indexOf("--voice");
+            const voice = voiceIdx >= 0 ? rest[voiceIdx + 1] : "default";
+            const result = await context.client.speak(text, voice);
+            context.addMessage("system", `Audio generated: ${result.url ?? result.audio_url ?? "processing"}`);
+            return;
+          }
+          if (sub === "transcribe") {
+            context.addMessage("system", "Transcribe: pipe audio file to this command (not yet implemented)");
+            return;
+          }
+          context.addMessage("error", `Unknown /voice subcommand '${sub}'. Try: list, speak, transcribe.`);
+        } catch (e) {
+          context.addMessage("error", `Voice: ${e.message}`);
+        }
+      }
+    };
+  }
+});
+
+// src/commands/wakeup.ts
+var wakeupCommand;
+var init_wakeup = __esm({
+  "src/commands/wakeup.ts"() {
+    "use strict";
+    init_esm_shims();
+    wakeupCommand = {
+      name: "wakeup",
+      args: "[create|list|cancel] [...args]",
+      description: "Manage wakeups (scheduled tasks): create, list, or cancel",
+      category: "config",
+      handler: async (args2, context) => {
+        const sub = (args2[0] ?? "list").toLowerCase();
+        const rest = args2.slice(1);
+        try {
+          if (sub === "list") {
+            const wakeups = await context.client.listWakeups();
+            context.addMessage("system", "Wakeups:");
+            if (Array.isArray(wakeups)) {
+              for (const wu of wakeups) {
+                context.addMessage("system", `  - ${wu.id}: ${wu.reason ?? wu.prompt ?? "scheduled"}`);
+              }
+            } else {
+              context.addMessage("system", JSON.stringify(wakeups, null, 2));
+            }
+            return;
+          }
+          if (sub === "create") {
+            const delayIdx = rest.indexOf("--delay");
+            const delay = delayIdx >= 0 ? Number(rest[delayIdx + 1]) : 60;
+            const reasonIdx = rest.indexOf("--reason");
+            const reason = reasonIdx >= 0 ? rest[reasonIdx + 1] : void 0;
+            const promptIdx = rest.indexOf("--prompt");
+            const prompt4 = promptIdx >= 0 ? rest.slice(promptIdx + 1).join(" ") : void 0;
+            const result = await context.client.createWakeup({
+              delay_seconds: delay,
+              reason,
+              prompt: prompt4
+            });
+            context.addMessage("system", `Wakeup created: ${result.id ?? "ok"}`);
+            return;
+          }
+          if (sub === "cancel") {
+            const id = rest[0];
+            if (!id) {
+              context.addMessage("system", "Usage: /wakeup cancel <ID>");
+              return;
+            }
+            await context.client.cancelWakeup(id);
+            context.addMessage("system", `Wakeup cancelled: ${id}`);
+            return;
+          }
+          context.addMessage("error", `Unknown /wakeup subcommand '${sub}'. Try: list, create, cancel.`);
+        } catch (e) {
+          context.addMessage("error", `Wakeup: ${e.message}`);
+        }
+      }
+    };
+  }
+});
+
+// src/commands/share.ts
+var shareCommand;
+var init_share = __esm({
+  "src/commands/share.ts"() {
+    "use strict";
+    init_esm_shims();
+    shareCommand = {
+      name: "share",
+      args: "[create|list|fetch] [...args]",
+      description: "Share chats: create, list, or fetch shared conversations",
+      category: "chat",
+      handler: async (args2, context) => {
+        const sub = (args2[0] ?? "list").toLowerCase();
+        const rest = args2.slice(1);
+        try {
+          if (sub === "list") {
+            const shares = await context.client.listShares();
+            context.addMessage("system", "Shared Chats:");
+            if (Array.isArray(shares)) {
+              for (const share of shares) {
+                const expiry = share.expiry_at ? ` (expires ${share.expiry_at})` : "";
+                context.addMessage("system", `  - ${share.token}: chat ${share.chat_id}${expiry}`);
+              }
+            } else {
+              context.addMessage("system", JSON.stringify(shares, null, 2));
+            }
+            return;
+          }
+          if (sub === "create") {
+            const chatId = rest[0];
+            const expiryIdx = rest.indexOf("--expiry");
+            const expiry = expiryIdx >= 0 ? Number(rest[expiryIdx + 1]) : void 0;
+            if (!chatId) {
+              context.addMessage("system", "Usage: /share create <CHAT-ID> [--expiry DAYS]");
+              return;
+            }
+            const result = await context.client.shareChat(chatId, expiry);
+            context.addMessage("system", `Share created: ${result.token ?? result.url ?? "ok"}`);
+            return;
+          }
+          if (sub === "fetch") {
+            const token = rest[0];
+            if (!token) {
+              context.addMessage("system", "Usage: /share fetch <TOKEN>");
+              return;
+            }
+            const result = await context.client.fetchSharedChat(token);
+            context.addMessage("system", `Fetched shared chat: ${result.chat_id ?? result.id}`);
+            return;
+          }
+          context.addMessage("error", `Unknown /share subcommand '${sub}'. Try: list, create, fetch.`);
+        } catch (e) {
+          context.addMessage("error", `Share: ${e.message}`);
+        }
+      }
+    };
+  }
+});
+
+// src/commands/notify.ts
+var notifyCommand;
+var init_notify = __esm({
+  "src/commands/notify.ts"() {
+    "use strict";
+    init_esm_shims();
+    notifyCommand = {
+      name: "notify",
+      args: "[preferences] [--get|--set KEY=VALUE]",
+      description: "Manage notification preferences (SSE stream not yet implemented)",
+      category: "config",
+      handler: async (args2, context) => {
+        try {
+          if (args2.length === 0 || args2[0] === "preferences" || args2[0] === "--get") {
+            const prefs = await context.client.getNotificationPreferences();
+            context.addMessage("system", "Notification Preferences:");
+            context.addMessage("system", JSON.stringify(prefs, null, 2));
+            return;
+          }
+          if (args2[0] === "--set") {
+            const updates = {};
+            for (let i = 1; i < args2.length; i++) {
+              const pair = args2[i].split("=");
+              if (pair.length === 2) {
+                updates[pair[0]] = pair[1] === "true" ? true : pair[1] === "false" ? false : pair[1];
+              }
+            }
+            const result = await context.client.setNotificationPreferences(updates);
+            context.addMessage("system", `Preferences updated: ${result.status ?? "ok"}`);
+            return;
+          }
+          context.addMessage("error", "Usage: /notify [--get] or /notify --set KEY=VALUE ...");
+        } catch (e) {
+          context.addMessage("error", `Notify: ${e.message}`);
+        }
+      }
+    };
+  }
+});
+
+// src/commands/mlineage.ts
+var mlineageCommand;
+var init_mlineage = __esm({
+  "src/commands/mlineage.ts"() {
+    "use strict";
+    init_esm_shims();
+    mlineageCommand = {
+      name: "mlineage",
+      args: "[events] [--follow]",
+      description: "List MLineage events (follow mode not yet implemented)",
+      category: "chat",
+      handler: async (args2, context) => {
+        try {
+          const follow = args2.includes("--follow");
+          const events = await context.client.listMLineageEvents();
+          context.addMessage("system", "MLineage Events:");
+          if (Array.isArray(events)) {
+            for (const evt of events) {
+              context.addMessage("system", `  - ${evt.id}: ${evt.type} @ ${evt.timestamp}`);
+            }
+          } else {
+            context.addMessage("system", JSON.stringify(events, null, 2));
+          }
+          if (follow) {
+            context.addMessage("system", "(follow mode not yet implemented)");
+          }
+        } catch (e) {
+          context.addMessage("error", `MLineage: ${e.message}`);
+        }
+      }
+    };
+  }
+});
+
+// src/commands/mfa.ts
+var mfaCommand;
+var init_mfa = __esm({
+  "src/commands/mfa.ts"() {
+    "use strict";
+    init_esm_shims();
+    mfaCommand = {
+      name: "mfa",
+      args: "[enroll|verify] [...args]",
+      description: "Enroll or verify MFA/TOTP",
+      category: "config",
+      handler: async (args2, context) => {
+        const sub = (args2[0] ?? "status").toLowerCase();
+        const rest = args2.slice(1);
+        try {
+          if (sub === "enroll") {
+            const method = rest[0] ?? "totp";
+            const result = await context.client.enrollMFA(method);
+            context.addMessage("system", `MFA enrollment initiated: ${method}`);
+            if (result.qr_code) {
+              context.addMessage("system", `QR Code: ${result.qr_code}`);
+            }
+            if (result.secret) {
+              context.addMessage("system", `Secret: ${result.secret}`);
+            }
+            return;
+          }
+          if (sub === "verify") {
+            const code = rest[0];
+            if (!code) {
+              context.addMessage("system", "Usage: /mfa verify <CODE>");
+              return;
+            }
+            const result = await context.client.verifyMFA(code);
+            context.addMessage("system", `MFA verified: ${result.status ?? "ok"}`);
+            return;
+          }
+          context.addMessage("error", `Unknown /mfa subcommand '${sub}'. Try: enroll, verify.`);
+        } catch (e) {
+          context.addMessage("error", `MFA: ${e.message}`);
+        }
+      }
+    };
+  }
+});
+
+// src/commands/mcp.ts
+var mcpCommand;
+var init_mcp = __esm({
+  "src/commands/mcp.ts"() {
+    "use strict";
+    init_esm_shims();
+    mcpCommand = {
+      name: "mcp",
+      args: "[connect|invoke|tools|disconnect] [...args]",
+      description: "MCP client surface: connect, invoke, list tools, disconnect",
+      category: "config",
+      handler: async (args2, context) => {
+        const sub = (args2[0] ?? "tools").toLowerCase();
+        const rest = args2.slice(1);
+        try {
+          if (sub === "connect") {
+            const url = rest[0];
+            if (!url) {
+              context.addMessage("system", "Usage: /mcp connect <server-url>");
+              return;
+            }
+            const result = await context.client.mcpConnect(url);
+            context.addMessage("system", `MCP Connected: ${result.status ?? "ok"}`);
+            return;
+          }
+          if (sub === "tools") {
+            const tools = await context.client.mcpTools();
+            context.addMessage("system", "Available MCP Tools:");
+            if (Array.isArray(tools)) {
+              for (const tool of tools) {
+                context.addMessage("system", `  - ${tool.name}: ${tool.description ?? ""}`);
+              }
+            } else if (typeof tools === "object") {
+              context.addMessage("system", JSON.stringify(tools, null, 2));
+            }
+            return;
+          }
+          if (sub === "invoke") {
+            const method = rest[0];
+            if (!method) {
+              context.addMessage("system", "Usage: /mcp invoke <method> [args...]");
+              return;
+            }
+            const argsStr = rest.slice(1).join(" ");
+            let argsObj;
+            try {
+              argsObj = argsStr ? JSON.parse(argsStr) : void 0;
+            } catch {
+              argsObj = { raw: argsStr };
+            }
+            const result = await context.client.mcpInvoke(method, argsObj);
+            context.addMessage("system", `MCP Result: ${JSON.stringify(result)}`);
+            return;
+          }
+          if (sub === "disconnect") {
+            const result = await context.client.mcpDisconnect();
+            context.addMessage("system", `MCP Disconnected: ${result.status ?? "ok"}`);
+            return;
+          }
+          context.addMessage("error", `Unknown /mcp subcommand '${sub}'. Try: connect, tools, invoke, disconnect.`);
+        } catch (e) {
+          context.addMessage("error", `MCP: ${e.message}`);
+        }
+      }
+    };
+  }
+});
+
+// src/commands/webhook.ts
+var webhookCommand;
+var init_webhook = __esm({
+  "src/commands/webhook.ts"() {
+    "use strict";
+    init_esm_shims();
+    webhookCommand = {
+      name: "webhook",
+      args: "[list|add|rm|deliveries|retry] [...args]",
+      description: "Manage webhooks: create, list, delete, and view delivery logs",
+      category: "project",
+      handler: async (args2, context) => {
+        const sub = (args2[0] ?? "list").toLowerCase();
+        const rest = args2.slice(1);
+        try {
+          if (sub === "list") {
+            const webhooks = await context.client.listWebhooks();
+            context.addMessage("system", "Webhooks:");
+            if (Array.isArray(webhooks) && webhooks.length > 0) {
+              for (const wh of webhooks) {
+                const id = wh.id ?? wh.webhook_id ?? "?";
+                const url = wh.url ?? "?";
+                const events = wh.events ? wh.events.join(", ") : "";
+                context.addMessage("system", `  - ${id}: ${url} (${events})`);
+              }
+            } else {
+              context.addMessage("system", "  (no webhooks)");
+            }
+            return;
+          }
+          if (sub === "add") {
+            const url = rest[0];
+            const events = rest.slice(1);
+            if (!url || events.length === 0) {
+              context.addMessage("system", "Usage: /webhook add <url> <event1> [event2] ...");
+              return;
+            }
+            const result = await context.client.createWebhook(url, events);
+            const id = result.id ?? result.webhook_id ?? "?";
+            context.addMessage("system", `Webhook created: ${id} \u2192 ${url}`);
+            return;
+          }
+          if (sub === "rm" || sub === "delete") {
+            const id = rest[0];
+            if (!id) {
+              context.addMessage("system", "Usage: /webhook rm <id>");
+              return;
+            }
+            await context.client.deleteWebhook(id);
+            context.addMessage("system", `Deleted webhook: ${id}`);
+            return;
+          }
+          if (sub === "deliveries") {
+            const webhookId = rest[0] || void 0;
+            const deliveries = await context.client.listWebhookDeliveries(webhookId);
+            const title = webhookId ? `Deliveries for webhook ${webhookId}:` : "Recent deliveries:";
+            context.addMessage("system", title);
+            if (Array.isArray(deliveries) && deliveries.length > 0) {
+              for (const d of deliveries) {
+                const id = d.id ?? d.delivery_id ?? "?";
+                const status = d.status ?? "?";
+                const at = d.delivered_at ?? d.created_at ?? "?";
+                context.addMessage("system", `  - ${id}: ${status} (${at})`);
+              }
+            } else {
+              context.addMessage("system", "  (no deliveries)");
+            }
+            return;
+          }
+          if (sub === "retry") {
+            const deliveryId = rest[0];
+            if (!deliveryId) {
+              context.addMessage("system", "Usage: /webhook retry <delivery-id>");
+              return;
+            }
+            const result = await context.client.retryWebhookDelivery(deliveryId);
+            context.addMessage("system", `Retrying delivery: ${deliveryId} (${result.status ?? "queued"})`);
+            return;
+          }
+          context.addMessage("error", `Unknown /webhook subcommand '${sub}'. Try: list, add, rm, deliveries, retry.`);
+        } catch (e) {
+          context.addMessage("error", `Webhook: ${e.message}`);
+        }
+      }
+    };
+  }
+});
+
 // src/commands/index.ts
 var commands_exports = {};
 __export(commands_exports, {
@@ -11412,6 +12080,16 @@ var init_commands = __esm({
     init_todo();
     init_outputStyle();
     init_totp();
+    init_budget();
+    init_image();
+    init_voice();
+    init_wakeup();
+    init_share();
+    init_notify();
+    init_mlineage();
+    init_mfa();
+    init_mcp();
+    init_webhook();
     commands = [
       loginCommand,
       unlockCommand,
@@ -11451,7 +12129,17 @@ var init_commands = __esm({
       noteCommand,
       todoCommand,
       outputStyleCommand,
-      totpCommand
+      totpCommand,
+      budgetCommand,
+      imageCommand,
+      voiceCommand,
+      wakeupCommand,
+      shareCommand,
+      notifyCommand,
+      mlineageCommand,
+      mfaCommand,
+      mcpCommand,
+      webhookCommand
     ];
   }
 });
@@ -15054,7 +15742,7 @@ import { jsx, jsxs } from "react/jsx-runtime";
 var Header = () => /* @__PURE__ */ jsxs(Box, { borderStyle: "single", borderColor: "cyan", paddingX: 1, marginBottom: 1, children: [
   /* @__PURE__ */ jsxs(Text, { bold: true, color: "cyan", children: [
     "\u25CF MSapling CLI v",
-    "2.3.6-beta.27"
+    "2.3.6-beta.28"
   ] }),
   /* @__PURE__ */ jsx(Box, { marginLeft: 2, children: /* @__PURE__ */ jsx(Text, { color: "gray", children: "Platinum Tier Architecture" }) })
 ] });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mtreeai/msapling-cli",
-  "version": "2.3.6-beta.27",
+  "version": "2.3.6-beta.28",
   "description": "MSapling CLI — React/Ink terminal client for the MSapling backend (chat, projects, MDrive, agent tools). Proprietary; redistribution prohibited.",
   "license": "UNLICENSED",
   "author": "MSapling Team",