office-core 0.1.0

package/.runtime-dist/src/task/reducer.js

@@ -0,0 +1,464 @@
+import { COMMAND_SCHEMA_VERSION, PROTOCOL_VERSION, } from "../types/protocol.js";
+class ReducerReject extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+    }
+}
+const ACCEPTED_BY_PHASE = {
+    new: [],
+    awareness: [],
+    collecting_understandings: ["understanding.submit", "status.upsert", "blocker.raise"],
+    alignment: ["understanding.submit", "alignment.proposed", "status.upsert", "blocker.raise"],
+    awaiting_human_confirmation: ["status.upsert", "blocker.raise"],
+    executing: ["execution.claim", "progress.update", "handoff", "task.complete", "status.upsert", "blocker.raise"],
+    blocked_or_handoff: ["execution.claim", "status.upsert", "blocker.raise"],
+    completed: ["bundle.ack"],
+};
+export function createTaskState(input) {
+    return {
+        snapshot: {
+            task_id: input.task_id,
+            project_id: input.project_id,
+            title: input.title,
+            phase: input.phase ?? "collecting_understandings",
+            task_version: 1,
+            event_seq: 0,
+            understanding_version: 1,
+            manifest_seq: input.manifest_seq ?? 1,
+            resolved_mode: "parallel_interpretation",
+            confirmation_required: input.confirmation_required ?? false,
+            human_confirmed: !(input.confirmation_required ?? false),
+            accepted_understanding: null,
+            facilitator_agent_id: null,
+            current_claim_token: null,
+            claimed_by_agent_id: null,
+            claim_expires_at: null,
+            attempt_count: 0,
+            blockers_open: 0,
+            updated_at: input.now,
+        },
+        events: [],
+        processed_commands: {},
+        project_status_seq: 0,
+    };
+}
+export function buildAgentCommandIdempotencyKey(command) {
+    return `agent-cmd:${command.agent_id}:${command.session_id}:${command.session_epoch}:${command.command_id}`;
+}
+export function applyTaskCommand(state, command, ctx) {
+    const key = buildAgentCommandIdempotencyKey(command);
+    const duplicate = state.processed_commands[key];
+    if (duplicate) {
+        return { state, response: duplicate, side_effects: [] };
+    }
+    try {
+        assertProtocol(command);
+        assertFence(command, ctx.current_fence);
+        assertObservedVersion(command, state.snapshot.task_version);
+        assertBundle(command, state.snapshot.manifest_seq);
+        if (command.type === "status.upsert") {
+            const payload = command.payload;
+            const next = { ...state, project_status_seq: state.project_status_seq + 1 };
+            return remember(next, key, accept(command, next.snapshot), [
+                {
+                    kind: "status_upsert",
+                    data: {
+                        agent_id: command.agent_id,
+                        task_id: command.task_id,
+                        summary: payload.task_summary,
+                        state: payload.state,
+                    },
+                },
+            ]);
+        }
+        if (command.type === "bundle.ack") {
+            return remember(state, key, accept(command, state.snapshot), []);
+        }
+        if (state.snapshot.confirmation_required && !state.snapshot.human_confirmed && command.type === "execution.claim") {
+            throw new ReducerReject("confirmation_required");
+        }
+        if (requiresLiveClaim(command.type)) {
+            assertLiveClaim(state.snapshot, command, ctx.now);
+        }
+        assertPhase(state.snapshot.phase, command.type);
+        if (command.type === "execution.claim" && hasLiveClaim(state.snapshot, ctx.now)) {
+            throw new ReducerReject("claim_conflict");
+        }
+        const event = commandToEvent(state.snapshot, command, ctx);
+        let nextSnapshot = rebuildSnapshot(state.snapshot, event);
+        if (command.type === "understanding.submit" &&
+            state.snapshot.phase === "collecting_understandings" &&
+            shouldAdvanceToAlignment(state.events, event)) {
+            nextSnapshot = advanceToAlignment(nextSnapshot);
+        }
+        const nextState = {
+            ...state,
+            snapshot: nextSnapshot,
+            events: [...state.events, event].slice(-500),
+        };
+        const claimToken = event.event_type === "claim.granted"
+            ? event.payload.claim_token
+            : undefined;
+        return remember(nextState, key, accept(command, nextSnapshot, claimToken), buildSideEffects(state.snapshot, nextSnapshot, event));
+    }
+    catch (error) {
+        if (error instanceof ReducerReject) {
+            return remember(state, key, reject(command, state.snapshot, error.code), []);
+        }
+        throw error;
+    }
+}
+export function applyHumanConfirmation(state, input) {
+    const event = input.type === "accept"
+        ? {
+            id: `evt_${crypto.randomUUID()}`,
+            event_type: "human.confirmed",
+            actor_type: "human",
+            actor_id: input.actor_id,
+            payload: {},
+            occurred_at: input.now,
+        }
+        : {
+            id: `evt_${crypto.randomUUID()}`,
+            event_type: "human.corrected",
+            actor_type: "human",
+            actor_id: input.actor_id,
+            payload: { correction_text: input.correction_text ?? "" },
+            occurred_at: input.now,
+        };
+    return {
+        ...state,
+        events: [...state.events, event],
+        snapshot: rebuildSnapshot(state.snapshot, event),
+    };
+}
+export function applyAlarm(state, now) {
+    if (!state.snapshot.current_claim_token || !state.snapshot.claim_expires_at) {
+        return { state, expired_claim: false };
+    }
+    if (state.snapshot.claim_expires_at > now) {
+        return { state, expired_claim: false };
+    }
+    const event = {
+        id: `evt_${crypto.randomUUID()}`,
+        event_type: "claim.expired",
+        actor_type: "system",
+        actor_id: "TaskDO",
+        payload: {
+            expired_claim_token: state.snapshot.current_claim_token,
+            expired_agent_id: state.snapshot.claimed_by_agent_id,
+        },
+        occurred_at: now,
+    };
+    return {
+        state: {
+            ...state,
+            events: [...state.events, event],
+            snapshot: rebuildSnapshot(state.snapshot, event),
+        },
+        expired_claim: true,
+    };
+}
+export function scheduleAlarm(snapshot) {
+    return snapshot.claim_expires_at;
+}
+function assertProtocol(command) {
+    if (command.protocol_version !== PROTOCOL_VERSION) {
+        throw new ReducerReject("protocol_mismatch");
+    }
+    if (command.command_schema_version !== COMMAND_SCHEMA_VERSION) {
+        throw new ReducerReject("protocol_mismatch");
+    }
+}
+function assertPhase(phase, type) {
+    const allowed = ACCEPTED_BY_PHASE[phase] ?? [];
+    if (!allowed.includes(type)) {
+        throw new ReducerReject("phase_closed");
+    }
+}
+function assertFence(command, current) {
+    if (command.session_id !== current.session_id || command.session_epoch !== current.session_epoch) {
+        throw new ReducerReject("stale_session");
+    }
+}
+function assertObservedVersion(command, currentTaskVersion) {
+    if (command.observed_task_version < currentTaskVersion) {
+        throw new ReducerReject("task_version_conflict");
+    }
+}
+function assertBundle(command, manifestSeq) {
+    if (manifestSeq !== null && command.bundle_seq < manifestSeq) {
+        throw new ReducerReject("stale_bundle");
+    }
+}
+function requiresLiveClaim(type) {
+    return type === "progress.update" || type === "handoff" || type === "task.complete";
+}
+function hasLiveClaim(snapshot, now) {
+    return Boolean(snapshot.current_claim_token && snapshot.claim_expires_at && snapshot.claim_expires_at > now);
+}
+function assertLiveClaim(snapshot, command, now) {
+    if (!snapshot.current_claim_token) {
+        throw new ReducerReject("claim_conflict");
+    }
+    if (command.claim_token !== snapshot.current_claim_token) {
+        throw new ReducerReject("token_mismatch");
+    }
+    if (!snapshot.claim_expires_at || snapshot.claim_expires_at <= now) {
+        throw new ReducerReject("token_expired");
+    }
+}
+function commandToEvent(snapshot, command, ctx) {
+    switch (command.type) {
+        case "understanding.submit":
+            {
+                const payload = command.payload;
+                return agentEvent(command, "understanding.submitted", {
+                    text: payload.text,
+                    confidence: payload.confidence,
+                });
+            }
+        case "alignment.proposed":
+            {
+                const payload = command.payload;
+                return agentEvent(command, "alignment.proposed", {
+                    proposal_text: payload.proposal_text,
+                });
+            }
+        case "execution.claim":
+            {
+                const payload = command.payload;
+                return agentEvent(command, "claim.granted", {
+                    claim_token: mintClaimToken(snapshot, command, ctx),
+                    granted_to_agent_id: command.agent_id,
+                    expires_at: plusSeconds(ctx.now, ctx.claim_expiry_sec),
+                    scope: payload.scope,
+                    approach_summary: payload.approach_summary,
+                });
+            }
+        case "progress.update":
+            {
+                const payload = command.payload;
+                return agentEvent(command, "progress.reported", {
+                    summary: payload.summary,
+                    percent_complete: payload.percent_complete,
+                });
+            }
+        case "blocker.raise":
+            {
+                const payload = command.payload;
+                return agentEvent(command, "blocker.raised", {
+                    message: payload.message,
+                    new_approach: payload.new_approach ?? false,
+                });
+            }
+        case "handoff":
+            {
+                const payload = command.payload;
+                return agentEvent(command, "handoff.accepted", {
+                    to_agent_id: payload.to_agent_id ?? null,
+                    reason: payload.reason,
+                    context_notes: payload.context_notes,
+                });
+            }
+        case "task.complete":
+            {
+                const payload = command.payload;
+                return agentEvent(command, "task.completed", {
+                    summary: payload.summary,
+                    artifact_ids: payload.artifact_ids ?? [],
+                });
+            }
+        default:
+            throw new ReducerReject("phase_closed");
+    }
+}
+function agentEvent(command, eventType, payload) {
+    return {
+        id: `evt_${crypto.randomUUID()}`,
+        event_type: eventType,
+        actor_type: "agent",
+        actor_id: command.agent_id,
+        payload,
+        occurred_at: command.sent_at,
+    };
+}
+function mintClaimToken(snapshot, command, ctx) {
+    return {
+        claim_token: `ctok_${crypto.randomUUID()}`,
+        task_id: snapshot.task_id,
+        task_version: snapshot.task_version,
+        granted_at: ctx.now,
+        expires_at: plusSeconds(ctx.now, ctx.claim_expiry_sec),
+        granted_to_agent_id: command.agent_id,
+    };
+}
+function rebuildSnapshot(previous, event) {
+    const next = { ...previous };
+    next.event_seq = previous.event_seq + 1;
+    next.updated_at = event.occurred_at;
+    switch (event.event_type) {
+        case "alignment.proposed":
+            next.accepted_understanding = String(event.payload.proposal_text ?? "");
+            if (next.confirmation_required) {
+                next.phase = "awaiting_human_confirmation";
+            }
+            else {
+                next.phase = "executing";
+                next.human_confirmed = true;
+                next.understanding_version = previous.understanding_version + 1;
+            }
+            break;
+        case "human.confirmed":
+            next.phase = "executing";
+            next.human_confirmed = true;
+            next.understanding_version = previous.understanding_version + 1;
+            break;
+        case "human.corrected":
+            next.phase = "alignment";
+            next.human_confirmed = false;
+            next.accepted_understanding = String(event.payload.correction_text ?? "");
+            next.understanding_version = previous.understanding_version + 1;
+            break;
+        case "claim.granted":
+            next.phase = "executing";
+            next.current_claim_token = String(event.payload.claim_token.claim_token);
+            next.claimed_by_agent_id = String(event.payload.granted_to_agent_id);
+            next.claim_expires_at = String(event.payload.claim_token.expires_at);
+            break;
+        case "progress.reported":
+            next.phase = "executing";
+            break;
+        case "blocker.raised":
+            next.phase = "blocked_or_handoff";
+            next.attempt_count = previous.attempt_count + 1;
+            next.blockers_open = previous.blockers_open + 1;
+            next.current_claim_token = null;
+            next.claimed_by_agent_id = null;
+            next.claim_expires_at = null;
+            break;
+        case "handoff.accepted":
+            next.phase = "blocked_or_handoff";
+            next.current_claim_token = null;
+            next.claimed_by_agent_id = null;
+            next.claim_expires_at = null;
+            break;
+        case "claim.expired":
+            next.phase = "blocked_or_handoff";
+            break;
+        case "task.completed":
+            next.phase = "completed";
+            next.current_claim_token = null;
+            next.claimed_by_agent_id = null;
+            next.claim_expires_at = null;
+            break;
+        case "understanding.submitted":
+            break;
+    }
+    if (canonicalSnapshotChanged(previous, next)) {
+        next.task_version = previous.task_version + 1;
+    }
+    return next;
+}
+function shouldAdvanceToAlignment(existingEvents, nextEvent) {
+    const agents = new Set();
+    for (const event of existingEvents) {
+        if (event.event_type === "understanding.submitted") {
+            agents.add(event.actor_id);
+        }
+    }
+    if (nextEvent.event_type === "understanding.submitted") {
+        agents.add(nextEvent.actor_id);
+    }
+    return agents.size >= 2;
+}
+function advanceToAlignment(snapshot) {
+    if (snapshot.phase === "alignment") {
+        return snapshot;
+    }
+    const next = { ...snapshot };
+    next.phase = "alignment";
+    next.task_version = snapshot.task_version + 1;
+    return next;
+}
+function canonicalSnapshotChanged(previous, next) {
+    return (previous.phase !== next.phase ||
+        previous.understanding_version !== next.understanding_version ||
+        previous.human_confirmed !== next.human_confirmed ||
+        previous.accepted_understanding !== next.accepted_understanding ||
+        previous.current_claim_token !== next.current_claim_token ||
+        previous.claimed_by_agent_id !== next.claimed_by_agent_id ||
+        previous.claim_expires_at !== next.claim_expires_at ||
+        previous.attempt_count !== next.attempt_count ||
+        previous.blockers_open !== next.blockers_open);
+}
+function buildSideEffects(previous, next, event) {
+    const effects = [];
+    if (event.event_type === "alignment.proposed" || event.event_type === "human.corrected") {
+        effects.push({
+            kind: "manifest_rebuild",
+            data: {
+                reason_code: event.event_type === "alignment.proposed"
+                    ? "human_confirmed_understanding"
+                    : "human_corrected_understanding",
+                task_id: next.task_id,
+                task_version: next.task_version,
+                expected_prev_manifest_seq: previous.manifest_seq ?? 0,
+            },
+        });
+    }
+    if (event.event_type !== "understanding.submitted") {
+        effects.push({
+            kind: "discord_mirror",
+            data: {
+                logical_key: `task:${next.task_id}:${event.event_type}:${event.actor_id}`,
+                render_version: next.task_version,
+            },
+        });
+    }
+    return effects;
+}
+function plusSeconds(now, seconds) {
+    return new Date(Date.parse(now) + seconds * 1000).toISOString();
+}
+function accept(command, snapshot, claimToken) {
+    return {
+        command_id: command.command_id,
+        accepted: true,
+        current_task_version: snapshot.task_version,
+        current_bundle_seq: snapshot.manifest_seq ?? undefined,
+        claim_token: claimToken,
+    };
+}
+function reject(command, snapshot, code) {
+    return {
+        command_id: command.command_id,
+        accepted: false,
+        current_task_version: snapshot.task_version,
+        current_bundle_seq: snapshot.manifest_seq ?? undefined,
+        rejection: {
+            code,
+            message: code,
+            current_task_version: snapshot.task_version,
+            current_bundle_seq: snapshot.manifest_seq ?? undefined,
+        },
+    };
+}
+const MAX_PROCESSED_COMMANDS = 500;
+function remember(state, key, response, sideEffects) {
+    let processed = { ...state.processed_commands, [key]: response };
+    const keys = Object.keys(processed);
+    if (keys.length > MAX_PROCESSED_COMMANDS) {
+        const excess = keys.length - MAX_PROCESSED_COMMANDS;
+        for (let i = 0; i < excess; i++) {
+            delete processed[keys[i]];
+        }
+    }
+    return {
+        state: { ...state, processed_commands: processed },
+        response,
+        side_effects: sideEffects,
+    };
+}

