local devhook

Author: hugodutka

bun.lock

@@ -1,6 +1,6 @@
 {
   "name": "blink",
-  "version": "1.1.36",
+  "version": "1.1.37",
   "description": "Blink is a tool for building and deploying AI agents.",
   "type": "module",
   "bin": {
@@ -93,7 +93,7 @@
     "@ai-sdk/xai": "^2.0.16",
     "@blink-sdk/compute": "^0.0.15",
     "@blink-sdk/events": "workspace:*",
-    "@blink.so/api": "^1.0.0",
+    "@blink.so/api": "^1.1.0",
     "@clack/prompts": "^0.11.0",
     "@hono/node-server": "^1.19.3",
     "@jaaydenh/gemini-cli": "0.11.0-nightly-20251022-2",

packages/blink/package.json

@@ -327,10 +327,26 @@ export default async function deploy(
           chalk.dim("  Skipping webhook tunnel migration in CI mode")
         );
       } else {
-        const productionUrl = `https://${devhookID}.blink.host`;
+        let productionUrl: string | undefined;
+        try {
+          productionUrl = await client.devhook.getUrl(devhookID);
+        } catch (error) {
+          const message =
+            error instanceof Error ? error.message : "Unknown error";
+          console.log(
+            chalk.yellow(
+              `Warning: unable to determine webhook tunnel URL (${message})`
+            )
+          );
+        }
         console.log("\n" + chalk.cyan("Webhook Tunnel"));
-        console.log(chalk.dim(`  Current: ${productionUrl} → local dev`));
-        console.log(chalk.dim(`  After: ${productionUrl} → production`));
+        if (productionUrl) {
+          console.log(chalk.dim(`  Current: ${productionUrl} → local dev`));
+          console.log(chalk.dim(`  After: ${productionUrl} → production`));
+        } else {
+          console.log(chalk.dim("  Current: (unknown URL) → local dev"));
+          console.log(chalk.dim("  After: (unknown URL) → production"));
+        }
         console.log(
           chalk.dim("  Migrating will keep your webhooks working in production")
         );

packages/blink/src/cli/deploy.ts

@@ -146,6 +146,7 @@ GITHUB_CLIENT_ID=active_client_id
 describe("setup github-app command", () => {
   function callSetupGithubApp(directory: string) {
     const client = createMockClient();
+    client.devhook.getUrl.mockResolvedValue("https://test.blink.so/devhook");
     return setupGithubApp(directory, {
       _deps: {
         authenticate: async () => {},

packages/blink/src/cli/setup-github-app.test.ts

@@ -1,6 +1,6 @@
 import { access, readFile, writeFile } from "node:fs/promises";
 import { basename, join } from "node:path";
-import type Client from "@blink.so/api";
+import Client from "@blink.so/api";
 import {
   confirm,
   intro,
@@ -133,12 +133,17 @@ export async function setupGithubApp(
   if (!devhookId) {
     throw new Error("Failed to obtain devhook ID");
   }
-  const webhookUrl = `https://${devhookId}.blink.host`;
 
   const host = getHostFn();
   if (!host) {
     throw new Error("No Blink host configured.");
   }
+  const client =
+    options?._deps?.client ??
+    new Client({
+      baseURL: host,
+    });
+  const webhookUrl = await client.devhook.getUrl(devhookId);
 
   // Create manifest with sensible defaults for a typical GitHub App
   const manifest = {

packages/blink/src/cli/setup-github-app.ts

@@ -248,10 +248,10 @@ SLACK_SIGNING_SECRET=active_secret
 describe("setup slack-app command", () => {
   function callSetupSlackApp(directory: string) {
     const client = createMockClient();
+    client.devhook.getUrl.mockResolvedValue("https://test.blink.so/devhook");
     // Mock devhook.listen to avoid WebSocket connections
     client.devhook.listen.mockImplementation(
-      ({ onConnect }: { onConnect?: () => void }) => {
-        setTimeout(() => onConnect?.(), 0);
+      () => {
         return { dispose: () => {}, [Symbol.dispose]: () => {} };
       }
     );

packages/blink/src/cli/setup-slack-app.test.ts

@@ -218,22 +218,10 @@ export async function setupSlackApp(
   const devhookId = hasDevhook(directory)
     ? getDevhookID(directory)
     : createDevhookID(directory);
-  const webhookUrl = `https://${devhookId}.blink.host`;
   if (!devhookId) {
     throw new Error("Failed to obtain devhook ID");
   }
 
-  log.info("Starting webhook listener...");
-
-  // State for handling Slack events
-  let signingSecret = "";
-  let botToken = "";
-  let dmReceived = false;
-  let dmChannel = "";
-  let dmTimestamp = "";
-  let signatureFailureDetected = false;
-  let lastFailedChannel: string | undefined;
-
   const host = getHostFn();
   if (!host) {
     throw new Error(
@@ -245,6 +233,18 @@ export async function setupSlackApp(
     new Client({
       baseURL: host,
     });
+  const webhookUrl = await client.devhook.getUrl(devhookId);
+
+  log.info("Starting webhook listener...");
+
+  // State for handling Slack events
+  let signingSecret = "";
+  let botToken = "";
+  let dmReceived = false;
+  let dmChannel = "";
+  let dmTimestamp = "";
+  let signatureFailureDetected = false;
+  let lastFailedChannel: string | undefined;
 
   let resolveConnected = () => {};
   let rejectConnected = (_error: unknown) => {};

packages/blink/src/cli/setup-slack-app.ts

@@ -36,7 +36,7 @@ export interface EditAgent {
 export function createEditAgent(options: {
   directory: string;
   env: Record<string, string>;
-  getDevhookUrl: () => string;
+  getDevhookUrl: () => Promise<string>;
 }): EditAgent {
   const agent = new Agent();
 

packages/blink/src/edit/agent.ts

@@ -4,7 +4,9 @@ import { isToolOrDynamicToolUIPart } from "ai";
 import { isToolApprovalOutput } from "../agent/tools";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { join } from "path";
-import type { Client, CapabilitiesResponse } from "../agent/client";
+import Client from "@blink.so/api";
+import type { CapabilitiesResponse } from "../agent/client";
+import { getHost } from "../cli/lib/auth";
 import { getDevhookID, createDevhookID, hasDevhook } from "../cli/lib/devhook";
 import { createLocalServer, type LocalServer } from "../local/server";
 import { isLogMessage, isStoredMessageMetadata } from "../local/types";
@@ -230,10 +232,12 @@ export default function useDevMode(options: UseDevModeOptions): UseDevMode {
     directory,
     apiServerUrl: server.url,
     env,
-    getDevhookUrl: useCallback(() => {
+    getDevhookUrl: useCallback(async () => {
       const id = getDevhookID(directory) ?? createDevhookID(directory);
       setDevhookID(id);
-      return `https://${id}.blink.host`;
+      const host = getHost();
+      const client = host ? new Client({ baseURL: host }) : new Client();
+      return client.devhook.getUrl(id);
     }, [directory]),
   });
 

packages/blink/src/react/use-dev-mode.ts

@@ -3,7 +3,7 @@ import { useEffect, useRef, useState } from "react";
 import { lock, getLockInfo } from "../local/lockfile";
 import { join } from "node:path";
 import chalk from "chalk";
-import { getDevhookID } from "../cli/lib/devhook";
+import { getHost } from "../cli/lib/auth";
 import type { Logger } from "./use-logger";
 
 export interface UseDevhookOptions {
@@ -25,6 +25,36 @@ export default function useDevhook(options: UseDevhookOptions) {
   const [status, setStatus] = useState<"connected" | "disconnected" | "error">(
     "disconnected"
   );
+  const [publicUrl, setPublicUrl] = useState<string | undefined>(undefined);
+
+  useEffect(() => {
+    if (!options.id) {
+      setPublicUrl(undefined);
+      return;
+    }
+    const host = getHost();
+    if (!host) {
+      // Skip URL lookup if not logged in
+      setPublicUrl(undefined);
+      return;
+    }
+    let cancelled = false;
+    setPublicUrl(undefined);
+    const client = new Client({ baseURL: host });
+    void client.devhook
+      .getUrl(options.id)
+      .then((url) => {
+        if (!cancelled) {
+          setPublicUrl(url);
+        }
+      })
+      .catch(() => {
+        // Ignore lookup errors; listener will retry on connect.
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [options.id]);
 
   useEffect(() => {
     // Don't connect if disabled or no devhook ID exists
@@ -95,6 +125,16 @@ export default function useDevhook(options: UseDevhookOptions) {
         );
       }
 
+      // Check if user is logged in before connecting
+      const host = getHost();
+      if (!host) {
+        options.logger.log(
+          "system",
+          `Run ${chalk.bold("blink login")} to send webhooks to your agent from anywhere`
+        );
+        return;
+      }
+
       // Lock acquired, now connect
       const connect = () => {
         if (disposed || isConnecting) return;
@@ -112,19 +152,19 @@ export default function useDevhook(options: UseDevhookOptions) {
         }
 
         // No authentication needed for devhooks.
-        const client = new Client({
-          // TODO: This shouldn't be hardcoded but our @blink.so/api package
-          // currently uses `BLINK_API_URL` which this does too 🤦🤦🤦.
-          baseURL: "https://blink.coder.com",
-        });
+        const client = new Client({ baseURL: host });
         currentListener = client.devhook.listen({
           id: options.id!,
           onRequest: async (request) => {
             return onRequestRef.current(request);
           },
           onConnect: () => {
-            isConnecting = false;
-            setStatus("connected");
+            void (async () => {
+              const url = await client.devhook.getUrl(options.id!);
+              isConnecting = false;
+              setStatus("connected");
+                setPublicUrl(url);
+            })();
           },
           onDisconnect: () => {
             isConnecting = false;
@@ -181,11 +221,11 @@ export default function useDevhook(options: UseDevhookOptions) {
         }
       }
     };
-  }, [options.disabled, options.directory]);
+  }, [options.disabled, options.directory, options.id]);
 
   return {
     id: options.id,
-    url: options.id ? `https://${options.id}.blink.host` : undefined,
+    url: publicUrl,
     status,
   };
 }