phibelle-kit 1.0.4 → 1.0.7

package/src/lib/scene-packaging.ts

@@ -1,238 +0,0 @@
-import * as fs from "fs/promises";
-import * as path from "path";
-import { queryOnce, mutateOnce } from "./convex-client.js";
-import { api } from "../convex/_generated/api.js";
-import { getSessionId } from "./conf.js";
-import type { PhibelleScene } from "./types.js";
-
-type SceneManifest = {
-  sceneScript: string;
-  entities: Record<string, string>;
-};
-
-async function getSceneFileContent(sceneId: string): Promise<string> {
-  const fileUrl = await queryOnce<
-    { sceneId: string },
-    string | null
-  >(api.scenes.getSceneFileUrl, { sceneId });
-
-  if (fileUrl == null) {
-    throw new Error("Scene file not found (scene may be missing or have no file yet)");
-  }
-
-  const response = await fetch(fileUrl);
-  if (!response.ok) {
-    throw new Error(`Failed to download scene file: ${response.status} ${response.statusText}`);
-  }
-  return response.text();
-}
-
-function parseSceneJson(content: string): PhibelleScene {
-  try {
-    return JSON.parse(content) as PhibelleScene;
-  } catch {
-    throw new Error("Invalid scene file: not valid JSON");
-  }
-}
-
-/** Matches entity script filenames; group 1 is engine id. Use in both .test() and .match(). */
-export const ENTITY_FILE_RE = /^entity-(\d+)\.tsx$/;
-
-async function uploadSceneJsonAndUpdate(sceneId: string, json: string): Promise<void> {
-  const uploadUrl = await mutateOnce(api.storage.generateUploadUrl, {});
-  if (typeof uploadUrl !== "string") {
-    throw new Error("Invalid upload URL response");
-  }
-  const uploadResult = await fetch(uploadUrl, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: json,
-  });
-  if (!uploadResult.ok) {
-    throw new Error(`Failed to upload scene file: ${uploadResult.status} ${uploadResult.statusText}`);
-  }
-  const uploadResponse = (await uploadResult.json()) as { storageId?: string };
-  const storageId = uploadResponse.storageId;
-  if (!storageId) {
-    throw new Error("Upload response missing storageId");
-  }
-  const sceneByteLength = Buffer.byteLength(json, "utf8");
-  await mutateOnce(api.scenes.update, {
-    id: sceneId as any,
-    sceneFileId: storageId as any,
-    sceneByteLength,
-    lastModifiedSessionId: getSessionId(),
-  });
-}
-
-export async function unpackageScene(sceneId: string, sceneDir: string): Promise<void> {
-  const content = await getSceneFileContent(sceneId);
-  const parsed = parseSceneJson(content);
-
-  await fs.mkdir(sceneDir, { recursive: true });
-
-  // Remove existing entity files so entities deleted in the editor are removed from disk
-  try {
-    const entries = await fs.readdir(sceneDir, { withFileTypes: true });
-    for (const ent of entries) {
-      if (ent.isFile() && ENTITY_FILE_RE.test(ent.name)) {
-        await fs.unlink(path.join(sceneDir, ent.name));
-      }
-    }
-  } catch {
-    // Directory might not exist or be empty; ignore
-  }
-
-  const entities = parsed.entityStore?.entities ?? {};
-  const manifest: SceneManifest = {
-    sceneScript: "scene.tsx",
-    entities: {},
-  };
-
-  await fs.writeFile(
-    path.join(sceneDir, "scene.tsx"),
-    parsed.sceneScriptStore?.sceneScript ?? "",
-    "utf8"
-  );
-
-  for (const idStr of Object.keys(entities)) {
-    const entity = entities[idStr];
-    if (!entity || typeof entity.script !== "string") continue;
-    const engineId = String(entity.engineId ?? idStr);
-    const fileName = `entity-${engineId}.tsx`;
-    manifest.entities[engineId] = fileName;
-    await fs.writeFile(path.join(sceneDir, fileName), entity.script, "utf8");
-  }
-
-  await fs.writeFile(
-    path.join(sceneDir, "manifest.json"),
-    JSON.stringify(manifest, null, 2),
-    "utf8"
-  );
-}
-
-export async function pushScriptChange(
-  sceneId: string,
-  sceneDir: string,
-  changedFile: string
-): Promise<void> {
-  const manifestPath = path.join(sceneDir, "manifest.json");
-  let manifestRaw: string;
-  try {
-    manifestRaw = await fs.readFile(manifestPath, "utf8");
-  } catch {
-    throw new Error("manifest.json not found; run watch-scene to unpackage first");
-  }
-  const manifest = JSON.parse(manifestRaw) as SceneManifest;
-
-  const content = await getSceneFileContent(sceneId);
-  const parsed = parseSceneJson(content);
-
-  const filePath = path.join(sceneDir, changedFile);
-  let fileContent: string;
-  try {
-    fileContent = await fs.readFile(filePath, "utf8");
-  } catch {
-    throw new Error(`Could not read file: ${changedFile}`);
-  }
-
-  const isSceneScript = manifest.sceneScript === changedFile;
-  if (isSceneScript) {
-    if (!parsed.sceneScriptStore) parsed.sceneScriptStore = { sceneScript: "", sceneProperties: [], lastModifiedSceneScript: 0 };
-    parsed.sceneScriptStore.sceneScript = fileContent;
-    if (typeof parsed.sceneScriptStore.lastModifiedSceneScript === "number") {
-      parsed.sceneScriptStore.lastModifiedSceneScript = Date.now();
-    }
-  } else {
-    const entityId = Object.entries(manifest.entities).find(([, f]) => f === changedFile)?.[0];
-    if (entityId == null) {
-      throw new Error(`Unknown script file: ${changedFile}`);
-    }
-    const entities = parsed.entityStore?.entities ?? {};
-    const entity = entities[entityId];
-    if (!entity) {
-      throw new Error(`Entity ${entityId} no longer in scene; skip or sync from app`);
-    }
-    entity.script = fileContent;
-    entity.scriptVersion = (entity.scriptVersion ?? 0) + 1;
-  }
-
-  const json = JSON.stringify(parsed);
-  await uploadSceneJsonAndUpdate(sceneId, json);
-}
-
-const DEFAULT_POSITION = '{"x":0,"y":0,"z":0}';
-const DEFAULT_ROTATION = '{"isEuler":true,"_x":0,"_y":0,"_z":0,"_order":"XYZ"}';
-const DEFAULT_SCALE = '{"x":1,"y":1,"z":1}';
-
-/** Add a new entity to the scene when user creates entity-<engineId>.tsx locally. */
-export async function pushNewEntity(
-  sceneId: string,
-  sceneDir: string,
-  engineId: number
-): Promise<void> {
-  const manifestPath = path.join(sceneDir, "manifest.json");
-  let manifestRaw: string;
-  try {
-    manifestRaw = await fs.readFile(manifestPath, "utf8");
-  } catch {
-    throw new Error("manifest.json not found; run watch-scene to unpackage first");
-  }
-  const manifest = JSON.parse(manifestRaw) as SceneManifest;
-
-  const idStr = String(engineId);
-  if (manifest.entities[idStr]) {
-    throw new Error(`Entity ${engineId} already exists in manifest`);
-  }
-
-  const content = await getSceneFileContent(sceneId);
-  const parsed = parseSceneJson(content);
-
-  const fileName = `entity-${engineId}.tsx`;
-  const filePath = path.join(sceneDir, fileName);
-  let script: string;
-  try {
-    script = await fs.readFile(filePath, "utf8");
-  } catch {
-    throw new Error(`Could not read file: ${fileName}`);
-  }
-
-  if (!parsed.entityStore) {
-    parsed.entityStore = {
-      _currId: 0,
-      rootEntities: [],
-      entities: {},
-      rootRenderVersion: 0,
-      lastRenderedVersion: 0,
-      selectedEntityIds: [],
-    };
-  }
-  const store = parsed.entityStore;
-  store._currId = Math.max(store._currId, engineId);
-  if (!store.rootEntities.includes(engineId)) {
-    store.rootEntities.push(engineId);
-  }
-  store.entities[idStr] = {
-    name: `Entity-${engineId}`,
-    engineId,
-    childrenIdsSet: [],
-    childrenIds: [],
-    isNodeOpen: false,
-    script,
-    scriptVersion: 0,
-    transform: {
-      position: DEFAULT_POSITION,
-      rotation: DEFAULT_ROTATION,
-      scale: DEFAULT_SCALE,
-    },
-    renderVersion: 0,
-    properties: [],
-    threeId: 0,
-  };
-
-  manifest.entities[idStr] = fileName;
-  await fs.writeFile(manifestPath, JSON.stringify(manifest, null, 2), "utf8");
-
-  const json = JSON.stringify(parsed);
-  await uploadSceneJsonAndUpdate(sceneId, json);
-}