package/.runtime-dist/src/types/project.js

@@ -0,0 +1 @@
+export {};

package/.runtime-dist/src/types/protocol.js

@@ -0,0 +1,3 @@
+export const PROTOCOL_VERSION = "1.0";
+export const COMMAND_SCHEMA_VERSION = 1;
+export const EVENT_SCHEMA_VERSION = 1;

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

@@ -0,0 +1 @@
+export {};

package/README.md

@@ -0,0 +1,148 @@
+# Office Core
+
+Office Core is a Cloudflare-hosted control plane with an installable local CLI for Codex and Claude agents.
+
+The product model is simple:
+
+- one browser UI
+- one active room per project
+- one or more connected machines
+- fresh Codex or Claude agents spawned into the current room
+- room context compacted into `summary.txt`
+- agent startup grounded only on `onboarding.txt` and the current room summary
+
+This repo contains:
+
+- the Worker and browser UI
+- the local host runtime
+- the local install and host menu scripts
+- the room, host, and task state model
+
+## Project shape
+
+- `public/`
+  - chat-first browser UI
+  - install script served by the Worker
+- `src/`
+  - Worker routes
+  - Durable Objects
+  - project read-models
+- `scripts/`
+  - local host runtime
+  - install flow
+  - host menu and helper scripts
+- `bin/`
+  - CLI entrypoint
+- `test/`
+  - node test suite
+
+## Requirements
+
+- Node.js 20+
+- npm
+- Cloudflare Wrangler for local Worker development
+- Windows if you want the visible local shell flow exactly as designed
+
+Optional local runners:
+
+- `codex`
+- `claude`
+
+## Install the CLI
+
+Install from a packaged tarball served by your Worker:
+
+```powershell
+npm install -g "https://your-worker.example/downloads/office-core.tgz"
+```
+
+Then launch the interactive CLI:
+
+```powershell
+office-core
+```
+
+Primary command:
+
+```powershell
+office-core
+```
+
+Supported aliases:
+
+```powershell
+office-host
+dp-host
+double-penetration-host
+```
+
+If you later publish to npm, the install becomes:
+
+```powershell
+npm install -g office-core
+```
+
+or:
+
+```powershell
+npx office-core
+```
+
+## Install for local development
+
+```powershell
+cd "C:\Users\Michael Goat Penis\Dev\Office-Core"
+npm install
+```
+
+## Run locally
+
+Window 1:
+
+```powershell
+cd "C:\Users\Michael Goat Penis\Dev\Office-Core"
+npm run dev
+```
+
+Window 2:
+
+```powershell
+cd "C:\Users\Michael Goat Penis\Dev\Office-Core"
+node .\bin\double-penetration-host.mjs install --baseUrl "http://127.0.0.1:8787" --project "prj_local" --workdir "C:\Users\Michael Goat Penis\Dev\Office-Core"
+node .\bin\double-penetration-host.mjs start
+```
+
+Open:
+
+- [http://127.0.0.1:8787/?projectId=prj_local](http://127.0.0.1:8787/?projectId=prj_local)
+
+## Useful commands
+
+```powershell
+npm run check
+npm run check:runtime
+npm test
+```
+
+```powershell
+node .\bin\double-penetration-host.mjs help
+node .\bin\double-penetration-host.mjs doctor
+node .\bin\double-penetration-host.mjs start
+```
+
+## Current product behavior
+
+- conversations are room-first
+- old conversations keep compacted context, not sleeping agents
+- `Add Agent` spawns a fresh visible local shell for the current room
+- room messages are delivered to session inbox/outbox paths
+- agent/system replies are posted back into the room
+- agent recursion is guarded so agents do not endlessly answer each other
+
+## Packaging
+
+- `npm pack` produces a prebuilt installable package
+- the tarball is copied to `public/downloads/office-core.tgz`
+- published installs can use `npm install -g office-core`
+- the package includes the compiled `.runtime-dist` runtime, so installed machines do not need TypeScript just to run the CLI
+- repo development can still use `node .\bin\double-penetration-host.mjs` without publishing or linking

package/bin/double-penetration-host.mjs

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+
+import path from "node:path";
+import process from "node:process";
+import { readFileSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+const rootDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const runtimeRunner = path.join(rootDir, "scripts", "run-runtime-script.mjs");
+
+const argv = process.argv.slice(2);
+const [command, ...rest] = argv;
+
+if (!command) {
+  runScript("scripts/office-cli.ts", rest);
+} else if (command === "menu") {
+  runScript("scripts/host-menu.ts", rest);
+} else if (command === "install" || command === "join") {
+  runScript("scripts/install-host.ts", rest);
+} else if (command === "start") {
+  runScript("scripts/home-agent-host.ts", rest);
+} else if (command === "doctor") {
+  runScript("scripts/host-doctor.ts", rest);
+} else if (command === "open") {
+  runScript("scripts/host-open.ts", rest);
+} else if (command === "login") {
+  runScript("scripts/host-login.ts", rest);
+} else if (command === "help" || command === "--help" || command === "-h") {
+  printHelp();
+  process.exit(0);
+} else if (command === "version" || command === "--version" || command === "-v") {
+  const pkg = JSON.parse(readFileSync(path.join(rootDir, "package.json"), "utf8"));
+  console.log(pkg.version);
+  process.exit(0);
+} else {
+  console.error(`Unknown command: ${command}`);
+  printHelp();
+  process.exit(1);
+}
+
+function runScript(relativeScript, args) {
+  const result = spawnSync(process.execPath, [runtimeRunner, relativeScript, ...args], {
+    cwd: rootDir,
+    stdio: "inherit",
+    env: process.env,
+  });
+
+  if (typeof result.status === "number") {
+    process.exit(result.status);
+  }
+
+  process.exit(1);
+}
+
+function printHelp() {
+  console.log(
+    [
+      "office-core",
+      "Aliases: office-host, dp-host, double-penetration-host",
+      "",
+      "Usage:",
+      "  office-core                            Interactive CLI (default)",
+      "  office-core menu                       Legacy numbered menu",
+      "  office-core install                    Register this machine and save host config",
+      "  office-core start                      Start the configured local host daemon",
+      "  office-core doctor                     Check worker health, config, and local runners",
+      "  office-core open                       Open the configured Office Core UI",
+      "  office-core login codex                Run Codex login locally",
+      "  office-core login claude               Run Claude auth locally",
+      "",
+      "Legacy aliases continue to work:",
+      "  office-host install --baseUrl https://your-worker.example --project prj_local --workdir C:\\repo",
+      "  dp-host install --baseUrl https://your-worker.example --project prj_local --workdir C:\\repo",
+      "  double-penetration-host start",
+      "",
+      "Examples:",
+      "  office-core install --baseUrl https://your-worker.example --project prj_local --workdir C:\\repo",
+      "  office-core start",
+      "  office-core doctor",
+    ].join("\n"),
+  );
+}