create-planet 1.0.2 → 1.0.5

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

@@ -35,15 +35,12 @@ 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",
-    },
-  );
+  // Clear any state left over from a prior test run
+  console.log(`[${name}] Clearing previous state...`);
+  execSync(`rm -rf .wrangler/state/test-planet-${id}`, {
+    cwd: PROJECT_ROOT,
+    stdio: "inherit",
+  });
 
   const child = spawn(
     "npx",
@@ -98,6 +95,48 @@ const startPlanet = (planet: (typeof allPlanets)[0]) => {
   });
 };
 
+async function getQuorumCount(planetUrl: string): Promise<number> {
+  const res = await fetch(`${planetUrl}/api/v1/control-ws`);
+  if (!res.ok) return 0;
+  const events = (await res.json()) as any[];
+  return events.filter((e) => e.type === "QUORUM_REACHED").length;
+}
+
+async function collectQuorumPlanIds(
+  planetUrls: string[],
+): Promise<Set<string>> {
+  const ids = new Set<string>();
+  for (const url of planetUrls) {
+    try {
+      const res = await fetch(`${url}/api/v1/control-ws`);
+      if (res.ok) {
+        const events = (await res.json()) as any[];
+        for (const e of events) {
+          if (e.type === "QUORUM_REACHED" && e.plan_id) ids.add(e.plan_id);
+        }
+      }
+    } catch {}
+  }
+  return ids;
+}
+
+async function waitForPlanQuorum(
+  allUrls: string[],
+  planId: string,
+  label: string,
+) {
+  for (let attempt = 0; attempt < 30; attempt++) {
+    await new Promise((r) => setTimeout(r, 2000));
+    const ids = await collectQuorumPlanIds(allUrls);
+    if (ids.has(planId)) {
+      console.log(`SUCCESS: ${label}`);
+      return;
+    }
+    console.log(`Waiting for ${label}... (attempt ${attempt + 1}/30)`);
+  }
+  throw new Error(`Timeout waiting for ${label}`);
+}
+
 describe("Federated Planets Protocol", () => {
   beforeAll(async () => {
     console.log(`Starting ${NUM_PLANETS} planets...`);
@@ -155,4 +194,118 @@ describe("Federated Planets Protocol", () => {
 
     expect(quorumReached).toBe(true);
   }, 90000); // 90s test timeout
+
+  it("should reject a third shuttle when the mutual-neighbor limit (2) is reached", async () => {
+    // Towel 3 and Towel 4 are mutual neighbors of each other; limit is 2
+    const origin = allPlanets[2]; // Towel 3
+    const dest = allPlanets[3]; // Towel 4
+    const allUrls = allPlanets.map((p) => p.url);
+
+    const initiate = (shipId: string) =>
+      fetch(`${origin.url}/api/v1/port?action=initiate`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          ship_id: shipId,
+          destination_url: dest.url,
+          departure_timestamp: Date.now(),
+        }),
+      });
+
+    // Shuttle 1
+    console.log("Initiating shuttle 1 from Towel 3 to Towel 4...");
+    const res1 = await initiate("SHUTTLE-A");
+    expect(res1.ok).toBe(true);
+    const plan1Id = ((await res1.json()) as any).plan.id;
+    console.log("Shuttle 1 plan:", plan1Id);
+    await waitForPlanQuorum(allUrls, plan1Id, "shuttle 1 quorum");
+    // Give origin's handleCommit time to write to its own DB after quorum is reached
+    await new Promise((r) => setTimeout(r, 3000));
+
+    // Shuttle 2
+    console.log("Initiating shuttle 2 from Towel 3 to Towel 4...");
+    const res2 = await initiate("SHUTTLE-B");
+    expect(res2.ok).toBe(true);
+    const plan2Id = ((await res2.json()) as any).plan.id;
+    console.log("Shuttle 2 plan:", plan2Id);
+    await waitForPlanQuorum(allUrls, plan2Id, "shuttle 2 quorum");
+    // Give origin's handleCommit time to write to its own DB after quorum is reached
+    await new Promise((r) => setTimeout(r, 3000));
+
+    // Shuttle 3 — should be rejected at origin
+    console.log("Initiating shuttle 3 (should be rejected)...");
+    const res3 = await initiate("SHUTTLE-C");
+    expect(res3.status).toBe(422);
+    const data3 = (await res3.json()) as any;
+    expect(data3.error).toBe("shuttle_limit_exceeded");
+    expect(data3.limit).toBe(2);
+    expect(data3.relationship).toBe("mutual_neighbors");
+    expect(data3.active_shuttles).toBe(2);
+    console.log("Shuttle 3 correctly rejected:", data3);
+  }, 180000); // 3 minutes for two quorum rounds
+
+  it("should refuse incoming travel at the destination when its shuttle limit is already reached", async () => {
+    // Use Towel 1 → Towel 3 (mutual neighbors, limit = 2).
+    // First establish 2 legitimate shuttles so Towel 3's DB is at the limit.
+    // Then use the test-only bypass header to skip Towel 1's origin check —
+    // the plan proceeds through consensus but Towel 3 refuses registration.
+    const origin = allPlanets[0]; // Towel 1
+    const dest = allPlanets[2]; // Towel 3
+    const allUrls = allPlanets.map((p) => p.url);
+
+    const initiate = (shipId: string, bypass = false) =>
+      fetch(`${origin.url}/api/v1/port?action=initiate`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...(bypass ? { "X-Bypass-Shuttle-Limit": "true" } : {}),
+        },
+        body: JSON.stringify({
+          ship_id: shipId,
+          destination_url: dest.url,
+          departure_timestamp: Date.now(),
+        }),
+      });
+
+    // Fill Towel 3's limit with 2 legitimate shuttles from Towel 1
+    console.log("Filling Towel 3 limit with 2 shuttles from Towel 1...");
+    const fillRes1 = await initiate("FILL-A");
+    expect(fillRes1.ok).toBe(true);
+    const fillPlan1 = ((await fillRes1.json()) as any).plan.id;
+    await waitForPlanQuorum(allUrls, fillPlan1, "fill shuttle 1 quorum");
+
+    const fillRes2 = await initiate("FILL-B");
+    expect(fillRes2.ok).toBe(true);
+    const fillPlan2 = ((await fillRes2.json()) as any).plan.id;
+    await waitForPlanQuorum(allUrls, fillPlan2, "fill shuttle 2 quorum");
+
+    // Now both Towel 1 and Towel 3 have count=2 for the 1↔3 pair.
+    // Use the bypass header to skip Towel 1's origin check — the plan enters
+    // consensus, but Towel 3 independently checks and refuses registration.
+    console.log(
+      "Initiating with bypass header — origin allows, destination should refuse...",
+    );
+    const response = await initiate("DEST-REFUSES", true);
+    expect(response.ok).toBe(true);
+    const planId = ((await response.json()) as any).plan.id;
+    console.log("Bypass plan initiated:", planId);
+
+    // Confirm no QUORUM_REACHED appears for this plan on any planet
+    console.log(
+      "Confirming destination refusal (no QUORUM_REACHED expected)...",
+    );
+    for (let attempt = 0; attempt < 10; attempt++) {
+      await new Promise((r) => setTimeout(r, 2000));
+      const quorumIds = await collectQuorumPlanIds(allUrls);
+      if (quorumIds.has(planId)) {
+        throw new Error(
+          `Plan ${planId} should have been refused by destination but reached quorum`,
+        );
+      }
+      console.log(
+        `No QUORUM_REACHED seen (attempt ${attempt + 1}/10) — destination is refusing`,
+      );
+    }
+    console.log("Confirmed: destination refused the travel plan");
+  }, 300000); // 5 minutes: two fill quorum rounds + 20s destination refusal confirmation
 });

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

