office-core 0.1.0

package/.runtime-dist/src/do/TaskDO.js

@@ -0,0 +1,356 @@
+import { applyAlarm, applyHumanConfirmation, applyTaskCommand, createTaskState, scheduleAlarm, } from "../task/reducer.js";
+export class TaskDO {
+    state;
+    env;
+    stateCache;
+    metaCache;
+    constructor(state, env) {
+        this.state = state;
+        this.env = env;
+    }
+    async fetch(request) {
+        const url = new URL(request.url);
+        if (request.method === "GET" && url.pathname === "/snapshot") {
+            return Response.json(await this.buildSnapshotView());
+        }
+        if (request.method === "POST" && url.pathname === "/create-from-discord") {
+            const body = await request.json();
+            return Response.json(await this.createFromDiscord(body));
+        }
+        if (request.method === "POST" && url.pathname === "/command") {
+            const body = await request.json();
+            const current = await this.requireState();
+            const meta = await this.requireMeta();
+            const currentEventId = current.events.at(-1)?.id ?? null;
+            const result = applyTaskCommand(current, body.command, {
+                now: body.command.sent_at,
+                current_fence: body.fence,
+                claim_expiry_sec: body.claim_expiry_sec,
+            });
+            let nextState = result.state;
+            if (result.response.accepted && result.side_effects.some((effect) => effect.kind === "manifest_rebuild")) {
+                nextState = this.publishManifest(nextState);
+            }
+            await this.persistState(nextState);
+            await this.applySideEffects(nextState, meta, result.side_effects);
+            const latestEvent = nextState.events.at(-1);
+            const taskChanged = nextState.snapshot.task_version !== current.snapshot.task_version ||
+                nextState.snapshot.manifest_seq !== current.snapshot.manifest_seq ||
+                nextState.events.length !== current.events.length;
+            if (taskChanged) {
+                await this.syncProjectSnapshot(nextState, meta);
+                if (latestEvent && latestEvent.id !== currentEventId) {
+                    await this.appendProjectEvent(nextState.snapshot.project_id, buildProjectEvent(latestEvent));
+                }
+            }
+            await this.rearmAlarm(nextState.snapshot);
+            return Response.json({
+                ...result.response,
+                current_bundle_seq: nextState.snapshot.manifest_seq ?? undefined,
+            });
+        }
+        if (request.method === "POST" && url.pathname === "/human-confirm") {
+            const body = await request.json();
+            const current = await this.requireState();
+            const meta = await this.requireMeta();
+            let next = applyHumanConfirmation(current, {
+                actor_id: body.actor_id,
+                type: body.type,
+                correction_text: body.correction_text,
+                now: body.now ?? new Date().toISOString(),
+            });
+            next = this.publishManifest(next);
+            await this.persistState(next);
+            await this.syncProjectSnapshot(next, meta);
+            const latestEvent = next.events.at(-1);
+            if (latestEvent) {
+                await this.appendProjectEvent(next.snapshot.project_id, buildProjectEvent(latestEvent));
+            }
+            await this.rearmAlarm(next.snapshot);
+            return Response.json(await this.buildSnapshotView());
+        }
+        if (request.method === "POST" && url.pathname === "/alarm-run") {
+            await this.alarm();
+            return Response.json(await this.buildSnapshotView());
+        }
+        return new Response("Not found", { status: 404 });
+    }
+    async createFromDiscord(input) {
+        const now = new Date().toISOString();
+        const task_id = input.task_id ?? `tsk_${crypto.randomUUID()}`;
+        const discord_thread_id = input.thread_id ?? input.discord_thread_id ?? `th_${crypto.randomUUID()}`;
+        const collaboration_policy = input.collaboration_policy ?? "multi_agent";
+        const nextState = createTaskState({
+            task_id,
+            project_id: input.project_id,
+            title: input.title,
+            now,
+            phase: "collecting_understandings",
+            confirmation_required: input.confirmation_required ?? false,
+            manifest_seq: 1,
+        });
+        nextState.snapshot.resolved_mode = resolveCollaborationMode(collaboration_policy);
+        const meta = {
+            collaboration_policy,
+            discord_thread_id,
+            raw_content: input.raw_content,
+            requested_by_discord_user_id: input.requested_by_discord_user_id,
+            created_at: now,
+        };
+        await this.persistMeta(meta);
+        await this.persistState(nextState);
+        await this.syncProjectSnapshot(nextState, meta);
+        await this.appendProjectEvent(input.project_id, {
+            ts: now,
+            kind: "human",
+            actor: input.requested_by_discord_user_id,
+            type: "task.created",
+            detail: `${task_id} \"${input.title}\"`,
+            payload: JSON.stringify({
+                collaboration_policy,
+                confirmation_required: nextState.snapshot.confirmation_required,
+            }),
+        });
+        return {
+            task_id,
+            task_version: nextState.snapshot.task_version,
+            discord_thread_id,
+        };
+    }
+    async alarm() {
+        const current = await this.loadState();
+        if (!current) {
+            return;
+        }
+        const meta = await this.requireMeta();
+        const result = applyAlarm(current, new Date().toISOString());
+        if (!result.expired_claim) {
+            await this.rearmAlarm(current.snapshot);
+            return;
+        }
+        await this.persistState(result.state);
+        await this.syncProjectSnapshot(result.state, meta);
+        const latestEvent = result.state.events.at(-1);
+        if (latestEvent) {
+            await this.appendProjectEvent(result.state.snapshot.project_id, buildProjectEvent(latestEvent));
+        }
+        await this.rearmAlarm(result.state.snapshot);
+    }
+    async buildSnapshotView() {
+        const state = await this.loadState();
+        if (!state) {
+            return null;
+        }
+        const meta = await this.requireMeta();
+        return {
+            ...state,
+            ...meta,
+            current_manifest_id: buildManifestId(state.snapshot.task_id, state.snapshot.manifest_seq),
+            current_manifest_seq: state.snapshot.manifest_seq,
+        };
+    }
+    async applySideEffects(state, meta, effects) {
+        for (const effect of effects) {
+            if (effect.kind === "status_upsert") {
+                const projectId = this.env.PROJECTS.idFromName(state.snapshot.project_id);
+                await this.env.PROJECTS.get(projectId).fetch(`https://do.internal/status/upsert?project_id=${encodeURIComponent(state.snapshot.project_id)}`, {
+                    method: "POST",
+                    headers: { "content-type": "application/json" },
+                    body: JSON.stringify({
+                        project_id: state.snapshot.project_id,
+                        agent_id: effect.data.agent_id,
+                        display_name: String(effect.data.agent_id ?? ""),
+                        task_id: effect.data.task_id,
+                        state: effect.data.state,
+                        summary: effect.data.summary,
+                        updated_at: state.snapshot.updated_at,
+                    }),
+                });
+                continue;
+            }
+            if (effect.kind === "manifest_rebuild") {
+                await this.appendProjectEvent(state.snapshot.project_id, {
+                    ts: state.snapshot.updated_at,
+                    kind: "evt",
+                    actor: "system",
+                    type: "bundle.published",
+                    detail: `${state.snapshot.task_id} → ${buildManifestId(state.snapshot.task_id, state.snapshot.manifest_seq)}`,
+                    payload: JSON.stringify({
+                        task_version: state.snapshot.task_version,
+                        manifest_seq: state.snapshot.manifest_seq,
+                        policy: meta.collaboration_policy,
+                    }),
+                });
+            }
+        }
+    }
+    async syncProjectSnapshot(state, meta) {
+        const projectId = this.env.PROJECTS.idFromName(state.snapshot.project_id);
+        const stub = this.env.PROJECTS.get(projectId);
+        const headers = { "content-type": "application/json" };
+        await Promise.all([
+            stub.fetch("https://do.internal/tasks/upsert", {
+                method: "POST",
+                headers,
+                body: JSON.stringify({
+                    project_id: state.snapshot.project_id,
+                    task_id: state.snapshot.task_id,
+                    title: state.snapshot.title,
+                    status: state.snapshot.phase,
+                    updated_at: state.snapshot.updated_at,
+                }),
+            }),
+            stub.fetch("https://do.internal/manifest", {
+                method: "POST",
+                headers,
+                body: JSON.stringify({
+                    project_id: state.snapshot.project_id,
+                    manifest_id: buildManifestId(state.snapshot.task_id, state.snapshot.manifest_seq),
+                    manifest_seq: state.snapshot.manifest_seq,
+                }),
+            }),
+            stub.fetch("https://do.internal/understanding", {
+                method: "POST",
+                headers,
+                body: JSON.stringify({
+                    project_id: state.snapshot.project_id,
+                    accepted_understanding: state.snapshot.accepted_understanding,
+                }),
+            }),
+        ]);
+    }
+    publishManifest(state) {
+        const currentSeq = state.snapshot.manifest_seq ?? 0;
+        return {
+            ...state,
+            snapshot: {
+                ...state.snapshot,
+                manifest_seq: currentSeq + 1,
+            },
+        };
+    }
+    async appendProjectEvent(project_id, event) {
+        const projectId = this.env.PROJECTS.idFromName(project_id);
+        await this.env.PROJECTS.get(projectId).fetch("https://do.internal/events/add", {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+                project_id,
+                ...event,
+            }),
+        });
+    }
+    async loadState() {
+        if (this.stateCache) {
+            return this.stateCache;
+        }
+        const stored = await this.state.storage.get("task-state");
+        this.stateCache = stored ?? undefined;
+        return stored ?? null;
+    }
+    async requireState() {
+        const state = await this.loadState();
+        if (!state) {
+            throw new Error("Task state not initialized");
+        }
+        return state;
+    }
+    async persistState(next) {
+        this.stateCache = next;
+        await this.state.storage.put("task-state", next);
+    }
+    async loadMeta() {
+        if (this.metaCache) {
+            return this.metaCache;
+        }
+        const stored = await this.state.storage.get("task-meta");
+        this.metaCache = stored ?? undefined;
+        return stored ?? null;
+    }
+    async requireMeta() {
+        const meta = await this.loadMeta();
+        if (!meta) {
+            throw new Error("Task metadata not initialized");
+        }
+        return meta;
+    }
+    async persistMeta(meta) {
+        this.metaCache = meta;
+        await this.state.storage.put("task-meta", meta);
+    }
+    async rearmAlarm(snapshot) {
+        const due = scheduleAlarm(snapshot);
+        if (!due) {
+            await this.state.storage.deleteAlarm();
+            return;
+        }
+        await this.state.storage.setAlarm(Date.parse(due));
+    }
+}
+function resolveCollaborationMode(policy) {
+    switch (policy) {
+        case "solo":
+            return "solo_visible";
+        case "broadcast":
+            return "consensus_required";
+        default:
+            return "parallel_interpretation";
+    }
+}
+function buildManifestId(task_id, manifest_seq) {
+    if (manifest_seq == null) {
+        return null;
+    }
+    return `mf_${task_id}_${manifest_seq}`;
+}
+function buildProjectEvent(event) {
+    const payload = JSON.stringify(event.payload);
+    switch (event.event_type) {
+        case "human.confirmed":
+        case "human.corrected":
+            return {
+                ts: event.occurred_at,
+                kind: "human",
+                actor: event.actor_id,
+                type: event.event_type,
+                detail: event.event_type === "human.corrected" ? "Human requested revision" : "Human approved the current interpretation",
+                payload,
+            };
+        case "claim.expired":
+            return {
+                ts: event.occurred_at,
+                kind: "sys",
+                actor: event.actor_id,
+                type: event.event_type,
+                detail: "Execution claim expired",
+                payload,
+            };
+        case "progress.reported":
+            return {
+                ts: event.occurred_at,
+                kind: "cmd",
+                actor: event.actor_id,
+                type: event.event_type,
+                detail: String(event.payload.summary ?? "Progress updated"),
+                payload,
+            };
+        case "understanding.submitted":
+            return {
+                ts: event.occurred_at,
+                kind: "cmd",
+                actor: event.actor_id,
+                type: event.event_type,
+                detail: "Submitted task understanding",
+                payload,
+            };
+        default:
+            return {
+                ts: event.occurred_at,
+                kind: event.actor_type === "system" ? "sys" : "cmd",
+                actor: event.actor_id,
+                type: event.event_type,
+                detail: null,
+                payload,
+            };
+    }
+}

