office-core 0.1.0

package/.runtime-dist/scripts/bundle-host-package.js

@@ -0,0 +1,46 @@
+import { copyFile, mkdir, rm } from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import { spawnSync } from "node:child_process";
+void main().catch((error) => {
+    console.error(error);
+    process.exitCode = 1;
+});
+async function main() {
+    const rootDir = process.cwd();
+    const result = process.platform === "win32"
+        ? spawnSync("cmd.exe", ["/d", "/s", "/c", "npm pack --json"], {
+            cwd: rootDir,
+            encoding: "utf8",
+            windowsHide: true,
+        })
+        : spawnSync("npm", ["pack", "--json"], {
+            cwd: rootDir,
+            encoding: "utf8",
+            windowsHide: true,
+        });
+    if (result.status !== 0) {
+        throw new Error(`npm pack failed\n${result.stdout}\n${result.stderr}`.trim());
+    }
+    const pack = JSON.parse(String(result.stdout).trim())?.[0];
+    if (!pack?.filename) {
+        throw new Error("npm pack did not return a filename");
+    }
+    const sourceTarball = path.join(rootDir, pack.filename);
+    const downloadsDir = path.join(rootDir, "public", "downloads");
+    await mkdir(downloadsDir, { recursive: true });
+    const versionedTarget = path.join(downloadsDir, pack.filename);
+    const stableTargets = [
+        path.join(downloadsDir, "office-core.tgz"),
+        path.join(downloadsDir, "office-host.tgz"),
+        path.join(downloadsDir, "dp-host.tgz"),
+        path.join(downloadsDir, "double-penetration-host.tgz"),
+    ];
+    await copyFile(sourceTarball, versionedTarget);
+    for (const stableTarget of stableTargets) {
+        await copyFile(sourceTarball, stableTarget);
+    }
+    await rm(sourceTarball, { force: true });
+    console.log(`Host package bundled: ${stableTargets[0]}`);
+    console.log(`Versioned package: ${versionedTarget}`);
+}

package/.runtime-dist/scripts/demo-multi-agent.js

@@ -0,0 +1,130 @@
+const baseUrl = process.env.OFFICE_BASE_URL ?? "http://127.0.0.1:8787";
+async function main() {
+    console.log(`Using Office Core at ${baseUrl}`);
+    const createdTask = await postJson(`${baseUrl}/api/tasks`, {
+        project_id: "prj_demo",
+        discord_event_id: `discord:${Date.now()}`,
+        channel_id: "discord-project-channel",
+        title: "Multi-agent office smoke test",
+        raw_content: "Stand up two agents, align, claim, and report progress.",
+        requested_by_discord_user_id: "human_demo",
+    });
+    console.log("Created task:", createdTask);
+    const agentA = await bootstrapAgent("agent_alpha", createdTask.task_id);
+    const agentB = await bootstrapAgent("agent_bravo", createdTask.task_id);
+    console.log("Bootstrapped agents:", {
+        alpha: agentA.fence,
+        bravo: agentB.fence,
+    });
+    const manifest = await getJson(`${baseUrl}${agentA.descriptor.manifest_fetch_url}`, agentA.session_token);
+    console.log("Fetched manifest:", manifest.manifest_id, manifest.blobs?.length ?? 0);
+    await sendAgentCommand(agentA.session_token, {
+        ...commandBase("cmd_alpha_status", "agent_alpha", createdTask.task_id),
+        type: "status.upsert",
+        payload: { task_summary: "Reading project brief", state: "active" },
+    });
+    await sendAgentCommand(agentA.session_token, {
+        ...commandBase("cmd_alpha_understanding", "agent_alpha", createdTask.task_id),
+        type: "understanding.submit",
+        payload: { text: "Need a shared task map and one executor", confidence: "high" },
+    });
+    await sendAgentCommand(agentB.session_token, {
+        ...commandBase("cmd_bravo_status", "agent_bravo", createdTask.task_id),
+        type: "status.upsert",
+        payload: { task_summary: "Checking agent flow", state: "active" },
+    });
+    await sendAgentCommand(agentB.session_token, {
+        ...commandBase("cmd_bravo_understanding", "agent_bravo", createdTask.task_id),
+        type: "understanding.submit",
+        payload: { text: "Need one alignment message then execution", confidence: "medium" },
+    });
+    await postJson(`${baseUrl}/api/tasks/${createdTask.task_id}/human-confirm`, {
+        actor_id: "human_demo",
+        type: "accept",
+    });
+    const claim = await sendAgentCommand(agentA.session_token, {
+        ...commandBase("cmd_alpha_claim", "agent_alpha", createdTask.task_id, 2),
+        type: "execution.claim",
+        payload: { scope: "full", approach_summary: "Take the first implementation pass." },
+    });
+    const claimToken = claim.results?.[0]?.claim_token?.claim_token;
+    if (!claimToken) {
+        throw new Error(`Claim failed: ${JSON.stringify(claim)}`);
+    }
+    await sendAgentCommand(agentA.session_token, {
+        ...commandBase("cmd_alpha_progress", "agent_alpha", createdTask.task_id, 3),
+        type: "progress.update",
+        claim_token: claimToken,
+        payload: { summary: "Prototype path is running with two agents.", percent_complete: 35 },
+    });
+    const task = await getJson(`${baseUrl}/api/tasks/${createdTask.task_id}`);
+    const project = await getJson(`${baseUrl}/api/projects/prj_demo`);
+    const status = await getJson(`${baseUrl}/api/projects/prj_demo/status`);
+    console.log("\nTask snapshot:");
+    console.dir(task, { depth: null });
+    console.log("\nProject summary:");
+    console.dir(project, { depth: null });
+    console.log("\nStatus feed:");
+    console.dir(status, { depth: null });
+}
+function commandBase(commandId, agentId, taskId, observedTaskVersion = 1) {
+    return {
+        protocol_version: "1.0",
+        command_schema_version: 1,
+        command_id: commandId,
+        session_id: "placeholder",
+        session_epoch: 1,
+        agent_id: agentId,
+        task_id: taskId,
+        observed_task_version: observedTaskVersion,
+        bundle_seq: 1,
+        sent_at: new Date().toISOString(),
+    };
+}
+async function bootstrapAgent(agentId, taskId) {
+    return postJson(`${baseUrl}/api/agents/bootstrap`, {
+        agent_id: agentId,
+        display_name: agentId,
+        workspace_id: "ws_demo",
+        active_project_id: "prj_demo",
+        active_task_id: taskId,
+    });
+}
+async function sendAgentCommand(token, command) {
+    const claims = parseSessionToken(token);
+    if (!claims) {
+        throw new Error("Invalid session token returned by bootstrap");
+    }
+    const body = structuredClone(command);
+    body.session_id = claims.session_id;
+    body.session_epoch = claims.session_epoch;
+    return postJson(`${baseUrl}/api/agents/events`, { commands: [body] }, token);
+}
+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();
+}
+void main().catch((error) => {
+    console.error(error);
+    process.exitCode = 1;
+});
+import { parseSessionToken } from "../src/auth/session-token.js";