office-core 0.1.0

package/.runtime-dist/src/routes/bundles.js

@@ -0,0 +1,198 @@
+import { parseSessionToken, readBearerToken } from "../auth/session-token.js";
+import { buildOfficeSnapshot } from "../project/office-view.js";
+import { fetchProjectState, fetchProjectStatus, fetchProjectTasks, normalizeBlockerThreshold } from "../project/read-model.js";
+export async function handleManifestRead(request, env, manifestId) {
+    const session = await requireAuthorizedSession(request, env);
+    if (session.current_manifest_id !== manifestId) {
+        return new Response("Manifest not available for this session", { status: 403 });
+    }
+    const taskSnapshot = session.active_task_id
+        ? await fetchTaskSnapshot(env, session.active_task_id)
+        : null;
+    const projectStub = env.PROJECTS.get(env.PROJECTS.idFromName(session.active_project_id));
+    const [statusFeed, projectState, tasks] = await Promise.all([
+        fetchProjectStatus(projectStub),
+        fetchProjectState(projectStub),
+        fetchProjectTasks(env, projectStub),
+    ]);
+    const office = buildOfficeSnapshot({
+        project_id: session.active_project_id,
+        project_state: projectState,
+        tasks,
+        blocker_threshold: normalizeBlockerThreshold(env.BLOCKER_THRESHOLD),
+    });
+    const roomContext = {
+        project_id: session.active_project_id,
+        as_of: new Date().toISOString(),
+        settings: office.room.settings,
+        directives: office.attention.human_directives,
+        recent_messages: office.room.recent_messages.slice(-12),
+        recent_decisions: office.room.recent_decisions.slice(0, 8),
+        recent_events: office.recent_events.slice(0, 8),
+    };
+    return Response.json({
+        manifest_id: manifestId,
+        manifest_seq: session.current_manifest_seq,
+        project_id: session.active_project_id,
+        task_id: session.active_task_id,
+        task_version: taskSnapshot?.task_version ?? 1,
+        reason_code: "bootstrap",
+        reason_note: null,
+        blobs: [
+            {
+                blob_id: `task_summary:${session.active_task_id}`,
+                kind: "task_summary",
+                scope: "task",
+                redaction_level: "team",
+                etag: `sha256:${manifestId}:task`,
+                fetch_url: session.active_task_id ? `/api/bundles/blobs/task_summary:${encodeURIComponent(session.active_task_id)}` : null,
+                size_bytes: taskSnapshot ? JSON.stringify(taskSnapshot).length : 0,
+                fresh_until: new Date(Date.now() + 5 * 60 * 1000).toISOString(),
+            },
+            {
+                blob_id: `project_snapshot:${session.active_project_id}`,
+                kind: "project_snapshot",
+                scope: "project",
+                redaction_level: "team",
+                etag: `sha256:${manifestId}:project`,
+                fetch_url: `/api/bundles/blobs/project_snapshot:${encodeURIComponent(session.active_project_id)}`,
+                size_bytes: JSON.stringify(office.current_project).length,
+                fresh_until: new Date(Date.now() + 60 * 1000).toISOString(),
+            },
+            {
+                blob_id: `room_context:${session.active_project_id}`,
+                kind: "room_context",
+                scope: "project",
+                redaction_level: "team",
+                etag: `sha256:${manifestId}:room`,
+                fetch_url: `/api/bundles/blobs/room_context:${encodeURIComponent(session.active_project_id)}`,
+                size_bytes: JSON.stringify(roomContext).length,
+                fresh_until: new Date(Date.now() + 30 * 1000).toISOString(),
+            },
+            {
+                blob_id: `status_feed:${session.active_project_id}`,
+                kind: "status_feed",
+                scope: "project",
+                redaction_level: "team",
+                etag: `sha256:${manifestId}:status`,
+                fetch_url: `/api/bundles/blobs/status_feed:${encodeURIComponent(session.active_project_id)}`,
+                size_bytes: JSON.stringify(statusFeed).length,
+                fresh_until: new Date(Date.now() + 60 * 1000).toISOString(),
+            },
+        ].filter((blob) => blob.fetch_url !== null),
+    });
+}
+export async function handleBlobRead(request, env, blobId) {
+    const session = await requireAuthorizedSession(request, env);
+    if (blobId.startsWith("task_summary:")) {
+        const taskId = blobId.slice("task_summary:".length);
+        if (taskId !== session.active_task_id) {
+            return new Response("Task blob forbidden", { status: 403 });
+        }
+        return Response.json(await fetchTaskSnapshot(env, taskId));
+    }
+    if (blobId.startsWith("project_snapshot:")) {
+        const projectId = blobId.slice("project_snapshot:".length);
+        if (projectId !== session.active_project_id) {
+            return new Response("Project blob forbidden", { status: 403 });
+        }
+        return Response.json(await buildProjectSnapshotBlob(env, projectId));
+    }
+    if (blobId.startsWith("room_context:")) {
+        const projectId = blobId.slice("room_context:".length);
+        if (projectId !== session.active_project_id) {
+            return new Response("Project blob forbidden", { status: 403 });
+        }
+        return Response.json(await buildRoomContextBlob(env, projectId));
+    }
+    if (blobId.startsWith("status_feed:")) {
+        const projectId = blobId.slice("status_feed:".length);
+        if (projectId !== session.active_project_id) {
+            return new Response("Project blob forbidden", { status: 403 });
+        }
+        return Response.json({
+            project_id: projectId,
+            as_of: new Date().toISOString(),
+            entries: await fetchProjectStatus(env.PROJECTS.get(env.PROJECTS.idFromName(projectId))),
+        });
+    }
+    return new Response("Unknown blob", { status: 404 });
+}
+async function buildProjectSnapshotBlob(env, projectId) {
+    const projectStub = env.PROJECTS.get(env.PROJECTS.idFromName(projectId));
+    const [projectState, tasks] = await Promise.all([
+        fetchProjectState(projectStub),
+        fetchProjectTasks(env, projectStub),
+    ]);
+    const office = buildOfficeSnapshot({
+        project_id: projectId,
+        project_state: projectState,
+        tasks,
+        blocker_threshold: normalizeBlockerThreshold(env.BLOCKER_THRESHOLD),
+    });
+    return {
+        project_id: projectId,
+        as_of: new Date().toISOString(),
+        current_project: office.current_project,
+        task_board: {
+            now: office.task_board.now.slice(0, 8),
+            review: office.task_board.review.slice(0, 8),
+            blocked: office.task_board.blocked.slice(0, 8),
+            ready: office.task_board.ready.slice(0, 8),
+            done: office.task_board.done.slice(0, 8),
+        },
+        attention: office.attention,
+        artifacts: office.artifacts.slice(0, 10),
+        hosts: office.hosts.slice(0, 8),
+    };
+}
+async function buildRoomContextBlob(env, projectId) {
+    const projectStub = env.PROJECTS.get(env.PROJECTS.idFromName(projectId));
+    const [projectState, tasks] = await Promise.all([
+        fetchProjectState(projectStub),
+        fetchProjectTasks(env, projectStub),
+    ]);
+    const office = buildOfficeSnapshot({
+        project_id: projectId,
+        project_state: projectState,
+        tasks,
+        blocker_threshold: normalizeBlockerThreshold(env.BLOCKER_THRESHOLD),
+    });
+    return {
+        project_id: projectId,
+        as_of: new Date().toISOString(),
+        settings: office.room.settings,
+        human_directives: office.attention.human_directives,
+        recent_messages: office.room.recent_messages.slice(-16),
+        recent_decisions: office.room.recent_decisions.slice(0, 12),
+        recent_events: office.recent_events.slice(0, 12),
+    };
+}
+async function requireAuthorizedSession(request, env) {
+    const token = readBearerToken(request);
+    if (!token) {
+        throw new Response("Missing bearer token", { status: 401 });
+    }
+    const claims = parseSessionToken(token);
+    if (!claims) {
+        throw new Response("Invalid bearer token", { status: 401 });
+    }
+    const agentId = env.AGENTS.idFromName(claims.agent_id);
+    const sessionResponse = await env.AGENTS.get(agentId).fetch("https://do.internal/session", {
+        method: "GET",
+        headers: { authorization: `Bearer ${token}` },
+    });
+    if (!sessionResponse.ok) {
+        throw new Response("Unauthorized", { status: 401 });
+    }
+    return sessionResponse.json();
+}
+async function fetchTaskSnapshot(env, taskId) {
+    const task = env.TASKS.get(env.TASKS.idFromName(taskId));
+    const response = await task.fetch("https://do.internal/snapshot");
+    if (!response.ok) {
+        return null;
+    }
+    const state = await response.json();
+    return state?.snapshot ?? state;
+}

