create-planet 1.0.0

package/template/src/pages/manifest.json.ts

@@ -0,0 +1,37 @@
+import type { APIRoute } from "astro";
+import { env } from "cloudflare:workers";
+import { PLANET_NAME, PLANET_DESCRIPTION } from "../lib/config";
+
+export const GET: APIRoute = async ({ request }) => {
+  // Robust helper to get simulation variables
+  const getSimVar = (name: string): string | undefined => {
+    if (env && (env as any)[name]) return (env as any)[name];
+    if (
+      typeof process !== "undefined" &&
+      process.env &&
+      (process.env as any)[name]
+    )
+      return (process.env as any)[name];
+    if (import.meta.env && (import.meta.env as any)[name])
+      return (import.meta.env as any)[name];
+    return undefined;
+  };
+
+  const simUrl = getSimVar("PUBLIC_SIM_LANDING_SITE");
+  const simName = getSimVar("PUBLIC_SIM_PLANET_NAME");
+
+  const landingSite = simUrl || new URL(request.url).origin;
+
+  const manifest: any = {
+    name: simName || PLANET_NAME,
+    description: PLANET_DESCRIPTION,
+    landing_site: landingSite,
+    space_port: `${landingSite}/api/v1/port`,
+  };
+
+  return new Response(JSON.stringify(manifest), {
+    headers: {
+      "Content-Type": "application/json",
+    },
+  });
+};

package/template/src/tests/protocol.test.ts

@@ -0,0 +1,158 @@
+import { describe, it, expect, beforeAll, afterAll, vi } from "vitest";
+import { spawn, execSync, type ChildProcess } from "child_process";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PROJECT_ROOT = path.join(__dirname, "../../");
+
+const NUM_PLANETS = 4; // Minimal quorum size (3f + 1 where f=1)
+const BASE_PORT = 4000;
+const BASE_INSPECTOR_PORT = 29229;
+
+const allPlanets = Array.from({ length: NUM_PLANETS }, (_, i) => ({
+  name: `Towel ${i + 1}`,
+  url: `http://towel-${i + 1}.localhost:${BASE_PORT + i}`,
+  port: BASE_PORT + i,
+  id: i + 1,
+}));
+
+const processes: ChildProcess[] = [];
+
+const cleanup = () => {
+  console.log("Cleaning up processes...");
+  processes.forEach((p) => {
+    try {
+      p.kill();
+    } catch (e) {}
+  });
+  try {
+    execSync("pkill -f 'test-planet' || true");
+  } catch (e) {}
+};
+
+const startPlanet = (planet: (typeof allPlanets)[0]) => {
+  const { id, name, url, port } = planet;
+  const inspectorPort = BASE_INSPECTOR_PORT + id;
+
+  // Initialize Database first
+  console.log(`[${name}] Initializing database...`);
+  execSync(
+    `npx wrangler d1 execute planet_db --file=schema.sql -c wrangler.dev.jsonc --local --persist-to=.wrangler/state/test-planet-${id}`,
+    {
+      cwd: PROJECT_ROOT,
+      stdio: "inherit",
+    },
+  );
+
+  const child = spawn(
+    "npx",
+    [
+      "wrangler",
+      "dev",
+      "--port",
+      port.toString(),
+      "--inspector-port",
+      inspectorPort.toString(),
+      "-c",
+      "wrangler.dev.jsonc",
+      "--persist-to",
+      `.wrangler/state/test-planet-${id}`,
+      "--var",
+      `PUBLIC_SIM_PLANET_NAME:"${name}"`,
+      "--var",
+      `PUBLIC_SIM_LANDING_SITE:"${url}"`,
+      "--var",
+      `PUBLIC_SIM_WARP_LINKS:'${JSON.stringify(allPlanets.filter((p) => p.url !== url).map((n) => ({ name: n.name, url: n.url })))}'`,
+    ],
+    {
+      cwd: PROJECT_ROOT,
+      env: process.env,
+      stdio: ["ignore", "pipe", "pipe"],
+      shell: true,
+    },
+  );
+
+  processes.push(child);
+
+  return new Promise<void>((resolve, reject) => {
+    let isReady = false;
+    const timeout = setTimeout(() => {
+      if (!isReady)
+        reject(new Error(`[${name}] Timed out waiting for readiness`));
+    }, 45000); // Increased timeout for CI/slow environments
+
+    const handleData = (data: Buffer) => {
+      const str = data.toString();
+      process.stdout.write(`[${name}] ${str}`);
+      if (str.includes("Ready on")) {
+        isReady = true;
+        clearTimeout(timeout);
+        resolve();
+      }
+    };
+
+    child.stdout?.on("data", handleData);
+    child.stderr?.on("data", handleData);
+    child.on("error", reject);
+  });
+};
+
+describe("Federated Planets Protocol", () => {
+  beforeAll(async () => {
+    console.log(`Starting ${NUM_PLANETS} planets...`);
+    const startupPromises = allPlanets.map((p) => startPlanet(p));
+    await Promise.all(startupPromises);
+  }, 120000); // 2 minute setup timeout
+
+  afterAll(() => {
+    cleanup();
+  });
+
+  it("should reach quorum when initiating a jump", async () => {
+    console.log("Initiating jump from Towel 1 to Towel 2...");
+    const response = await fetch(
+      `${allPlanets[0].url}/api/v1/port?action=initiate`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          ship_id: "TEST-SHIP",
+          destination_url: allPlanets[1].url,
+          departure_timestamp: Date.now(),
+        }),
+      },
+    );
+
+    expect(response.ok).toBe(true);
+    const data = (await response.json()) as any;
+    expect(data.plan.id).toBeDefined();
+    console.log("Plan initiated:", data.plan.id);
+
+    console.log("Monitoring events for QUORUM_REACHED...");
+    let quorumReached = false;
+    for (let attempt = 0; attempt < 30; attempt++) {
+      await new Promise((r) => setTimeout(r, 2000));
+
+      const eventsRes = await fetch(`${allPlanets[0].url}/api/v1/control-ws`);
+      if (eventsRes.ok) {
+        const events = (await eventsRes.json()) as any[];
+        const quorumEvent = events.find((e) => e.type === "QUORUM_REACHED");
+        const errorEvent = events.find((e) => e.type === "API_ERROR");
+
+        if (errorEvent) {
+          console.error("API ERROR DETECTED:", errorEvent.error);
+        }
+
+        if (quorumEvent) {
+          console.log("SUCCESS: Quorum reached!");
+          quorumReached = true;
+          break;
+        }
+      }
+      console.log(`Waiting for quorum... (attempt ${attempt + 1}/30)`);
+    }
+
+    expect(quorumReached).toBe(true);
+  }, 90000); // 90s test timeout
+});