package/.runtime-dist/src/index.js

@@ -0,0 +1,123 @@
+import { AgentDO } from "./do/AgentDO.js";
+import { GatewayShardDO } from "./do/GatewayShardDO.js";
+import { ProjectDO } from "./do/ProjectDO.js";
+import { TaskDO } from "./do/TaskDO.js";
+import { handleAgentsBootstrap } from "./routes/agents-bootstrap.js";
+import { handleAgentsDescriptor } from "./routes/agents-descriptor.js";
+import { handleAgentsEvents } from "./routes/agents-events.js";
+import { handleAgentsHeartbeat } from "./routes/agents-heartbeat.js";
+import { handleAgentsTaskContext } from "./routes/agents-task-context.js";
+import { handleBlobRead, handleManifestRead } from "./routes/bundles.js";
+import { handleLocalHostCommandComplete, handleLocalHostCommandPull, handleLocalHostCommandQueue, handleLocalHostHeartbeat, handleLocalHostProjectSwitch, handleLocalHostRegister, handleLocalHostRoomPull, handleLocalHostSessionRemove, } from "./routes/local-host.js";
+import { handleProjectCreate, handleProjectRead, handleProjectRoomMessageWrite, handleProjectRoomRead, handleProjectRoomSettingsWrite, } from "./routes/projects.js";
+import { handleTaskCreate, handleTaskHumanConfirm, handleTaskRead } from "./routes/tasks.js";
+export { AgentDO, GatewayShardDO, ProjectDO, TaskDO };
+export default {
+    async fetch(request, env) {
+        try {
+            const url = new URL(request.url);
+            // Serve dashboard for root — fall through to Workers Assets
+            if (request.method === "GET" && (url.pathname === "/" || url.pathname === "/dashboard")) {
+                return env.ASSETS.fetch(new Request(new URL("/index.html", request.url), request));
+            }
+            if (request.method === "GET" && url.pathname === "/i") {
+                return env.ASSETS.fetch(new Request(new URL("/install-host.ps1", request.url), request));
+            }
+            if (request.method === "GET" && url.pathname === "/healthz") {
+                return Response.json({ ok: true });
+            }
+            if (request.method === "POST" && url.pathname === "/api/agents/bootstrap") {
+                return handleAgentsBootstrap(request, env);
+            }
+            if (request.method === "GET" && url.pathname === "/api/agents/descriptor") {
+                return handleAgentsDescriptor(request, env);
+            }
+            if (request.method === "POST" && url.pathname === "/api/agents/heartbeat") {
+                return handleAgentsHeartbeat(request, env);
+            }
+            if (request.method === "POST" && url.pathname === "/api/agents/events") {
+                return handleAgentsEvents(request, env);
+            }
+            if (request.method === "POST" && url.pathname === "/api/agents/task-context") {
+                return handleAgentsTaskContext(request, env);
+            }
+            if (request.method === "GET" && url.pathname.startsWith("/api/bundles/manifests/")) {
+                return handleManifestRead(request, env, url.pathname.split("/").at(-1) ?? "");
+            }
+            if (request.method === "GET" && url.pathname.startsWith("/api/bundles/blobs/")) {
+                return handleBlobRead(request, env, decodeURIComponent(url.pathname.split("/").at(-1) ?? ""));
+            }
+            if (request.method === "GET" && url.pathname.endsWith("/room")) {
+                return handleProjectRoomRead(request, env);
+            }
+            if (request.method === "GET" && url.pathname.endsWith("/room/messages")) {
+                return handleProjectRoomRead(request, env);
+            }
+            if (request.method === "POST" && (url.pathname.endsWith("/room/messages") || url.pathname.endsWith("/room/messages/upsert"))) {
+                return handleProjectRoomMessageWrite(request, env);
+            }
+            if (request.method === "POST" && url.pathname.endsWith("/room/settings")) {
+                return handleProjectRoomSettingsWrite(request, env);
+            }
+            if (request.method === "POST" && url.pathname === "/api/projects") {
+                return handleProjectCreate(request, env);
+            }
+            if (request.method === "GET" && url.pathname.startsWith("/api/projects/")) {
+                return handleProjectRead(request, env);
+            }
+            if (request.method === "POST" && url.pathname.endsWith("/local-host/register")) {
+                return handleLocalHostRegister(request, env);
+            }
+            if (request.method === "POST" && url.pathname.endsWith("/local-host/heartbeat")) {
+                return handleLocalHostHeartbeat(request, env);
+            }
+            if (request.method === "POST" && url.pathname.endsWith("/local-host/commands/queue")) {
+                return handleLocalHostCommandQueue(request, env);
+            }
+            if (request.method === "POST" && url.pathname.endsWith("/local-host/commands/pull")) {
+                return handleLocalHostCommandPull(request, env);
+            }
+            if (request.method === "POST" && url.pathname.endsWith("/local-host/room/pull")) {
+                return handleLocalHostRoomPull(request, env);
+            }
+            if (request.method === "POST" && url.pathname.endsWith("/local-host/commands/complete")) {
+                return handleLocalHostCommandComplete(request, env);
+            }
+            if (request.method === "POST" && url.pathname.endsWith("/local-host/sessions/remove")) {
+                return handleLocalHostSessionRemove(request, env);
+            }
+            if (request.method === "POST" && url.pathname.endsWith("/local-host/switch")) {
+                return handleLocalHostProjectSwitch(request, env);
+            }
+            if (request.method === "POST" && url.pathname === "/api/tasks") {
+                return handleTaskCreate(request, env);
+            }
+            if (request.method === "POST" && url.pathname.endsWith("/human-confirm")) {
+                return handleTaskHumanConfirm(request, env);
+            }
+            if (request.method === "GET" && url.pathname.startsWith("/api/tasks/")) {
+                return handleTaskRead(request, env);
+            }
+            if (url.pathname === "/do/task") {
+                const id = env.TASKS.idFromName(url.searchParams.get("task_id") ?? "tsk_demo");
+                return env.TASKS.get(id).fetch(request);
+            }
+            if (url.pathname === "/do/project") {
+                const id = env.PROJECTS.idFromName(url.searchParams.get("project_id") ?? "prj_demo");
+                return env.PROJECTS.get(id).fetch(request);
+            }
+            if (url.pathname === "/do/agent") {
+                const agentId = url.searchParams.get("agent_id") ?? "agent_demo";
+                const id = env.AGENTS.idFromName(agentId);
+                return env.AGENTS.get(id).fetch(request);
+            }
+            return new Response("Not found", { status: 404 });
+        }
+        catch (error) {
+            if (error instanceof Response) {
+                return error;
+            }
+            throw error;
+        }
+    },
+};