package/.runtime-dist/src/routes/local-host.js

@@ -0,0 +1,49 @@
+function forwardHeaders(request) {
+    const headers = {
+        "content-type": "application/json",
+    };
+    const authorization = request.headers.get("authorization");
+    if (authorization) {
+        headers.authorization = authorization;
+    }
+    const enrollSecret = request.headers.get("x-enroll-secret");
+    if (enrollSecret) {
+        headers["x-enroll-secret"] = enrollSecret;
+    }
+    return headers;
+}
+async function forwardToProject(request, env, internalPath) {
+    const { projectId, stub } = resolveProjectStub(request, env);
+    if (!projectId || !stub) {
+        return new Response("projectId required", { status: 400 });
+    }
+    const body = await request.json();
+    return stub.fetch(`https://do.internal${internalPath}`, {
+        method: "POST",
+        headers: forwardHeaders(request),
+        body: JSON.stringify({
+            ...body,
+            project_id: projectId,
+        }),
+    });
+}
+export const handleLocalHostRegister = (r, e) => forwardToProject(r, e, "/local-host/register");
+export const handleLocalHostHeartbeat = (r, e) => forwardToProject(r, e, "/local-host/heartbeat");
+export const handleLocalHostCommandQueue = (r, e) => forwardToProject(r, e, "/local-host/commands/queue");
+export const handleLocalHostCommandPull = (r, e) => forwardToProject(r, e, "/local-host/commands/pull");
+export const handleLocalHostRoomPull = (r, e) => forwardToProject(r, e, "/local-host/room/pull");
+export const handleLocalHostCommandComplete = (r, e) => forwardToProject(r, e, "/local-host/commands/complete");
+export const handleLocalHostSessionRemove = (r, e) => forwardToProject(r, e, "/local-host/sessions/remove");
+export const handleLocalHostProjectSwitch = (r, e) => forwardToProject(r, e, "/local-host/switch");
+function resolveProjectStub(request, env) {
+    const url = new URL(request.url);
+    const parts = url.pathname.split("/").filter(Boolean);
+    const projectId = parts[2] ?? null;
+    if (!projectId) {
+        return { projectId: null, stub: null };
+    }
+    return {
+        projectId,
+        stub: env.PROJECTS.get(env.PROJECTS.idFromName(projectId)),
+    };
+}

