phibelle-kit 1.0.0

package/.vscode/settings.json

@@ -0,0 +1,22 @@
+{
+  "workbench.colorCustomizations": {
+    "activityBar.activeBackground": "#422810",
+    "activityBar.background": "#422810",
+    "activityBar.foreground": "#e7e7e7",
+    "activityBar.inactiveForeground": "#e7e7e799",
+    "activityBarBadge.background": "#1f804e",
+    "activityBarBadge.foreground": "#e7e7e7",
+    "commandCenter.border": "#e7e7e799",
+    "sash.hoverBorder": "#422810",
+    "statusBar.background": "#190f06",
+    "statusBar.foreground": "#e7e7e7",
+    "statusBarItem.hoverBackground": "#422810",
+    "statusBarItem.remoteBackground": "#190f06",
+    "statusBarItem.remoteForeground": "#e7e7e7",
+    "titleBar.activeBackground": "#190f06",
+    "titleBar.activeForeground": "#e7e7e7",
+    "titleBar.inactiveBackground": "#190f0699",
+    "titleBar.inactiveForeground": "#e7e7e799"
+  },
+  "peacock.color": "#190f06"
+}

package/README.md

@@ -0,0 +1,27 @@
+# phibelle-kit
+
+CLI for working with [Phibelle](https://phibelle.studio/) scenes.
+
+**Requirements:** Node.js 20 or later.
+
+## Commands
+
+**clone**: One-time download of a scene.
+
+```bash
+npx phibelle-kit clone <sceneId>
+```
+
+**watch**: Subscribe to scene updates and sync scripts.
+
+```bash
+npx phibelle-kit watch <sceneId>
+```
+
+
+## After cloning
+
+1. `cd <scene-folder>` to enter the scene directory.
+2. `npm install` to install dependencies (for types and intellisense).
+3. `npm run watch` in the scene folder to push edits, or run `npx phibelle-kit watch <sceneId>` from the parent directory.
+

package/convex/_generated/api.d.ts

@@ -0,0 +1,53 @@
+/* eslint-disable */
+/**
+ * Generated `api` utility.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+
+import type * as assets from "../assets.js";
+import type * as scenes from "../scenes.js";
+import type * as storage from "../storage.js";
+
+import type {
+  ApiFromModules,
+  FilterApi,
+  FunctionReference,
+} from "convex/server";
+
+declare const fullApi: ApiFromModules<{
+  assets: typeof assets;
+  scenes: typeof scenes;
+  storage: typeof storage;
+}>;
+
+/**
+ * A utility for referencing Convex functions in your app's public API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = api.myModule.myFunction;
+ * ```
+ */
+export declare const api: FilterApi<
+  typeof fullApi,
+  FunctionReference<any, "public">
+>;
+
+/**
+ * A utility for referencing Convex functions in your app's internal API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = internal.myModule.myFunction;
+ * ```
+ */
+export declare const internal: FilterApi<
+  typeof fullApi,
+  FunctionReference<any, "internal">
+>;
+
+export declare const components: {};

package/convex/_generated/api.js

@@ -0,0 +1,23 @@
+/* eslint-disable */
+/**
+ * Generated `api` utility.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+
+import { anyApi, componentsGeneric } from "convex/server";
+
+/**
+ * A utility for referencing Convex functions in your app's API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = api.myModule.myFunction;
+ * ```
+ */
+export const api = anyApi;
+export const internal = anyApi;
+export const components = componentsGeneric();

package/convex/_generated/dataModel.d.ts

@@ -0,0 +1,60 @@
+/* eslint-disable */
+/**
+ * Generated data model types.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+
+import type {
+  DataModelFromSchemaDefinition,
+  DocumentByName,
+  TableNamesInDataModel,
+  SystemTableNames,
+} from "convex/server";
+import type { GenericId } from "convex/values";
+import schema from "../schema.js";
+
+/**
+ * The names of all of your Convex tables.
+ */
+export type TableNames = TableNamesInDataModel<DataModel>;
+
+/**
+ * The type of a document stored in Convex.
+ *
+ * @typeParam TableName - A string literal type of the table name (like "users").
+ */
+export type Doc<TableName extends TableNames> = DocumentByName<
+  DataModel,
+  TableName
+>;
+
+/**
+ * An identifier for a document in Convex.
+ *
+ * Convex documents are uniquely identified by their `Id`, which is accessible
+ * on the `_id` field. To learn more, see [Document IDs](https://docs.convex.dev/using/document-ids).
+ *
+ * Documents can be loaded using `db.get(tableName, id)` in query and mutation functions.
+ *
+ * IDs are just strings at runtime, but this type can be used to distinguish them from other
+ * strings when type checking.
+ *
+ * @typeParam TableName - A string literal type of the table name (like "users").
+ */
+export type Id<TableName extends TableNames | SystemTableNames> =
+  GenericId<TableName>;
+
+/**
+ * A type describing your Convex data model.
+ *
+ * This type includes information about what tables you have, the type of
+ * documents stored in those tables, and the indexes defined on them.
+ *
+ * This type is used to parameterize methods like `queryGeneric` and
+ * `mutationGeneric` to make them type-safe.
+ */
+export type DataModel = DataModelFromSchemaDefinition<typeof schema>;

package/convex/_generated/server.d.ts

@@ -0,0 +1,143 @@
+/* eslint-disable */
+/**
+ * Generated utilities for implementing server-side Convex query and mutation functions.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+
+import {
+  ActionBuilder,
+  HttpActionBuilder,
+  MutationBuilder,
+  QueryBuilder,
+  GenericActionCtx,
+  GenericMutationCtx,
+  GenericQueryCtx,
+  GenericDatabaseReader,
+  GenericDatabaseWriter,
+} from "convex/server";
+import type { DataModel } from "./dataModel.js";
+
+/**
+ * Define a query in this Convex app's public API.
+ *
+ * This function will be allowed to read your Convex database and will be accessible from the client.
+ *
+ * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
+ * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
+ */
+export declare const query: QueryBuilder<DataModel, "public">;
+
+/**
+ * Define a query that is only accessible from other Convex functions (but not from the client).
+ *
+ * This function will be allowed to read from your Convex database. It will not be accessible from the client.
+ *
+ * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
+ * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
+ */
+export declare const internalQuery: QueryBuilder<DataModel, "internal">;
+
+/**
+ * Define a mutation in this Convex app's public API.
+ *
+ * This function will be allowed to modify your Convex database and will be accessible from the client.
+ *
+ * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
+ * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
+ */
+export declare const mutation: MutationBuilder<DataModel, "public">;
+
+/**
+ * Define a mutation that is only accessible from other Convex functions (but not from the client).
+ *
+ * This function will be allowed to modify your Convex database. It will not be accessible from the client.
+ *
+ * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
+ * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
+ */
+export declare const internalMutation: MutationBuilder<DataModel, "internal">;
+
+/**
+ * Define an action in this Convex app's public API.
+ *
+ * An action is a function which can execute any JavaScript code, including non-deterministic
+ * code and code with side-effects, like calling third-party services.
+ * They can be run in Convex's JavaScript environment or in Node.js using the "use node" directive.
+ * They can interact with the database indirectly by calling queries and mutations using the {@link ActionCtx}.
+ *
+ * @param func - The action. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped action. Include this as an `export` to name it and make it accessible.
+ */
+export declare const action: ActionBuilder<DataModel, "public">;
+
+/**
+ * Define an action that is only accessible from other Convex functions (but not from the client).
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped function. Include this as an `export` to name it and make it accessible.
+ */
+export declare const internalAction: ActionBuilder<DataModel, "internal">;
+
+/**
+ * Define an HTTP action.
+ *
+ * The wrapped function will be used to respond to HTTP requests received
+ * by a Convex deployment if the requests matches the path and method where
+ * this action is routed. Be sure to route your httpAction in `convex/http.js`.
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument
+ * and a Fetch API `Request` object as its second.
+ * @returns The wrapped function. Import this function from `convex/http.js` and route it to hook it up.
+ */
+export declare const httpAction: HttpActionBuilder;
+
+/**
+ * A set of services for use within Convex query functions.
+ *
+ * The query context is passed as the first argument to any Convex query
+ * function run on the server.
+ *
+ * This differs from the {@link MutationCtx} because all of the services are
+ * read-only.
+ */
+export type QueryCtx = GenericQueryCtx<DataModel>;
+
+/**
+ * A set of services for use within Convex mutation functions.
+ *
+ * The mutation context is passed as the first argument to any Convex mutation
+ * function run on the server.
+ */
+export type MutationCtx = GenericMutationCtx<DataModel>;
+
+/**
+ * A set of services for use within Convex action functions.
+ *
+ * The action context is passed as the first argument to any Convex action
+ * function run on the server.
+ */
+export type ActionCtx = GenericActionCtx<DataModel>;
+
+/**
+ * An interface to read from the database within Convex query functions.
+ *
+ * The two entry points are {@link DatabaseReader.get}, which fetches a single
+ * document by its {@link Id}, or {@link DatabaseReader.query}, which starts
+ * building a query.
+ */
+export type DatabaseReader = GenericDatabaseReader<DataModel>;
+
+/**
+ * An interface to read from and write to the database within Convex mutation
+ * functions.
+ *
+ * Convex guarantees that all writes within a single mutation are
+ * executed atomically, so you never have to worry about partial writes leaving
+ * your data in an inconsistent state. See [the Convex Guide](https://docs.convex.dev/understanding/convex-fundamentals/functions#atomicity-and-optimistic-concurrency-control)
+ * for the guarantees Convex provides your functions.
+ */
+export type DatabaseWriter = GenericDatabaseWriter<DataModel>;

package/convex/_generated/server.js

@@ -0,0 +1,93 @@
+/* eslint-disable */
+/**
+ * Generated utilities for implementing server-side Convex query and mutation functions.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+
+import {
+  actionGeneric,
+  httpActionGeneric,
+  queryGeneric,
+  mutationGeneric,
+  internalActionGeneric,
+  internalMutationGeneric,
+  internalQueryGeneric,
+} from "convex/server";
+
+/**
+ * Define a query in this Convex app's public API.
+ *
+ * This function will be allowed to read your Convex database and will be accessible from the client.
+ *
+ * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
+ * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
+ */
+export const query = queryGeneric;
+
+/**
+ * Define a query that is only accessible from other Convex functions (but not from the client).
+ *
+ * This function will be allowed to read from your Convex database. It will not be accessible from the client.
+ *
+ * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
+ * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
+ */
+export const internalQuery = internalQueryGeneric;
+
+/**
+ * Define a mutation in this Convex app's public API.
+ *
+ * This function will be allowed to modify your Convex database and will be accessible from the client.
+ *
+ * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
+ * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
+ */
+export const mutation = mutationGeneric;
+
+/**
+ * Define a mutation that is only accessible from other Convex functions (but not from the client).
+ *
+ * This function will be allowed to modify your Convex database. It will not be accessible from the client.
+ *
+ * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
+ * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
+ */
+export const internalMutation = internalMutationGeneric;
+
+/**
+ * Define an action in this Convex app's public API.
+ *
+ * An action is a function which can execute any JavaScript code, including non-deterministic
+ * code and code with side-effects, like calling third-party services.
+ * They can be run in Convex's JavaScript environment or in Node.js using the "use node" directive.
+ * They can interact with the database indirectly by calling queries and mutations using the {@link ActionCtx}.
+ *
+ * @param func - The action. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped action. Include this as an `export` to name it and make it accessible.
+ */
+export const action = actionGeneric;
+
+/**
+ * Define an action that is only accessible from other Convex functions (but not from the client).
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped function. Include this as an `export` to name it and make it accessible.
+ */
+export const internalAction = internalActionGeneric;
+
+/**
+ * Define an HTTP action.
+ *
+ * The wrapped function will be used to respond to HTTP requests received
+ * by a Convex deployment if the requests matches the path and method where
+ * this action is routed. Be sure to route your httpAction in `convex/http.js`.
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument
+ * and a Fetch API `Request` object as its second.
+ * @returns The wrapped function. Import this function from `convex/http.js` and route it to hook it up.
+ */
+export const httpAction = httpActionGeneric;

package/dist/clone-scene.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Clone: one-time fetch of scene data. Creates scene dir, writes scene.json,
+ * sets up package.json/global.d.ts, unpacks scripts. No watcher, no opening folder.
+ */
+export declare function cloneSceneCommand(sceneId: string): Promise<void>;

package/dist/clone-scene.js

@@ -0,0 +1,39 @@
+import chalk from "chalk";
+import * as path from "path";
+import { queryOnce } from "./lib/convex-client.js";
+import { api } from "./convex/_generated/api.js";
+import { BASE_URL } from "./lib/public-env.js";
+import { sceneNameToFolder } from "./lib/file-system.js";
+import { setupSceneFiles, unpackageWithLogging } from "./lib/first-run-setup.js";
+/**
+ * Clone: one-time fetch of scene data. Creates scene dir, writes scene.json,
+ * sets up package.json/global.d.ts, unpacks scripts. No watcher, no opening folder.
+ */
+export async function cloneSceneCommand(sceneId) {
+    console.log();
+    console.log(chalk.bold.cyan("  📥 Cloning scene..."));
+    console.log(chalk.gray(`  Scene ID: ${sceneId}`));
+    console.log();
+    const scene = await queryOnce(api.scenes.getById, {
+        id: sceneId,
+    });
+    if (scene === null) {
+        console.log(chalk.red("  ✖ Scene not found"));
+        console.log();
+        process.exit(1);
+    }
+    const sceneFolderName = sceneNameToFolder(scene.name);
+    const sceneDir = path.join(process.cwd(), sceneFolderName);
+    setupSceneFiles(scene, sceneDir, true);
+    await unpackageWithLogging(scene._id, sceneDir, "Edit the scene in the app once to create a scene file, then run clone again.");
+    console.log(chalk.green("  ✓ Cloned scene"));
+    console.log(chalk.white(`    Name: ${scene.name}`));
+    console.log(chalk.white(`    Path: ${sceneDir}`));
+    console.log(chalk.white("    Scene link: ") + chalk.cyan(`${BASE_URL}/editor?sceneId=${scene._id}`));
+    console.log();
+    console.log(chalk.gray("  Next steps:"));
+    console.log(chalk.gray("    1. ") + chalk.blueBright("cd ") + chalk.cyan(sceneFolderName) + chalk.gray(" to open the scene directory."));
+    console.log(chalk.gray("    2. ") + chalk.blueBright("npm install") + chalk.gray(" to install the dependencies."));
+    console.log(chalk.gray("    3. ") + chalk.blueBright("phibelle watch ") + chalk.cyan(sceneId) + chalk.gray(" to watch for changes and push edits."));
+    console.log();
+}

package/dist/commands/clone-scene.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Clone: one-time fetch of scene data. Creates scene dir, writes scene.json,
+ * sets up package.json/global.d.ts, unpacks scripts. No watcher, no opening folder.
+ */
+export declare function cloneSceneCommand(sceneId: string): Promise<void>;

package/dist/commands/clone-scene.js

@@ -0,0 +1,39 @@
+import chalk from "chalk";
+import * as path from "path";
+import { queryOnce } from "../lib/convex-client.js";
+import { api } from "../convex/_generated/api.js";
+import { BASE_URL } from "../lib/public-env.js";
+import { sceneNameToFolder } from "../lib/file-system.js";
+import { setupSceneFiles, unpackageWithLogging } from "../lib/first-run-setup.js";
+/**
+ * Clone: one-time fetch of scene data. Creates scene dir, writes scene.json,
+ * sets up package.json/global.d.ts, unpacks scripts. No watcher, no opening folder.
+ */
+export async function cloneSceneCommand(sceneId) {
+    console.log();
+    console.log(chalk.bold.cyan("  📥 Cloning scene..."));
+    console.log(chalk.gray(`  Scene ID: ${sceneId}`));
+    console.log();
+    const scene = await queryOnce(api.scenes.getById, {
+        id: sceneId,
+    });
+    if (scene === null) {
+        console.log(chalk.red("  ✖ Scene not found"));
+        console.log();
+        process.exit(1);
+    }
+    const sceneFolderName = sceneNameToFolder(scene.name);
+    const sceneDir = path.join(process.cwd(), sceneFolderName);
+    setupSceneFiles(scene, sceneDir, true);
+    await unpackageWithLogging(scene._id, sceneDir, "Edit the scene in the app once to create a scene file, then run clone again.");
+    console.log(chalk.green("  ✓ Cloned scene"));
+    console.log(chalk.white(`    Name: ${scene.name}`));
+    console.log(chalk.white(`    Path: ${sceneDir}`));
+    console.log(chalk.white("    Scene link: ") + chalk.cyan(`${BASE_URL}/editor?sceneId=${scene._id}`));
+    console.log();
+    console.log(chalk.gray("  Next steps:"));
+    console.log(chalk.gray("    1. ") + chalk.blueBright("cd ") + chalk.cyan(sceneFolderName) + chalk.gray(" to open the scene directory."));
+    console.log(chalk.gray("    2. ") + chalk.blueBright("npm install") + chalk.gray(" to install the dependencies."));
+    console.log(chalk.gray("    3. ") + chalk.blueBright("npm run watch ") + chalk.gray(" to watch for changes and push edits."));
+    console.log();
+}

package/dist/commands/hello.d.ts

@@ -0,0 +1 @@
+export declare function helloCommand(): Promise<void>;

package/dist/commands/hello.js

@@ -0,0 +1,10 @@
+import chalk from "chalk";
+import { getStoredUsername } from "../lib/conf.js";
+export async function helloCommand() {
+    const username = getStoredUsername();
+    const greeting = username ? `Hello ${username}! 👋` : "Hello World! 👋";
+    console.log();
+    console.log(chalk.bold.magenta(`  ${greeting}`));
+    console.log(chalk.gray("  Phibelle CLI is working correctly."));
+    console.log();
+}

package/dist/commands/login.d.ts

@@ -0,0 +1 @@
+export declare function loginCommand(): Promise<void>;

package/dist/commands/login.js

@@ -0,0 +1,75 @@
+import chalk from "chalk";
+import * as readline from "readline/promises";
+import { BASE_URL } from "../lib/constants.js";
+import { CONFIG, getStoredToken } from "../lib/conf.js";
+async function fetchUsernameFromAPI(token) {
+    try {
+        const response = await fetch(`${BASE_URL}/api/cli/user-info`, {
+            method: "GET",
+            headers: {
+                Authorization: `Bearer ${token}`,
+            },
+        });
+        if (!response.ok) {
+            return null;
+        }
+        const data = await response.json();
+        return data.username || null;
+    }
+    catch (error) {
+        return null;
+    }
+}
+export async function loginCommand() {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    if (getStoredToken() !== undefined) {
+        console.log();
+        console.log(chalk.yellow("  You are already logged in. Please logout first."));
+        console.log();
+        rl.close();
+        return;
+    }
+    console.log();
+    console.log(chalk.bold.cyan("  🔐 Phibelle CLI Login"));
+    console.log();
+    console.log(chalk.gray("  To authenticate, follow these steps:"));
+    console.log();
+    console.log(chalk.white("  1. Open this URL in your browser:"));
+    console.log();
+    console.log(chalk.cyan(`     ${BASE_URL}/cli-token`));
+    console.log();
+    console.log(chalk.white("  2. Sign in if prompted"));
+    console.log(chalk.white("  3. Copy the token displayed on the page"));
+    console.log(chalk.white("  4. Paste it below"));
+    console.log();
+    const token = await rl.question(chalk.yellow("  Enter your token: "));
+    if (!token || token.trim() === "") {
+        console.log();
+        console.log(chalk.red("  ✖ No token provided. Login cancelled."));
+        console.log();
+        rl.close();
+        throw new Error("No token provided");
+    }
+    const trimmedToken = token.trim();
+    console.log(chalk.gray("  Fetching user information..."));
+    const username = await fetchUsernameFromAPI(trimmedToken);
+    if (username) {
+        CONFIG.set("username", username);
+    }
+    if (!username) {
+        console.log();
+        console.log(chalk.red("  ✖ Failed to fetch user information. Login cancelled."));
+        console.log();
+        rl.close();
+        throw new Error("Failed to fetch user information");
+    }
+    CONFIG.set("authToken", trimmedToken);
+    console.log();
+    console.log(chalk.green("  ✔ Successfully logged in!"));
+    console.log(chalk.gray("  Your token has been saved."));
+    console.log();
+    rl.close();
+}

package/dist/commands/logout.d.ts

@@ -0,0 +1 @@
+export declare function logoutCommand(): Promise<void>;

package/dist/commands/logout.js

@@ -0,0 +1,16 @@
+import chalk from "chalk";
+import { clearToken, getStoredToken } from "../lib/conf.js";
+export async function logoutCommand() {
+    const token = getStoredToken();
+    if (!token) {
+        console.log();
+        console.log(chalk.yellow("  ℹ You are not currently logged in."));
+        console.log();
+        return;
+    }
+    clearToken();
+    console.log();
+    console.log(chalk.green("  ✔ Successfully logged out!"));
+    console.log(chalk.gray("  Your token has been cleared."));
+    console.log();
+}

package/dist/commands/watch-scene.d.ts

@@ -0,0 +1 @@
+export declare function watchSceneCommand(sceneId: string): Promise<void>;