deepspace 0.15.0 → 0.17.0

package/dist/server.js

@@ -180,19 +180,21 @@ var MAX_UPLOAD_REQUEST_BYTES = 25 * 1024 * 1024;
 var UPLOAD_PART_BYTES = 20 * 1024 * 1024;
 var MAX_UPLOAD_PARTS = Math.ceil(MAX_APP_FILE_BYTES / UPLOAD_PART_BYTES);
 var MAX_BASE64_UPLOAD_BYTES = Math.floor(MAX_UPLOAD_REQUEST_BYTES * 3 / 4);
-var APP_STORAGE_LIMIT_BYTES = {
+var GIB = 1024 * 1024 * 1024;
+var ACCOUNT_STORAGE_LIMIT_BYTES = {
   test: 0,
-  free: 128 * 1024 * 1024,
-  starter: 512 * 1024 * 1024,
-  premium: 2 * 1024 * 1024 * 1024,
-  admin: 10 * 1024 * 1024 * 1024
+  free: 1 * GIB,
+  starter: 10 * GIB,
+  premium: 30 * GIB,
+  admin: 100 * GIB
 };
 function storageLimitForTier(tier) {
-  if (tier && Object.hasOwn(APP_STORAGE_LIMIT_BYTES, tier)) {
-    return APP_STORAGE_LIMIT_BYTES[tier];
+  if (tier && Object.hasOwn(ACCOUNT_STORAGE_LIMIT_BYTES, tier)) {
+    return ACCOUNT_STORAGE_LIMIT_BYTES[tier];
   }
-  return APP_STORAGE_LIMIT_BYTES.free;
+  return ACCOUNT_STORAGE_LIMIT_BYTES.free;
 }
+var REPO_STORE_LIMIT_BYTES = 256 * 1024 * 1024;
 function storageQuotaMessage(incomingBytes, usedBytes, limitBytes) {
   const free = Math.max(0, limitBytes - usedBytes);
   return `This upload needs ${formatBytes(incomingBytes)} but the app's file storage has ${formatBytes(free)} free (${formatBytes(usedBytes)} of ${formatBytes(limitBytes)} used). Delete files with \`deepspace app files rm <key>\`, or upgrade the owner's plan.`;
@@ -283,7 +285,7 @@ function declaredLength(request, what) {
 function isKeyWithinPrefix(key, prefix) {
   return key.startsWith(prefix);
 }
-async function allocationUsage(bucket, prefix) {
+async function prefixUsage(bucket, prefix) {
   let total = 0;
   let cursor;
   do {
@@ -293,6 +295,13 @@ async function allocationUsage(bucket, prefix) {
   } while (cursor !== void 0);
   return total;
 }
+async function allocationUsage(bucket, storage) {
+  const siblings = storage.siblingPrefixes ? await storage.siblingPrefixes() : [];
+  if (siblings === null) return null;
+  const prefixes = [storage.prefix, ...siblings.filter((p) => p !== storage.prefix)];
+  const totals = await Promise.all(prefixes.map((prefix) => prefixUsage(bucket, prefix)));
+  return totals.reduce((sum, bytes) => sum + bytes, 0);
+}
 async function admitStorage(bucket, storage, incomingBytes, replacesKey) {
   if (!storage) return null;
   const limit = await storage.limitBytes();
@@ -303,7 +312,14 @@ async function admitStorage(bucket, storage, incomingBytes, replacesKey) {
       "storage_limit_unavailable"
     );
   }
-  const stored = await allocationUsage(bucket, storage.prefix);
+  const stored = await allocationUsage(bucket, storage);
+  if (stored === null) {
+    return fail(
+      503,
+      "The storage already used by this account could not be measured; nothing was uploaded. Retry shortly.",
+      "storage_limit_unavailable"
+    );
+  }
   const replaced = replacesKey === null ? 0 : (await bucket.head(replacesKey))?.size ?? 0;
   const used = stored - replaced;
   if (used + incomingBytes <= limit) return null;
@@ -319,7 +335,11 @@ async function admitAssembledObject(bucket, storage, key, objectBytes) {
     console.error("[files:quota] limit unavailable at complete; keeping", key);
     return null;
   }
-  const stored = await allocationUsage(bucket, storage.prefix);
+  const stored = await allocationUsage(bucket, storage);
+  if (stored === null) {
+    console.error("[files:quota] account usage unmeasurable at complete; keeping", key);
+    return null;
+  }
   if (stored <= limit) return null;
   await bucket.delete(key).catch(() => void 0);
   return fail(
@@ -716,9 +736,10 @@ async function handleList(bucket, prefix, url, scope, auth) {
   });
   let storage;
   if (auth.storage) {
-    storage = { usedBytes: await allocationUsage(bucket, auth.storage.prefix) };
+    const usedBytes = await allocationUsage(bucket, auth.storage);
+    if (usedBytes !== null) storage = { usedBytes };
     const limitBytes = await auth.storage.limitBytes();
-    if (limitBytes !== null) storage.limitBytes = limitBytes;
+    if (storage && limitBytes !== null) storage.limitBytes = limitBytes;
   }
   return Response.json(
     { files, truncated: listed.truncated, ...storage ? { storage } : {} },
@@ -2199,15 +2220,6 @@ var MSG = {
   ACK: "records.ack",
   LIST_SCHEMAS: "records.list_schemas",
   RESUBSCRIBE: "records.resubscribe",
-  // ---- GameRoom --------------------------------------------------------
-  GAME_STATE: "game.state",
-  GAME_INPUT: "game.input",
-  GAME_PLAYER_JOIN: "game.player_join",
-  GAME_PLAYER_LEAVE: "game.player_leave",
-  GAME_PLAYER_READY: "game.player_ready",
-  GAME_START: "game.start",
-  GAME_END: "game.end",
-  GAME_TICK: "game.tick",
   // ---- CanvasRoom ------------------------------------------------------
   CANVAS_SHAPES: "canvas.shapes",
   CANVAS_ADD: "canvas.add",
@@ -2701,14 +2713,6 @@ var serverBuild = {
     type: MSG.YJS_JOIN,
     payload: { collection, recordId, fieldName, canWrite }
   }),
-  // Game
-  gameState: (state, tick, players, running) => ({ type: MSG.GAME_STATE, payload: { state, tick, players, running } }),
-  gameTick: (state, tick) => ({ type: MSG.GAME_TICK, payload: { state, tick } }),
-  gameStart: (state, tick) => ({ type: MSG.GAME_START, payload: { state, tick } }),
-  gameEnd: (state, tick) => ({ type: MSG.GAME_END, payload: { state, tick } }),
-  gamePlayerJoin: (player) => ({ type: MSG.GAME_PLAYER_JOIN, payload: { player } }),
-  gamePlayerLeave: (userId) => ({ type: MSG.GAME_PLAYER_LEAVE, payload: { userId } }),
-  gamePlayerReady: (userId) => ({ type: MSG.GAME_PLAYER_READY, payload: { userId } }),
   // Canvas
   canvasShapes: (shapes, viewports) => ({ type: MSG.CANVAS_SHAPES, payload: { shapes, viewports } }),
   canvasAdd: (shape) => ({ type: MSG.CANVAS_ADD, payload: { shape } }),
@@ -4304,136 +4308,6 @@ var RecordRoom = class extends BaseRoom {
       );
     `);
     this.ensureAllCollectionTables();
-    await this.migrateUsersTableIfExists();
-    await this.migrateRecordsTable();
-  }
-  async migrateUsersTableIfExists() {
-    try {
-      const tableCheck = this.sql.exec(
-        `SELECT name FROM sqlite_master WHERE type='table' AND name='users'`
-      );
-      if (tableCheck.toArray().length === 0) {
-        return;
-      }
-      const oldUsers = this.sql.exec(`SELECT * FROM users`).toArray();
-      if (oldUsers.length === 0) {
-        this.sql.exec(`DROP TABLE IF EXISTS users`);
-        return;
-      }
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      for (const row of oldUsers) {
-        const r = row;
-        const existing = this.sql.exec(`SELECT 1 FROM c_users WHERE _row_id = ?`, r.user_id).toArray();
-        if (existing.length > 0) continue;
-        this.sql.exec(
-          `INSERT INTO c_users (_row_id, _created_by, _created_at, _updated_at, col_email, col_name, col_imageurl, col_role, col_createdat, col_lastseenat) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-          r.user_id,
-          r.user_id,
-          r.created_at,
-          now,
-          r.email,
-          r.name,
-          r.image_url || null,
-          r.role,
-          r.created_at,
-          r.last_seen_at
-        );
-      }
-      this.sql.exec(`DROP TABLE IF EXISTS users`);
-    } catch (error) {
-      console.error(`[RecordRoom] Users table migration error:`, error);
-    }
-  }
-  async migrateRecordsTable() {
-    try {
-      const tableCheck = this.sql.exec(
-        `SELECT name FROM sqlite_master WHERE type='table' AND name='records'`
-      );
-      if (tableCheck.toArray().length === 0) return;
-      const rows = this.sql.exec(`SELECT * FROM records`).toArray();
-      if (rows.length === 0) {
-        this.sql.exec(`DROP TABLE IF EXISTS records`);
-        return;
-      }
-      const prepared = [];
-      const blocked = {
-        missingSchema: 0,
-        invalidData: 0,
-        targetConflict: 0
-      };
-      for (const row of rows) {
-        const r = row;
-        const schema = this.schemaRegistry.get(r.collection);
-        if (!schema || !schema.columns) {
-          blocked.missingSchema++;
-          continue;
-        }
-        const tbl = collectionTableName(r.collection);
-        const tblExists = this.sql.exec(`SELECT name FROM sqlite_master WHERE type='table' AND name=?`, tbl).toArray().length > 0;
-        if (!tblExists) {
-          this.ensureCollectionTable(schema);
-        }
-        const existing = this.sql.exec(`SELECT 1 FROM "${tbl}" WHERE _row_id = ?`, r.record_id).toArray();
-        if (existing.length > 0) {
-          blocked.targetConflict++;
-          continue;
-        }
-        let data;
-        try {
-          data = JSON.parse(r.data);
-        } catch {
-          blocked.invalidData++;
-          continue;
-        }
-        if (data === null || typeof data !== "object" || Array.isArray(data)) {
-          blocked.invalidData++;
-          continue;
-        }
-        const columns = schema.columns.map(resolveColumn);
-        const colValues = dataToColumnValues(data, columns);
-        const colIds = Object.keys(colValues);
-        const allCols = [
-          "_row_id",
-          "_created_by",
-          "_created_at",
-          "_updated_at",
-          ...colIds.map((c) => `"${c}"`)
-        ];
-        const placeholders = allCols.map(() => "?").join(", ");
-        const params = [
-          r.record_id,
-          r.created_by,
-          r.created_at,
-          r.updated_at,
-          ...colIds.map((c) => colValues[c])
-        ];
-        prepared.push({
-          sql: `INSERT INTO "${tbl}" (${allCols.join(", ")}) VALUES (${placeholders})`,
-          params
-        });
-      }
-      const blockedCount = blocked.missingSchema + blocked.invalidData + blocked.targetConflict;
-      if (blockedCount > 0) {
-        console.error(
-          `[RecordRoom] Legacy records migration blocked; no records migrated and the records table was retained for retry (${blockedCount} blocked: ${blocked.missingSchema} missing schema, ${blocked.invalidData} invalid data, ${blocked.targetConflict} target conflict)`
-        );
-        return;
-      }
-      this.state.storage.transactionSync(() => {
-        for (const record of prepared) {
-          this.sql.exec(record.sql, ...record.params);
-        }
-        this.sql.exec(`DROP TABLE IF EXISTS records`);
-      });
-      console.log(
-        `[RecordRoom] Migrated ${prepared.length} records from document-mode; legacy records table removed`
-      );
-    } catch (error) {
-      console.error(
-        `[RecordRoom] Legacy records migration failed; no records migrated and the records table was retained for retry:`,
-        error
-      );
-    }
   }
   // ============================================================================
   // Table-Mode Schema Management
@@ -4910,6 +4784,9 @@ var YjsRoom = class extends BaseRoom {
   }
 };
 
+// src/server/rooms/canvas-room.ts
+import * as Y5 from "yjs";
+
 // src/shared/roles.ts
 var ROLES = {
   VIEWER: "viewer",
@@ -4917,271 +4794,7 @@ var ROLES = {
   ADMIN: "admin"
 };
 
-// src/server/rooms/game-room.ts
-var GAME_WRITE_TYPES = /* @__PURE__ */ new Set([
-  MSG.GAME_INPUT,
-  MSG.GAME_PLAYER_READY,
-  MSG.GAME_START,
-  MSG.GAME_END
-]);
-var GameRoom = class extends BaseRoom {
-  config;
-  players = /* @__PURE__ */ new Map();
-  inputBuffer = [];
-  currentTick = 0;
-  gameState = {};
-  running = false;
-  initialized = false;
-  constructor(state, env, config = {}) {
-    super(state, env);
-    this.config = {
-      tickRate: config.tickRate ?? 20,
-      minPlayers: config.minPlayers ?? 1,
-      maxPlayers: config.maxPlayers ?? Infinity
-    };
-  }
-  ensureInitialized() {
-    if (this.initialized) return;
-    this.initialized = true;
-    this.sql.exec(`
-      CREATE TABLE IF NOT EXISTS game_state (
-        id INTEGER PRIMARY KEY CHECK (id = 1),
-        state TEXT NOT NULL,
-        tick INTEGER NOT NULL DEFAULT 0,
-        updated_at TEXT NOT NULL
-      )
-    `);
-    const rows = this.sql.exec("SELECT state, tick FROM game_state WHERE id = 1").toArray();
-    if (rows.length > 0) {
-      try {
-        const parsed = JSON.parse(rows[0].state);
-        this.gameState = this.onHydrateState(parsed);
-        this.currentTick = rows[0].tick;
-      } catch {
-      }
-    }
-  }
-  persistState() {
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    this.sql.exec(
-      `INSERT INTO game_state (id, state, tick, updated_at) VALUES (1, ?, ?, ?)
-       ON CONFLICT(id) DO UPDATE SET state = ?, tick = ?, updated_at = ?`,
-      JSON.stringify(this.gameState),
-      this.currentTick,
-      now,
-      JSON.stringify(this.gameState),
-      this.currentTick,
-      now
-    );
-  }
-  // ==========================================================================
-  // BaseRoom Lifecycle
-  // ==========================================================================
-  onConnect(ws, user) {
-    this.ensureInitialized();
-    const role = user.role ?? ROLES.VIEWER;
-    const canWrite = role === ROLES.MEMBER || role === ROLES.ADMIN;
-    const attachment = {
-      ...user,
-      joinedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      canWrite
-    };
-    this.sendTo(ws, { type: MSG.AUTH, payload: { canWrite } });
-    if (!canWrite) {
-      this.sendTo(ws, {
-        type: MSG.GAME_STATE,
-        payload: {
-          state: this.gameState,
-          tick: this.currentTick,
-          players: Array.from(this.players.values()),
-          running: this.running
-        }
-      });
-      return attachment;
-    }
-    const player = {
-      userId: user.userId,
-      userName: user.userName,
-      ready: false,
-      connectedAt: attachment.joinedAt,
-      data: {}
-    };
-    if (this.config.maxPlayers !== Infinity && this.players.size >= this.config.maxPlayers) {
-      this.sendTo(ws, { type: MSG.ERROR, payload: { error: "Game is full" } });
-      return attachment;
-    }
-    this.players.set(user.userId, player);
-    this.sendTo(ws, {
-      type: MSG.GAME_STATE,
-      payload: {
-        state: this.gameState,
-        tick: this.currentTick,
-        players: Array.from(this.players.values()),
-        running: this.running
-      }
-    });
-    this.broadcast({ type: MSG.GAME_PLAYER_JOIN, payload: { player } }, ws);
-    this.onPlayerJoin(player);
-    return attachment;
-  }
-  async onMessage(ws, user, message) {
-    this.ensureInitialized();
-    const { type, payload } = message;
-    if (GAME_WRITE_TYPES.has(type) && !user.canWrite) {
-      this.sendTo(ws, {
-        type: MSG.ERROR,
-        payload: { error: "Write access denied: spectators cannot drive the game" }
-      });
-      return;
-    }
-    switch (type) {
-      case MSG.GAME_INPUT: {
-        this.inputBuffer.push({
-          userId: user.userId,
-          action: payload.action,
-          data: payload.data ?? {},
-          tick: this.currentTick
-        });
-        break;
-      }
-      case MSG.GAME_PLAYER_READY: {
-        const player = this.players.get(user.userId);
-        if (player) {
-          player.ready = true;
-          this.broadcast({ type: MSG.GAME_PLAYER_READY, payload: { userId: user.userId } });
-          this.checkAutoStart();
-        }
-        break;
-      }
-      case MSG.GAME_START: {
-        if (!this.running) {
-          this.startGame();
-        }
-        break;
-      }
-      case MSG.GAME_END: {
-        if (this.running) {
-          this.stopGame();
-        }
-        break;
-      }
-      default:
-        this.sendTo(ws, { type: MSG.ERROR, payload: { error: `Unknown game message type: ${type}` } });
-    }
-  }
-  onDisconnect(_ws, user) {
-    const player = this.players.get(user.userId);
-    if (player) {
-      this.players.delete(user.userId);
-      this.broadcast({ type: MSG.GAME_PLAYER_LEAVE, payload: { userId: user.userId } });
-      this.onPlayerLeave(player);
-      if (this.running && this.players.size === 0) {
-        this.stopGame();
-      }
-    }
-  }
-  async onAlarm() {
-    if (!this.running) return;
-    const inputs = this.inputBuffer.splice(0);
-    this.currentTick++;
-    const newState = await this.onTick(this.gameState, inputs, this.currentTick);
-    if (newState !== void 0) {
-      this.gameState = newState;
-    }
-    if (this.currentTick % 10 === 0) {
-      this.persistState();
-    }
-    this.broadcast({
-      type: MSG.GAME_TICK,
-      payload: {
-        state: this.gameState,
-        tick: this.currentTick
-      }
-    });
-    if (this.running) {
-      const intervalMs = 1e3 / this.config.tickRate;
-      this.state.storage.setAlarm(Date.now() + intervalMs);
-    }
-  }
-  // ==========================================================================
-  // Game Control
-  // ==========================================================================
-  checkAutoStart() {
-    if (this.running) return;
-    const readyCount = Array.from(this.players.values()).filter((p) => p.ready).length;
-    if (readyCount >= this.config.minPlayers && readyCount === this.players.size) {
-      this.startGame();
-    }
-  }
-  startGame() {
-    this.running = true;
-    this.currentTick = 0;
-    this.inputBuffer = [];
-    this.onGameStart();
-    this.broadcast({ type: MSG.GAME_START, payload: { state: this.gameState, tick: 0 } });
-    const intervalMs = 1e3 / this.config.tickRate;
-    this.state.storage.setAlarm(Date.now() + intervalMs);
-  }
-  stopGame() {
-    this.running = false;
-    this.persistState();
-    this.onGameEnd(this.gameState);
-    this.broadcast({ type: MSG.GAME_END, payload: { state: this.gameState, tick: this.currentTick } });
-  }
-  // ==========================================================================
-  // Protected Accessors (for subclasses)
-  // ==========================================================================
-  getGameState() {
-    return this.gameState;
-  }
-  setGameState(state) {
-    this.gameState = state;
-  }
-  getPlayers() {
-    return Array.from(this.players.values());
-  }
-  isRunning() {
-    return this.running;
-  }
-  getCurrentTick() {
-    return this.currentTick;
-  }
-  /** Called when a player connects */
-  onPlayerJoin(_player) {
-  }
-  /** Called when a player disconnects */
-  onPlayerLeave(_player) {
-  }
-  /** Called when the game starts */
-  onGameStart() {
-  }
-  /** Called when the game ends */
-  onGameEnd(_finalState) {
-  }
-  /**
-   * Called once when the DO first hydrates persisted state from storage.
-   * Receives the parsed state blob as it was written by a previous build.
-   * Return the state object to install as `gameState`.
-   *
-   * Subclasses with evolving schemas should override this hook to:
-   *   - merge new fields onto a default template,
-   *   - upgrade shapes across versioned states,
-   *   - or discard stale blobs entirely by returning a fresh object.
-   *
-   * The default implementation is a pass-through, preserving the legacy
-   * "stored blob is gospel" behavior for subclasses that don't care.
-   *
-   * If JSON parsing of the stored blob fails this hook is NOT called — the
-   * DO starts with an empty state and the subclass's `onGameStart` (or
-   * first `onTick`) is responsible for initializing.
-   */
-  onHydrateState(stored) {
-    return stored;
-  }
-};
-
 // src/server/rooms/canvas-room.ts
-import * as Y5 from "yjs";
 var CANVAS_WRITE_TYPES = /* @__PURE__ */ new Set([
   MSG.CANVAS_ADD,
   MSG.CANVAS_MOVE,
@@ -7984,12 +7597,12 @@ var RefundError = class extends Error {
   }
 };
 export {
+  ACCOUNT_STORAGE_LIMIT_BYTES,
   AI_CHATS_SCHEMA,
   AI_MESSAGES_SCHEMA,
   ALLOWED_BINDING_TYPES,
   APP_ID_RE,
   APP_NAME_RULES,
-  APP_STORAGE_LIMIT_BYTES,
   AUTO_PROVISIONABLE_TYPES,
   AUTO_PROVISION_SENTINEL,
   BASE_USERS_SCHEMA,
@@ -8012,7 +7625,6 @@ export {
   DeepSpaceAgentProfileError,
   GLOBAL_DO_TYPES,
   GLOBAL_DO_TYPE_NAMES,
-  GameRoom,
   JobRoom,
   MAX_APP_FILE_BYTES,
   MAX_DEPLOY_ASSET_FILE_BYTES,