Skip to content

armgit / alook

Public Imported from GitHub
0

Multi-Agent Collaboration for Team and Friends

feat(web): workspace, agent, conversation, message routes

Gener4f628404ae7a
diff --git a/src/web/src/app/api/agents/[id]/conversations/route.ts b/src/web/src/app/api/agents/[id]/conversations/route.ts
new file mode 100644
index 000000000..b72efc030
--- /dev/null
+++ b/src/web/src/app/api/agents/[id]/conversations/route.ts
@@ -0,0 +1,33 @@
+import { getCloudflareContext } from "@opennextjs/cloudflare"
+import { createDb, queries } from "@alook/shared"
+import { withAuth } from "@/lib/middleware/auth";
+import { withWorkspaceMember } from "@/lib/middleware/workspace";
+import { writeJSON, writeError } from "@/lib/middleware/helpers";
+import { conversationToResponse } from "@/lib/api/responses";
+
+export const GET = withAuth(async (req, ctx) => {
+ const ws = await withWorkspaceMember(req, ctx);
+ if (ws instanceof Response) return ws;
+
+ const { env } = getCloudflareContext()
+ const db = createDb((env as Env).DB)
+
+ const id = ctx.params?.id;
+ if (!id) {
+ return writeError("agent id is required", 400);
+ }
+
+ const agent = await queries.agent.getAgentInWorkspace(db, id, ws.workspaceId);
+ if (!agent) {
+ return writeError("agent not found", 404);
+ }
+
+ const conversations = await queries.conversation.listConversationsByAgent(
+ db,
+ ws.workspaceId,
+ ctx.userId,
+ id
+ );
+
+ return writeJSON(conversations.map(conversationToResponse));
+});
diff --git a/src/web/src/app/api/agents/[id]/route.ts b/src/web/src/app/api/agents/[id]/route.ts
new file mode 100644
index 000000000..7b42f2481
--- /dev/null
+++ b/src/web/src/app/api/agents/[id]/route.ts
@@ -0,0 +1,83 @@
+import { getCloudflareContext } from "@opennextjs/cloudflare"
+import { createDb, queries } from "@alook/shared"
+import { withAuth } from "@/lib/middleware/auth";
+import { withWorkspaceMember } from "@/lib/middleware/workspace";
+import { writeJSON, writeError } from "@/lib/middleware/helpers";
+import { agentToResponse } from "@/lib/api/responses";
+
+export const GET = withAuth(async (req, ctx) => {
+ const ws = await withWorkspaceMember(req, ctx);
+ if (ws instanceof Response) return ws;
+
+ const { env } = getCloudflareContext()
+ const db = createDb((env as Env).DB)
+
+ const id = ctx.params?.id;
+ if (!id) {
+ return writeError("agent id is required", 400);
+ }
+
+ const agent = await queries.agent.getAgentInWorkspace(db, id, ws.workspaceId);
+ if (!agent) {
+ return writeError("agent not found", 404);
+ }
+
+ return writeJSON(agentToResponse(agent));
+});
+
+export const PATCH = withAuth(async (req, ctx) => {
+ const ws = await withWorkspaceMember(req, ctx);
+ if (ws instanceof Response) return ws;
+
+ const { env } = getCloudflareContext()
+ const db = createDb((env as Env).DB)
+
+ const id = ctx.params?.id;
+ if (!id) {
+ return writeError("agent id is required", 400);
+ }
+
+ let body: Record<string, unknown>;
+ try {
+ body = await req.json();
+ } catch {
+ return writeError("invalid request body", 400);
+ }
+
+ const data: Record<string, unknown> = {};
+ if (typeof body.name === "string") data.name = body.name;
+ if (typeof body.description === "string") data.description = body.description;
+ if (typeof body.instructions === "string") data.instructions = body.instructions;
+ if (typeof body.runtime_id === "string") data.runtimeId = body.runtime_id;
+
+ if (Object.keys(data).length === 0) {
+ return writeError("no fields to update", 400);
+ }
+
+ const updated = await queries.agent.updateAgent(db, id, ws.workspaceId, data as { name?: string; description?: string; instructions?: string; runtimeId?: string });
+ if (!updated) {
+ return writeError("agent not found", 404);
+ }
+
+ return writeJSON(agentToResponse(updated));
+});
+
+export const DELETE = withAuth(async (req, ctx) => {
+ const ws = await withWorkspaceMember(req, ctx);
+ if (ws instanceof Response) return ws;
+
+ const { env } = getCloudflareContext()
+ const db = createDb((env as Env).DB)
+
+ const id = ctx.params?.id;
+ if (!id) {
+ return writeError("agent id is required", 400);
+ }
+
+ const deleted = await queries.agent.deleteAgent(db, id, ws.workspaceId);
+ if (!deleted) {
+ return writeError("agent not found", 404);
+ }
+
+ return new Response(null, { status: 204 });
+});
diff --git a/src/web/src/app/api/agents/route.ts b/src/web/src/app/api/agents/route.ts
new file mode 100644
index 000000000..0f1f328fc
--- /dev/null
+++ b/src/web/src/app/api/agents/route.ts
@@ -0,0 +1,89 @@
+import { NextRequest } from "next/server";
+import { getCloudflareContext } from "@opennextjs/cloudflare"
+import { createDb, queries } from "@alook/shared"
+import { withAuth } from "@/lib/middleware/auth";
+import { withWorkspaceMember } from "@/lib/middleware/workspace";
+import { writeJSON, writeError } from "@/lib/middleware/helpers";
+import { agentToResponse } from "@/lib/api/responses";
+import { TaskService } from "@/lib/services/task";
+
+export const GET = withAuth(async (req, ctx) => {
+ const ws = await withWorkspaceMember(req, ctx);
+ if (ws instanceof Response) return ws;
+
+ const { env } = getCloudflareContext()
+ const db = createDb((env as Env).DB)
+
+ const agents = await queries.agent.listAgents(db, ws.workspaceId);
+ return writeJSON(agents.map(agentToResponse));
+});
+
+export const POST = withAuth(async (req: NextRequest, ctx) => {
+ const ws = await withWorkspaceMember(req, ctx);
+ if (ws instanceof Response) return ws;
+
+ const { env } = getCloudflareContext()
+ const db = createDb((env as Env).DB)
+
+ let body: {
+ name?: string;
+ description?: string;
+ instructions?: string;
+ runtime_id?: string;
+ runtime_config?: unknown;
+ max_concurrent_tasks?: number;
+ };
+ try {
+ body = await req.json();
+ } catch {
+ return writeError("invalid request body", 400);
+ }
+
+ const name = (body.name || "").trim();
+ if (!name) {
+ return writeError("name is required", 400);
+ }
+
+ const runtimeId = body.runtime_id || "";
+ if (!runtimeId) {
+ return writeError("runtime_id is required", 400);
+ }
+
+ let maxConcurrentTasks = body.max_concurrent_tasks || 0;
+ if (maxConcurrentTasks <= 0) maxConcurrentTasks = 6;
+
+ const runtime = await queries.runtime.getAgentRuntimeForWorkspace(
+ db,
+ runtimeId,
+ ws.workspaceId
+ );
+ if (!runtime) {
+ return writeError("runtime not found in workspace", 404);
+ }
+
+ const newAgent = await queries.agent.createAgent(db, {
+ workspaceId: ws.workspaceId,
+ name,
+ description: body.description || "",
+ instructions: body.instructions || "",
+ runtimeId,
+ runtimeMode: runtime.runtimeMode,
+ runtimeConfig: body.runtime_config ?? null,
+ visibility: "private",
+ maxConcurrentTasks,
+ ownerId: ctx.userId,
+ });
+
+ if (runtime.status === "online") {
+ const taskService = new TaskService(db);
+ await taskService.reconcileAgentStatus(newAgent.id);
+ const updated = await queries.agent.getAgentInWorkspace(
+ db,
+ newAgent.id,
+ ws.workspaceId
+ );
+ if (updated) return writeJSON(agentToResponse(updated), 201);
+ }
+
+ return writeJSON(agentToResponse(newAgent), 201);
+});
diff --git a/src/web/src/app/api/conversations/[id]/messages/route.ts b/src/web/src/app/api/conversations/[id]/messages/route.ts
new file mode 100644
index 000000000..84e5bd59a
--- /dev/null
+++ b/src/web/src/app/api/conversations/[id]/messages/route.ts
@@ -0,0 +1,102 @@
+import { NextRequest } from "next/server";
+import { getCloudflareContext } from "@opennextjs/cloudflare"
+import { createDb, queries } from "@alook/shared"
+import { withAuth } from "@/lib/middleware/auth";
+import { withWorkspaceMember } from "@/lib/middleware/workspace";
+import { writeJSON, writeError } from "@/lib/middleware/helpers";
+import { messageToResponse, taskToResponse } from "@/lib/api/responses";
+import { TaskService } from "@/lib/services/task";
+import { log } from "@/lib/logger";
+
+function truncateTitle(text: string, maxLen = 50): string {
+ const trimmed = text.replace(/\s+/g, " ").trim();
+ if (trimmed.length <= maxLen) return trimmed;
+ const cut = trimmed.slice(0, maxLen);
+ const lastSpace = cut.lastIndexOf(" ");
+ const title = lastSpace > 20 ? cut.slice(0, lastSpace) : cut;
+ return title + "...";
+}
+
+export const GET = withAuth(async (req, ctx) => {
+ const ws = await withWorkspaceMember(req, ctx);
+ if (ws instanceof Response) return ws;
+
+ const { env } = getCloudflareContext()
+ const db = createDb((env as Env).DB)
+
+ const id = ctx.params?.id;
+ if (!id) {
+ return writeError("conversation id is required", 400);
+ }
+
+ const conversation = await queries.conversation.getConversation(db, id);
+ if (!conversation || conversation.workspaceId !== ws.workspaceId) {
+ return writeError("conversation not found", 404);
+ }
+
+ const messages = await queries.message.listMessages(db, id);
+ return writeJSON(messages.map(messageToResponse));
+});
+
+export const POST = withAuth(async (req: NextRequest, ctx) => {
+ const ws = await withWorkspaceMember(req, ctx);
+ if (ws instanceof Response) return ws;
+
+ const { env } = getCloudflareContext()
+ const db = createDb((env as Env).DB)
+
+ const id = ctx.params?.id;
+ if (!id) {
+ return writeError("conversation id is required", 400);
+ }
+
+ let body: { content?: string };
+ try {
+ body = await req.json();
+ } catch {
+ return writeError("invalid request body", 400);
+ }
+
+ const content = body.content || "";
+ if (!content) {
+ return writeError("content is required", 400);
+ }
+
+ const conversation = await queries.conversation.getConversation(db, id);
+ if (!conversation || conversation.workspaceId !== ws.workspaceId) {
+ return writeError("conversation not found", 404);
+ }
+
+ const message = await queries.message.createMessage(db, {
+ conversationId: id,
+ role: "user",
+ content,
+ });
+
+ // Auto-title: conditional WHERE title = '' ensures only the first message sets it
+ queries.conversation.updateConversationTitle(db, id, truncateTitle(content)).catch(() => {});
+
+ const taskService = new TaskService(db);
+ try {
+ const task = await taskService.enqueueTask(
+ conversation.agentId,
+ id,
+ ws.workspaceId,
+ content
+ );
+ return writeJSON(
+ { message: messageToResponse(message), task: taskToResponse(task) },
+ 201
+ );
+ } catch (err: unknown) {
+ log.error("enqueueTask error", { err });
+ return writeJSON(
+ {
+ message: messageToResponse(message),
+ task: null,
+ error: err instanceof Error ? err.message : "Unknown error",
+ },
+ 500
+ );
+ }
+});
diff --git a/src/web/src/app/api/conversations/[id]/route.ts b/src/web/src/app/api/conversations/[id]/route.ts
new file mode 100644
index 000000000..656811899
--- /dev/null
+++ b/src/web/src/app/api/conversations/[id]/route.ts
@@ -0,0 +1,51 @@
+import { getCloudflareContext } from "@opennextjs/cloudflare"
+import { createDb, queries } from "@alook/shared"
+import { withAuth } from "@/lib/middleware/auth";
+import { withWorkspaceMember } from "@/lib/middleware/workspace";
+import { writeJSON, writeError } from "@/lib/middleware/helpers";
+import { conversationToResponse } from "@/lib/api/responses";
+
+export const GET = withAuth(async (req, ctx) => {
+ const ws = await withWorkspaceMember(req, ctx);
+ if (ws instanceof Response) return ws;
+
+ const { env } = getCloudflareContext()
+ const db = createDb((env as Env).DB)
+
+ const id = ctx.params?.id;
+ if (!id) {
+ return writeError("conversation id is required", 400);
+ }
+
+ const conversation = await queries.conversation.getConversation(db, id);
+ if (!conversation || conversation.workspaceId !== ws.workspaceId) {
+ return writeError("conversation not found", 404);
+ }
+
+ return writeJSON(conversationToResponse(conversation));
+});
+
+export const DELETE = withAuth(async (req, ctx) => {
+ const ws = await withWorkspaceMember(req, ctx);
+ if (ws instanceof Response) return ws;
+
+ const { env } = getCloudflareContext()
+ const db = createDb((env as Env).DB)
+
+ const id = ctx.params?.id;
+ if (!id) {
+ return writeError("conversation id is required", 400);
+ }
+
+ const conversation = await queries.conversation.getConversation(db, id);
+ if (!conversation || conversation.workspaceId !== ws.workspaceId) {
+ return writeError("conversation not found", 404);
+ }
+
+ // Delete tasks first (no cascade on FK)
+ await queries.task.deleteTasksByConversation(db, id);
+ // Messages cascade automatically via schema
+ await queries.conversation.deleteConversation(db, id);
+
+ return new Response(null, { status: 204 });
+});
diff --git a/src/web/src/app/api/conversations/route.ts b/src/web/src/app/api/conversations/route.ts
new file mode 100644
index 000000000..abe7d3a5f
--- /dev/null
+++ b/src/web/src/app/api/conversations/route.ts
@@ -0,0 +1,51 @@
+import { NextRequest } from "next/server";
+import { getCloudflareContext } from "@opennextjs/cloudflare"
+import { createDb, queries } from "@alook/shared"
+import { withAuth } from "@/lib/middleware/auth";
+import { withWorkspaceMember } from "@/lib/middleware/workspace";
+import { writeJSON, writeError } from "@/lib/middleware/helpers";
+import { conversationToResponse } from "@/lib/api/responses";
+
+export const GET = withAuth(async (req, ctx) => {
+ const ws = await withWorkspaceMember(req, ctx);
+ if (ws instanceof Response) return ws;
+
+ const { env } = getCloudflareContext()
+ const db = createDb((env as Env).DB)
+
+ const conversations = await queries.conversation.listConversations(
+ db,
+ ws.workspaceId,
+ ctx.userId
+ );
+ return writeJSON(conversations.map(conversationToResponse));
+});
+
+export const POST = withAuth(async (req: NextRequest, ctx) => {
+ const ws = await withWorkspaceMember(req, ctx);
+ if (ws instanceof Response) return ws;
+
+ const { env } = getCloudflareContext()
+ const db = createDb((env as Env).DB)
+
+ let body: { agent_id?: string };
+ try {
+ body = await req.json();
+ } catch {
+ return writeError("invalid request body", 400);
+ }
+
+ const agentId = body.agent_id || "";
+ if (!agentId) {
+ return writeError("agent_id is required", 400);
+ }
+
+ const conversation = await queries.conversation.createConversation(db, {
+ workspaceId: ws.workspaceId,
+ agentId,
+ userId: ctx.userId,
+ title: "",
+ });
+
+ return writeJSON(conversationToResponse(conversation), 201);
+});
diff --git a/src/web/src/app/api/workspaces/[id]/route.ts b/src/web/src/app/api/workspaces/[id]/route.ts
new file mode 100644
index 000000000..4d666fc77
--- /dev/null
+++ b/src/web/src/app/api/workspaces/[id]/route.ts
@@ -0,0 +1,22 @@
+import { getCloudflareContext } from "@opennextjs/cloudflare"
+import { createDb, queries } from "@alook/shared"
+import { withAuth } from "@/lib/middleware/auth";
+import { writeJSON, writeError } from "@/lib/middleware/helpers";
+import { workspaceToResponse } from "@/lib/api/responses";
+
+export const GET = withAuth(async (_req, ctx) => {
+ const { env } = getCloudflareContext()
+ const db = createDb((env as Env).DB)
+
+ const id = ctx.params?.id;
+ if (!id) {
+ return writeError("workspace id is required", 400);
+ }
+
+ const workspace = await queries.workspace.getWorkspace(db, id);
+ if (!workspace) {
+ return writeError("workspace not found", 404);
+ }
+
+ return writeJSON(workspaceToResponse(workspace));
+});
diff --git a/src/web/src/app/api/workspaces/route.ts b/src/web/src/app/api/workspaces/route.ts
new file mode 100644
index 000000000..f5ff416b9
--- /dev/null
+++ b/src/web/src/app/api/workspaces/route.ts
@@ -0,0 +1,53 @@
+import { NextRequest } from "next/server";
+import { getCloudflareContext } from "@opennextjs/cloudflare"
+import { createDb, queries } from "@alook/shared"
+import { withAuth } from "@/lib/middleware/auth";
+import { writeJSON, writeError } from "@/lib/middleware/helpers";
+import { workspaceToResponse } from "@/lib/api/responses";
+
+export const GET = withAuth(async (_req, ctx) => {
+ const { env } = getCloudflareContext()
+ const db = createDb((env as Env).DB)
+
+ const workspaces = await queries.workspace.listWorkspaces(db, ctx.userId);
+ return writeJSON(workspaces.map(workspaceToResponse));
+});
+
+export const POST = withAuth(async (req: NextRequest, ctx) => {
+ const { env } = getCloudflareContext()
+ const db = createDb((env as Env).DB)
+
+ let body: { name?: string; slug?: string };
+ try {
+ body = await req.json();
+ } catch {
+ return writeError("invalid request body", 400);
+ }
+
+ const name = (body.name || "").trim();
+ const slug = (body.slug || "").toLowerCase().trim();
+
+ if (!name) {
+ return writeError("name is required", 400);
+ }
+ if (!slug) {
+ return writeError("slug is required", 400);
+ }
+
+ try {
+ const ws = await queries.workspace.createWorkspace(db, { name, slug });
+ await queries.member.createMember(db, {
+ workspaceId: ws.id,
+ userId: ctx.userId,
+ role: "owner",
+ });
+ return writeJSON(workspaceToResponse(ws), 201);
+ } catch (err: unknown) {
+ const e = err as Record<string, unknown>;
+ // SQLite unique constraint violation code
+ if (e.code === "SQLITE_CONSTRAINT_UNIQUE" || (typeof e.message === "string" && e.message.includes("UNIQUE"))) {
+ return writeError("workspace slug already exists", 409);
+ }
+ throw err;
+ }
+});