Skip to content

armgit / alook

Public Imported from GitHub
0

Multi-Agent Collaboration for Team and Friends

fix: auth and ws expire

Gus1bd53fd63924
diff --git a/src/shared/src/db/queries/session.ts b/src/shared/src/db/queries/session.ts
index 2b90a1485..1c2fa959e 100644
--- a/src/shared/src/db/queries/session.ts
+++ b/src/shared/src/db/queries/session.ts
@@ -1,4 +1,4 @@
-import { eq } from "drizzle-orm";
+import { eq, and, gt } from "drizzle-orm";
import { session } from "../schema";
import type { Database } from "../index";
@@ -6,7 +6,12 @@ export async function getValidSession(db: Database, token: string) {
const rows = await db
.select({ userId: session.userId })
.from(session)
- .where(eq(session.token, token));
+ .where(
+ and(
+ eq(session.token, token),
+ gt(session.expiresAt, new Date().toISOString())
+ )
+ );
if (rows.length === 0) return null;
return rows[0].userId;
}
diff --git a/src/shared/src/db/queries/task-message.ts b/src/shared/src/db/queries/task-message.ts
index 85daf3345..4f30e1dbf 100644
--- a/src/shared/src/db/queries/task-message.ts
+++ b/src/shared/src/db/queries/task-message.ts
@@ -1,5 +1,5 @@
import { eq, and, gt, asc } from "drizzle-orm";
-import { taskMessage } from "../schema";
+import { taskMessage, agentTaskQueue } from "../schema";
import type { Database } from "../index";
export async function createTaskMessage(
@@ -31,7 +31,26 @@ export async function createTaskMessage(
return rows[0]!;
}
-export async function listTaskMessages(db: Database, taskId: string) {
+export async function listTaskMessages(db: Database, taskId: string, workspaceId?: string) {
+ if (workspaceId) {
+ return db
+ .select({
+ id: taskMessage.id,
+ taskId: taskMessage.taskId,
+ seq: taskMessage.seq,
+ type: taskMessage.type,
+ tool: taskMessage.tool,
+ content: taskMessage.content,
+ callId: taskMessage.callId,
+ input: taskMessage.input,
+ output: taskMessage.output,
+ createdAt: taskMessage.createdAt,
+ })
+ .from(taskMessage)
+ .innerJoin(agentTaskQueue, eq(taskMessage.taskId, agentTaskQueue.id))
+ .where(and(eq(taskMessage.taskId, taskId), eq(agentTaskQueue.workspaceId, workspaceId)))
+ .orderBy(asc(taskMessage.seq));
+ }
return db
.select()
.from(taskMessage)
diff --git a/src/shared/src/db/queries/task.ts b/src/shared/src/db/queries/task.ts
index 73edafb83..8b8d3cb1f 100644
--- a/src/shared/src/db/queries/task.ts
+++ b/src/shared/src/db/queries/task.ts
@@ -107,12 +107,12 @@ export async function claimTask(db: Database, agentId: string, workspaceId: stri
return ClaimedTaskRowSchema.parse(row);
}
-export async function startTask(db: Database, id: string) {
+export async function startTask(db: Database, id: string, workspaceId: string) {
const rows = await db
.update(agentTaskQueue)
.set({ status: "running", startedAt: new Date().toISOString() })
.where(
- and(eq(agentTaskQueue.id, id), eq(agentTaskQueue.status, "dispatched"))
+ and(eq(agentTaskQueue.id, id), eq(agentTaskQueue.workspaceId, workspaceId), eq(agentTaskQueue.status, "dispatched"))
)
.returning();
return rows[0] ?? null;
@@ -121,6 +121,7 @@ export async function startTask(db: Database, id: string) {
export async function completeTask(
db: Database,
id: string,
+ workspaceId: string,
data: { result: unknown; sessionId: string | null }
) {
const rows = await db
@@ -132,7 +133,7 @@ export async function completeTask(
sessionId: data.sessionId,
})
.where(
- and(eq(agentTaskQueue.id, id), eq(agentTaskQueue.status, "running"))
+ and(eq(agentTaskQueue.id, id), eq(agentTaskQueue.workspaceId, workspaceId), eq(agentTaskQueue.status, "running"))
)
.returning();
return rows[0] ?? null;
@@ -141,6 +142,7 @@ export async function completeTask(
export async function failTask(
db: Database,
id: string,
+ workspaceId: string,
error: string
) {
const rows = await db
@@ -149,6 +151,7 @@ export async function failTask(
.where(
and(
eq(agentTaskQueue.id, id),
+ eq(agentTaskQueue.workspaceId, workspaceId),
inArray(agentTaskQueue.status, ["dispatched", "running"])
)
)
diff --git a/src/shared/src/db/queries/workspace.ts b/src/shared/src/db/queries/workspace.ts
index 0ea35140e..cc4e1d1c5 100644
--- a/src/shared/src/db/queries/workspace.ts
+++ b/src/shared/src/db/queries/workspace.ts
@@ -1,9 +1,19 @@
-import { eq, asc } from "drizzle-orm";
+import { eq, and, asc } from "drizzle-orm";
import { workspace, member } from "../schema";
import type { Database } from "../index";
-export async function getWorkspace(db: Database, id: string) {
- const rows = await db.select().from(workspace).where(eq(workspace.id, id));
+export async function getWorkspace(db: Database, id: string, userId: string) {
+ const rows = await db
+ .select({
+ id: workspace.id,
+ name: workspace.name,
+ slug: workspace.slug,
+ createdAt: workspace.createdAt,
+ updatedAt: workspace.updatedAt,
+ })
+ .from(workspace)
+ .innerJoin(member, eq(member.workspaceId, workspace.id))
+ .where(and(eq(workspace.id, id), eq(member.userId, userId)));
return rows[0] ?? null;
}
diff --git a/src/web/src/app/api/daemon/routes.test.ts b/src/web/src/app/api/daemon/routes.test.ts
index 5a51d3b6f..00348f31f 100644
--- a/src/web/src/app/api/daemon/routes.test.ts
+++ b/src/web/src/app/api/daemon/routes.test.ts
@@ -513,6 +513,9 @@ describe("daemon route body validation", () => {
...real,
createDb: vi.fn(() => ({})),
queries: {
+ task: {
+ getTask: vi.fn().mockResolvedValue({ id: "t1", workspaceId: "w1" }),
+ },
taskMessage: {
createTaskMessage: vi.fn().mockResolvedValue(undefined),
},
@@ -556,6 +559,9 @@ describe("daemon route body validation", () => {
...real,
createDb: vi.fn(() => ({})),
queries: {
+ task: {
+ getTask: vi.fn().mockResolvedValue({ id: "t1", workspaceId: "w1" }),
+ },
taskMessage: { createTaskMessage: createMock },
},
};
@@ -606,6 +612,9 @@ describe("daemon route body validation", () => {
...real,
createDb: vi.fn(() => ({})),
queries: {
+ task: {
+ getTask: vi.fn().mockResolvedValue({ id: "t1", workspaceId: "w1" }),
+ },
taskMessage: { createTaskMessage: vi.fn().mockResolvedValue(undefined) },
},
};
diff --git a/src/web/src/app/api/daemon/tasks/[taskId]/complete/route.test.ts b/src/web/src/app/api/daemon/tasks/[taskId]/complete/route.test.ts
new file mode 100644
index 000000000..768cd5364
--- /dev/null
+++ b/src/web/src/app/api/daemon/tasks/[taskId]/complete/route.test.ts
@@ -0,0 +1,96 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { NextRequest } from "next/server";
+
+const mockCompleteTask = vi.fn();
+const mockTaskToResponse = vi.fn();
+
+let mockAuthCtx: Record<string, unknown> = { userId: "u1", email: "[email protected]", workspaceId: "w1" };
+
+vi.mock("@opennextjs/cloudflare", () => ({
+ getCloudflareContext: vi.fn(() => ({ env: { DB: {} } })),
+}));
+vi.mock("@alook/shared", async () => {
+ const real = await vi.importActual<typeof import("@alook/shared")>("@alook/shared");
+ return {
+ ...real,
+ createDb: vi.fn(() => ({})),
+ };
+});
+vi.mock("@/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, { ...mockAuthCtx, params });
+ }),
+}));
+vi.mock("@/lib/middleware/helpers", async () => {
+ return await vi.importActual<typeof import("@/lib/middleware/helpers")>(
+ "@/lib/middleware/helpers"
+ );
+});
+vi.mock("@/lib/services/task", () => {
+ const MockTaskService = function (this: any) {
+ this.completeTask = (...a: any[]) => mockCompleteTask(...a);
+ } as any;
+ return { TaskService: MockTaskService };
+});
+vi.mock("@/lib/api/responses", () => ({
+ taskToResponse: (...args: any[]) => mockTaskToResponse(...args),
+}));
+vi.mock("@/lib/broadcast", () => ({
+ broadcastToUser: vi.fn().mockResolvedValue(undefined),
+}));
+
+import { POST } from "./route";
+
+const withParams = (taskId: string) => ({
+ params: Promise.resolve({ taskId }),
+});
+
+const makeReq = (taskId: string, body: Record<string, unknown> = {}) =>
+ new NextRequest(`http://localhost/api/daemon/tasks/${taskId}/complete`, {
+ method: "POST",
+ headers: { "Content-Type": "application/json" },
+ body: JSON.stringify(body),
+ });
+
+describe("POST /api/daemon/tasks/[taskId]/complete", () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ mockAuthCtx = { userId: "u1", email: "[email protected]", workspaceId: "w1" };
+ });
+
+ it("returns completed task", async () => {
+ const fakeTask = { id: "t1", status: "completed" };
+ mockCompleteTask.mockResolvedValue(fakeTask);
+ mockTaskToResponse.mockReturnValue({ id: "t1", status: "completed" });
+
+ const res = await POST(makeReq("t1", { output: "done" }), withParams("t1"));
+ const body = await res.json();
+
+ expect(res.status).toBe(200);
+ expect(body).toEqual({ id: "t1", status: "completed" });
+ expect(mockCompleteTask).toHaveBeenCalledWith("t1", "w1", expect.any(String), "");
+ });
+
+ it("returns 403 when workspaceId is missing (session auth)", async () => {
+ mockAuthCtx = { userId: "u1", email: "[email protected]" };
+
+ const res = await POST(makeReq("t1", { output: "done" }), withParams("t1"));
+ const body = await res.json();
+
+ expect(res.status).toBe(403);
+ expect(body.error).toBe("Forbidden: machine token required");
+ expect(mockCompleteTask).not.toHaveBeenCalled();
+ });
+
+ it("rejects cross-workspace task complete (task not found for workspace)", async () => {
+ mockCompleteTask.mockRejectedValue(new Error("cannot complete task in 'unknown' status"));
+
+ const res = await POST(makeReq("t-other", { output: "done" }), withParams("t-other"));
+ const body = await res.json();
+
+ expect(res.status).toBe(400);
+ expect(mockCompleteTask).toHaveBeenCalledWith("t-other", "w1", expect.any(String), "");
+ });
+});
diff --git a/src/web/src/app/api/daemon/tasks/[taskId]/complete/route.ts b/src/web/src/app/api/daemon/tasks/[taskId]/complete/route.ts
index 01b8fe5ae..05728c9bd 100644
--- a/src/web/src/app/api/daemon/tasks/[taskId]/complete/route.ts
+++ b/src/web/src/app/api/daemon/tasks/[taskId]/complete/route.ts
@@ -9,6 +9,10 @@ import { CompleteTaskRequestSchema } from "@alook/shared";
import { broadcastToUser } from "@/lib/broadcast";
export const POST = withAuth(async (req: NextRequest, ctx) => {
+ if (!ctx.workspaceId) {
+ return writeError("Forbidden: machine token required", 403);
+ }
+
const { env } = getCloudflareContext()
const db = getDb((env as Env).DB)
@@ -27,6 +31,7 @@ export const POST = withAuth(async (req: NextRequest, ctx) => {
try {
const task = await taskService.completeTask(
taskId,
+ ctx.workspaceId,
result,
sessionId
);
diff --git a/src/web/src/app/api/daemon/tasks/[taskId]/fail/route.test.ts b/src/web/src/app/api/daemon/tasks/[taskId]/fail/route.test.ts
new file mode 100644
index 000000000..ca97efa14
--- /dev/null
+++ b/src/web/src/app/api/daemon/tasks/[taskId]/fail/route.test.ts
@@ -0,0 +1,96 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { NextRequest } from "next/server";
+
+const mockFailTask = vi.fn();
+const mockTaskToResponse = vi.fn();
+
+let mockAuthCtx: Record<string, unknown> = { userId: "u1", email: "[email protected]", workspaceId: "w1" };
+
+vi.mock("@opennextjs/cloudflare", () => ({
+ getCloudflareContext: vi.fn(() => ({ env: { DB: {} } })),
+}));
+vi.mock("@alook/shared", async () => {
+ const real = await vi.importActual<typeof import("@alook/shared")>("@alook/shared");
+ return {
+ ...real,
+ createDb: vi.fn(() => ({})),
+ };
+});
+vi.mock("@/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, { ...mockAuthCtx, params });
+ }),
+}));
+vi.mock("@/lib/middleware/helpers", async () => {
+ return await vi.importActual<typeof import("@/lib/middleware/helpers")>(
+ "@/lib/middleware/helpers"
+ );
+});
+vi.mock("@/lib/services/task", () => {
+ const MockTaskService = function (this: any) {
+ this.failTask = (...a: any[]) => mockFailTask(...a);
+ } as any;
+ return { TaskService: MockTaskService };
+});
+vi.mock("@/lib/api/responses", () => ({
+ taskToResponse: (...args: any[]) => mockTaskToResponse(...args),
+}));
+vi.mock("@/lib/broadcast", () => ({
+ broadcastToUser: vi.fn().mockResolvedValue(undefined),
+}));
+
+import { POST } from "./route";
+
+const withParams = (taskId: string) => ({
+ params: Promise.resolve({ taskId }),
+});
+
+const makeReq = (taskId: string, body: Record<string, unknown> = {}) =>
+ new NextRequest(`http://localhost/api/daemon/tasks/${taskId}/fail`, {
+ method: "POST",
+ headers: { "Content-Type": "application/json" },
+ body: JSON.stringify(body),
+ });
+
+describe("POST /api/daemon/tasks/[taskId]/fail", () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ mockAuthCtx = { userId: "u1", email: "[email protected]", workspaceId: "w1" };
+ });
+
+ it("returns failed task", async () => {
+ const fakeTask = { id: "t1", status: "failed" };
+ mockFailTask.mockResolvedValue(fakeTask);
+ mockTaskToResponse.mockReturnValue({ id: "t1", status: "failed" });
+
+ const res = await POST(makeReq("t1", { error: "boom" }), withParams("t1"));
+ const body = await res.json();
+
+ expect(res.status).toBe(200);
+ expect(body).toEqual({ id: "t1", status: "failed" });
+ expect(mockFailTask).toHaveBeenCalledWith("t1", "w1", "boom");
+ });
+
+ it("returns 403 when workspaceId is missing (session auth)", async () => {
+ mockAuthCtx = { userId: "u1", email: "[email protected]" };
+
+ const res = await POST(makeReq("t1", { error: "boom" }), withParams("t1"));
+ const body = await res.json();
+
+ expect(res.status).toBe(403);
+ expect(body.error).toBe("Forbidden: machine token required");
+ expect(mockFailTask).not.toHaveBeenCalled();
+ });
+
+ it("rejects cross-workspace task fail (task not found for workspace)", async () => {
+ mockFailTask.mockRejectedValue(new Error("cannot fail task in 'unknown' status"));
+
+ const res = await POST(makeReq("t-other", { error: "boom" }), withParams("t-other"));
+ const body = await res.json();
+
+ expect(res.status).toBe(400);
+ expect(mockFailTask).toHaveBeenCalledWith("t-other", "w1", "boom");
+ });
+});
diff --git a/src/web/src/app/api/daemon/tasks/[taskId]/fail/route.ts b/src/web/src/app/api/daemon/tasks/[taskId]/fail/route.ts
index 4a4ddf592..a5e6bad56 100644
--- a/src/web/src/app/api/daemon/tasks/[taskId]/fail/route.ts
+++ b/src/web/src/app/api/daemon/tasks/[taskId]/fail/route.ts
@@ -9,6 +9,10 @@ import { FailTaskRequestSchema } from "@alook/shared";
import { broadcastToUser } from "@/lib/broadcast";
export const POST = withAuth(async (req: NextRequest, ctx) => {
+ if (!ctx.workspaceId) {
+ return writeError("Forbidden: machine token required", 403);
+ }
+
const { env } = getCloudflareContext()
const db = getDb((env as Env).DB)
@@ -22,7 +26,7 @@ export const POST = withAuth(async (req: NextRequest, ctx) => {
const taskService = new TaskService(db);
try {
- const task = await taskService.failTask(taskId, body.error);
+ const task = await taskService.failTask(taskId, ctx.workspaceId, body.error);
broadcastToUser(ctx.userId, { type: "task.updated", taskId, status: "failed" }).catch(() => {});
return writeJSON(taskToResponse(task));
} catch (e: unknown) {
diff --git a/src/web/src/app/api/daemon/tasks/[taskId]/messages/route.test.ts b/src/web/src/app/api/daemon/tasks/[taskId]/messages/route.test.ts
new file mode 100644
index 000000000..ec73c3d33
--- /dev/null
+++ b/src/web/src/app/api/daemon/tasks/[taskId]/messages/route.test.ts
@@ -0,0 +1,160 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { NextRequest } from "next/server";
+
+const mockListTaskMessages = vi.fn();
+const mockCreateTaskMessage = vi.fn();
+const mockGetTask = vi.fn();
+const mockTaskMessageToResponse = vi.fn((m: any) => m);
+
+let mockAuthCtx: Record<string, unknown> = { userId: "u1", email: "[email protected]", workspaceId: "w1" };
+
+vi.mock("@opennextjs/cloudflare", () => ({
+ getCloudflareContext: vi.fn(() => ({ env: { DB: {} } })),
+}));
+vi.mock("@alook/shared", async () => {
+ const real = await vi.importActual<typeof import("@alook/shared")>("@alook/shared");
+ return {
+ ...real,
+ createDb: vi.fn(() => ({})),
+ queries: {
+ taskMessage: {
+ listTaskMessages: (...args: any[]) => mockListTaskMessages(...args),
+ createTaskMessage: (...args: any[]) => mockCreateTaskMessage(...args),
+ },
+ task: {
+ getTask: (...args: any[]) => mockGetTask(...args),
+ },
+ },
+ };
+});
+vi.mock("@/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, { ...mockAuthCtx, params });
+ }),
+}));
+vi.mock("@/lib/middleware/helpers", async () => {
+ return await vi.importActual<typeof import("@/lib/middleware/helpers")>(
+ "@/lib/middleware/helpers"
+ );
+});
+vi.mock("@/lib/api/responses", () => ({
+ taskMessageToResponse: (...args: any[]) => mockTaskMessageToResponse(...args),
+}));
+vi.mock("@/lib/broadcast", () => ({
+ broadcastToUser: vi.fn().mockResolvedValue(undefined),
+}));
+vi.mock("@/lib/logger", () => ({
+ log: { warn: vi.fn(), info: vi.fn(), error: vi.fn() },
+}));
+
+import { GET, POST } from "./route";
+
+const withParams = (taskId: string) => ({
+ params: Promise.resolve({ taskId }),
+});
+
+describe("GET /api/daemon/tasks/[taskId]/messages", () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ mockAuthCtx = { userId: "u1", email: "[email protected]", workspaceId: "w1" };
+ });
+
+ it("returns messages for workspace-scoped task", async () => {
+ const msgs = [{ id: "m1", seq: 1, content: "hi" }];
+ mockListTaskMessages.mockResolvedValue(msgs);
+
+ const res = await GET(
+ new NextRequest("http://localhost/api/daemon/tasks/t1/messages"),
+ withParams("t1")
+ );
+ const body = await res.json();
+
+ expect(res.status).toBe(200);
+ expect(body).toHaveLength(1);
+ expect(mockListTaskMessages).toHaveBeenCalledWith({}, "t1", "w1");
+ });
+
+ it("returns 403 when workspaceId is missing (session auth)", async () => {
+ mockAuthCtx = { userId: "u1", email: "[email protected]" };
+
+ const res = await GET(
+ new NextRequest("http://localhost/api/daemon/tasks/t1/messages"),
+ withParams("t1")
+ );
+ const body = await res.json();
+
+ expect(res.status).toBe(403);
+ expect(body.error).toBe("Forbidden: machine token required");
+ expect(mockListTaskMessages).not.toHaveBeenCalled();
+ });
+});
+
+describe("POST /api/daemon/tasks/[taskId]/messages", () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ mockAuthCtx = { userId: "u1", email: "[email protected]", workspaceId: "w1" };
+ });
+
+ it("creates messages for workspace-scoped task", async () => {
+ mockGetTask.mockResolvedValue({ id: "t1", workspaceId: "w1" });
+ mockCreateTaskMessage.mockResolvedValue({ id: "m1" });
+
+ const res = await POST(
+ new NextRequest("http://localhost/api/daemon/tasks/t1/messages", {
+ method: "POST",
+ headers: { "Content-Type": "application/json" },
+ body: JSON.stringify({
+ messages: [{ seq: 1, type: "text", content: "hello" }],
+ }),
+ }),
+ withParams("t1")
+ );
+ const body = await res.json();
+
+ expect(res.status).toBe(200);
+ expect(body.status).toBe("ok");
+ expect(mockGetTask).toHaveBeenCalledWith({}, "t1", "w1");
+ });
+
+ it("returns 403 when workspaceId is missing (session auth)", async () => {
+ mockAuthCtx = { userId: "u1", email: "[email protected]" };
+
+ const res = await POST(
+ new NextRequest("http://localhost/api/daemon/tasks/t1/messages", {
+ method: "POST",
+ headers: { "Content-Type": "application/json" },
+ body: JSON.stringify({
+ messages: [{ seq: 1, type: "text", content: "hello" }],
+ }),
+ }),
+ withParams("t1")
+ );
+ const body = await res.json();
+
+ expect(res.status).toBe(403);
+ expect(body.error).toBe("Forbidden: machine token required");
+ expect(mockGetTask).not.toHaveBeenCalled();
+ });
+
+ it("returns 404 when task belongs to another workspace", async () => {
+ mockGetTask.mockResolvedValue(null);
+
+ const res = await POST(
+ new NextRequest("http://localhost/api/daemon/tasks/t-other/messages", {
+ method: "POST",
+ headers: { "Content-Type": "application/json" },
+ body: JSON.stringify({
+ messages: [{ seq: 1, type: "text", content: "hello" }],
+ }),
+ }),
+ withParams("t-other")
+ );
+ const body = await res.json();
+
+ expect(res.status).toBe(404);
+ expect(body.error).toBe("task not found");
+ expect(mockCreateTaskMessage).not.toHaveBeenCalled();
+ });
+});
diff --git a/src/web/src/app/api/daemon/tasks/[taskId]/messages/route.ts b/src/web/src/app/api/daemon/tasks/[taskId]/messages/route.ts
index 542eaa93e..56d08e764 100644
--- a/src/web/src/app/api/daemon/tasks/[taskId]/messages/route.ts
+++ b/src/web/src/app/api/daemon/tasks/[taskId]/messages/route.ts
@@ -11,6 +11,10 @@ import { broadcastToUser } from "@/lib/broadcast";
import { log } from "@/lib/logger";
export const GET = withAuth(async (_req, ctx) => {
+ if (!ctx.workspaceId) {
+ return writeError("Forbidden: machine token required", 403);
+ }
+
const { env } = getCloudflareContext()
const db = getDb((env as Env).DB)
@@ -19,11 +23,15 @@ export const GET = withAuth(async (_req, ctx) => {
return writeError("task_id is required", 400);
}
- const messages = await queries.taskMessage.listTaskMessages(db, taskId);
+ const messages = await queries.taskMessage.listTaskMessages(db, taskId, ctx.workspaceId);
return writeJSON(messages.map(taskMessageToResponse));
});
export const POST = withAuth(async (req: NextRequest, ctx) => {
+ if (!ctx.workspaceId) {
+ return writeError("Forbidden: machine token required", 403);
+ }
+
const { env } = getCloudflareContext()
const db = getDb((env as Env).DB)
@@ -32,6 +40,11 @@ export const POST = withAuth(async (req: NextRequest, ctx) => {
return writeError("task_id is required", 400);
}
+ const task = await queries.task.getTask(db, taskId, ctx.workspaceId);
+ if (!task) {
+ return writeError("task not found", 404);
+ }
+
const [body, err] = await parseBody(req, ReportMessagesRequestSchema);
if (err) return err;
diff --git a/src/web/src/app/api/daemon/tasks/[taskId]/start/route.test.ts b/src/web/src/app/api/daemon/tasks/[taskId]/start/route.test.ts
index 840969ca9..46ffeb730 100644
--- a/src/web/src/app/api/daemon/tasks/[taskId]/start/route.test.ts
+++ b/src/web/src/app/api/daemon/tasks/[taskId]/start/route.test.ts
@@ -4,6 +4,8 @@ import { NextRequest } from "next/server";
const mockStartTask = vi.fn();
const mockTaskToResponse = vi.fn();
+let mockAuthCtx: Record<string, unknown> = { userId: "u1", email: "[email protected]", workspaceId: "w1" };
+
vi.mock("@opennextjs/cloudflare", () => ({
getCloudflareContext: vi.fn(() => ({ env: { DB: {} } })),
}));
@@ -16,7 +18,7 @@ vi.mock("@/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, { userId: "u1", email: "[email protected]", workspaceId: "w1", params });
+ return handler(req, { ...mockAuthCtx, params });
}),
}));
vi.mock("@/lib/middleware/helpers", async () => {
@@ -41,7 +43,10 @@ const withParams = (taskId: string) => ({
});
describe("POST /api/daemon/tasks/[taskId]/start", () => {
- beforeEach(() => vi.clearAllMocks());
+ beforeEach(() => {
+ vi.clearAllMocks();
+ mockAuthCtx = { userId: "u1", email: "[email protected]", workspaceId: "w1" };
+ });
it("returns started task", async () => {
const fakeTask = {
@@ -62,7 +67,7 @@ describe("POST /api/daemon/tasks/[taskId]/start", () => {
expect(res.status).toBe(200);
expect(body).toEqual({ id: "t1", status: "running" });
- expect(mockStartTask).toHaveBeenCalledWith("t1");
+ expect(mockStartTask).toHaveBeenCalledWith("t1", "w1");
});
it("returns 400 when task not in dispatched status", async () => {
@@ -79,4 +84,36 @@ describe("POST /api/daemon/tasks/[taskId]/start", () => {
expect(res.status).toBe(400);
expect(body.error).toBe("task not in dispatched status");
});
+
+ it("returns 403 when workspaceId is missing (session auth)", async () => {
+ mockAuthCtx = { userId: "u1", email: "[email protected]" };
+
+ const res = await POST(
+ new NextRequest("http://localhost/api/daemon/tasks/t1/start", {
+ method: "POST",
+ }),
+ withParams("t1")
+ );
+ const body = await res.json();
+
+ expect(res.status).toBe(403);
+ expect(body.error).toBe("Forbidden: machine token required");
+ expect(mockStartTask).not.toHaveBeenCalled();
+ });
+
+ it("rejects cross-workspace task start (task not found for workspace)", async () => {
+ mockStartTask.mockRejectedValue(new Error("task not in dispatched status"));
+
+ const res = await POST(
+ new NextRequest("http://localhost/api/daemon/tasks/t-other/start", {
+ method: "POST",
+ }),
+ withParams("t-other")
+ );
+ const body = await res.json();
+
+ expect(res.status).toBe(400);
+ expect(body.error).toBe("task not in dispatched status");
+ expect(mockStartTask).toHaveBeenCalledWith("t-other", "w1");
+ });
});
diff --git a/src/web/src/app/api/daemon/tasks/[taskId]/start/route.ts b/src/web/src/app/api/daemon/tasks/[taskId]/start/route.ts
index 6e0290090..7ff723146 100644
--- a/src/web/src/app/api/daemon/tasks/[taskId]/start/route.ts
+++ b/src/web/src/app/api/daemon/tasks/[taskId]/start/route.ts
@@ -6,6 +6,10 @@ import { taskToResponse } from "@/lib/api/responses";
import { TaskService } from "@/lib/services/task";
export const POST = withAuth(async (_req, ctx) => {
+ if (!ctx.workspaceId) {
+ return writeError("Forbidden: machine token required", 403);
+ }
+
const { env } = getCloudflareContext()
const db = getDb((env as Env).DB)
@@ -16,7 +20,7 @@ export const POST = withAuth(async (_req, ctx) => {
const taskService = new TaskService(db);
try {
- const task = await taskService.startTask(taskId);
+ const task = await taskService.startTask(taskId, ctx.workspaceId);
return writeJSON(taskToResponse(task));
} catch (err: unknown) {
return writeError(err instanceof Error ? err.message : "Unknown error", 400);
diff --git a/src/web/src/app/api/workspaces/[id]/route.test.ts b/src/web/src/app/api/workspaces/[id]/route.test.ts
index 679ac5029..75a5f03a1 100644
--- a/src/web/src/app/api/workspaces/[id]/route.test.ts
+++ b/src/web/src/app/api/workspaces/[id]/route.test.ts
@@ -1,6 +1,8 @@
import { describe, it, expect, vi, beforeEach } from "vitest";
import { NextRequest } from "next/server";
+let mockAuthCtx: Record<string, unknown> = { userId: "u1", email: "[email protected]" };
+
vi.mock("@opennextjs/cloudflare", () => ({
getCloudflareContext: vi.fn(() => ({ env: { DB: {} } })),
}));
@@ -19,7 +21,7 @@ vi.mock("@alook/shared", () => ({
vi.mock("@/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, { userId: "u1", email: "[email protected]", params });
+ return handler(req, { ...mockAuthCtx, params });
}),
}));
@@ -38,9 +40,12 @@ vi.mock("@/lib/api/responses", () => ({
import { GET } from "./route";
describe("GET /api/workspaces/[id]", () => {
- beforeEach(() => vi.clearAllMocks());
+ beforeEach(() => {
+ vi.clearAllMocks();
+ mockAuthCtx = { userId: "u1", email: "[email protected]" };
+ });
- it("returns workspace", async () => {
+ it("returns workspace for a member", async () => {
mockGetWorkspace.mockResolvedValue({ id: "w1", name: "Acme", slug: "acme" });
const req = new NextRequest("http://localhost/api/workspaces/w1");
@@ -48,10 +53,10 @@ describe("GET /api/workspaces/[id]", () => {
expect(res.status).toBe(200);
expect(await res.json()).toEqual({ id: "w1", name: "Acme", slug: "acme" });
- expect(mockGetWorkspace).toHaveBeenCalledWith({}, "w1");
+ expect(mockGetWorkspace).toHaveBeenCalledWith({}, "w1", "u1");
});
- it("returns 404 when not found", async () => {
+ it("returns 404 when workspace does not exist", async () => {
mockGetWorkspace.mockResolvedValue(null);
const req = new NextRequest("http://localhost/api/workspaces/w999");
@@ -60,4 +65,26 @@ describe("GET /api/workspaces/[id]", () => {
expect(res.status).toBe(404);
expect(await res.json()).toEqual({ error: "workspace not found" });
});
+
+ it("returns 404 when user is not a member of the workspace", async () => {
+ mockGetWorkspace.mockResolvedValue(null);
+
+ const req = new NextRequest("http://localhost/api/workspaces/w-other");
+ const res = await GET(req, { params: Promise.resolve({ id: "w-other" }) } as any);
+
+ expect(res.status).toBe(404);
+ expect(await res.json()).toEqual({ error: "workspace not found" });
+ expect(mockGetWorkspace).toHaveBeenCalledWith({}, "w-other", "u1");
+ });
+
+ it("passes userId to query so membership is enforced in SQL", async () => {
+ mockAuthCtx = { userId: "u2", email: "[email protected]" };
+ mockGetWorkspace.mockResolvedValue(null);
+
+ const req = new NextRequest("http://localhost/api/workspaces/w1");
+ const res = await GET(req, { params: Promise.resolve({ id: "w1" }) } as any);
+
+ expect(res.status).toBe(404);
+ expect(mockGetWorkspace).toHaveBeenCalledWith({}, "w1", "u2");
+ });
});
diff --git a/src/web/src/app/api/workspaces/[id]/route.ts b/src/web/src/app/api/workspaces/[id]/route.ts
index 43dc7e5f7..2ab59c883 100644
--- a/src/web/src/app/api/workspaces/[id]/route.ts
+++ b/src/web/src/app/api/workspaces/[id]/route.ts
@@ -14,7 +14,7 @@ export const GET = withAuth(async (_req, ctx) => {
return writeError("workspace id is required", 400);
}
- const workspace = await queries.workspace.getWorkspace(db, id);
+ const workspace = await queries.workspace.getWorkspace(db, id, ctx.userId);
if (!workspace) {
return writeError("workspace not found", 404);
}
diff --git a/src/web/src/lib/services/task.test.ts b/src/web/src/lib/services/task.test.ts
index d26a5ba35..cab9d2b63 100644
--- a/src/web/src/lib/services/task.test.ts
+++ b/src/web/src/lib/services/task.test.ts
@@ -259,7 +259,7 @@ describe("TaskService", () => {
it("throws when not in dispatched status", async () => {
taskQ.startTask.mockResolvedValue(null);
- await expect(service.startTask("t1")).rejects.toThrow(
+ await expect(service.startTask("t1", "w1")).rejects.toThrow(
"task not in dispatched status"
);
});
@@ -268,8 +268,9 @@ describe("TaskService", () => {
const task = { id: "t1", status: "running" };
taskQ.startTask.mockResolvedValue(task);
- const result = await service.startTask("t1");
+ const result = await service.startTask("t1", "w1");
expect(result).toEqual(task);
+ expect(taskQ.startTask).toHaveBeenCalledWith({}, "t1", "w1");
});
});
@@ -290,6 +291,7 @@ describe("TaskService", () => {
await service.completeTask(
"t1",
+ "w1",
JSON.stringify({ output: "Here is the answer" }),
"sess-1"
);
@@ -314,7 +316,7 @@ describe("TaskService", () => {
taskQ.countRunningTasks.mockResolvedValue(0);
agentQ.updateAgentStatus.mockResolvedValue(undefined);
- await service.completeTask("t1", JSON.stringify({}), "sess-1");
+ await service.completeTask("t1", "w1", JSON.stringify({}), "sess-1");
expect(messageQ.createMessage).not.toHaveBeenCalled();
});
@@ -331,7 +333,7 @@ describe("TaskService", () => {
taskQ.countRunningTasks.mockResolvedValue(1);
agentQ.updateAgentStatus.mockResolvedValue(undefined);
- await service.completeTask("t1", JSON.stringify({}), "sess-1");
+ await service.completeTask("t1", "w1", JSON.stringify({}), "sess-1");
expect(agentQ.updateAgentStatus).toHaveBeenCalledWith(
{},
@@ -357,7 +359,7 @@ describe("TaskService", () => {
taskQ.countRunningTasks.mockResolvedValue(0);
agentQ.updateAgentStatus.mockResolvedValue(undefined);
- await service.failTask("t1", "something went wrong");
+ await service.failTask("t1", "w1", "something went wrong");
expect(messageQ.createMessage).toHaveBeenCalledWith({}, {
conversationId: "c1",
@@ -379,7 +381,7 @@ describe("TaskService", () => {
taskQ.countRunningTasks.mockResolvedValue(0);
agentQ.updateAgentStatus.mockResolvedValue(undefined);
- await service.failTask("t1", "");
+ await service.failTask("t1", "w1", "");
expect(messageQ.createMessage).not.toHaveBeenCalled();
});
@@ -396,7 +398,7 @@ describe("TaskService", () => {
taskQ.countRunningTasks.mockResolvedValue(2);
agentQ.updateAgentStatus.mockResolvedValue(undefined);
- await service.failTask("t1", "err");
+ await service.failTask("t1", "w1", "err");
expect(agentQ.updateAgentStatus).toHaveBeenCalledWith(
{},
@@ -605,7 +607,7 @@ describe("TaskService", () => {
taskQ.countRunningTasks.mockResolvedValue(0);
agentQ.updateAgentStatus.mockResolvedValue(undefined);
- await service.completeTask("t1", JSON.stringify({}), "sess-1");
+ await service.completeTask("t1", "w1", JSON.stringify({}), "sess-1");
expect(messageQ.activateNextBufferedMessage).toHaveBeenCalledWith({}, "c1");
});
@@ -626,7 +628,7 @@ describe("TaskService", () => {
taskQ.countRunningTasks.mockResolvedValue(0);
agentQ.updateAgentStatus.mockResolvedValue(undefined);
- await service.failTask("t1", "err");
+ await service.failTask("t1", "w1", "err");
expect(messageQ.activateNextBufferedMessage).toHaveBeenCalledWith({}, "c1");
});
diff --git a/src/web/src/lib/services/task.ts b/src/web/src/lib/services/task.ts
index 6216fabe7..fd7b5f8cc 100644
--- a/src/web/src/lib/services/task.ts
+++ b/src/web/src/lib/services/task.ts
@@ -87,8 +87,8 @@ export class TaskService {
return claimed;
}
- async startTask(taskId: string) {
- const task = await taskQueries.startTask(this.db, taskId);
+ async startTask(taskId: string, workspaceId: string) {
+ const task = await taskQueries.startTask(this.db, taskId, workspaceId);
if (!task) {
throw new Error("task not in dispatched status");
}
@@ -97,6 +97,7 @@ export class TaskService {
async completeTask(
taskId: string,
+ workspaceId: string,
result: string,
sessionId: string
) {
@@ -107,7 +108,7 @@ export class TaskService {
parsed = { raw: result };
}
- const task = await taskQueries.completeTask(this.db, taskId, {
+ const task = await taskQueries.completeTask(this.db, taskId, workspaceId, {
result: parsed,
sessionId: sessionId || null,
});
@@ -137,8 +138,8 @@ export class TaskService {
return task;
}
- async failTask(taskId: string, error: string) {
- const task = await taskQueries.failTask(this.db, taskId, error);
+ async failTask(taskId: string, workspaceId: string, error: string) {
+ const task = await taskQueries.failTask(this.db, taskId, workspaceId, error);
if (!task) {
const existing = await taskQueries.getTask(this.db, taskId);
diff --git a/src/ws-do/src/ws-durable.test.ts b/src/ws-do/src/ws-durable.test.ts
index dd8fda508..72de6bf49 100644
--- a/src/ws-do/src/ws-durable.test.ts
+++ b/src/ws-do/src/ws-durable.test.ts
@@ -218,6 +218,20 @@ describe("WebSocketDurableObject", () => {
expect(ws.close).toHaveBeenCalledWith(1008, "Not authenticated")
})
+ it("closes with 1008 when session token is expired (getValidSession returns null)", async () => {
+ const { durable } = createDO()
+ mockGetValidSession.mockResolvedValue(null)
+
+ const ws = createMockWebSocket()
+ ws.serializeAttachment({ userId: "", authenticated: false })
+
+ await durable.webSocketMessage(ws as any, JSON.stringify({ type: "auth", token: "expired-token" }))
+
+ expect(ws.close).toHaveBeenCalledWith(1008, "Unauthorized")
+ expect(ws.send).not.toHaveBeenCalled()
+ expect(ws.deserializeAttachment()).toEqual({ userId: "", authenticated: false })
+ })
+
it("closes on invalid JSON", async () => {
const { durable } = createDO()