package/src/lib/script-watcher.ts

@@ -1,103 +0,0 @@
-import * as path from "path";
-import * as fs from "fs";
-import chokidar from "chokidar";
-import { pushScriptChange, pushNewEntity, ENTITY_FILE_RE } from "./scene-packaging.js";
-
-const DEBOUNCE_MS = 600;
-
-export type ScriptWatcher = { close: () => void };
-
-export type WatchCallbacks = {
-  onPushed: (file: string) => void;
-  onNewEntity: (engineId: number) => void;
-  onError: (file: string, err: Error) => void;
-};
-
-export function createScriptWatcher(
-  sceneId: string,
-  sceneDir: string,
-  onPushed: (file: string) => void,
-  onNewEntity: (engineId: number) => void,
-  onError: (file: string, err: Error) => void
-): ScriptWatcher {
-  const manifestPath = path.join(sceneDir, "manifest.json");
-
-  function readManifest(): { sceneScript: string; entities: Record<string, string> } | null {
-    try {
-      const raw = fs.readFileSync(manifestPath, "utf8");
-      return JSON.parse(raw);
-    } catch {
-      return null;
-    }
-  }
-
-  let debounceTimer: ReturnType<typeof setTimeout> | null = null;
-  let lastEvent: { type: "change" | "add"; file: string } | null = null;
-
-  function schedule(type: "change" | "add", file: string) {
-    lastEvent = { type, file };
-    if (debounceTimer) clearTimeout(debounceTimer);
-    debounceTimer = setTimeout(async () => {
-      debounceTimer = null;
-      const ev = lastEvent;
-      lastEvent = null;
-      if (!ev) return;
-      const manifest = readManifest();
-      if (!manifest) return;
-
-      const basename = ev.file;
-      if (basename === manifest.sceneScript) {
-        try {
-          await pushScriptChange(sceneId, sceneDir, basename);
-          onPushed(basename);
-        } catch (err) {
-          onError(basename, err instanceof Error ? err : new Error(String(err)));
-        }
-        return;
-      }
-
-      const entityMatch = basename.match(ENTITY_FILE_RE);
-      if (entityMatch) {
-        const engineId = parseInt(entityMatch[1], 10);
-        const isNew = !manifest.entities[String(engineId)];
-        if (isNew) {
-          try {
-            await pushNewEntity(sceneId, sceneDir, engineId);
-            onNewEntity(engineId);
-          } catch (err) {
-            onError(basename, err instanceof Error ? err : new Error(String(err)));
-          }
-        } else {
-          try {
-            await pushScriptChange(sceneId, sceneDir, basename);
-            onPushed(basename);
-          } catch (err) {
-            onError(basename, err instanceof Error ? err : new Error(String(err)));
-          }
-        }
-      }
-    }, DEBOUNCE_MS);
-  }
-
-  const watcher = chokidar.watch(sceneDir, { ignoreInitial: true });
-  watcher.on("change", (filePath: string) => {
-    const basename = path.basename(filePath);
-    if (basename === "manifest.json") return;
-    if (basename === "scene.tsx" || ENTITY_FILE_RE.test(basename)) {
-      schedule("change", basename);
-    }
-  });
-  watcher.on("add", (filePath: string) => {
-    const basename = path.basename(filePath);
-    if (basename === "scene.tsx" || ENTITY_FILE_RE.test(basename)) {
-      schedule("add", basename);
-    }
-  });
-
-  return {
-    close: () => {
-      if (debounceTimer) clearTimeout(debounceTimer);
-      watcher.close();
-    },
-  };
-}