package/.runtime-dist/src/routes/projects.js

@@ -0,0 +1,119 @@
+import { buildProjectPayload, fetchProjectState, fetchProjectTasks } from "../project/read-model.js";
+import { buildOfficeSnapshot } from "../project/office-view.js";
+import { normalizeBlockerThreshold } from "../project/read-model.js";
+async function respondWithEtag(request, payload) {
+    const body = JSON.stringify(payload);
+    const digest = await crypto.subtle.digest("SHA-1", new TextEncoder().encode(body));
+    const etag = `"${Array.from(new Uint8Array(digest)).map((b) => b.toString(16).padStart(2, "0")).join("")}"`;
+    if (request.headers.get("if-none-match") === etag) {
+        return new Response(null, { status: 304 });
+    }
+    return new Response(body, {
+        headers: { "content-type": "application/json", etag },
+    });
+}
+export async function handleProjectCreate(request, env) {
+    const body = await request.json();
+    const projectId = String(body.project_id ?? "").trim();
+    if (!projectId) {
+        return new Response("project_id required", { status: 400 });
+    }
+    const stub = env.PROJECTS.get(env.PROJECTS.idFromName(projectId));
+    return stub.fetch("https://do.internal/init", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+            project_id: projectId,
+            name: String(body.name ?? projectId).trim() || projectId,
+        }),
+    });
+}
+export async function handleProjectRead(request, env) {
+    const url = new URL(request.url);
+    const parts = url.pathname.split("/").filter(Boolean);
+    const projectId = parts[2];
+    if (!projectId) {
+        return new Response("projectId required", { status: 400 });
+    }
+    const stub = env.PROJECTS.get(env.PROJECTS.idFromName(projectId));
+    if (parts[3] === "status") {
+        return stub.fetch("https://do.internal/status");
+    }
+    if (parts[3] === "tasks") {
+        return Response.json(await fetchProjectTasks(env, stub));
+    }
+    if (parts[3] === "events") {
+        return stub.fetch("https://do.internal/events");
+    }
+    if (parts[3] === "local-hosts") {
+        return stub.fetch("https://do.internal/local-hosts");
+    }
+    const projectState = await fetchProjectState(stub);
+    const tasks = await fetchProjectTasks(env, stub);
+    if (parts[3] === "office") {
+        const payload = buildOfficeSnapshot({
+            project_id: projectId,
+            project_state: projectState,
+            tasks,
+            blocker_threshold: normalizeBlockerThreshold(env.BLOCKER_THRESHOLD),
+        });
+        return respondWithEtag(request, payload);
+    }
+    const payload = buildProjectPayload({
+        env,
+        project_id: projectId,
+        project_state: projectState,
+        tasks,
+    });
+    return respondWithEtag(request, payload);
+}
+export async function handleProjectRoomRead(request, env) {
+    const url = new URL(request.url);
+    const parts = url.pathname.split("/").filter(Boolean);
+    const projectId = parts[2];
+    if (!projectId) {
+        return new Response("projectId required", { status: 400 });
+    }
+    const stub = env.PROJECTS.get(env.PROJECTS.idFromName(projectId));
+    if (parts[4] === "messages") {
+        return stub.fetch("https://do.internal/room/messages");
+    }
+    return stub.fetch("https://do.internal/room");
+}
+export async function handleProjectRoomMessageWrite(request, env) {
+    const url = new URL(request.url);
+    const parts = url.pathname.split("/").filter(Boolean);
+    const projectId = parts[2];
+    if (!projectId) {
+        return new Response("projectId required", { status: 400 });
+    }
+    const stub = env.PROJECTS.get(env.PROJECTS.idFromName(projectId));
+    const body = await request.json();
+    const targetPath = parts[5] === "upsert" ? "https://do.internal/room/messages/upsert" : "https://do.internal/room/messages";
+    return stub.fetch(targetPath, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+            ...body,
+            project_id: projectId,
+        }),
+    });
+}
+export async function handleProjectRoomSettingsWrite(request, env) {
+    const url = new URL(request.url);
+    const parts = url.pathname.split("/").filter(Boolean);
+    const projectId = parts[2];
+    if (!projectId) {
+        return new Response("projectId required", { status: 400 });
+    }
+    const stub = env.PROJECTS.get(env.PROJECTS.idFromName(projectId));
+    const body = await request.json();
+    return stub.fetch("https://do.internal/room/settings", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+            ...body,
+            project_id: projectId,
+        }),
+    });
+}

