@opencomputer/cli 0.4.0 → 0.4.2

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",
@@ -1045,6 +1046,18 @@ function tomlString(source, key) {
     }
 }
 export async function readManifest(root) {
+    if (!(await exists(resolve(root, "opencomputer.toml")))) {
+        const id = agentIdFromName(basename(root));
+        return {
+            schema: 1,
+            id,
+            name: id
+                .split("-")
+                .map((part) => `${part.slice(0, 1).toUpperCase()}${part.slice(1)}`)
+                .join(" "),
+            template: "hello-world",
+        };
+    }
     const source = await readFile(resolve(root, "opencomputer.toml"), "utf8");
     const schema = Number(source.match(/^\s*schema\s*=\s*(\d+)\s*$/m)?.[1]);
     const id = tomlString(source, "id");
@@ -1064,12 +1077,10 @@ 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")))) {
+        if ((await exists(resolve(directory, "agent.ts")))) {
             return directory;
         }
-        if ((await exists(resolve(nested, "opencomputer.toml"))) &&
-            (await exists(resolve(nested, "instructions.md")))) {
+        if ((await exists(resolve(nested, "agent.ts")))) {
             return nested;
         }
         for (const agentsDirectory of [
@@ -1085,8 +1096,7 @@ export async function findAgentRoot(startDirectory = process.cwd()) {
                 if (!entry.isDirectory())
                     continue;
                 const agent = resolve(agentsDirectory, entry.name);
-                if ((await exists(resolve(agent, "opencomputer.toml"))) &&
-                    (await exists(resolve(agent, "instructions.md")))) {
+                if ((await exists(resolve(agent, "agent.ts")))) {
                     detected.push(agent);
                 }
             }
@@ -1215,19 +1225,46 @@ export async function initializeTemplateAgentProject(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",
@@ -1250,7 +1287,6 @@ export async function initializeTemplateAgentProject(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({
@@ -1275,8 +1311,9 @@ export async function initializeTemplateAgentProject(template, directory) {
         "opencode.json",
         "package.json",
         ".gitignore",
+        "README.md",
         "agent.ts",
-        "instructions.md",
+        "opencomputer.ts",
         "workspace/README.md",
     ];
     if (template.integrations.includes("Gmail")) {
@@ -1480,6 +1517,22 @@ const HELLO_WORLD_TEMPLATE = {
     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))) {
@@ -1488,7 +1541,7 @@ export async function assertStarterTarget(directory) {
     }
     const reserved = [
         "opencomputer/project.ts",
-        "opencomputer/agents/hello-world/opencomputer.toml",
+        "opencomputer/agents/hello-world/agent.ts",
         "package.json",
         "vite.config.ts",
         "index.html",
@@ -1508,20 +1561,45 @@ 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);
+    await initializeTemplateAgentProject(HELLO_WORLD_TEMPLATE, agentRoot);
     const manifest = {
-        ...initialized.manifest,
-        ...(project ? { id: project.agentId } : {}),
+        schema: 1,
+        id: project?.agentId ?? "hello-world",
         name: "Hello World",
+        template: "hello-world",
     };
-    await writeManifest(agentRoot, manifest);
-    await rm(resolve(agentRoot, "package.json"), { force: true });
-    await rm(resolve(agentRoot, ".gitignore"), { force: true });
+    for (const path of [
+        "opencomputer.toml",
+        "opencomputer.config.ts",
+        "opencomputer.ts",
+        "opencode.json",
+        "package.json",
+        ".gitignore",
+        "README.md",
+        "tools",
+        "connections",
+        "skills",
+        "channels",
+        "workspace",
+        "evals",
+    ]) {
+        await rm(resolve(agentRoot, path), { recursive: true, force: true });
+    }
+    await writeFile(resolve(agentRoot, "agent.ts"), `import { useInput, useModel } from "@opencomputer/agent";
+
+export default function Agent() {
+  const input = useInput();
+  useModel("anthropic/claude-sonnet-4.6");
+
+  return input.text
+    ? "You are a helpful OpenComputer agent. Respond directly to: " + input.text
+    : "You are a helpful OpenComputer agent.";
+}
+`);
     await updateGitignore(root);
     await mkdir(resolve(root, "src"), { recursive: true });
     await writeFile(resolve(root, "opencomputer", "project.ts"), `export default {
-  id: ${JSON.stringify(project?.id ?? manifest.id)},
-  name: ${JSON.stringify(project?.name ?? "Hello World")},
+  name: ${JSON.stringify(project?.name ?? basename(root))},
   agents: ["hello-world"],
 };
 `);
@@ -1538,17 +1616,16 @@ export async function initializeAgentProject(directory, project) {
             deploy: "opencomputer deploy",
         },
         dependencies: {
+            "@opencomputer/agent": "^0.1.0",
             react: "^19.2.0",
             "react-dom": "^19.2.0",
         },
         devDependencies: {
-            "@opencomputer/cli": "^0.4.0",
-            "@opencode-ai/plugin": "^1.18.4",
+            "@opencomputer/cli": "^0.4.2",
             "@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",
         },
@@ -1565,7 +1642,7 @@ function openComputerDev() {
         resolve("opencomputer/agents/hello-world/.opencomputer/dev.json"),
         "utf8",
       ),
-    ) as { url: string; token: string };
+    ) as { url: string; token: string; agent: string };
   } catch {
     throw new Error(
       "OpenComputer is not running. Start npm run dev in another terminal first.",
@@ -1573,10 +1650,29 @@ function openComputerDev() {
   }
 }
 
+function openComputerAgent() {
+  try {
+    const binding = JSON.parse(
+      readFileSync(resolve(".opencomputer/project.json"), "utf8"),
+    ) as { agentId?: string };
+    if (binding.agentId) return binding.agentId;
+  } catch {
+    // The production build below reports the actionable binding error.
+  }
+  throw new Error(
+    "This app is not connected to an OpenComputer project. Run npm run dev first.",
+  );
+}
+
 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": {
@@ -1624,7 +1720,7 @@ export default defineConfig(({ command }) => {
   </body>
 </html>
 `);
-    await writeFile(resolve(root, "src", "use-agent.ts"), `import { useCallback, useState } from "react";
+    await writeFile(resolve(root, "src", "use-agent.ts"), `import { useCallback, useRef, useState } from "react";
 
 export interface AgentMessage {
   id: string;
@@ -1633,13 +1729,31 @@ export interface AgentMessage {
 }
 
 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>();
 
@@ -1660,32 +1774,28 @@ export function useAgent() {
     setIsRunning(true);
     setError(undefined);
     try {
-      const endpoint = sessionId
-        ? \`/api/opencomputer/sessions/\${encodeURIComponent(sessionId)}\`
-        : "/api/opencomputer/sessions";
-      const response = await fetch(endpoint, {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ prompt }),
-      });
-      if (!response.ok || !response.body) {
-        throw new Error(\`Agent request failed (\${response.status})\`);
+      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",
+        });
       }
-      const createdSession = response.headers.get("x-opencomputer-session-id");
-      if (createdSession) setSessionId(createdSession);
-      const reader = response.body.getReader();
-      const decoder = new TextDecoder();
-      let buffered = "";
       let streamed = "";
-      for (;;) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        buffered += decoder.decode(value, { stream: true });
-        const lines = buffered.split("\\n");
-        buffered = lines.pop() ?? "";
-        for (const line of lines) {
-          if (!line.trim()) continue;
-          const event = JSON.parse(line) as AgentEvent;
+      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) =>
@@ -1702,11 +1812,26 @@ export function useAgent() {
                 message.id === assistantId ? { ...message, text } : message,
               ),
             );
-          } else if (event.type === "session.failed") {
-            throw new Error(String(event.data.message ?? "Agent failed"));
           }
+            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);
@@ -1720,7 +1845,7 @@ export function useAgent() {
     } finally {
       setIsRunning(false);
     }
-  }, [isRunning, sessionId]);
+  }, [isRunning]);
 
   return { messages, send, isRunning, error };
 }
@@ -1744,7 +1869,7 @@ export default function App() {
       <section className="hero">
         <span className="eyebrow">OpenComputer</span>
         <h1>Hello, world.</h1>
-        <p>Your first agent is live. Ask it anything to see the local backend and React app working together.</p>
+        <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">
@@ -1822,12 +1947,15 @@ form button:disabled { cursor: default; opacity: .45; }
 This project keeps agent definitions in \`opencomputer/\` and the React app in
 \`src/\`.
 
-Start the agent server in one terminal:
+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
@@ -1852,17 +1980,54 @@ npm run dev:web
         manifest,
         files: [
             "opencomputer/project.ts",
-            ...initialized.files
-                .filter((path) => path !== "package.json" && path !== ".gitignore")
-                .map((path) => `opencomputer/agents/hello-world/${path}`),
+            "opencomputer/agents/hello-world/agent.ts",
             ...appFiles,
         ],
     };
 }
+function literalHookIds(source, hook) {
+    const pattern = new RegExp(`\\b${hook}\\(\\s*["']([^"']+)["']`, "g");
+    return [...source.matchAll(pattern)].map((match) => match[1]).sort();
+}
+function definedMcpServerIds(source) {
+    return [...source.matchAll(/\bdefineMcpServer\s*\(\s*\{[\s\S]*?\bid\s*:\s*["']([^"']+)["'][\s\S]*?\}\s*\)/g)].map((match) => match[1]).sort();
+}
+function agentApiRuntimeSource() {
+    return `function hooks() {
+  const value = globalThis[Symbol.for("opencomputer.agent-hooks")];
+  if (!value) throw new Error("OpenComputer hooks can only run while rendering an agent");
+  return value;
+}
+function id(value, kind) {
+  const normalized = String(value).trim();
+  if (!normalized) throw new Error(kind + " requires a non-empty id");
+  return normalized;
+}
+export const connection = (value) => Object.freeze({ kind: "connection", id: id(value, "connection") });
+export const defineMcpServer = (input) => {
+  const url = new URL(input.url);
+  if (url.protocol !== "https:") throw new Error("MCP server URLs must use HTTPS");
+  return Object.freeze({ kind: "mcp", ...input, id: id(input.id, "defineMcpServer"), url: url.toString() });
+};
+export const useInput = () => hooks().useInput();
+export const useCurrentInput = useInput;
+export const useModel = (model) => hooks().useModel(model);
+export const useTool = (tool) => hooks().useTool(tool);
+export const useSubagent = (agent) => hooks().useSubagent(agent);
+export const useConnection = (value) => hooks().useConnection(value);
+export const useMcpServer = (server) => hooks().useMcpServer(server);
+export const useSessionData = (key) => hooks().useSessionData(key);
+`;
+}
 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);
+    if (!reactive) {
+        throw new Error("agent.ts must default-export a synchronous agent function");
+    }
     await writeFile(resolve(runtime, "AGENTS.md"), `# OpenComputer runtime identity
 
 You are an OpenComputer agent. OpenCode is an internal execution detail, not
@@ -1882,9 +2047,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")}`);
+`);
     const openCodeConfig = resolve(root, "opencode.json");
     if (await exists(openCodeConfig)) {
         const parsed = JSON.parse(await readFile(openCodeConfig, "utf8"));
@@ -1931,6 +2094,57 @@ ${await readFile(resolve(root, "instructions.md"), "utf8")}`);
     if (await exists(workspace)) {
         await cp(workspace, runtime, { recursive: true });
     }
+    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("; ")}`);
+    }
+    const compiledSource = compiledAgent.outputText.replace(/(["'])@opencomputer\/agent\1/g, '"./opencomputer-agent.js"');
+    await writeFile(resolve(runtime, "agent.js"), compiledSource);
+    await writeFile(resolve(runtime, "opencomputer-agent.js"), agentApiRuntimeSource());
+    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: 2,
+        entry: "../agent.js",
+        tools: [...new Set([
+                ...reactiveTools,
+                ...literalHookIds(agentSource, "useTool"),
+            ])].sort(),
+        subagents: literalHookIds(agentSource, "useSubagent"),
+        connections: [...new Set([
+                ...literalHookIds(agentSource, "connection"),
+                ...literalHookIds(agentSource, "useConnection"),
+            ])].sort(),
+        mcpServers: [...new Set([
+                ...definedMcpServerIds(agentSource),
+                ...literalHookIds(agentSource, "useMcpServer"),
+            ])].sort(),
+    }, null, 2)}\n`);
     return runtime;
 }
 async function collectNames(root, type) {
@@ -1992,7 +2206,7 @@ async function validateTemplateRequirements(root, manifest) {
         throw new Error("PTO calendar tools are missing. Run `opencomputer tools add calendar` before deploying.");
     }
 }
-export async function buildAgentArtifact(root) {
+export async function buildAgentArtifact(root, agentId) {
     const startedAt = performance.now();
     const manifest = await readManifest(root);
     await validateTemplateRequirements(root, manifest);
@@ -2005,7 +2219,7 @@ export async function buildAgentArtifact(root) {
         files: await collectFiles(runtime),
     }));
     return {
-        agentId: manifest.id,
+        agentId: agentId ?? manifest.id,
         name: manifest.name,
         channels,
         connections,