@@ -30,14 +30,11 @@ const cleanup = () => {
 
 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(`[${TEST_NAME}] Clearing previous state...`);
+    execSync(`rm -rf .wrangler/state/warp-test`, {
+      cwd: PROJECT_ROOT,
+      stdio: "inherit",
+    });
 
     console.log(`Starting ${TEST_NAME} on http://${TEST_HOST}:${TEST_PORT}...`);
 

package/template/src/traffic-control.ts

@@ -6,7 +6,38 @@ export default class TrafficControl extends DurableObject {
 
   constructor(state: any, env: any) {
     super(state, env);
-    console.log("[TrafficControl] Initialized");
+    this.ctx.storage.sql.exec(`
+      CREATE TABLE IF NOT EXISTS travel_plans (
+        id TEXT PRIMARY KEY,
+        ship_id TEXT NOT NULL,
+        origin_url TEXT NOT NULL,
+        destination_url TEXT NOT NULL,
+        start_timestamp INTEGER NOT NULL,
+        end_timestamp INTEGER NOT NULL,
+        status TEXT CHECK(status IN ('PREPARING', 'PLAN_ACCEPTED')) NOT NULL DEFAULT 'PREPARING',
+        signatures TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_travel_plans_active ON travel_plans (end_timestamp, origin_url, destination_url);
+
+      CREATE TABLE IF NOT EXISTS traffic_controllers (
+        planet_url TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        space_port_url TEXT NOT NULL,
+        last_manifest_fetch INTEGER NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS identity (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS consensus_plans (
+        id TEXT PRIMARY KEY,
+        data TEXT NOT NULL,
+        expires_at INTEGER NOT NULL
+      );
+    `);
+    console.log("[TrafficControl] Initialized with SQLite storage");
   }
 
   async fetch(request: Request) {
@@ -20,6 +51,10 @@ export default class TrafficControl extends DurableObject {
       return new Response("OK");
     }
 
+    if (url.pathname === "/storage" && request.method === "POST") {
+      return this.handleStorage(request);
+    }
+
     if (request.headers.get("Upgrade") === "websocket") {
       const pair = new WebSocketPair();
       const [client, server] = Object.values(pair);
@@ -40,6 +75,74 @@ export default class TrafficControl extends DurableObject {
     });
   }
 
+  private async handleStorage(request: Request): Promise<Response> {
+    const body: any = await request.json();
+    const { action } = body;
+
+    switch (action) {
+      case "getIdentity": {
+        const pub = this.ctx.storage.sql
+          .exec("SELECT value FROM identity WHERE key = 'identity_public'")
+          .toArray();
+        const priv = this.ctx.storage.sql
+          .exec("SELECT value FROM identity WHERE key = 'identity_private'")
+          .toArray();
+        return Response.json({
+          public: pub.length > 0 ? (pub[0] as any).value : null,
+          private: priv.length > 0 ? (priv[0] as any).value : null,
+        });
+      }
+
+      case "setIdentity": {
+        this.ctx.storage.sql.exec(
+          "INSERT OR REPLACE INTO identity (key, value) VALUES ('identity_public', ?), ('identity_private', ?)",
+          body.publicKey,
+          body.privateKey,
+        );
+        return Response.json({ success: true });
+      }
+
+      case "savePlan": {
+        const expiresAt = Date.now() + 3600 * 1000;
+        this.ctx.storage.sql.exec(
+          "INSERT OR REPLACE INTO consensus_plans (id, data, expires_at) VALUES (?, ?, ?)",
+          body.planId,
+          body.data,
+          expiresAt,
+        );
+        return Response.json({ success: true });
+      }
+
+      case "getPlan": {
+        const rows = this.ctx.storage.sql
+          .exec(
+            "SELECT data FROM consensus_plans WHERE id = ? AND expires_at > ?",
+            body.planId,
+            Date.now(),
+          )
+          .toArray();
+        return Response.json({
+          data: rows.length > 0 ? (rows[0] as any).data : null,
+        });
+      }
+
+      case "query": {
+        const results = this.ctx.storage.sql
+          .exec(body.sql, ...(body.params || []))
+          .toArray();
+        return Response.json({ results });
+      }
+
+      case "exec": {
+        this.ctx.storage.sql.exec(body.sql, ...(body.params || []));
+        return Response.json({ success: true });
+      }
+
+      default:
+        return Response.json({ error: "Unknown action" }, { status: 400 });
+    }
+  }
+
   broadcast(message: string) {
     for (const ws of this.sessions) {
       try {

package/template/wrangler.build.jsonc

@@ -5,20 +5,6 @@
     "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": [
       {
@@ -30,7 +16,7 @@
   "migrations": [
     {
       "tag": "v1",
-      "new_classes": ["TrafficControl"],
+      "new_sqlite_classes": ["TrafficControl"],
     },
   ],
 }

package/template/wrangler.dev.jsonc

@@ -6,20 +6,6 @@
     "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": [
       {
@@ -31,11 +17,12 @@
   "vars": {
     "WARP_MS_PER_FY": "10000",
     "DEPARTURE_BUFFER_MS": "5000",
+    "ALLOW_TEST_SHUTTLE_BYPASS": "true",
   },
   "migrations": [
     {
       "tag": "v1",
-      "new_classes": ["TrafficControl"],
+      "new_sqlite_classes": ["TrafficControl"],
     },
   ],
 }

package/template/schema.sql

@@ -1,22 +0,0 @@
--- Travel Plans Table: Tracks all journeys (active and historical)
-CREATE TABLE IF NOT EXISTS travel_plans (
-    id TEXT PRIMARY KEY,
-    ship_id TEXT NOT NULL,
-    origin_url TEXT NOT NULL,
-    destination_url TEXT NOT NULL,
-    start_timestamp INTEGER NOT NULL,
-    end_timestamp INTEGER NOT NULL,
-    status TEXT CHECK(status IN ('PREPARING', 'PLAN_ACCEPTED')) NOT NULL DEFAULT 'PREPARING',
-    signatures TEXT NOT NULL -- JSON array of cryptographic signatures
-);
-
--- Index for fast retrieval of active plans (not yet arrived)
-CREATE INDEX IF NOT EXISTS idx_travel_plans_active ON travel_plans (end_timestamp, origin_url, destination_url);
-
--- Traffic Controllers Cache: Known neighbors with space ports
-CREATE TABLE IF NOT EXISTS traffic_controllers (
-    planet_url TEXT PRIMARY KEY,
-    name TEXT NOT NULL,
-    space_port_url TEXT NOT NULL,
-    last_manifest_fetch INTEGER NOT NULL
-);