package/src/lib/types.ts

@@ -1,63 +0,0 @@
-/** Scene document from Convex (scenes.getById / listMyScenes) */
-export type Scene = {
-  _id: string;
-  name: string;
-  updatedAt: number;
-  ownerId: string;
-  sceneFileId: string;
-  createdAt: number;
-  sceneByteLength?: number;
-  screenshotFileId?: string;
-  /** Set when scene file is updated; used to avoid re-unpack when this CLI saved. */
-  lastModifiedSessionId?: string;
-};
-
-export type PhibelleScene = {
-  entityStore: {
-    _currId: number;
-    rootEntities: number[];
-    entities: {
-      [id: string]: {
-        name: string;
-        engineId: number;
-        childrenIdsSet: number[];
-        childrenIds: number[];
-        isNodeOpen: boolean;
-        script: string;
-        scriptVersion: number;
-        transform: {
-          position: string;
-          rotation: string;
-          scale: string;
-        };
-        renderVersion: number;
-        properties: Array<{
-          name: string;
-          type: string;
-          value: any;
-        }>;
-        threeId: number;
-      }
-    };
-    rootRenderVersion: number;
-    lastRenderedVersion: number;
-    selectedEntityIds: number[];
-  };
-  editorCameraStore: {
-    orthographic: boolean;
-    cameraPosition: [number, number, number];
-    cameraRotation: [number, number, number, string];
-    targetPosition: [number, number, number];
-  };
-  errorStore: Record<string, unknown>;
-  sceneScriptStore: {
-    sceneScript: string;
-    sceneProperties: any[];
-    lastModifiedSceneScript: number;
-  };
-  engineModeStore: {
-    engineMode: string;
-    transformMode: string;
-  };
-  version: string;
-};

