Skip to content

armgit / alook

Public Imported from GitHub
0

Multi-Agent Collaboration for Team and Friends

feat(ws): broadcast runtime.registered and auto-close connect sheet

Gener66bc4de0c1ed
diff --git a/src/shared/src/types.ts b/src/shared/src/types.ts
index b81763360..3b686117b 100644
--- a/src/shared/src/types.ts
+++ b/src/shared/src/types.ts
@@ -151,7 +151,7 @@ export interface CreateAgentRequest {
/** WebSocket event types — single source of truth for the WS protocol. */
export type WsMessage =
- | { type: "runtime.registered"; daemonId: string; hostname: string }
+ | { type: "runtime.registered"; daemonId: string; hostname: string; workspaceId: string }
| { type: "runtime.status"; daemonId: string; workspaceId: string; status: string }
| { type: "runtime.deleted"; daemonId: string }
| { type: "task.updated"; taskId: string; status: string }
diff --git a/src/web/src/app/(app)/w/[slug]/runtimes/page.tsx b/src/web/src/app/(app)/w/[slug]/runtimes/page.tsx
index 6b6f4d93d..11b571fc2 100644
--- a/src/web/src/app/(app)/w/[slug]/runtimes/page.tsx
+++ b/src/web/src/app/(app)/w/[slug]/runtimes/page.tsx
@@ -129,7 +129,7 @@ function ConnectMachineSteps({
}
export default function RuntimesPage() {
- const { runtimes, loading, handleGenerateToken, handleDeleteMachine, reload } =
+ const { runtimes, loading, handleGenerateToken, handleDeleteMachine, reload, subscribeWs, workspaceId } =
useAgentContext();
const searchParams = useSearchParams();
const router = useRouter();
@@ -153,6 +153,17 @@ export default function RuntimesPage() {
}
}, [searchParams, router, pathname]);
+ // Close the sheet automatically when a daemon registers for this workspace
+ useEffect(() => {
+ return subscribeWs((msg) => {
+ if (msg.type === "runtime.registered" && msg.workspaceId === workspaceId) {
+ setSheetOpen(false);
+ setGeneratedToken("");
+ toast.success("Machine connected");
+ }
+ });
+ }, [subscribeWs, workspaceId]);
+
const openConfirm = (
title: string,
description: string,
diff --git a/src/web/src/app/api/daemon/register/route.test.ts b/src/web/src/app/api/daemon/register/route.test.ts
new file mode 100644
index 000000000..8a318496c
--- /dev/null
+++ b/src/web/src/app/api/daemon/register/route.test.ts
@@ -0,0 +1,150 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { NextRequest } from "next/server";
+
+const mockGetMember = vi.fn();
+const mockUpsertMachine = vi.fn();
+const mockUpsertAgentRuntime = vi.fn();
+const mockBroadcastToUser = vi.fn();
+
+function sharedMocks() {
+ return {
+ "@opennextjs/cloudflare": {
+ getCloudflareContext: vi.fn(() => ({ env: { DB: {} } })),
+ },
+ "@alook/shared": async () => ({
+ createDb: vi.fn(() => ({})),
+ queries: {
+ member: {
+ getMemberByUserAndWorkspace: (...a: any[]) => mockGetMember(...a),
+ },
+ machine: {
+ upsertMachine: (...a: any[]) => mockUpsertMachine(...a),
+ },
+ runtime: {
+ upsertAgentRuntime: (...a: any[]) => mockUpsertAgentRuntime(...a),
+ },
+ },
+ RegisterDaemonRequestSchema: (await import("@alook/shared"))
+ .RegisterDaemonRequestSchema,
+ }),
+ "@/lib/broadcast": {
+ broadcastToUser: (...a: any[]) => mockBroadcastToUser(...a),
+ },
+ "@/lib/api/responses": {
+ runtimeToResponse: (rt: any) => ({ id: rt.id, name: rt.name }),
+ },
+ };
+}
+
+function makeReq(body: unknown) {
+ return new NextRequest("http://localhost/api/daemon/register", {
+ method: "POST",
+ body: JSON.stringify(body),
+ headers: { "Content-Type": "application/json" },
+ });
+}
+
+describe("POST /api/daemon/register", () => {
+ beforeEach(() => vi.clearAllMocks());
+
+ async function loadRoute(authCtx: Record<string, unknown>) {
+ vi.resetModules();
+
+ const mocks = sharedMocks();
+
+ vi.doMock("@opennextjs/cloudflare", () => mocks["@opennextjs/cloudflare"]);
+ vi.doMock("@alook/shared", mocks["@alook/shared"]);
+ vi.doMock("@/lib/broadcast", () => mocks["@/lib/broadcast"]);
+ vi.doMock("@/lib/api/responses", () => mocks["@/lib/api/responses"]);
+ vi.doMock("@/lib/middleware/auth", () => ({
+ withAuth: vi.fn((handler: any) => async (req: any, ctx?: any) => {
+ const params =
+ ctx?.params instanceof Promise ? await ctx.params : ctx?.params;
+ return handler(req, { ...authCtx, params });
+ }),
+ }));
+ vi.doMock("@/lib/middleware/helpers", async () => {
+ return await vi.importActual<typeof import("@/lib/middleware/helpers")>(
+ "@/lib/middleware/helpers"
+ );
+ });
+
+ const { POST } = await import("./route");
+ return POST;
+ }
+
+ const validBody = {
+ workspace_id: "w1",
+ daemon_id: "d1",
+ device_name: "MyMachine",
+ cli_version: "0.0.2",
+ runtimes: [
+ { name: "claude", type: "claude", version: "1.0", runtime_mode: "local" },
+ ],
+ };
+
+ const authCtx = { userId: "u1", email: "[email protected]" };
+
+ it("upserts machine + runtimes and returns 200", async () => {
+ const POST = await loadRoute(authCtx);
+
+ mockGetMember.mockResolvedValue({ userId: "u1", workspaceId: "w1" });
+ mockUpsertMachine.mockResolvedValue(undefined);
+ mockUpsertAgentRuntime.mockResolvedValue({ id: "r1", name: "claude" });
+ mockBroadcastToUser.mockResolvedValue(undefined);
+
+ const res = await POST(makeReq(validBody));
+ const body = await res.json();
+
+ expect(res.status).toBe(200);
+ expect(body).toEqual({ runtimes: [{ id: "r1", name: "claude" }] });
+ expect(mockUpsertMachine).toHaveBeenCalledTimes(1);
+ expect(mockUpsertAgentRuntime).toHaveBeenCalledTimes(1);
+ });
+
+ it("broadcasts runtime.registered after upserts", async () => {
+ const POST = await loadRoute(authCtx);
+
+ mockGetMember.mockResolvedValue({ userId: "u1", workspaceId: "w1" });
+ mockUpsertMachine.mockResolvedValue(undefined);
+ mockUpsertAgentRuntime.mockResolvedValue({ id: "r1", name: "claude" });
+ mockBroadcastToUser.mockResolvedValue(undefined);
+
+ await POST(makeReq(validBody));
+
+ expect(mockBroadcastToUser).toHaveBeenCalledTimes(1);
+ expect(mockBroadcastToUser).toHaveBeenCalledWith("u1", {
+ type: "runtime.registered",
+ daemonId: "d1",
+ hostname: "MyMachine",
+ workspaceId: "w1",
+ });
+ });
+
+ it("returns 404 when membership is missing and does not broadcast", async () => {
+ const POST = await loadRoute(authCtx);
+
+ mockGetMember.mockResolvedValue(null);
+
+ const res = await POST(makeReq(validBody));
+ const body = await res.json();
+
+ expect(res.status).toBe(404);
+ expect(body.error).toBe("workspace not found");
+ expect(mockUpsertMachine).not.toHaveBeenCalled();
+ expect(mockBroadcastToUser).not.toHaveBeenCalled();
+ });
+
+ it("does not fail the request if broadcast throws (fire-and-forget)", async () => {
+ const POST = await loadRoute(authCtx);
+
+ mockGetMember.mockResolvedValue({ userId: "u1", workspaceId: "w1" });
+ mockUpsertMachine.mockResolvedValue(undefined);
+ mockUpsertAgentRuntime.mockResolvedValue({ id: "r1", name: "claude" });
+ mockBroadcastToUser.mockRejectedValue(new Error("ws down"));
+
+ const res = await POST(makeReq(validBody));
+
+ expect(res.status).toBe(200);
+ });
+});
diff --git a/src/web/src/app/api/daemon/register/route.ts b/src/web/src/app/api/daemon/register/route.ts
index 2f0bb4fd8..d0bb0844a 100644
--- a/src/web/src/app/api/daemon/register/route.ts
+++ b/src/web/src/app/api/daemon/register/route.ts
@@ -5,6 +5,7 @@ import { withAuth } from "@/lib/middleware/auth";
import { writeJSON, parseBody } from "@/lib/middleware/helpers";
import { runtimeToResponse } from "@/lib/api/responses";
import { RegisterDaemonRequestSchema } from "@alook/shared";
+import { broadcastToUser } from "@/lib/broadcast";
export const POST = withAuth(async (req: NextRequest, ctx) => {
const { env } = getCloudflareContext()
@@ -57,5 +58,12 @@ export const POST = withAuth(async (req: NextRequest, ctx) => {
results.push({ ...result, machineLastSeenAt: new Date().toISOString() });
}
+ broadcastToUser(ctx.userId, {
+ type: "runtime.registered",
+ daemonId,
+ hostname: deviceName.trim(),
+ workspaceId,
+ }).catch(() => {});
+
return writeJSON({ runtimes: results.map(runtimeToResponse) });
});
diff --git a/src/web/src/app/api/machine-tokens/activate/route.ts b/src/web/src/app/api/machine-tokens/activate/route.ts
index aa25bf9f1..948edbfef 100644
--- a/src/web/src/app/api/machine-tokens/activate/route.ts
+++ b/src/web/src/app/api/machine-tokens/activate/route.ts
@@ -65,6 +65,7 @@ export async function POST(req: NextRequest) {
type: "runtime.registered",
daemonId,
hostname,
+ workspaceId: mt.workspaceId,
}).catch(() => {});
return writeJSON({
diff --git a/src/web/src/contexts/agent-context.tsx b/src/web/src/contexts/agent-context.tsx
index af0fcc8bc..16f5c8d97 100644
--- a/src/web/src/contexts/agent-context.tsx
+++ b/src/web/src/contexts/agent-context.tsx
@@ -31,6 +31,7 @@ import { useUserWs } from "@/lib/use-user-ws";
type WsSubscriber = (msg: WsMessage) => void;
interface AgentContextValue {
+ workspaceId: string;
agents: Agent[];
runtimes: Runtime[];
loading: boolean;
@@ -116,6 +117,10 @@ export function AgentProvider({
// AgentProvider only reloads agents/runtimes for runtime events
switch (msg.type) {
case "runtime.registered":
+ // Filter by workspaceId — ignore registrations in other workspaces
+ if (msg.workspaceId !== workspaceId) break;
+ reload();
+ break;
case "runtime.deleted":
reload();
break;
@@ -214,6 +219,7 @@ export function AgentProvider({
return (
<AgentContext.Provider
value={{
+ workspaceId,
agents,
runtimes,
loading,