office-core 0.1.0

package/.runtime-dist/scripts/run-local-project.js

@@ -0,0 +1,277 @@
+import path from "node:path";
+import process from "node:process";
+import { parseSessionToken } from "../src/auth/session-token.js";
+import { runLocalRunner } from "./lib/local-runner.js";
+const args = parseArgs(process.argv.slice(2));
+const baseUrl = args.baseUrl ?? "http://127.0.0.1:8787";
+const workdir = path.resolve(args.dir ?? process.cwd());
+const projectId = args.project ?? "prj_demo";
+const taskText = args.task;
+const title = args.title ?? summarizeTitle(taskText);
+const agents = parseAgents(args.agents ?? "codex:agent_alpha,claude:agent_bravo");
+const executorId = args.executor ?? agents[0]?.agent_id ?? "agent_alpha";
+if (!taskText) {
+    console.error("Usage: npm run project -- --task \"...\" [--dir PATH] [--agents codex:alpha,claude:bravo]");
+    process.exit(1);
+}
+void main().catch((error) => {
+    console.error(error);
+    process.exitCode = 1;
+});
+async function main() {
+    console.log(`Using Office Core at ${baseUrl}`);
+    console.log(`Working directory: ${workdir}`);
+    const createdTask = await postJson(`${baseUrl}/api/tasks`, {
+        project_id: projectId,
+        discord_event_id: `discord:${Date.now()}`,
+        channel_id: "discord-project-channel",
+        title,
+        raw_content: taskText,
+        requested_by_discord_user_id: "human_demo",
+    });
+    console.log("Created task:", createdTask.task_id);
+    for (const agent of agents) {
+        const boot = await postJson(`${baseUrl}/api/agents/bootstrap`, {
+            agent_id: agent.agent_id,
+            display_name: agent.display_name,
+            workspace_id: "ws_demo",
+            active_project_id: projectId,
+            active_task_id: createdTask.task_id,
+        });
+        agent.session_token = boot.session_token;
+        agent.descriptor = boot.descriptor;
+    }
+    for (const agent of agents) {
+        await updateStatus(agent, createdTask.task_id, "Reading current task", "active");
+        const understanding = await generateUnderstanding(agent, createdTask.task_id, taskText);
+        await sendCommand(agent, {
+            type: "understanding.submit",
+            task_id: createdTask.task_id,
+            payload: {
+                text: understanding,
+                confidence: "medium",
+            },
+        });
+    }
+    const afterUnderstandings = await getTask(createdTask.task_id);
+    if (afterUnderstandings.snapshot.phase !== "alignment") {
+        throw new Error(`Expected task to reach alignment, got ${afterUnderstandings.snapshot.phase}`);
+    }
+    const facilitator = agents[0];
+    const alignmentText = await generateAlignment(facilitator, createdTask.task_id, afterUnderstandings);
+    await sendCommand(facilitator, {
+        type: "alignment.proposed",
+        task_id: createdTask.task_id,
+        payload: {
+            proposal_text: alignmentText,
+        },
+    });
+    const afterAlignment = await getTask(createdTask.task_id);
+    if (afterAlignment.snapshot.phase !== "executing") {
+        throw new Error(`Expected task to reach executing, got ${afterAlignment.snapshot.phase}`);
+    }
+    const executor = agents.find((agent) => agent.agent_id === executorId) ?? agents[0];
+    await updateStatus(executor, createdTask.task_id, "Claiming execution", "active");
+    const claimResponse = await sendCommand(executor, {
+        type: "execution.claim",
+        task_id: createdTask.task_id,
+        payload: {
+            scope: "full",
+            approach_summary: "Execute the aligned task in the local workspace.",
+        },
+    });
+    const claimToken = claimResponse.results?.[0]?.claim_token?.claim_token;
+    if (!claimToken) {
+        throw new Error(`Execution claim failed: ${JSON.stringify(claimResponse)}`);
+    }
+    const executionSummary = await runExecution(executor, createdTask.task_id, afterAlignment.snapshot.accepted_understanding ?? taskText);
+    await sendCommand(executor, {
+        type: "progress.update",
+        task_id: createdTask.task_id,
+        claim_token: claimToken,
+        payload: {
+            summary: executionSummary.slice(0, 500),
+            percent_complete: 100,
+        },
+    });
+    await sendCommand(executor, {
+        type: "task.complete",
+        task_id: createdTask.task_id,
+        claim_token: claimToken,
+        payload: {
+            summary: executionSummary.slice(0, 1000),
+        },
+    });
+    await updateStatus(executor, createdTask.task_id, "Completed task", "done");
+    const finalTask = await getTask(createdTask.task_id);
+    const finalStatus = await getJson(`${baseUrl}/api/projects/${projectId}/status`);
+    console.log("\nFinal task snapshot:");
+    console.dir(finalTask.snapshot, { depth: null });
+    console.log("\nFinal status feed:");
+    console.dir(finalStatus, { depth: null });
+}
+async function generateUnderstanding(agent, taskId, taskText) {
+    const descriptor = await refreshDescriptor(agent);
+    const manifest = descriptor?.manifest_fetch_url
+        ? await getJson(`${baseUrl}${descriptor.manifest_fetch_url}`, agent.session_token)
+        : null;
+    const taskBlob = manifest.blobs?.find((blob) => blob.kind === "task_summary");
+    const taskSummary = taskBlob?.fetch_url
+        ? await getJson(`${baseUrl}${taskBlob.fetch_url}`, agent.session_token)
+        : await getTask(taskId);
+    const prompt = [
+        `You are ${agent.display_name}, one agent in a multi-agent development office.`,
+        "Return a short understanding of the current task and your immediate approach.",
+        "Keep it to 2-4 sentences, plain text, no markdown bullets.",
+        "",
+        "Task request:",
+        taskText,
+        "",
+        "Current task snapshot:",
+        JSON.stringify(taskSummary, null, 2),
+    ].join("\n");
+    return runLocalRunner({
+        runner: agent.runner,
+        workdir,
+        prompt,
+    });
+}
+async function generateAlignment(agent, taskId, taskState) {
+    const prompt = [
+        `You are ${agent.display_name}, acting as facilitator.`,
+        "Synthesize the team's understanding into one concise execution-ready plan.",
+        "Return plain text only, 3-6 sentences.",
+        "",
+        "Task state:",
+        JSON.stringify(taskState, null, 2),
+    ].join("\n");
+    return runLocalRunner({
+        runner: agent.runner,
+        workdir,
+        prompt,
+    });
+}
+async function runExecution(agent, taskId, acceptedUnderstanding) {
+    const taskState = await getTask(taskId);
+    const prompt = [
+        `You are ${agent.display_name}. Execute this task in the local workspace now.`,
+        "Make the changes or perform the inspection needed in the working directory.",
+        "Return a concise summary of what you changed or found.",
+        "",
+        "Accepted understanding:",
+        acceptedUnderstanding,
+        "",
+        "Current task state:",
+        JSON.stringify(taskState.snapshot, null, 2),
+    ].join("\n");
+    return runLocalRunner({
+        runner: agent.runner,
+        workdir,
+        prompt,
+        timeout_ms: 30 * 60 * 1000,
+    });
+}
+async function updateStatus(agent, taskId, summary, state) {
+    await sendCommand(agent, {
+        type: "status.upsert",
+        task_id: taskId,
+        payload: {
+            task_summary: summary,
+            state,
+        },
+    });
+}
+async function sendCommand(agent, command) {
+    if (!agent.session_token) {
+        throw new Error(`Agent ${agent.agent_id} is not bootstrapped`);
+    }
+    const claims = parseSessionToken(agent.session_token);
+    if (!claims) {
+        throw new Error(`Invalid session token for ${agent.agent_id}`);
+    }
+    const descriptor = await refreshDescriptor(agent);
+    const task = await getTask(command.task_id);
+    const envelope = {
+        protocol_version: "1.0",
+        command_schema_version: 1,
+        command_id: `${agent.agent_id}:${command.type}:${crypto.randomUUID()}`,
+        session_id: claims.session_id,
+        session_epoch: claims.session_epoch,
+        agent_id: agent.agent_id,
+        task_id: command.task_id,
+        observed_task_version: task.snapshot.task_version,
+        bundle_seq: descriptor?.current_manifest_seq ?? 1,
+        claim_token: command.claim_token,
+        type: command.type,
+        payload: command.payload,
+        sent_at: new Date().toISOString(),
+    };
+    return postJson(`${baseUrl}/api/agents/events`, { commands: [envelope] }, agent.session_token);
+}
+async function refreshDescriptor(agent) {
+    if (!agent.session_token) {
+        throw new Error(`Agent ${agent.agent_id} is not bootstrapped`);
+    }
+    agent.descriptor = await getJson(`${baseUrl}/api/agents/descriptor`, agent.session_token);
+    return agent.descriptor;
+}
+async function getTask(taskId) {
+    return getJson(`${baseUrl}/api/tasks/${taskId}`);
+}
+function parseArgs(argv) {
+    const result = {};
+    for (let i = 0; i < argv.length; i += 1) {
+        const item = argv[i];
+        if (!item.startsWith("--")) {
+            continue;
+        }
+        const key = item.slice(2);
+        const value = argv[i + 1];
+        if (!value || value.startsWith("--")) {
+            result[key] = "true";
+            continue;
+        }
+        result[key] = value;
+        i += 1;
+    }
+    return result;
+}
+function parseAgents(value) {
+    return value.split(",").map((entry, index) => {
+        const [runnerRaw, idRaw] = entry.split(":", 2);
+        const runner = (runnerRaw?.trim() || "codex");
+        const agent_id = idRaw?.trim() || `agent_${index + 1}`;
+        return {
+            runner,
+            agent_id,
+            display_name: agent_id,
+        };
+    });
+}
+function summarizeTitle(task) {
+    const trimmed = task.trim().replace(/\s+/g, " ");
+    return trimmed.length > 72 ? `${trimmed.slice(0, 69)}...` : trimmed;
+}
+async function getJson(url, token) {
+    const response = await fetch(url, {
+        headers: token ? { authorization: `Bearer ${token}` } : {},
+    });
+    if (!response.ok) {
+        throw new Error(`GET ${url} failed: ${response.status} ${await response.text()}`);
+    }
+    return response.json();
+}
+async function postJson(url, body, token) {
+    const response = await fetch(url, {
+        method: "POST",
+        headers: {
+            "content-type": "application/json",
+            ...(token ? { authorization: `Bearer ${token}` } : {}),
+        },
+        body: JSON.stringify(body),
+    });
+    if (!response.ok) {
+        throw new Error(`POST ${url} failed: ${response.status} ${await response.text()}`);
+    }
+    return response.json();
+}