package/src/lib/utils.ts

@@ -1,3 +0,0 @@
-export function toErrorMessage(err: unknown): string {
-  return err instanceof Error ? err.message : String(err);
-}

package/src/lib/wait-for-token.ts

@@ -1,34 +0,0 @@
-import http from "node:http";
-import { setToken } from "./conf.js";
-import { BASE_URL } from "./public-env.js";
-import open from "open";
-
-const PORT = 13131;
-
-export function waitForToken(): Promise<string> {
-  return new Promise((resolve) => {
-    const server = http.createServer((req, res) => {
-      const url = new URL(req.url!, `http://localhost`);
-      const token = url.searchParams.get("token");
-
-      res.setHeader("Access-Control-Allow-Origin", "*");
-      res.setHeader("Access-Control-Allow-Methods", "GET");
-
-      if (token) {
-        res.writeHead(200, { "Content-Type": "text/html" });
-        res.end("Token received");
-        server.close();
-        resolve(token);
-        setToken(token);
-      } else {
-        res.writeHead(400);
-        res.end("Missing token");
-      }
-    });
-
-    server.listen(PORT, () => {
-      console.log("Opening browser to authenticate...");
-      open(`${BASE_URL}/cli-token`);
-    });
-  });
-}

package/src/package/global-module.ts

@@ -1,117 +0,0 @@
-export const GLOBAL_MODULE = `
-import type React from "react";
-import type * as THREE_IMPORT from "three";
-import type * as DREI_IMPORT from "@react-three/drei";
-import type * as R3F_IMPORT from "@react-three/fiber";
-import type * as UIKIT_IMPORT from "@react-three/uikit";
-import type * as RAPIER_IMPORT from "@react-three/rapier";
-
-declare global {
-  const THREE: typeof THREE_IMPORT;
-  const DREI: typeof DREI_IMPORT;
-  const R3F: typeof R3F_IMPORT;
-  const UIKIT: typeof UIKIT_IMPORT;
-  const RAPIER: typeof RAPIER_IMPORT;
-
-  namespace PHI {
-    type Transform = {
-      position: THREE_IMPORT.Vector3;
-      rotation: THREE_IMPORT.Euler;
-      scale: THREE_IMPORT.Vector3;
-    };
-
-    type PropertyType = string;
-
-    type Property = {
-      name: string;
-      type: PropertyType;
-      value: unknown;
-    };
-
-    type EntityData = {
-      name: string;
-      engineId: number;
-      threeId?: number;
-      parentId?: number;
-      childrenIds: number[];
-      transform: Transform;
-      properties: Property[];
-    };
-
-    type GamepadInfo = {
-      connected: boolean;
-      buttonA: boolean;
-      buttonB: boolean;
-      buttonX: boolean;
-      buttonY: boolean;
-      joystick: [number, number];
-      joystickRight: [number, number];
-      RB: boolean;
-      LB: boolean;
-      RT: boolean;
-      LT: boolean;
-      start: boolean;
-      select: boolean;
-      up: boolean;
-      down: boolean;
-      left: boolean;
-      right: boolean;
-    };
-
-    type EngineMode = {
-      editMode: boolean;
-      playMode: boolean;
-    };
-
-    type SceneScriptState = {
-      sceneProperties: Record<string, unknown>;
-    };
-
-    type EntityRenderRegistry = Record<
-      string,
-      React.FC<{ entityData: EntityData }>
-    >;
-  }
-
-  const PHI: {
-    globalStore: Record<string, any>;
-
-    PROPERTY_TYPES: ReadonlyArray<{
-      type: PHI.PropertyType;
-      defaultValue: unknown;
-    }>;
-
-    phibelleResetSelectedEntityIds(): void;
-
-    useEntityThreeObject(
-      entityData: PHI.EntityData,
-      threeScene: THREE_IMPORT.Scene
-    ): THREE_IMPORT.Object3D | null;
-
-    useGamepad(): PHI.GamepadInfo;
-
-    usePlayModeFrame(
-      callback: (state: R3F_IMPORT.RootState, delta: number) => void
-    ): void;
-
-    useEngineMode(): PHI.EngineMode;
-
-    useSceneScriptStore(): PHI.SceneScriptState;
-    useSceneScriptStore<T>(
-      selector: (state: PHI.SceneScriptState) => T
-    ): T;
-
-    editEntities(
-      edits: Array<{ id: number; newData: Partial<PHI.EntityData> }>
-    ): void;
-
-    useEntity(entityId: number): { entityData: PHI.EntityData };
-
-    PhibelleRoot: React.FC<{
-      entityRenderRegistry: PHI.EntityRenderRegistry;
-    }>;
-  };
-}
-
-export {};
-`