package/template/src/tests/warp-links.test.ts

@@ -0,0 +1,117 @@
+import { describe, it, expect, beforeAll, afterAll, vi } from "vitest";
+import { spawn, execSync, type ChildProcess } from "child_process";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PROJECT_ROOT = path.join(__dirname, "../../");
+
+const TEST_PORT = 4500;
+const TEST_HOST = "towel-warp-test.localhost";
+const TEST_NAME = "Warp Test Planet";
+const TEST_LINKS = [
+  { name: "Test Link Alpha", url: "https://alpha.test" },
+  { name: "Test Link Beta", url: "https://beta.test" },
+];
+
+const processes: ChildProcess[] = [];
+
+const cleanup = () => {
+  console.log("Cleaning up...");
+  processes.forEach((p) => {
+    try {
+      p.kill();
+    } catch (e) {}
+  });
+  try {
+    execSync("pkill -f 'warp-test' || true");
+  } catch (e) {}
+};
+
+describe("Warp Links Configuration", () => {
+  beforeAll(async () => {
+    console.log(`[${TEST_NAME}] Initializing database...`);
+    execSync(
+      `npx wrangler d1 execute planet_db --file=schema.sql -c wrangler.dev.jsonc --local --persist-to=.wrangler/state/warp-test`,
+      {
+        cwd: PROJECT_ROOT,
+        stdio: "inherit",
+      },
+    );
+
+    console.log(`Starting ${TEST_NAME} on http://${TEST_HOST}:${TEST_PORT}...`);
+
+    const child = spawn(
+      "npx",
+      [
+        "wrangler",
+        "dev",
+        "--port",
+        TEST_PORT.toString(),
+        "-c",
+        "wrangler.dev.jsonc",
+        "--persist-to",
+        ".wrangler/state/warp-test",
+        "--var",
+        `PUBLIC_SIM_PLANET_NAME:"${TEST_NAME}"`,
+        "--var",
+        `PUBLIC_SIM_LANDING_SITE:"http://${TEST_HOST}:${TEST_PORT}"`,
+        "--var",
+        `PUBLIC_SIM_WARP_LINKS:'${JSON.stringify(TEST_LINKS)}'`,
+      ],
+      {
+        cwd: PROJECT_ROOT,
+        env: { ...process.env },
+        stdio: ["ignore", "pipe", "pipe"],
+        shell: true,
+      },
+    );
+
+    processes.push(child);
+
+    await new Promise<void>((resolve, reject) => {
+      let isReady = false;
+      const timeout = setTimeout(() => {
+        if (!isReady)
+          reject(new Error(`[${TEST_NAME}] Timed out waiting for readiness`));
+      }, 45000);
+
+      const handleData = (data: Buffer) => {
+        const str = data.toString();
+        process.stdout.write(`[${TEST_NAME}] ${str}`);
+        if (str.includes("Ready on")) {
+          isReady = true;
+          clearTimeout(timeout);
+          resolve();
+        }
+      };
+
+      child.stdout?.on("data", handleData);
+      child.stderr?.on("data", handleData);
+      child.on("error", reject);
+    });
+  }, 60000);
+
+  afterAll(() => {
+    cleanup();
+  });
+
+  it("should override planet name in manifest", async () => {
+    const response = await fetch(
+      `http://${TEST_HOST}:${TEST_PORT}/manifest.json`,
+    );
+    expect(response.ok).toBe(true);
+    const manifest = (await response.json()) as any;
+    expect(manifest.name).toBe(TEST_NAME);
+  });
+
+  it("should correctly override warp links on homepage", async () => {
+    const homeRes = await fetch(`http://${TEST_HOST}:${TEST_PORT}/`);
+    expect(homeRes.ok).toBe(true);
+    const html = await homeRes.text();
+
+    expect(html).toContain("Test Link Alpha");
+    expect(html).toContain("Test Link Beta");
+    expect(html).not.toContain("Aether Reach"); // Default link should be absent
+  });
+});