package/.runtime-dist/src/routes/tasks.js

@@ -0,0 +1,67 @@
+export async function handleTaskCreate(request, env) {
+    const body = await request.json();
+    if (!body.project_id || !body.title) {
+        return new Response("project_id and title are required", { status: 400 });
+    }
+    const task_id = body.task_id ?? `tsk_${crypto.randomUUID()}`;
+    const taskId = env.TASKS.idFromName(task_id);
+    return env.TASKS.get(taskId).fetch("https://do.internal/create-from-discord", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+            ...body,
+            task_id,
+            raw_content: body.raw_content ?? body.title,
+            requested_by_discord_user_id: body.requested_by_discord_user_id ?? "human_dashboard",
+            channel_id: body.channel_id ?? "dashboard-project-channel",
+            discord_event_id: body.discord_event_id ?? `dashboard:${crypto.randomUUID()}`,
+            thread_id: body.thread_id ?? body.discord_thread_id ?? null,
+            collaboration_policy: body.collaboration_policy ?? "multi_agent",
+            confirmation_required: body.confirmation_required ?? false,
+        }),
+    });
+}
+export async function handleTaskHumanConfirm(request, env) {
+    const parts = new URL(request.url).pathname.split("/").filter(Boolean);
+    const taskId = parts[2];
+    if (!taskId) {
+        return new Response("taskId required", { status: 400 });
+    }
+    const body = await request.json();
+    const mapped = body.action === "approve"
+        ? { ...body, type: "accept", actor_id: body.actor_id ?? "human_dashboard" }
+        : body.action === "modify"
+            ? {
+                ...body,
+                type: "correct",
+                actor_id: body.actor_id ?? "human_dashboard",
+                correction_text: body.correction_text ?? "Human requested modifications before execution.",
+            }
+            : body.action === "reject"
+                ? {
+                    ...body,
+                    type: "correct",
+                    actor_id: body.actor_id ?? "human_dashboard",
+                    correction_text: body.correction_text ?? "Human rejected the current interpretation. Rework required.",
+                }
+                : {
+                    ...body,
+                    type: body.type ?? "accept",
+                    actor_id: body.actor_id ?? "human_dashboard",
+                };
+    const stub = env.TASKS.get(env.TASKS.idFromName(taskId));
+    return stub.fetch("https://do.internal/human-confirm", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(mapped),
+    });
+}
+export async function handleTaskRead(request, env) {
+    const parts = new URL(request.url).pathname.split("/").filter(Boolean);
+    const taskId = parts[2];
+    if (!taskId) {
+        return new Response("taskId required", { status: 400 });
+    }
+    const stub = env.TASKS.get(env.TASKS.idFromName(taskId));
+    return stub.fetch("https://do.internal/snapshot");
+}