Surface shared Supabase deploy output in local agent (#3288)

rules/git-workflow.md

@@ -135,6 +135,7 @@ The stashed changes will be automatically merged back after the rebase completes
 ### Conflict resolution tips
 
 - **Modify/delete conflicts**: When a rebase shows `CONFLICT (modify/delete): <file> deleted in <commit> and modified in HEAD`, use `git rm <file>` (not `git add`) to resolve by confirming the deletion. Use `git add <file>` only when you want to keep the modified version instead.
+- **Non-interactive rebase continue**: After resolving conflicts, prefer `GIT_EDITOR=true git rebase --continue` in agent shells. Plain `git rebase --continue` can open `vi` for `COMMIT_EDITMSG` and fail with `error: vi died of signal 15` when stdin is not interactive.
 - **Before rebasing:** If `npm install` modified `package-lock.json` (common in CI/local), discard changes with `git restore package-lock.json` to avoid "unstaged changes" errors
 - When resolving import conflicts (e.g., `<<<<<<< HEAD` with different imports), keep **both** imports if both are valid and needed by the component
 - When resolving conflicts in i18n-related commits, watch for duplicate constant definitions that conflict with imports from `@/lib/schemas` (e.g., `DEFAULT_ZOOM_LEVEL`)

rules/local-agent-tools.md

@@ -11,6 +11,10 @@ Agent tool definitions live in `src/pro/main/ipc/handlers/local_agent/tools/`. E
 
 - Use `fs.promises` (not sync `fs` methods) in any code running on the Electron main process (e.g., `todo_persistence.ts`) to avoid blocking the event loop.
 
+## User-visible tool output
+
+- For Local Agent post-tool side effects that happen after the model/tool loop (for example shared Supabase function redeploys), use `ctx.onXmlComplete(...)` with escaped `<dyad-output>` content to surface warnings/errors inline. `warningMessages` creates toast warnings, and throwing turns the whole stream into a `ChatErrorBox`.
+
 ## Stream retries
 
 - When extending `handleLocalAgentStream` retry behavior, do not only match transport errors like `"terminated"`. Providers can emit structured stream errors such as `{ type: "error", error: { type: "server_error", ... } }`, and those transient 5xx / rate-limit failures need explicit retry classification too.

src/__tests__/evals/fixtures/fetch_client.ts

 // fetch_client.ts — authenticated fetch wrapper used by all service layers
 
-import { createLogger } from "./logger";
 import { getAuthToken } from "./auth";
 
-const logger = createLogger("fetch-client");
-
 const BASE_URL =
   process.env.SERVICE_BASE_URL ?? "https://api.internal.example.com";
 const DEFAULT_TIMEOUT_MS = 8_000;

src/__tests__/evals/fixtures/order_processor.ts

@@ -16,12 +16,6 @@ interface ProcessResult {
   error?: string;
 }
 
-interface FulfillmentResult {
-  transactionId: string;
-  trackingNumber: string;
-  estimatedDelivery: string;
-}
-
 interface RefundResult {
   refundId: string;
   amount: number;
@@ -30,29 +24,29 @@ interface RefundResult {
 
 // ── External service stubs ─────────────────────────────────────────────────
 
-async function getInventory(productId: string): Promise<InventoryItem | null> {
+async function getInventory(_productId: string): Promise<InventoryItem | null> {
   // Implementation elided — hits the warehouse API
   return null;
 }
 
 async function reserveInventory(
-  productId: string,
-  quantity: number,
+  _productId: string,
+  _quantity: number,
 ): Promise<boolean> {
   // Implementation elided — locks inventory for the order
   return true;
 }
 
 async function releaseInventory(
-  productId: string,
-  quantity: number,
+  _productId: string,
+  _quantity: number,
 ): Promise<void> {
   // Implementation elided — releases a previously-reserved hold
 }
 
 async function chargePayment(
-  method: PaymentMethod,
-  amount: number,
+  _method: PaymentMethod,
+  _amount: number,
 ): Promise<{ transactionId: string }> {
   // Implementation elided — hits the payment gateway
   return { transactionId: "txn_placeholder" };
@@ -67,8 +61,8 @@ async function refundPayment(
 }
 
 async function createShipment(
-  address: ShippingAddress,
-  items: string[],
+  _address: ShippingAddress,
+  _items: string[],
 ): Promise<{ trackingNumber: string; estimatedDelivery: string }> {
   // Implementation elided — hits the shipping API
   return {
@@ -79,25 +73,25 @@ async function createShipment(
   };
 }
 
-async function cancelShipment(trackingNumber: string): Promise<void> {
+async function cancelShipment(_trackingNumber: string): Promise<void> {
   // Implementation elided — cancels a shipment before it ships
 }
 
-async function saveOrder(order: Order): Promise<string> {
+async function saveOrder(_order: Order): Promise<string> {
   // Implementation elided — writes to DB
   return "order_placeholder";
 }
 
 async function updateOrderStatus(
-  orderId: string,
-  status: string,
+  _orderId: string,
+  _status: string,
 ): Promise<void> {
   // Implementation elided — updates DB record
 }
 
 async function notifyOrderConfirmed(
-  orderId: string,
-  email: string,
+  _orderId: string,
+  _email: string,
 ): Promise<void> {
   // Implementation elided — sends confirmation email
 }
@@ -270,7 +264,7 @@ export async function getOrderStatus(orderId: string): Promise<string | null> {
 export async function listOrdersForCustomer(
   customerEmail: string,
   page: number,
-  limit: number,
+  _limit: number,
 ): Promise<Order[]> {
   logger.info(`Listing orders for customer ${customerEmail} (page=${page})`);
   // Implementation elided — queries DB

src/__tests__/evals/fixtures/user_handler.ts

@@ -19,15 +19,6 @@ interface User {
   isActive: boolean;
 }
 
-interface CreateUserBody {
-  email: string;
-  name: string;
-  age: number;
-  role: UserRole;
-  bio?: string;
-  avatarUrl?: string;
-}
-
 interface UpdateUserBody {
   name?: string;
   age?: number;

src/__tests__/local_agent_handler.test.ts

@@ -276,7 +276,7 @@ vi.mock("@/pro/main/ipc/handlers/local_agent/tool_definitions", () => ({
 vi.mock(
   "@/pro/main/ipc/handlers/local_agent/processors/file_operations",
   () => ({
-    deployAllFunctionsIfNeeded: vi.fn(async () => {}),
+    deployAllFunctionsIfNeeded: vi.fn(async () => ({ success: true })),
     commitAllChanges: vi.fn(async () => ({ commitHash: "abc123" })),
   }),
 );
@@ -304,6 +304,10 @@ vi.mock("@/ipc/handlers/compaction/compaction_handler", () => ({
 import { handleLocalAgentStream } from "@/pro/main/ipc/handlers/local_agent/local_agent_handler";
 import { DyadError, DyadErrorKind } from "@/errors/dyad_error";
 import { buildAgentToolSet } from "@/pro/main/ipc/handlers/local_agent/tool_definitions";
+import {
+  commitAllChanges,
+  deployAllFunctionsIfNeeded,
+} from "@/pro/main/ipc/handlers/local_agent/processors/file_operations";
 
 // ============================================================================
 // Tests
@@ -468,6 +472,89 @@ describe("handleLocalAgentStream", () => {
         warningMessages: [warningMessage],
       });
     });
+
+    it("appends shared-module Supabase deploy warnings as dyad-output", async () => {
+      const { event } = createFakeEvent();
+      mockSettings = buildTestSettings({ enableDyadPro: true });
+      mockChatData = buildTestChat({
+        supabaseProjectId: "supabase-project-id",
+      });
+      mockStreamResult = createFakeStream([{ type: "text-delta", text: "ok" }]);
+      vi.mocked(deployAllFunctionsIfNeeded).mockResolvedValueOnce({
+        success: true,
+        warning:
+          "Some Supabase functions failed to deploy: Failed to bundle get-user-role: Rate limited (429): Too Many Requests",
+      });
+
+      await handleLocalAgentStream(
+        event,
+        { chatId: 1, prompt: "test" },
+        new AbortController(),
+        {
+          placeholderMessageId: 10,
+          systemPrompt: "You are helpful",
+          dyadRequestId,
+        },
+      );
+
+      const contentUpdates = dbOperations.updates.filter(
+        (u) => u.data.content !== undefined,
+      );
+      const finalContent = contentUpdates[contentUpdates.length - 1].data
+        .content as string;
+
+      expect(finalContent).toContain('<dyad-output type="warning"');
+      expect(finalContent).toContain(
+        'message="Supabase function deploy warning"',
+      );
+      expect(finalContent).toContain(
+        "Some Supabase functions failed to deploy: Failed to bundle get-user-role: Rate limited (429): Too Many Requests",
+      );
+      expect(commitAllChanges).toHaveBeenCalled();
+    });
+
+    it("appends shared-module Supabase deploy failures as dyad-output and still commits", async () => {
+      const { event, getMessagesByChannel } = createFakeEvent();
+      mockSettings = buildTestSettings({ enableDyadPro: true });
+      mockChatData = buildTestChat({
+        supabaseProjectId: "supabase-project-id",
+      });
+      mockStreamResult = createFakeStream([{ type: "text-delta", text: "ok" }]);
+      vi.mocked(deployAllFunctionsIfNeeded).mockResolvedValueOnce({
+        success: false,
+        error:
+          "Failed to redeploy Supabase functions: RateLimitError: Rate limited (429): Too Many Requests",
+      });
+
+      await handleLocalAgentStream(
+        event,
+        { chatId: 1, prompt: "test" },
+        new AbortController(),
+        {
+          placeholderMessageId: 10,
+          systemPrompt: "You are helpful",
+          dyadRequestId,
+        },
+      );
+
+      const errorMessages = getMessagesByChannel("chat:response:error");
+      expect(errorMessages).toHaveLength(0);
+
+      const contentUpdates = dbOperations.updates.filter(
+        (u) => u.data.content !== undefined,
+      );
+      const finalContent = contentUpdates[contentUpdates.length - 1].data
+        .content as string;
+
+      expect(finalContent).toContain('<dyad-output type="error"');
+      expect(finalContent).toContain(
+        'message="Failed to deploy Supabase functions"',
+      );
+      expect(finalContent).toContain(
+        "Failed to redeploy Supabase functions: RateLimitError: Rate limited (429): Too Many Requests",
+      );
+      expect(commitAllChanges).toHaveBeenCalled();
+    });
   });
 
   describe("Context compaction setting", () => {

src/pro/main/ipc/handlers/local_agent/local_agent_handler.ts

@@ -1358,7 +1358,17 @@ export async function handleLocalAgentStream(
     // In read-only and plan mode, skip deploys and commits
     if (!readOnly && !planModeOnly) {
       // Deploy all Supabase functions if shared modules changed
-      await deployAllFunctionsIfNeeded(ctx);
+      const deployResult = await deployAllFunctionsIfNeeded(ctx);
+      if (deployResult.warning) {
+        ctx.onXmlComplete(
+          `<dyad-output type="warning" message="${escapeXmlAttr("Supabase function deploy warning")}">${escapeXmlContent(deployResult.warning)}</dyad-output>`,
+        );
+      }
+      if (!deployResult.success) {
+        ctx.onXmlComplete(
+          `<dyad-output type="error" message="${escapeXmlAttr("Failed to deploy Supabase functions")}">${escapeXmlContent(deployResult.error ?? "Unknown deploy error")}</dyad-output>`,
+        );
+      }
 
       // Commit all changes
       const commitResult = await commitAllChanges(ctx, ctx.chatSummary);