Publish Forma Engine 0.3.0 source with documentation and CI

2026-09-09 15:49:08 +03:00
commit e52bc0e33b
70 changed files with 19610 additions and 0 deletions
@@ -0,0 +1,186 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtemp, rm, readFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { createService } from "../server/index.ts";
+import { unpackProject } from "../engine/archive.ts";
+import { unzipSync } from "fflate";
+import { triangleGlb } from "./fixtures.ts";
+test("real MCP HTTP + stdio share revisions, models, scripts, resources and exports", async () => {
+  const dir = await mkdtemp(path.join(os.tmpdir(), "forma-test-"));
+  const s = await createService({ projectDir: dir, port: 0, blank: true });
+  const client = new Client({ name: "acceptance", version: "1" });
+  let bridge: Client | undefined;
+  try {
+    const url = "http://127.0.0.1:" + s.port + "/mcp";
+    const unauthorized = await fetch(url, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: "{}",
+    });
+    assert.equal(unauthorized.status, 401);
+    const origin = await fetch(url, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        origin: "https://untrusted.example",
+        authorization: "Bearer " + s.token,
+      },
+      body: "{}",
+    });
+    assert.equal(origin.status, 403);
+    await client.connect(
+      new StreamableHTTPClientTransport(new URL(url), {
+        requestInit: { headers: { authorization: "Bearer " + s.token } },
+      }),
+    );
+    const tools = await client.listTools();
+    assert.ok(tools.tools.length >= 25);
+    assert.ok(tools.tools.some((t) => t.name === "runtime_capture"));
+    const page = await fetch("http://127.0.0.1:" + s.port + "/").then((r) =>
+      r.text(),
+    );
+    for (const asset of ["/studio/editor.js", "/studio/editor.css"]) {
+      assert.ok(page.includes(asset));
+      assert.equal(
+        (await fetch("http://127.0.0.1:" + s.port + asset)).status,
+        200,
+      );
+    }
+    const toggle = async (enabled: boolean) =>
+      fetch("http://127.0.0.1:" + s.port + "/api/mcp", {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          origin: "http://127.0.0.1:" + s.port,
+        },
+        body: JSON.stringify({ enabled }),
+      });
+    assert.equal((await toggle(false)).status, 200);
+    await assert.rejects(() =>
+      client.callTool({ name: "project_read", arguments: {} }),
+    );
+    assert.equal((await toggle(true)).status, 200);
+    const resources = await client.listResources();
+    assert.equal(resources.resources.length, 3);
+    assert.ok(
+      (await client.readResource({ uri: "forma://reference/scripts" })).contents
+        .length,
+    );
+    const prompts = await client.listPrompts();
+    assert.deepEqual(prompts.prompts.map((p) => p.name), ["create_scene"]);
+    const prompt = await client.getPrompt({ name: "create_scene", arguments: { theme: "architecture" } });
+    assert.match(JSON.stringify(prompt.messages), /architecture/);
+    const invoke = async (name: string, args: any = {}) => {
+      const r = await client.callTool({ name, arguments: args });
+      if (r.isError) throw Error(JSON.stringify(r.content));
+      return r.structuredContent as any;
+    };
+    let p = await invoke("project_read");
+    assert.equal(p.revision, 0);
+    assert.equal(p.assets.length, 0);
+    assert.equal(p.scripts.length, 0);
+    assert.equal(s.service.store.project.scenes[0].entities.length, 0);
+    await invoke("model_generate", {
+      kind: "arena",
+      expectedRevision: 0,
+      seed: 41,
+      obstacles: 3,
+      requestId: "arena-1",
+    });
+    assert.equal(s.service.store.project.revision, 1);
+    assert.ok(s.service.store.project.scenes[0].entities.length > 20);
+    const stale = await client.callTool({
+      name: "node_create",
+      arguments: { name: "stale", expectedRevision: 0 },
+    });
+    assert.equal(stale.isError, true);
+    assert.equal(s.service.store.project.revision, 1);
+    await invoke("model_generate", {
+      kind: "arena",
+      expectedRevision: 0,
+      seed: 41,
+      obstacles: 3,
+      requestId: "arena-1",
+    });
+    assert.equal(s.service.store.project.revision, 1);
+    const bytes = triangleGlb(true);
+    await invoke("asset_import_glb", {
+      expectedRevision: 1,
+      name: "test.glb",
+      base64: bytes.toString("base64"),
+      instantiate: true,
+    });
+    assert.equal(s.service.store.project.revision, 2);
+    bridge = new Client({ name: "stdio-acceptance", version: "1" });
+    await bridge.connect(
+      new StdioClientTransport({
+        command: process.execPath,
+        args: [
+          fileURLToPath(new URL("../server/stdio.mjs", import.meta.url)),
+          "--project",
+          dir,
+          "--url",
+          url,
+        ],
+        cwd: os.tmpdir(),
+        stderr: "pipe",
+      }),
+    );
+    assert.equal((await bridge.listTools()).tools.length, tools.tools.length);
+    const change = await bridge.callTool({
+      name: "node_create",
+      arguments: {
+        name: "From stdio",
+        id: "stdio_object",
+        expectedRevision: 2,
+        components: { mesh: { type: "sphere", size: [1, 1, 1] } },
+      },
+    });
+    assert.equal(change.isError, undefined);
+    assert.equal(s.service.store.project.revision, 3);
+    assert.ok(
+      s.service.store.project.scenes[0].entities.some(
+        (n) => n.id === "stdio_object",
+      ),
+    );
+    await invoke("history_undo", { expectedRevision: 3 });
+    assert.equal(s.service.store.project.revision, 4);
+    assert.ok(
+      !s.service.store.project.scenes[0].entities.some(
+        (n) => n.id === "stdio_object",
+      ),
+    );
+    await invoke("history_redo", { expectedRevision: 4 });
+    const save = await invoke("project_save");
+    assert.equal(
+      unpackProject(new Uint8Array(await readFile(save.path))).revision,
+      5,
+    );
+    const exported = await invoke("project_export_web");
+    const files = unzipSync(new Uint8Array(await readFile(exported.path)));
+    assert.ok(files["index.html"] && files["player.js"] && files["player.css"]);
+    assert.ok(files["player.js"].length > 100000);
+    assert.equal(
+      JSON.parse(new TextDecoder().decode(files["project.forma.json"]))
+        .revision,
+      5,
+    );
+    const noEditor = await client.callTool({
+      name: "runtime_play",
+      arguments: {},
+    });
+    assert.equal(noEditor.isError, true);
+    assert.match(JSON.stringify(noEditor.content), /EDITOR_DISCONNECTED/);
+  } finally {
+    await bridge?.close();
+    await client.close();
+    await s.close();
+    await rm(dir, { recursive: true, force: true });
+  }
+});