package/.runtime-dist/src/auth/session-token.js

@@ -0,0 +1,62 @@
+const SESSION_PREFIX = "devsession";
+const HOST_PREFIX = "hostsession";
+export function mintSessionToken(claims) {
+    return `${SESSION_PREFIX}.${base64UrlEncode(JSON.stringify(claims))}`;
+}
+export function parseSessionToken(token) {
+    const [prefix, payload] = token.split(".", 2);
+    if (prefix !== SESSION_PREFIX || !payload) {
+        return null;
+    }
+    try {
+        return JSON.parse(base64UrlDecode(payload));
+    }
+    catch {
+        return null;
+    }
+}
+export function readBearerToken(request) {
+    const header = request.headers.get("authorization") ?? request.headers.get("Authorization");
+    if (!header) {
+        return null;
+    }
+    const [scheme, token] = header.split(/\s+/, 2);
+    if (!scheme || !token || scheme.toLowerCase() !== "bearer") {
+        return null;
+    }
+    return token;
+}
+export function mintHostToken(claims) {
+    return `${HOST_PREFIX}.${base64UrlEncode(JSON.stringify(claims))}`;
+}
+export function parseHostToken(token) {
+    const [prefix, payload] = token.split(".", 2);
+    if (prefix !== HOST_PREFIX || !payload) {
+        return null;
+    }
+    try {
+        return JSON.parse(base64UrlDecode(payload));
+    }
+    catch {
+        return null;
+    }
+}
+export function requireSessionClaims(request) {
+    const token = readBearerToken(request);
+    if (!token) {
+        return new Response("Missing bearer token", { status: 401 });
+    }
+    const claims = parseSessionToken(token);
+    if (!claims) {
+        return new Response("Invalid bearer token", { status: 401 });
+    }
+    return claims;
+}
+function base64UrlEncode(value) {
+    return btoa(value).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+function base64UrlDecode(value) {
+    const normalized = value.replace(/-/g, "+").replace(/_/g, "/");
+    const pad = normalized.length % 4 === 0 ? "" : "=".repeat(4 - (normalized.length % 4));
+    return atob(normalized + pad);
+}

package/.runtime-dist/src/discord/outbox-ledger.js

@@ -0,0 +1,56 @@
+export function createOutboxLedgerState() {
+    return {
+        deliveries: {},
+        by_idempotency_key: {},
+    };
+}
+export function recordOutboxDelivery(state, delivery) {
+    const existing_id = state.by_idempotency_key[delivery.idempotency_key];
+    if (existing_id) {
+        return {
+            state,
+            result: {
+                accepted: true,
+                duplicate: true,
+                delivery_id: existing_id,
+            },
+        };
+    }
+    return {
+        state: {
+            deliveries: {
+                ...state.deliveries,
+                [delivery.delivery_id]: {
+                    ...delivery,
+                    status: "pending",
+                },
+            },
+            by_idempotency_key: {
+                ...state.by_idempotency_key,
+                [delivery.idempotency_key]: delivery.delivery_id,
+            },
+        },
+        result: {
+            accepted: true,
+            duplicate: false,
+            delivery_id: delivery.delivery_id,
+        },
+    };
+}
+export function markOutboxDeliverySent(state, input) {
+    const existing = state.deliveries[input.delivery_id];
+    if (!existing) {
+        return state;
+    }
+    return {
+        ...state,
+        deliveries: {
+            ...state.deliveries,
+            [input.delivery_id]: {
+                ...existing,
+                status: "sent",
+                discord_message_id: input.discord_message_id,
+            },
+        },
+    };
+}

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

@@ -0,0 +1,205 @@
+import { mintSessionToken, parseSessionToken, readBearerToken } from "../auth/session-token.js";
+export class AgentDO {
+    state;
+    env;
+    constructor(state, env) {
+        this.state = state;
+        this.env = env;
+    }
+    async fetch(request) {
+        try {
+            const url = new URL(request.url);
+            if (request.method === "POST" && url.pathname === "/bootstrap") {
+                const body = await request.json();
+                const session = await this.bootstrap(body);
+                return Response.json(session);
+            }
+            if (request.method === "GET" && url.pathname === "/descriptor") {
+                const session = await this.requireSession(request);
+                return Response.json(buildDescriptor(await this.hydrateSession(session)));
+            }
+            if (request.method === "GET" && url.pathname === "/session") {
+                const session = await this.requireSession(request);
+                return Response.json(await this.hydrateSession(session));
+            }
+            if (request.method === "POST" && url.pathname === "/heartbeat") {
+                const session = await this.requireSession(request);
+                const body = await request.json();
+                if (body.session_id !== session.session_id || body.session_epoch !== session.session_epoch) {
+                    return Response.json({ ok: false, rejection: { code: "stale_session", message: "Session fence mismatch" } }, { status: 409 });
+                }
+                const updated = {
+                    ...session,
+                    active_task_id: body.last_task_id ?? session.active_task_id,
+                    current_manifest_seq: body.last_manifest_seq ?? session.current_manifest_seq,
+                    last_seen_at: new Date().toISOString(),
+                };
+                await this.saveSession(updated);
+                return Response.json({ ok: true, lease_expires_at: plusSeconds(updated.last_seen_at, updated.heartbeat_interval_sec * 2) });
+            }
+            if (request.method === "POST" && url.pathname === "/events") {
+                const session = await this.requireSession(request);
+                const body = await request.json();
+                const commands = body.commands ?? [];
+                const fence = { session_id: session.session_id, session_epoch: session.session_epoch };
+                // Group commands by task_id to preserve ordering within a task
+                const groups = new Map();
+                for (let i = 0; i < commands.length; i++) {
+                    const cmd = commands[i];
+                    let group = groups.get(cmd.task_id);
+                    if (!group) {
+                        group = { indices: [], commands: [] };
+                        groups.set(cmd.task_id, group);
+                    }
+                    group.indices.push(i);
+                    group.commands.push(cmd);
+                }
+                // Process task groups in parallel, commands within each group sequentially
+                const results = new Array(commands.length);
+                await Promise.all(Array.from(groups.entries()).map(async ([taskId, group]) => {
+                    const stub = this.env.TASKS.get(this.env.TASKS.idFromName(taskId));
+                    for (let j = 0; j < group.commands.length; j++) {
+                        const response = await stub.fetch("https://do.internal/command", {
+                            method: "POST",
+                            headers: { "content-type": "application/json" },
+                            body: JSON.stringify({
+                                command: group.commands[j],
+                                fence,
+                                claim_expiry_sec: session.claim_expiry_sec,
+                            }),
+                        });
+                        results[group.indices[j]] = await response.json();
+                    }
+                }));
+                return Response.json({ results });
+            }
+            if (request.method === "POST" && url.pathname === "/task-context") {
+                const session = await this.requireSession(request);
+                const body = await request.json();
+                const updated = {
+                    ...session,
+                    active_task_id: body.active_task_id ?? session.active_task_id,
+                    current_manifest_id: body.current_manifest_id ?? session.current_manifest_id,
+                    current_manifest_seq: body.current_manifest_seq ?? session.current_manifest_seq,
+                    task_thread_id: body.task_thread_id ?? session.task_thread_id,
+                    last_seen_at: new Date().toISOString(),
+                };
+                await this.saveSession(updated);
+                return Response.json({ ok: true, descriptor: buildDescriptor(await this.hydrateSession(updated)) });
+            }
+            return new Response("Not found", { status: 404 });
+        }
+        catch (error) {
+            if (error instanceof Response) {
+                return error;
+            }
+            throw error;
+        }
+    }
+    async bootstrap(input) {
+        const previous = await this.loadSession();
+        const session_id = `sess_${crypto.randomUUID()}`;
+        const session_epoch = (previous?.session_epoch ?? 0) + 1;
+        const active_task_id = input.active_task_id ?? previous?.active_task_id ?? "tsk_demo";
+        const session = {
+            agent_id: input.agent_id,
+            display_name: input.display_name ?? previous?.display_name ?? input.agent_id,
+            workspace_id: input.workspace_id ?? previous?.workspace_id ?? "ws_demo",
+            active_project_id: input.active_project_id ?? previous?.active_project_id ?? "prj_demo",
+            active_task_id,
+            project_channel_id: previous?.project_channel_id ?? "discord-project-channel",
+            task_thread_id: active_task_id ? previous?.task_thread_id ?? `thread_${active_task_id}` : null,
+            status_channel_id: previous?.status_channel_id ?? "discord-status-channel",
+            session_id,
+            session_epoch,
+            current_manifest_id: active_task_id ? buildManifestId(active_task_id, previous?.current_manifest_seq ?? 1) : null,
+            current_manifest_seq: active_task_id ? 1 : null,
+            heartbeat_interval_sec: previous?.heartbeat_interval_sec ?? 15,
+            claim_expiry_sec: Number(this.env.CLAIM_EXPIRY_SEC),
+            last_seen_at: new Date().toISOString(),
+        };
+        await this.saveSession(session);
+        const fence = { agent_id: session.agent_id, session_id, session_epoch };
+        return {
+            fence,
+            session_token: mintSessionToken(fence),
+            descriptor: buildDescriptor(await this.hydrateSession(session)),
+        };
+    }
+    async requireSession(request) {
+        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 session = await this.loadSession();
+        if (!session) {
+            throw new Response("Agent session not found", { status: 401 });
+        }
+        if (session.agent_id !== claims.agent_id ||
+            session.session_id !== claims.session_id ||
+            session.session_epoch !== claims.session_epoch) {
+            throw new Response("Stale session", { status: 401 });
+        }
+        return session;
+    }
+    async loadSession() {
+        return (await this.state.storage.get("session")) ?? null;
+    }
+    async saveSession(session) {
+        await this.state.storage.put("session", session);
+    }
+    async hydrateSession(session) {
+        if (!session.active_task_id) {
+            return session;
+        }
+        const taskId = this.env.TASKS.idFromName(session.active_task_id);
+        const response = await this.env.TASKS.get(taskId).fetch("https://do.internal/snapshot");
+        if (!response.ok) {
+            return session;
+        }
+        const task = await response.json();
+        const snapshot = task?.snapshot ?? task;
+        const current_manifest_seq = snapshot?.manifest_seq ?? session.current_manifest_seq;
+        return {
+            ...session,
+            current_manifest_seq,
+            current_manifest_id: buildManifestId(session.active_task_id, current_manifest_seq),
+            task_thread_id: task?.discord_thread_id ?? session.task_thread_id,
+        };
+    }
+}
+function buildDescriptor(session) {
+    return {
+        descriptor_version: 1,
+        protocol_version: "1.0",
+        command_schema_version: 1,
+        event_schema_version: 1,
+        workspace_id: session.workspace_id,
+        session_id: session.session_id,
+        session_epoch: session.session_epoch,
+        active_project_id: session.active_project_id,
+        active_task_id: session.active_task_id,
+        current_manifest_id: session.current_manifest_id,
+        current_manifest_seq: session.current_manifest_seq,
+        manifest_fetch_url: session.current_manifest_id ? `/api/bundles/manifests/${session.current_manifest_id}` : null,
+        project_channel_id: session.project_channel_id,
+        task_thread_id: session.task_thread_id,
+        status_channel_id: session.status_channel_id,
+        ws_url: `/ws/agent?agent_id=${encodeURIComponent(session.agent_id)}`,
+        heartbeat_interval_sec: session.heartbeat_interval_sec,
+        claim_expiry_sec: session.claim_expiry_sec,
+    };
+}
+function plusSeconds(iso, seconds) {
+    return new Date(Date.parse(iso) + seconds * 1000).toISOString();
+}
+function buildManifestId(taskId, manifestSeq) {
+    if (manifestSeq == null) {
+        return null;
+    }
+    return `mf_${taskId}_${manifestSeq}`;
+}

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

@@ -0,0 +1,9 @@
+export class GatewayShardDO {
+    _state;
+    constructor(_state) {
+        this._state = _state;
+    }
+    async fetch() {
+        return Response.json({ ok: true, note: "GatewayShardDO stub" });
+    }
+}