@opencomputer/cli 0.3.13 → 0.4.1

package/dist/project.js

@@ -1,6 +1,7 @@
 import { createHash, randomInt, randomUUID } from "node:crypto";
 import { access, cp, mkdir, readFile, readdir, rm, writeFile, } from "node:fs/promises";
-import { dirname, relative, resolve } from "node:path";
+import { basename, dirname, relative, resolve } from "node:path";
+import ts from "typescript";
 const AGENT_ID_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 const AGENT_NAME_ADJECTIVES = [
     "Amber",
@@ -55,7 +56,7 @@ async function prepareInitializationTarget(root, template) {
         "opencode.json",
         "package.json",
         "agent.ts",
-        "instructions.md",
+        "opencomputer.ts",
         ...(template.id === "pr-review-readiness"
             ? [
                 "tools/github.ts",
@@ -88,7 +89,13 @@ async function prepareInitializationTarget(root, template) {
 }
 async function updateGitignore(root) {
     const path = resolve(root, ".gitignore");
-    const required = ["node_modules/", ".opencomputer/", ".env"];
+    const required = [
+        "node_modules/",
+        "dist/",
+        ".opencomputer/",
+        ".env",
+        ".env.local",
+    ];
     let existing = "";
     try {
         existing = await readFile(path, "utf8");
@@ -1057,10 +1064,39 @@ export async function readManifest(root) {
 export async function findAgentRoot(startDirectory = process.cwd()) {
     let directory = resolve(startDirectory);
     for (;;) {
+        const nested = resolve(directory, "opencomputer");
         if ((await exists(resolve(directory, "opencomputer.toml"))) &&
-            (await exists(resolve(directory, "instructions.md")))) {
+            (await exists(resolve(directory, "agent.ts")))) {
             return directory;
         }
+        if ((await exists(resolve(nested, "opencomputer.toml"))) &&
+            (await exists(resolve(nested, "agent.ts")))) {
+            return nested;
+        }
+        for (const agentsDirectory of [
+            resolve(directory, "opencomputer", "agents"),
+            resolve(directory, "agents"),
+        ]) {
+            if (!(await exists(agentsDirectory)))
+                continue;
+            const detected = [];
+            for (const entry of await readdir(agentsDirectory, {
+                withFileTypes: true,
+            })) {
+                if (!entry.isDirectory())
+                    continue;
+                const agent = resolve(agentsDirectory, entry.name);
+                if ((await exists(resolve(agent, "opencomputer.toml"))) &&
+                    (await exists(resolve(agent, "agent.ts")))) {
+                    detected.push(agent);
+                }
+            }
+            if (detected.length === 1)
+                return detected[0];
+            if (detected.length > 1) {
+                throw new Error("This project has multiple agents. Select an agent when starting dev mode.");
+            }
+        }
         const parent = dirname(directory);
         if (parent === directory)
             return undefined;
@@ -1161,7 +1197,7 @@ export async function addSlackChannel(root) {
     }, null, 2)}\n`);
     return ["channels/slack.ts", "slack/manifest.json"];
 }
-export async function initializeAgentProject(template, directory) {
+export async function initializeTemplateAgentProject(template, directory) {
     const root = resolve(directory);
     await prepareInitializationTarget(root, template);
     for (const path of [
@@ -1180,19 +1216,46 @@ export async function initializeAgentProject(template, directory) {
         name: generateAgentName(),
         template: template.id,
     };
+    const reactiveTools = templateReactiveTools(template);
     await writeManifest(root, manifest);
     await writeFile(resolve(root, "opencomputer.config.ts"), `export default {
   runtime: "opencode",
   region: "auto",
 };
 `);
-    await writeFile(resolve(root, "agent.ts"), `export default {
-  model: process.env.OPENCOMPUTER_MODEL,
-  permissions: {
-    shell: "${template.id === "pto-calendar" ? "deny" : "ask"}",
-    files: "allow",
-  },
+    await writeFile(resolve(root, "agent.ts"), `${reactiveTools.length ? 'import { useTool } from "./opencomputer.js";\n\n' : ""}export default function Agent() {
+${reactiveTools
+        .map((tool) => `  useTool(${JSON.stringify(tool)});`)
+        .join("\n")}${reactiveTools.length ? "\n" : ""}
+  return ${JSON.stringify(templateInstructions(template))};
+}
+`);
+    await writeFile(resolve(root, "opencomputer.ts"), `export type SessionDataValue =
+  | null | boolean | number | string
+  | readonly SessionDataValue[]
+  | { readonly [key: string]: SessionDataValue };
+
+type Hooks = {
+  useModel(model: string | { provider: string; model: string }): void;
+  useTool(tool: string | { id: string }): void;
+  useSubagent(agent: string | { id: string }): void;
+  useSessionData<T extends SessionDataValue>(key: string): T | undefined;
 };
+
+function hooks(): Hooks {
+  const value = (globalThis as Record<PropertyKey, unknown>)[
+    Symbol.for("opencomputer.agent-hooks")
+  ];
+  if (!value) throw new Error("OpenComputer hooks can only run while rendering an agent");
+  return value as Hooks;
+}
+
+export const useModel: Hooks["useModel"] = (model) => hooks().useModel(model);
+export const useTool: Hooks["useTool"] = (tool) => hooks().useTool(tool);
+export const useSubagent: Hooks["useSubagent"] = (agent) => hooks().useSubagent(agent);
+export function useSessionData<T extends SessionDataValue>(key: string): T | undefined {
+  return hooks().useSessionData<T>(key);
+}
 `);
     await writeFile(resolve(root, "opencode.json"), `${JSON.stringify({
         $schema: "https://opencode.ai/config.json",
@@ -1215,7 +1278,6 @@ export async function initializeAgentProject(template, directory) {
                 : {}),
         },
     }, null, 2)}\n`);
-    await writeFile(resolve(root, "instructions.md"), templateInstructions(template));
     await writeFile(resolve(root, "workspace", "README.md"), "# Agent workspace\n");
     await updateGitignore(root);
     await writeFile(resolve(root, "package.json"), `${JSON.stringify({
@@ -1241,7 +1303,7 @@ export async function initializeAgentProject(template, directory) {
         "package.json",
         ".gitignore",
         "agent.ts",
-        "instructions.md",
+        "opencomputer.ts",
         "workspace/README.md",
     ];
     if (template.integrations.includes("Gmail")) {
@@ -1437,10 +1499,464 @@ Pass criteria:
     }
     return { root, manifest, files };
 }
+const HELLO_WORLD_TEMPLATE = {
+    id: "hello-world",
+    name: "Hello World",
+    description: "Greet the user, explain that this agent is running live, and answer simple questions clearly.",
+    category: "Getting started",
+    integrations: [],
+    suggestedPrompts: ["Say hello and tell me what you can do."],
+};
+function templateReactiveTools(template) {
+    const tools = [];
+    if (template.integrations.includes("Gmail")) {
+        tools.push("gmail_search", "gmail_read", "gmail_read_full", "gmail_modify", "gmail_send");
+    }
+    if (template.integrations.includes("Google Calendar")) {
+        tools.push("calendar_list", "calendar_events", "calendar_freebusy", "calendar_create_time_off");
+    }
+    if (template.integrations.includes("GitHub")) {
+        tools.push("github_pr_context", "github_checkout");
+    }
+    if (tools.length) {
+        tools.push("opencomputer_connections_list", "opencomputer_connections_request");
+    }
+    return tools;
+}
+export async function assertStarterTarget(directory) {
+    const root = resolve(directory);
+    if (!(await exists(root))) {
+        await mkdir(root, { recursive: true });
+        return;
+    }
+    const reserved = [
+        "opencomputer/project.ts",
+        "opencomputer/agents/hello-world/opencomputer.toml",
+        "package.json",
+        "vite.config.ts",
+        "index.html",
+        "src/App.tsx",
+        "src/main.tsx",
+    ];
+    const conflicts = [];
+    for (const path of reserved) {
+        if (await exists(resolve(root, path)))
+            conflicts.push(path);
+    }
+    if (conflicts.length) {
+        throw new Error(`Target already contains OpenComputer app files: ${conflicts.join(", ")}`);
+    }
+}
+export async function initializeAgentProject(directory, project) {
+    const root = resolve(directory);
+    const agentRoot = resolve(root, "opencomputer", "agents", "hello-world");
+    await assertStarterTarget(root);
+    const initialized = await initializeTemplateAgentProject(HELLO_WORLD_TEMPLATE, agentRoot);
+    const manifest = {
+        ...initialized.manifest,
+        ...(project ? { id: project.agentId } : {}),
+        name: "Hello World",
+    };
+    await writeManifest(agentRoot, manifest);
+    await rm(resolve(agentRoot, "package.json"), { force: true });
+    await rm(resolve(agentRoot, ".gitignore"), { force: true });
+    await updateGitignore(root);
+    await mkdir(resolve(root, "src"), { recursive: true });
+    await writeFile(resolve(root, "opencomputer", "project.ts"), `export default {
+${project ? `  id: ${JSON.stringify(project.id)},\n` : ""}  name: ${JSON.stringify(project?.name ?? basename(root))},
+  agents: ["hello-world"],
+};
+`);
+    await writeFile(resolve(root, "package.json"), `${JSON.stringify({
+        name: `opencomputer-app-${manifest.id}`,
+        version: "0.1.0",
+        private: true,
+        type: "module",
+        scripts: {
+            dev: "opencomputer dev",
+            "dev:web": "vite",
+            build: "tsc -b && vite build",
+            session: "opencomputer session",
+            deploy: "opencomputer deploy",
+        },
+        dependencies: {
+            react: "^19.2.0",
+            "react-dom": "^19.2.0",
+        },
+        devDependencies: {
+            "@opencomputer/cli": "^0.4.1",
+            "@opencode-ai/plugin": "^1.18.4",
+            "@types/node": "^24.0.0",
+            "@types/react": "^19.2.0",
+            "@types/react-dom": "^19.2.0",
+            "@vitejs/plugin-react": "^6.0.0",
+            "opencode-ai": "1.18.4",
+            typescript: "^5.9.0",
+            vite: "^8.0.0",
+        },
+    }, null, 2)}\n`);
+    await writeFile(resolve(root, "vite.config.ts"), `import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import react from "@vitejs/plugin-react";
+import { defineConfig } from "vite";
+
+function openComputerDev() {
+  try {
+    return JSON.parse(
+      readFileSync(
+        resolve("opencomputer/agents/hello-world/.opencomputer/dev.json"),
+        "utf8",
+      ),
+    ) as { url: string; token: string; agent: string };
+  } catch {
+    throw new Error(
+      "OpenComputer is not running. Start npm run dev in another terminal first.",
+    );
+  }
+}
+
+function openComputerAgent() {
+  const manifest = readFileSync(
+    resolve("opencomputer/agents/hello-world/opencomputer.toml"),
+    "utf8",
+  );
+  const id = manifest.match(/^id\\s*=\\s*"([^"]+)"/m)?.[1];
+  if (!id) throw new Error("The hello-world agent manifest has no id.");
+  return id;
+}
+
+export default defineConfig(({ command }) => {
+  const dev = command === "serve" ? openComputerDev() : undefined;
+  return {
+    plugins: [react()],
+    define: {
+      __OPENCOMPUTER_AGENT__: JSON.stringify(
+        dev?.agent ?? \`\${openComputerAgent()}@production\`,
+      ),
+    },
+    ...(dev ? { server: {
+      proxy: {
+        "/api/opencomputer": {
+          target: dev.url,
+          headers: { authorization: \`Bearer \${dev.token}\` },
+          rewrite: (path) => path.replace(/^\\/api\\/opencomputer/, ""),
+        },
+      },
+    } } : {}),
+  };
+});
+`);
+    await writeFile(resolve(root, "tsconfig.json"), `${JSON.stringify({
+        compilerOptions: {
+            target: "ES2022",
+            useDefineForClassFields: true,
+            lib: ["ES2022", "DOM", "DOM.Iterable"],
+            allowJs: false,
+            skipLibCheck: true,
+            esModuleInterop: true,
+            allowSyntheticDefaultImports: true,
+            strict: true,
+            forceConsistentCasingInFileNames: true,
+            module: "ESNext",
+            moduleResolution: "Bundler",
+            resolveJsonModule: true,
+            isolatedModules: true,
+            noEmit: true,
+            jsx: "react-jsx",
+            types: ["node", "vite/client"],
+        },
+        include: ["src", "vite.config.ts"],
+    }, null, 2)}\n`);
+    await writeFile(resolve(root, "index.html"), `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta name="theme-color" content="#11110f" />
+    <title>Hello World · OpenComputer</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>
+`);
+    await writeFile(resolve(root, "src", "use-agent.ts"), `import { useCallback, useRef, useState } from "react";
+
+export interface AgentMessage {
+  id: string;
+  role: "user" | "assistant";
+  text: string;
+}
+
+interface AgentEvent {
+  seq: number;
+  type: string;
+  data: Record<string, unknown>;
+}
+
+declare const __OPENCOMPUTER_AGENT__: string;
+const AGENT = __OPENCOMPUTER_AGENT__;
+
+async function request<T>(path: string, init?: RequestInit): Promise<T> {
+  const response = await fetch(\`/api/opencomputer/managed-agents\${path}\`, {
+    ...init,
+    headers: { "content-type": "application/json", ...init?.headers },
+  });
+  const body = await response.json();
+  if (!response.ok) {
+    throw new Error(body?.error?.message ?? \`Agent request failed (\${response.status})\`);
+  }
+  return body as T;
+}
+
+export function useAgent() {
+  const [messages, setMessages] = useState<AgentMessage[]>([]);
+  const [sessionId, setSessionId] = useState<string>();
+  const sessionRef = useRef<string | undefined>(undefined);
+  const cursorRef = useRef(0);
+  const [isRunning, setIsRunning] = useState(false);
+  const [error, setError] = useState<string>();
+
+  const send = useCallback(async (value: string) => {
+    const prompt = value.trim();
+    if (!prompt || isRunning) return;
+    const userMessage: AgentMessage = {
+      id: crypto.randomUUID(),
+      role: "user",
+      text: prompt,
+    };
+    const assistantId = crypto.randomUUID();
+    setMessages((current) => [
+      ...current,
+      userMessage,
+      { id: assistantId, role: "assistant", text: "" },
+    ]);
+    setIsRunning(true);
+    setError(undefined);
+    try {
+      let activeSession = sessionRef.current;
+      if (!activeSession) {
+        const created = await request<{ session: { id: string } }>("/sessions", {
+          method: "POST",
+          body: JSON.stringify({ agentId: AGENT, source: "local-react" }),
+        });
+        activeSession = created.session.id;
+        sessionRef.current = activeSession;
+        setSessionId(activeSession);
+      } else {
+        await request(\`/sessions/\${encodeURIComponent(activeSession)}/resume\`, {
+          method: "POST",
+        });
+      }
+      let streamed = "";
+      const waitFor = async (terminal: (event: AgentEvent) => boolean) => {
+        for (;;) {
+          const result = await request<{ events: AgentEvent[] }>(
+            \`/sessions/\${encodeURIComponent(activeSession!)}/events?after=\${cursorRef.current}\`,
+          );
+          for (const event of result.events) {
+            cursorRef.current = Math.max(cursorRef.current, event.seq);
+          if (event.type === "message.delta") {
+            streamed += String(event.data.text ?? "");
+            setMessages((current) =>
+              current.map((message) =>
+                message.id === assistantId
+                  ? { ...message, text: streamed }
+                  : message,
+              ),
+            );
+          } else if (event.type === "message.completed" && !streamed) {
+            const text = String(event.data.text ?? "");
+            setMessages((current) =>
+              current.map((message) =>
+                message.id === assistantId ? { ...message, text } : message,
+              ),
+            );
+          }
+            if (terminal(event)) return event;
+          }
+          await new Promise((done) => setTimeout(done, 500));
+        }
+      };
+      await waitFor((event) => event.type === "runtime.connected");
+      await request(\`/sessions/\${encodeURIComponent(activeSession)}/turns\`, {
+        method: "POST",
+        body: JSON.stringify({ input: prompt, idempotencyKey: crypto.randomUUID() }),
+      });
+      const completed = await waitFor((event) =>
+        event.type === "turn.completed" || event.type === "turn.failed",
+      );
+      if (completed.type === "turn.failed") {
+        throw new Error(String(completed.data.message ?? "Agent failed"));
+      }
+      await request(\`/sessions/\${encodeURIComponent(activeSession)}/suspend\`, {
+        method: "POST",
+      });
+    } catch (cause) {
+      const message = cause instanceof Error ? cause.message : String(cause);
+      setError(message);
+      setMessages((current) =>
+        current.map((item) =>
+          item.id === assistantId && !item.text
+            ? { ...item, text: "I couldn't complete that request." }
+            : item,
+        ),
+      );
+    } finally {
+      setIsRunning(false);
+    }
+  }, [isRunning]);
+
+  return { messages, send, isRunning, error };
+}
+`);
+    await writeFile(resolve(root, "src", "App.tsx"), `import { FormEvent, useState } from "react";
+import { useAgent } from "./use-agent";
+
+export default function App() {
+  const [input, setInput] = useState("");
+  const { messages, send, isRunning, error } = useAgent();
+
+  function submit(event: FormEvent) {
+    event.preventDefault();
+    const prompt = input;
+    setInput("");
+    void send(prompt);
+  }
+
+  return (
+    <main>
+      <section className="hero">
+        <span className="eyebrow">OpenComputer</span>
+        <h1>Hello, world.</h1>
+        <p>Your first agent is live. The React app stays local while agent code syncs to Development (Cloud).</p>
+      </section>
+
+      <section className="chat" aria-label="Agent conversation">
+        <div className="messages">
+          {messages.length === 0 ? (
+            <button className="suggestion" onClick={() => void send("Say hello and tell me what you can do.")}>
+              Say hello and tell me what you can do →
+            </button>
+          ) : (
+            messages.map((message) => (
+              <article key={message.id} className={message.role}>
+                <strong>{message.role === "user" ? "You" : "Agent"}</strong>
+                <p>{message.text || "Thinking…"}</p>
+              </article>
+            ))
+          )}
+        </div>
+        {error ? <p className="error">{error}</p> : null}
+        <form onSubmit={submit}>
+          <input
+            value={input}
+            onChange={(event) => setInput(event.target.value)}
+            placeholder="Message the hello-world agent…"
+            aria-label="Message"
+          />
+          <button disabled={isRunning || !input.trim()}>
+            {isRunning ? "Running…" : "Send"}
+          </button>
+        </form>
+      </section>
+    </main>
+  );
+}
+`);
+    await writeFile(resolve(root, "src", "main.tsx"), `import { StrictMode } from "react";
+import { createRoot } from "react-dom/client";
+import App from "./App";
+import "./styles.css";
+
+createRoot(document.getElementById("root")!).render(
+  <StrictMode>
+    <App />
+  </StrictMode>,
+);
+`);
+    await writeFile(resolve(root, "src", "styles.css"), `@import url("https://fonts.googleapis.com/css2?family=DM+Sans:wght@400;500;600&family=DM+Serif+Display&display=swap");
+
+:root { color: #1d1c19; background: #f4f1e9; font-family: "DM Sans", sans-serif; }
+* { box-sizing: border-box; }
+body { margin: 0; min-width: 320px; min-height: 100vh; }
+button, input { font: inherit; }
+main { width: min(760px, calc(100% - 32px)); margin: 0 auto; padding: 12vh 0 48px; }
+.hero { margin-bottom: 36px; }
+.eyebrow { color: #706b60; font-size: 12px; font-weight: 600; letter-spacing: .12em; text-transform: uppercase; }
+h1 { margin: 10px 0; font: 400 clamp(48px, 10vw, 84px)/.95 "DM Serif Display", serif; }
+.hero p { max-width: 580px; color: #625e55; font-size: 18px; line-height: 1.6; }
+.chat { overflow: hidden; border: 1px solid #d9d4c8; border-radius: 18px; background: rgba(255,255,255,.72); box-shadow: 0 18px 60px rgba(56,48,34,.08); }
+.messages { display: grid; gap: 14px; min-height: 260px; max-height: 52vh; overflow-y: auto; padding: 24px; }
+article { max-width: 82%; border-radius: 14px; padding: 12px 14px; }
+article strong { display: block; margin-bottom: 4px; font-size: 12px; color: #777166; }
+article p { margin: 0; line-height: 1.55; white-space: pre-wrap; }
+article.user { justify-self: end; background: #1d1c19; color: white; }
+article.user strong { color: #bdb7ab; }
+article.assistant { background: #ece8de; }
+.suggestion { align-self: center; justify-self: center; border: 1px solid #d9d4c8; border-radius: 999px; background: transparent; padding: 10px 16px; cursor: pointer; }
+.suggestion:hover { background: #ece8de; }
+.error { margin: 0 24px 12px; color: #a33a2b; font-size: 14px; }
+form { display: flex; gap: 10px; border-top: 1px solid #ddd8cc; padding: 14px; background: white; }
+input { min-width: 0; flex: 1; border: 0; outline: 0; padding: 10px; background: transparent; }
+form button { border: 0; border-radius: 10px; background: #d85b35; color: white; padding: 10px 18px; font-weight: 600; cursor: pointer; }
+form button:disabled { cursor: default; opacity: .45; }
+`);
+    await writeFile(resolve(root, "README.md"), `# Hello World OpenComputer app
+
+This project keeps agent definitions in \`opencomputer/\` and the React app in
+\`src/\`.
+
+Sync agent code to Development (Cloud) in one terminal:
+
+\`\`\`bash
+npm run dev
+\`\`\`
+
+The first run asks you to create a cloud project or select an existing one.
+That choice is saved for later development runs.
+
+Then start the React app in another:
+
+\`\`\`bash
+npm run dev:web
+\`\`\`
+`);
+    const appFiles = [
+        "package.json",
+        "vite.config.ts",
+        "tsconfig.json",
+        "index.html",
+        "README.md",
+        ".gitignore",
+        "src/App.tsx",
+        "src/main.tsx",
+        "src/styles.css",
+        "src/use-agent.ts",
+    ];
+    return {
+        root,
+        agentRoot,
+        manifest,
+        files: [
+            "opencomputer/project.ts",
+            ...initialized.files
+                .filter((path) => path !== "package.json" && path !== ".gitignore")
+                .map((path) => `opencomputer/agents/hello-world/${path}`),
+            ...appFiles,
+        ],
+    };
+}
 export async function prepareAgent(root) {
     const runtime = resolve(root, ".opencomputer", "runtime");
     await rm(runtime, { recursive: true, force: true });
     await mkdir(runtime, { recursive: true });
+    const agentSource = await readFile(resolve(root, "agent.ts"), "utf8");
+    const reactive = /export\s+default\s+(?:async\s+)?function\b/.test(agentSource);
+    const legacyInstructions = reactive
+        ? ""
+        : await readFile(resolve(root, "instructions.md"), "utf8");
     await writeFile(resolve(runtime, "AGENTS.md"), `# OpenComputer runtime identity
 
 You are an OpenComputer agent. OpenCode is an internal execution detail, not
@@ -1460,9 +1976,7 @@ the product or support surface presented to users.
 - If a connection tool fails, report its exact error. Do not invent alternate
   controls or third-party support instructions.
 
-# Agent instructions
-
-${await readFile(resolve(root, "instructions.md"), "utf8")}`);
+${legacyInstructions ? `# Agent instructions\n\n${legacyInstructions}` : ""}`);
     const openCodeConfig = resolve(root, "opencode.json");
     if (await exists(openCodeConfig)) {
         const parsed = JSON.parse(await readFile(openCodeConfig, "utf8"));
@@ -1509,6 +2023,48 @@ ${await readFile(resolve(root, "instructions.md"), "utf8")}`);
     if (await exists(workspace)) {
         await cp(workspace, runtime, { recursive: true });
     }
+    if (reactive) {
+        await writeFile(resolve(runtime, "package.json"), `${JSON.stringify({ private: true, type: "module" }, null, 2)}\n`);
+        const transpile = (source, filename) => ts.transpileModule(source, {
+            fileName: filename,
+            compilerOptions: {
+                target: ts.ScriptTarget.ES2022,
+                module: ts.ModuleKind.ESNext,
+                moduleResolution: ts.ModuleResolutionKind.Bundler,
+            },
+            reportDiagnostics: true,
+        });
+        const compiledAgent = transpile(agentSource, "agent.ts");
+        const diagnostics = compiledAgent.diagnostics ?? [];
+        if (diagnostics.some((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Error)) {
+            throw new Error(`agent.ts could not be compiled: ${diagnostics
+                .map((diagnostic) => ts.flattenDiagnosticMessageText(diagnostic.messageText, " "))
+                .join("; ")}`);
+        }
+        await writeFile(resolve(runtime, "agent.js"), compiledAgent.outputText);
+        const hookSource = await readFile(resolve(root, "opencomputer.ts"), "utf8");
+        await writeFile(resolve(runtime, "opencomputer.js"), transpile(hookSource, "opencomputer.ts").outputText);
+        const toolEntries = await readdir(resolve(runtime, ".opencode", "tools"), {
+            withFileTypes: true,
+        });
+        const reactiveTools = [];
+        for (const entry of toolEntries.filter((candidate) => candidate.isFile())) {
+            const stem = entry.name
+                .replace(/\.[^.]+$/, "")
+                .replace(/[^a-zA-Z0-9_]+/g, "_");
+            const source = await readFile(resolve(runtime, ".opencode", "tools", entry.name), "utf8");
+            for (const match of source.matchAll(/export\s+const\s+([a-zA-Z0-9_]+)\s*=/g)) {
+                reactiveTools.push(`${stem}_${match[1]}`);
+            }
+        }
+        await mkdir(resolve(runtime, ".opencomputer"), { recursive: true });
+        await writeFile(resolve(runtime, ".opencomputer", "reactive.json"), `${JSON.stringify({
+            version: 1,
+            entry: "../agent.js",
+            tools: [...new Set(reactiveTools)].sort(),
+            subagents: [],
+        }, null, 2)}\n`);
+    }
     return runtime;
 }
 async function collectNames(root, type) {
@@ -1565,7 +2121,8 @@ async function validateTemplateRequirements(root, manifest) {
     catch {
         // Report one actionable error below for an incomplete PTO project.
     }
-    if (!(await exists(resolve(root, "tools", "calendar.ts"))) || !calendarDeclared) {
+    if (!(await exists(resolve(root, "tools", "calendar.ts"))) ||
+        !calendarDeclared) {
         throw new Error("PTO calendar tools are missing. Run `opencomputer tools add calendar` before deploying.");
     }
 }