package/src/package/npm-package.ts

@@ -1,16 +0,0 @@
-export const getNpmPackage = (sceneId: string) => {
-  return `{
-  "scripts": {
-    "watch": "npx phibelle-kit watch ${sceneId}"
-  },
-  "dependencies": {
-    "@react-three/drei": "^10.7.7",
-    "@react-three/fiber": "^9.5.0",
-    "@react-three/rapier": "^2.2.0",
-    "@react-three/uikit": "^1.0.61",
-    "react": "^19.1.1",
-    "react-dom": "19.1.1",
-    "three": "^0.179.1"
-  }
-}`;
-}

package/src/package/setup.ts

@@ -1,47 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { getNpmPackage } from "./npm-package.js";
-import { GLOBAL_MODULE } from "./global-module.js";
-
-const PACKAGE_JSON = "package.json";
-const GLOBAL_D_TS = "global.d.ts";
-
-const PROBE_DEP = "react";
-
-export function setupSceneDirectory(sceneDir: string, sceneId: string) {
-  const packagePath = path.join(sceneDir, PACKAGE_JSON);
-  const globalDtsPath = path.join(sceneDir, GLOBAL_D_TS);
-
-  let shouldPromptInstall = false;
-
-  // 1. Create package.json
-  const pkgJson = `${getNpmPackage(sceneId)}\n`;
-  if (!fs.existsSync(packagePath) || fs.readFileSync(packagePath, "utf8") !== pkgJson) {
-    fs.writeFileSync(packagePath, pkgJson);
-    shouldPromptInstall = true;
-  }
-
-  // 2. Write global.d.ts
-  fs.writeFileSync(globalDtsPath, GLOBAL_MODULE.trimStart());
-
-  // 3. If node_modules doesn't have real deps yet, prompt install
-  const probePath = path.join(sceneDir, "node_modules", PROBE_DEP, "package.json");
-  if (!fs.existsSync(probePath)) {
-    shouldPromptInstall = true;
-  }
-
-  return { shouldPromptInstall };
-}
-
-export function getInstallHint(sceneDir: string): string {
-  const hasPnpm = fs.existsSync(path.join(sceneDir, "pnpm-lock.yaml"));
-  const hasYarn = fs.existsSync(path.join(sceneDir, "yarn.lock"));
-  const hasBun = fs.existsSync(path.join(sceneDir, "bun.lockb"));
-  const hasNpm = fs.existsSync(path.join(sceneDir, "package-lock.json"));
-
-  if (hasPnpm) return "pnpm install";
-  if (hasYarn) return "yarn install";
-  if (hasBun) return "bun install";
-  if (hasNpm) return "npm install";
-  return "npm install (or pnpm / yarn / bun install)";
-}

package/tsconfig.json

@@ -1,19 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "declaration": true,
-    "resolveJsonModule": true,
-    "allowJs": true,
-    "checkJs": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}