package/template/src/traffic-control.ts

@@ -0,0 +1,52 @@
+import { DurableObject } from "cloudflare:workers";
+
+export default class TrafficControl extends DurableObject {
+  private sessions: Set<WebSocket> = new Set();
+  private events: any[] = [];
+
+  constructor(state: any, env: any) {
+    super(state, env);
+    console.log("[TrafficControl] Initialized");
+  }
+
+  async fetch(request: Request) {
+    const url = new URL(request.url);
+
+    if (url.pathname === "/events" && request.method === "POST") {
+      const event = await request.json();
+      this.events.push({ ...event, timestamp: Date.now() });
+      if (this.events.length > 50) this.events.shift();
+      this.broadcast(JSON.stringify(event));
+      return new Response("OK");
+    }
+
+    if (request.headers.get("Upgrade") === "websocket") {
+      const pair = new WebSocketPair();
+      const [client, server] = Object.values(pair);
+      // @ts-ignore
+      server.accept();
+      this.sessions.add(server);
+
+      server.send(JSON.stringify({ type: "history", data: this.events }));
+
+      server.addEventListener("close", () => this.sessions.delete(server));
+      server.addEventListener("error", () => this.sessions.delete(server));
+
+      return new Response(null, { status: 101, webSocket: client });
+    }
+
+    return new Response(JSON.stringify(this.events), {
+      headers: { "Content-Type": "application/json" },
+    });
+  }
+
+  broadcast(message: string) {
+    for (const ws of this.sessions) {
+      try {
+        ws.send(message);
+      } catch (e) {
+        this.sessions.delete(ws);
+      }
+    }
+  }
+}

package/template/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "astro/tsconfigs/strict",
+  "compilerOptions": {
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["src/*"]
+    }
+  }
+}

package/template/vitest.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: "node",
+    testTimeout: 90000, // Increased for full builds
+    hookTimeout: 60000,
+    fileParallelism: true,
+    include: ["src/tests/**/*.test.{ts,js}"],
+  },
+});

package/template/wrangler.build.jsonc

@@ -0,0 +1,36 @@
+{
+  "name": "federated-planet",
+  "compatibility_date": "2026-03-31",
+  "assets": {
+    "directory": "dist/client",
+    "binding": "STATIC_ASSETS",
+  },
+  "d1_databases": [
+    {
+      "binding": "DB",
+      "database_name": "planet_db",
+      "database_id": "your-d1-id-here", // To be replaced during deployment
+      "migrations_dir": "migrations",
+    },
+  ],
+  "kv_namespaces": [
+    {
+      "binding": "KV",
+      "id": "your-kv-id-here", // To be replaced during deployment
+    },
+  ],
+  "durable_objects": {
+    "bindings": [
+      {
+        "name": "TRAFFIC_CONTROL",
+        "class_name": "TrafficControl",
+      },
+    ],
+  },
+  "migrations": [
+    {
+      "tag": "v1",
+      "new_classes": ["TrafficControl"],
+    },
+  ],
+}

package/template/wrangler.dev.jsonc

@@ -0,0 +1,41 @@
+{
+  "name": "federated-planet",
+  "main": "dist/server/entry.mjs",
+  "compatibility_date": "2026-03-31",
+  "assets": {
+    "directory": "dist/client",
+    "binding": "STATIC_ASSETS",
+  },
+  "d1_databases": [
+    {
+      "binding": "DB",
+      "database_name": "planet_db",
+      "database_id": "your-d1-id-here",
+      "migrations_dir": "migrations",
+    },
+  ],
+  "kv_namespaces": [
+    {
+      "binding": "KV",
+      "id": "your-kv-id-here",
+    },
+  ],
+  "durable_objects": {
+    "bindings": [
+      {
+        "name": "TRAFFIC_CONTROL",
+        "class_name": "TrafficControl",
+      },
+    ],
+  },
+  "vars": {
+    "WARP_MS_PER_FY": "10000",
+    "DEPARTURE_BUFFER_MS": "5000",
+  },
+  "migrations": [
+    {
+      "tag": "v1",
+      "new_classes": ["TrafficControl"],
+    },
+  ],
+}