fix(gateway): abort gmail tailscale setup

samzong · samzong · commit c550d5d83ab8 · 2026-05-16T14:24:06.000+08:00
Signed-off-by: samzong &lt;samzong.lu@gmail.com&gt;
diff --git a/src/gateway/server-startup-post-attach.test.ts b/src/gateway/server-startup-post-attach.test.ts
@@ -788,9 +788,12 @@ describe("startGatewayPostAttachRuntime", () => {
 
   it("runs Gmail watcher after sidecars are ready", async () => {
     let resolveWatcher: (() => void) | undefined;
+    let watcherSignal: AbortSignal | undefined;
     hoisted.startGmailWatcherWithLogs.mockImplementationOnce(
-      async () =>
+      async (...args: unknown[]) =>
         await new Promise<void>((resolve) => {
+          const [params] = args as [{ signal?: AbortSignal }];
+          watcherSignal = params.signal;
           resolveWatcher = resolve;
         }),
     );
@@ -825,11 +828,14 @@ describe("startGatewayPostAttachRuntime", () => {
     await vi.waitFor(() => {
       expect(hoisted.startGmailWatcherWithLogs).toHaveBeenCalledTimes(1);
     });
+    expect(watcherSignal?.aborted).toBe(false);
     expect(log.warn).not.toHaveBeenCalled();
 
     if (!resolveWatcher) {
       throw new Error("Expected gmail watcher resolver to be initialized");
     }
+    result.postReadySidecars[0]?.stop();
+    expect(watcherSignal?.aborted).toBe(true);
     resolveWatcher();
   });
 
diff --git a/src/gateway/server-startup-post-attach.ts b/src/gateway/server-startup-post-attach.ts
@@ -150,24 +150,26 @@ function schedulePostReadySidecarTask(params: {
   startupTrace?: GatewayStartupTrace;
   name: string;
   log: { warn: (msg: string) => void };
-  run: (isStopped: () => boolean) => Awaitable<void>;
+  run: (isStopped: () => boolean, signal: AbortSignal) => Awaitable<void>;
 }): GatewayPostReadySidecarHandle {
   let stopped = false;
+  const abortController = new AbortController();
   const isStopped = () => stopped;
   const handle = setImmediate(() => {
     if (isStopped()) {
       return;
     }
-    void measureStartup(params.startupTrace, params.name, () => params.run(isStopped)).catch(
-      (err) => {
-        params.log.warn(`${params.name} failed after gateway ready: ${String(err)}`);
-      },
-    );
+    void measureStartup(params.startupTrace, params.name, () =>
+      params.run(isStopped, abortController.signal),
+    ).catch((err) => {
+      params.log.warn(`${params.name} failed after gateway ready: ${String(err)}`);
+    });
   });
   handle.unref?.();
   return {
     stop: () => {
       stopped = true;
+      abortController.abort();
       clearImmediate(handle);
     },
   };
@@ -620,7 +622,7 @@ export async function startGatewaySidecars(params: {
         startupTrace: params.startupTrace,
         name: "sidecars.gmail-watch",
         log: params.log,
-        run: async (isStopped) => {
+        run: async (isStopped, signal) => {
           const { startGmailWatcherWithLogs } = await import("../hooks/gmail-watcher-lifecycle.js");
           if (isStopped()) {
             return;
@@ -629,6 +631,7 @@ export async function startGatewaySidecars(params: {
             cfg: params.cfg,
             log: params.logHooks,
             isCancelled: isStopped,
+            signal,
           });
         },
       }),
diff --git a/src/hooks/gmail-setup-utils.test.ts b/src/hooks/gmail-setup-utils.test.ts
@@ -205,4 +205,47 @@ describe("ensureTailscaleEndpoint", () => {
     expect(message).toContain("stdout: not-json");
     expect(message).toContain("code=0");
   });
+
+  it("passes abort signal to tailscale status and serve commands", async () => {
+    const abortController = new AbortController();
+    runCommandWithTimeoutMock
+      .mockResolvedValueOnce({
+        stdout: JSON.stringify({ Self: { DNSName: "host.tailnet.ts.net." } }),
+        stderr: "",
+        code: 0,
+        signal: null,
+        killed: false,
+      })
+      .mockResolvedValueOnce({
+        stdout: "",
+        stderr: "",
+        code: 0,
+        signal: null,
+        killed: false,
+      });
+
+    await ensureTailscaleEndpoint({
+      mode: "serve",
+      path: "/gmail-pubsub",
+      port: 8788,
+      signal: abortController.signal,
+    });
+
+    expect(runCommandWithTimeoutMock).toHaveBeenNthCalledWith(
+      1,
+      ["tailscale", "status", "--json"],
+      {
+        timeoutMs: 30_000,
+        signal: abortController.signal,
+      },
+    );
+    expect(runCommandWithTimeoutMock).toHaveBeenNthCalledWith(
+      2,
+      ["tailscale", "serve", "--bg", "--set-path", "/gmail-pubsub", "--yes", "8788"],
+      {
+        timeoutMs: 30_000,
+        signal: abortController.signal,
+      },
+    );
+  });
 });
diff --git a/src/hooks/gmail-setup-utils.ts b/src/hooks/gmail-setup-utils.ts
@@ -264,6 +264,7 @@ export async function ensureTailscaleEndpoint(params: {
   mode: "off" | "serve" | "funnel";
   path: string;
   port?: number;
+  signal?: AbortSignal;
   target?: string;
   token?: string;
 }): Promise<string> {
@@ -276,6 +277,7 @@ export async function ensureTailscaleEndpoint(params: {
   const statusCommand = formatCommand("tailscale", statusArgs);
   const status = await runCommandWithTimeout([tailscaleBin, ...statusArgs], {
     timeoutMs: 30_000,
+    signal: params.signal,
   });
   if (status.code !== 0) {
     throw new Error(formatCommandFailure(statusCommand, status));
@@ -305,6 +307,7 @@ export async function ensureTailscaleEndpoint(params: {
   const funnelCommand = formatCommand("tailscale", funnelArgs);
   const funnelResult = await runCommandWithTimeout([tailscaleBin, ...funnelArgs], {
     timeoutMs: 30_000,
+    signal: params.signal,
   });
   if (funnelResult.code !== 0) {
     throw new Error(formatCommandFailure(funnelCommand, funnelResult));
diff --git a/src/hooks/gmail-watcher-lifecycle.test.ts b/src/hooks/gmail-watcher-lifecycle.test.ts
@@ -31,15 +31,20 @@ describe("startGmailWatcherWithLogs", () => {
 
   it("passes cancellation state to watcher startup", async () => {
     const isCancelled = vi.fn(() => true);
+    const abortController = new AbortController();
     startGmailWatcherMock.mockResolvedValue({ started: false, reason: "startup cancelled" });
 
     await startGmailWatcherWithLogs({
       cfg: {},
       log,
       isCancelled,
+      signal: abortController.signal,
     });
 
-    expect(startGmailWatcherMock).toHaveBeenCalledWith({}, { isCancelled });
+    expect(startGmailWatcherMock).toHaveBeenCalledWith(
+      {},
+      { isCancelled, signal: abortController.signal },
+    );
   });
 
   it("logs startup success", async () => {
diff --git a/src/hooks/gmail-watcher-lifecycle.ts b/src/hooks/gmail-watcher-lifecycle.ts
@@ -13,14 +13,18 @@ export async function startGmailWatcherWithLogs(params: {
   log: GMailWatcherLog;
   onSkipped?: () => void;
   isCancelled?: () => boolean;
+  signal?: AbortSignal;
 }) {
   if (isTruthyEnvValue(process.env.OPENCLAW_SKIP_GMAIL_WATCHER)) {
     params.onSkipped?.();
     return;
   }
 
   try {
-    const gmailResult = await startGmailWatcher(params.cfg, { isCancelled: params.isCancelled });
+    const gmailResult = await startGmailWatcher(params.cfg, {
+      isCancelled: params.isCancelled,
+      signal: params.signal,
+    });
     if (gmailResult.started) {
       params.log.info("gmail watcher started");
       return;
diff --git a/src/hooks/gmail-watcher.test.ts b/src/hooks/gmail-watcher.test.ts
@@ -146,4 +146,52 @@ describe("startGmailWatcher", () => {
     });
     expect(mocks.spawn).not.toHaveBeenCalled();
   });
+
+  it("aborts tailscale setup and does not spawn gog serve when cancelled in flight", async () => {
+    let cancelled = false;
+    let tailscaleSignal: AbortSignal | undefined;
+    mocks.runCommandWithTimeout.mockImplementation(
+      async (_args, options: { signal?: AbortSignal }) =>
+        await new Promise<{ code: number | null; stdout: string; stderr: string }>((resolve) => {
+          tailscaleSignal = options.signal;
+          options.signal?.addEventListener(
+            "abort",
+            () => resolve({ code: null, stdout: "", stderr: "aborted" }),
+            { once: true },
+          );
+        }),
+    );
+    const startPromise = startGmailWatcher(
+      {
+        hooks: {
+          enabled: true,
+          token: "hook-token",
+          gmail: {
+            account: "me@example.com",
+            topic: "projects/demo/topics/gmail",
+            pushToken: "push-token",
+            tailscale: { mode: "serve" },
+          },
+        },
+      } as never,
+      {
+        isCancelled: () => cancelled,
+      },
+    );
+
+    await vi.waitFor(() => {
+      expect(tailscaleSignal).toBeDefined();
+    });
+    cancelled = true;
+
+    await vi.waitFor(() => {
+      expect(tailscaleSignal?.aborted).toBe(true);
+    });
+
+    await expect(startPromise).resolves.toEqual({
+      started: false,
+      reason: "startup cancelled",
+    });
+    expect(mocks.spawn).not.toHaveBeenCalled();
+  });
 });
diff --git a/src/hooks/gmail-watcher.ts b/src/hooks/gmail-watcher.ts
@@ -164,6 +164,17 @@ export type GmailWatcherStartResult = {
   reason?: string;
 };
 
+type GmailWatcherCancellation = {
+  dispose: () => void;
+  isCancelled: () => boolean;
+  signal?: AbortSignal;
+};
+
+type GmailWatcherStartOptions = {
+  isCancelled?: () => boolean;
+  signal?: AbortSignal;
+};
+
 function cancelledGmailWatcherStart(
   expectedConfig: GmailHookRuntimeConfig,
 ): GmailWatcherStartResult {
@@ -173,13 +184,63 @@ function cancelledGmailWatcherStart(
   return { started: false, reason: "startup cancelled" };
 }
 
+function isGmailWatcherStartCancelled(options: GmailWatcherStartOptions): boolean {
+  return options.signal?.aborted === true || options.isCancelled?.() === true;
+}
+
+function createGmailWatcherCancellation(
+  options: GmailWatcherStartOptions,
+): GmailWatcherCancellation {
+  if (!options.signal && !options.isCancelled) {
+    return {
+      dispose: () => {},
+      isCancelled: () => false,
+    };
+  }
+
+  const abortController = new AbortController();
+  const abort = () => {
+    if (!abortController.signal.aborted) {
+      abortController.abort();
+    }
+  };
+  const onAbort = () => abort();
+  options.signal?.addEventListener("abort", onAbort, { once: true });
+
+  let cancelPoll: ReturnType<typeof setInterval> | null = null;
+  if (options.isCancelled) {
+    cancelPoll = setInterval(() => {
+      if (options.isCancelled?.()) {
+        abort();
+      }
+    }, 100);
+    cancelPoll.unref?.();
+  }
+
+  if (isGmailWatcherStartCancelled(options)) {
+    abort();
+  }
+
+  return {
+    dispose: () => {
+      if (cancelPoll) {
+        clearInterval(cancelPoll);
+        cancelPoll = null;
+      }
+      options.signal?.removeEventListener("abort", onAbort);
+    },
+    isCancelled: () => abortController.signal.aborted || isGmailWatcherStartCancelled(options),
+    signal: abortController.signal,
+  };
+}
+
 /**
  * Start the Gmail watcher service.
  * Called automatically by the gateway if hooks.gmail is configured.
  */
 export async function startGmailWatcher(
   cfg: OpenClawConfig,
-  options: { isCancelled?: () => boolean } = {},
+  options: GmailWatcherStartOptions = {},
 ): Promise<GmailWatcherStartResult> {
   // Check if gmail hooks are configured
   if (!cfg.hooks?.enabled) {
@@ -203,54 +264,55 @@ export async function startGmailWatcher(
   }
 
   const runtimeConfig = resolved.value;
-  if (options.isCancelled?.()) {
+  if (isGmailWatcherStartCancelled(options)) {
     return cancelledGmailWatcherStart(runtimeConfig);
   }
   currentConfig = runtimeConfig;
 
   // Set up Tailscale endpoint if needed
   if (runtimeConfig.tailscale.mode !== "off") {
+    const cancellation = createGmailWatcherCancellation(options);
     try {
       await ensureTailscaleEndpoint({
         mode: runtimeConfig.tailscale.mode,
         path: runtimeConfig.tailscale.path,
         port: runtimeConfig.serve.port,
+        signal: cancellation.signal,
         target: runtimeConfig.tailscale.target,
       });
       log.info(
         `tailscale ${runtimeConfig.tailscale.mode} configured for port ${runtimeConfig.serve.port}`,
       );
-      if (options.isCancelled?.()) {
+      if (cancellation.isCancelled()) {
         return cancelledGmailWatcherStart(runtimeConfig);
       }
     } catch (err) {
+      if (cancellation.isCancelled()) {
+        return cancelledGmailWatcherStart(runtimeConfig);
+      }
       log.error(`tailscale setup failed: ${String(err)}`);
       return {
         started: false,
         reason: `tailscale setup failed: ${String(err)}`,
       };
+    } finally {
+      cancellation.dispose();
     }
   }
 
   // Start the Gmail watch (register with Gmail API)
-  const abortController = new AbortController();
-  const cancelPoll = setInterval(() => {
-    if (options.isCancelled?.()) {
-      abortController.abort();
-    }
-  }, 100);
-  cancelPoll.unref?.();
-  const watchStarted = await startGmailWatch(runtimeConfig, { signal: abortController.signal });
-  clearInterval(cancelPoll);
-  if (options.isCancelled?.()) {
+  const cancellation = createGmailWatcherCancellation(options);
+  const watchStarted = await startGmailWatch(runtimeConfig, { signal: cancellation.signal });
+  cancellation.dispose();
+  if (cancellation.isCancelled()) {
     return cancelledGmailWatcherStart(runtimeConfig);
   }
   if (!watchStarted) {
     log.warn("gmail watch start failed, but continuing with serve");
   }
 
   // Spawn the gog serve process
-  if (options.isCancelled?.()) {
+  if (isGmailWatcherStartCancelled(options)) {
     return cancelledGmailWatcherStart(runtimeConfig);
   }
   shuttingDown = false;
