@fireberry/cli 0.0.5-beta.9 → 0.2.0

package/CLAUDE.md

@@ -0,0 +1,156 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Overview
+
+`@fireberry/cli` is a command-line tool for managing Fireberry applications. It allows developers to initialize credentials, create new apps from templates, push components to the Fireberry platform, and install apps on Fireberry accounts.
+
+## Development Commands
+
+### Build and Development
+
+```bash
+npm run build          # Compile TypeScript to dist/
+npm run build:dev      # Clean, build, link globally, and make executable
+npm run dev            # Watch mode compilation
+npm run clean          # Remove dist/ directory
+```
+
+### Testing
+
+```bash
+npm test              # Run smoke test (verifies CLI --help works)
+```
+
+### Local Development
+
+```bash
+npm run build:dev     # Build and link CLI locally
+fireberry --help      # Test the linked CLI
+```
+
+### Publishing
+
+```bash
+npm run publish:beta  # Version bump (beta) and publish to npm with beta tag
+npm run publish:prod  # Publish to npm with latest tag
+```
+
+## Architecture
+
+### Module System
+
+- **Type**: ESM (ES Modules) with `"type": "module"` in package.json
+- **Module Resolution**: NodeNext
+- **Import Extensions**: All local imports must use `.js` extension (e.g., `import { foo } from "./bar.js"`)
+- **JSON Imports**: Use `with { type: "json" }` syntax (e.g., `import packageJson from "../../package.json" with { type: "json" }`)
+
+### CLI Entry Point
+
+- **Binary**: [dist/bin/fireberry.js](dist/bin/fireberry.js) (generated from [src/bin/fireberry.ts](src/bin/fireberry.ts))
+- **Framework**: Commander.js for command parsing and routing
+- **Error Handling**: Global error handler in [src/bin/fireberry.ts](src/bin/fireberry.ts) catches and formats errors
+
+### Command Structure
+
+Each CLI command is in [src/commands/](src/commands/):
+
+- **init**: Stores Fireberry API token in local config using `env-paths`
+- **create**: Creates new Fireberry app from templates with generated UUIDs
+- **push**: Validates manifest, zips components, uploads to Fireberry API
+- **install**: Installs app on user's Fireberry account
+- **delete**: Deletes app from Fireberry platform (requires confirmation)
+
+### Configuration System
+
+- **User Config**: Stored via `env-paths` ("Fireberry CLI") in OS-specific config directory
+- **Config File**: `config.json` with `{ apiToken, createdAt }`
+- **Environment**: [src/config/env.ts](src/config/env.ts) loads `.env` file from project root using dotenv
+
+### API Layer ([src/api/](src/api/))
+
+- **axios.ts**: Axios instance with automatic token injection via interceptors
+- **API URL Logic**:
+  - Beta versions (version contains "beta") → Uses `FIREBERRY_STAGING_URL` environment variable
+  - Production versions → `FIREBERRY_API_URL` or `https://api.fireberry.com/api/v3`
+- **Authentication**: Token passed via `tokenId` header (read from config in interceptor)
+- **requests.ts**: API endpoints (`createApp`, `pushComponents`, `installApp`, `deleteApp`)
+- **types.ts**: TypeScript interfaces for API requests/responses
+
+### Component System
+
+Component utilities in [src/utils/components.utils.ts](src/utils/components.utils.ts):
+
+- **Manifest Parsing**: YAML manifest loaded from `manifest.yml` in current directory
+- **Component Validation**: Checks paths exist, components are unique, validates required settings per component type
+- **Component Zipping**: Creates tar.gz archives of component builds (directories or single files)
+- **Component Types** ([src/constants/component-types.ts](src/constants/component-types.ts)):
+  - **record**: Record page component with required settings: `iconName` (string), `iconColor` (string), `objectType` (number)
+  - **global-menu**: Global menu component with required setting: `displayName` (string)
+  - **side-menu**: Side menu component with required settings: `icon` (string), `width` (string: "S" | "M" | "L")
+- **Manifest Structure**:
+  ```yaml
+  app:
+    id: "uuid"
+    name: "App Name"
+  components:
+    - type: record | global-menu | side-menu
+      title: component-name
+      id: "uuid"
+      path: relative/path/to/build
+      settings:
+        # For record type:
+        iconName: "icon-name"
+        iconColor: "#hexcolor"
+        objectType: 1
+        # For global-menu type:
+        displayName: "Menu Name"
+        # For side-menu type:
+        icon: "icon-name"
+        width: "S" | "M" | "L"
+  ```
+
+### Templates ([src/templates/](src/templates/))
+
+Templates use mustache-style placeholders (`{{appName}}`, `{{appId}}`, `{{componentId}}`):
+
+- **manifest.yml**: Default manifest with single component
+- **index.html**: Basic HTML template
+
+## Key Patterns
+
+### Error Handling
+
+- Commands throw errors which are caught by the global handler in [src/bin/fireberry.ts:47](src/bin/fireberry.ts#L47)
+- Errors are formatted with chalk.red and prefixed with "Error:" if not already present
+- API errors map HTTP status codes to user-friendly messages
+
+### User Feedback
+
+- Use `ora` spinners for long-running operations (start → succeed/fail)
+- Use `chalk` for colored output (cyan for highlights, gray for details, yellow for warnings)
+- Use `inquirer` for interactive prompts when arguments are missing
+
+### File Operations
+
+- Use `fs-extra` for all file operations (promisified, ensures directories exist)
+- Check `fs.pathExists()` before operations
+- Use `process.cwd()` as base for relative paths in user projects
+
+### Component Path Resolution
+
+Component paths in manifest.yml are relative to the current working directory, not the CLI installation directory. Example: `path: static/comp/build` resolves to `process.cwd() + "/static/comp/build"`.
+
+## Important Notes
+
+- **Manifest Required**: `push`, `install`, and `delete` commands must be run from a directory containing `manifest.yml`
+- **Token Required**: Most commands require prior `init` to store API token
+- **Component IDs**: Must be unique UUIDs within a manifest
+- **Component Settings Validation**: Each component type has required settings that are validated during `push`:
+  - `record`: Must have `iconName`, `iconColor`, and `objectType`
+  - `global-menu`: Must have `displayName`
+  - `side-menu`: Must have `icon` and `width` (S/M/L)
+- **Build Zipping**: Single files are wrapped in a directory before tar.gz creation
+- **Template Location**: Templates are resolved from `src/templates/` at compile time, copied to `dist/templates/`
+- **Delete Safety**: Delete command requires user confirmation before executing (cannot be undone)

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Fireberry LTD
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/api/axios.js

@@ -46,7 +46,7 @@ export async function sendApiRequest(config) {
             let errorMessage;
             switch (status) {
                 case 401:
-                    console.log(error.response?.data?.message || error.message);
+                    console.log(error.response?.data?.message || error.message); // TODO: remove this
                     errorMessage = "Unauthorized user.";
                     break;
                 case 500:

package/dist/api/requests.d.ts

@@ -1,4 +1,6 @@
 import "../config/env.js";
-import type { CreateAppRequest, ZippedComponent } from "./types.js";
-export declare const createApp: (data: CreateAppRequest) => Promise<void>;
-export declare const pushComponents: (appId: string, components: ZippedComponent[]) => Promise<void>;
+import type { Manifest, ZippedComponent } from "./types.js";
+export declare const createApp: (manifest: Manifest) => Promise<void>;
+export declare const pushComponents: (appId: string, components: ZippedComponent[], manifest: Manifest) => Promise<void>;
+export declare const installApp: (manifest: Manifest) => Promise<void>;
+export declare const deleteApp: (manifest: Manifest) => Promise<void>;

package/dist/api/requests.js

@@ -1,18 +1,37 @@
 import "../config/env.js";
+import { BASE_SERVICE_URL } from "../constants/component-types.js";
 import { api } from "./axios.js";
-export const createApp = async (data) => {
-    const url = "/services/developer/create";
+export const createApp = async (manifest) => {
+    const url = `${BASE_SERVICE_URL}/create`;
     try {
-        await api.post(url, data);
+        await api.post(url, { manifest });
     }
     catch (error) {
         throw new Error(error instanceof Error ? error.message : "Unknown error");
     }
 };
-export const pushComponents = async (appId, components) => {
-    const url = `/services/developer/push`;
+export const pushComponents = async (appId, components, manifest) => {
+    const url = `${BASE_SERVICE_URL}/push`;
     try {
-        await api.post(url, { appId, components });
+        await api.post(url, { appId, components, manifest });
+    }
+    catch (error) {
+        throw new Error(error instanceof Error ? error.message : "Unknown error");
+    }
+};
+export const installApp = async (manifest) => {
+    const url = `${BASE_SERVICE_URL}/install`;
+    try {
+        await api.post(url, { manifest }, { timeout: 300000 }); // 5 minutes
+    }
+    catch (error) {
+        throw new Error(error instanceof Error ? error.message : "Unknown error");
+    }
+};
+export const deleteApp = async (manifest) => {
+    const url = `${BASE_SERVICE_URL}/delete`;
+    try {
+        await api.delete(url, { manifest });
     }
     catch (error) {
         throw new Error(error instanceof Error ? error.message : "Unknown error");

package/dist/api/types.d.ts

@@ -1,5 +1,8 @@
+import { COMPONENT_TYPE } from "../constants/component-types.js";
+import { HeightOption } from "../constants/height-options.js";
 export interface CreateAppRequest {
     appId: string;
+    componentId: string;
 }
 export interface ApiError {
     message: string;
@@ -16,10 +19,38 @@ interface ManifestApp {
     name: string;
     description?: string;
 }
-export interface ManifestComponent {
+export interface RecordComponentSettings {
+    iconName: string;
+    iconColor: string;
+    objectType: number;
+    height: HeightOption;
+}
+export interface GlobalMenuComponentSettings {
+    displayName: string;
+}
+export interface SideMenuComponentSettings {
+    icon: string;
+    width: "S" | "M" | "L";
+}
+export type ComponentSettings = RecordComponentSettings | GlobalMenuComponentSettings | SideMenuComponentSettings;
+export interface BaseManifestComponent {
+    title: string;
+    id: string;
+    path: string;
+}
+export interface RecordComponent extends BaseManifestComponent {
+    type: typeof COMPONENT_TYPE.RECORD;
+    settings: RecordComponentSettings;
+}
+export interface GlobalMenuComponent extends BaseManifestComponent {
+    type: typeof COMPONENT_TYPE.GLOBAL_MENU;
+    settings: GlobalMenuComponentSettings;
+}
+export type ManifestComponent = RecordComponent | GlobalMenuComponent;
+export interface UntypedManifestComponent {
     type: string;
     title: string;
-    key: string;
+    id: string;
     path: string;
     settings?: Record<string, unknown>;
 }
@@ -29,7 +60,7 @@ export interface Manifest {
 }
 export interface ZippedComponent {
     title: string;
-    key: string;
+    id: string;
     build: Buffer;
 }
 export {};

package/dist/bin/fireberry.js

@@ -5,6 +5,8 @@ import { runInit } from "../commands/init.js";
 import { runCreate } from "../commands/create.js";
 import packageJson from "../../package.json" with { type: "json" };
 import { runPush } from "../commands/push.js";
+import { runInstall } from "../commands/install.js";
+import { runDelete } from "../commands/delete.js";
 const program = new Command();
 program
     .name("fireberry")
@@ -31,6 +33,17 @@ program
     .action(async () => {
     await runPush();
 });
+program.command("install")
+    .description("Install app on your Fireberry account")
+    .action(async () => {
+    await runInstall();
+});
+program
+    .command("delete")
+    .description("Delete a Fireberry app")
+    .action(async () => {
+    await runDelete();
+});
 program.parseAsync(process.argv).catch((err) => {
     const errorMessage = err instanceof Error
         ? err.message

package/dist/commands/create.js

@@ -6,6 +6,7 @@ import { fileURLToPath } from "node:url";
 import ora from "ora";
 import chalk from "chalk";
 import { createApp } from "../api/requests.js";
+import { getManifest } from "../utils/components.utils.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 function slugifyName(name) {
@@ -28,23 +29,26 @@ export async function runCreate({ name }) {
     }
     const slug = slugifyName(appName);
     const appId = uuidv4();
+    const componentId = uuidv4();
     const appDir = path.resolve(process.cwd(), slug);
     if (await fs.pathExists(appDir)) {
         throw new Error(`Already exists. ${chalk.yellow(slug)}`);
     }
     const spinner = ora(`Creating app "${chalk.cyan(appName)}"...`).start();
     try {
-        await createApp({ appId });
         await fs.ensureDir(appDir);
         const templatesDir = path.join(__dirname, "..", "..", "src", "templates");
         const manifestTemplate = await fs.readFile(path.join(templatesDir, "manifest.yml"), "utf-8");
         const htmlTemplate = await fs.readFile(path.join(templatesDir, "index.html"), "utf-8");
         const manifestContent = manifestTemplate
             .replace(/{{appName}}/g, appName)
-            .replace(/{{appId}}/g, appId);
+            .replace(/{{appId}}/g, appId)
+            .replace(/{{componentId}}/g, componentId);
         const htmlContent = htmlTemplate.replace(/{{appName}}/g, appName);
         await fs.writeFile(path.join(appDir, "manifest.yml"), manifestContent);
         await fs.writeFile(path.join(appDir, "index.html"), htmlContent);
+        const manifest = await getManifest(appDir);
+        await createApp(manifest);
         spinner.succeed(`Successfully created "${chalk.cyan(appName)}" app!`);
         console.log(chalk.gray(`📁 Location: ${appDir}`));
         console.log(chalk.gray(`App ID: ${appId}`));

package/dist/commands/delete.d.ts

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

package/dist/commands/delete.js

@@ -0,0 +1,31 @@
+import ora from "ora";
+import chalk from "chalk";
+import inquirer from "inquirer";
+import { deleteApp } from "../api/requests.js";
+import { getManifest } from "../utils/components.utils.js";
+export async function runDelete() {
+    const spinner = ora("Loading manifest...").start();
+    try {
+        const manifest = await getManifest();
+        spinner.stop();
+        const confirmAnswer = await inquirer.prompt([
+            {
+                type: "confirm",
+                name: "confirm",
+                message: `Are you sure you want to delete app ${chalk.yellow(manifest.app.name)} (${chalk.gray(manifest.app.id)})? This action cannot be undone.`,
+                default: false,
+            },
+        ]);
+        if (!confirmAnswer.confirm) {
+            console.log(chalk.gray("Delete operation cancelled."));
+            return;
+        }
+        spinner.start(`Deleting app "${chalk.cyan(manifest.app.name)}"...`);
+        await deleteApp(manifest);
+        spinner.succeed(`Successfully deleted app "${chalk.cyan(manifest.app.name)}"`);
+    }
+    catch (error) {
+        spinner.fail("Failed to delete app");
+        throw error;
+    }
+}

package/dist/commands/install.d.ts

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

package/dist/commands/install.js

@@ -0,0 +1,17 @@
+import ora from "ora";
+import { installApp } from "../api/requests.js";
+import { getManifest, validateManifestComponents, } from "../utils/components.utils.js";
+export async function runInstall() {
+    const spinner = ora("Loading manifest...").start();
+    try {
+        const manifest = await getManifest();
+        await validateManifestComponents(manifest);
+        spinner.start("Installing app on Fireberry...");
+        await installApp(manifest);
+        spinner.succeed("App installed successfully");
+    }
+    catch (error) {
+        spinner.fail("Installation failed");
+        throw error;
+    }
+}

package/dist/commands/push.js

@@ -15,10 +15,10 @@ export async function runPush() {
             console.log(chalk.cyan("\nComponents ready to push:"));
             zippedComponents.forEach((comp, idx) => {
                 const sizeKB = (comp.build.length / 1024).toFixed(2);
-                console.log(chalk.gray(`  ${idx + 1}. ${comp.title} (${comp.key}) - ${sizeKB} KB`));
+                console.log(chalk.gray(`  ${idx + 1}. ${comp.title} (${comp.id}) - ${sizeKB} KB`));
             });
             spinner.start("Uploading to Fireberry...");
-            await pushComponents(manifest.app.id, zippedComponents);
+            await pushComponents(manifest.app.id, zippedComponents, manifest);
             spinner.succeed("Components pushed successfully");
         }
         else {

package/dist/constants/component-types.d.ts

@@ -0,0 +1,7 @@
+export declare const COMPONENT_TYPE: {
+    readonly RECORD: "record";
+    readonly GLOBAL_MENU: "global-menu";
+    readonly SIDE_MENU: "side-menu";
+};
+export type ComponentType = (typeof COMPONENT_TYPE)[keyof typeof COMPONENT_TYPE];
+export declare const BASE_SERVICE_URL = "/services/developer/app";

package/dist/constants/component-types.js

@@ -0,0 +1,6 @@
+export const COMPONENT_TYPE = {
+    RECORD: "record",
+    GLOBAL_MENU: "global-menu",
+    SIDE_MENU: "side-menu",
+};
+export const BASE_SERVICE_URL = "/services/developer/app";

package/dist/constants/height-options.d.ts

@@ -0,0 +1,2 @@
+export declare const HEIGHT_OPTIONS: readonly ["S", "M", "L", "XL"];
+export type HeightOption = (typeof HEIGHT_OPTIONS)[number];

package/dist/constants/height-options.js

@@ -0,0 +1 @@
+export const HEIGHT_OPTIONS = ["S", "M", "L", "XL"];

package/dist/utils/components.utils.d.ts

@@ -1,5 +1,6 @@
-import { Manifest, ManifestComponent, ZippedComponent } from "../api/types.js";
-export declare const getManifest: () => Promise<Manifest>;
-export declare const validateComponentBuild: (componentPath: string, comp: ManifestComponent) => Promise<void>;
+import { Manifest, ZippedComponent, UntypedManifestComponent } from "../api/types.js";
+export declare const getManifest: (basePath?: string) => Promise<Manifest>;
+export declare const validateComponentBuild: (componentPath: string, comp: UntypedManifestComponent) => Promise<void>;
 export declare const zipComponentBuild: (componentPath: string, title: string) => Promise<Buffer>;
+export declare const validateManifestComponents: (manifest: Manifest) => Promise<void>;
 export declare const handleComponents: (manifest: Manifest) => Promise<ZippedComponent[]>;

package/dist/utils/components.utils.js

@@ -4,10 +4,13 @@ import yaml from "js-yaml";
 import chalk from "chalk";
 import * as tar from "tar";
 import os from "node:os";
-export const getManifest = async () => {
-    const manifestPath = path.join(process.cwd(), "manifest.yml");
+import { COMPONENT_TYPE } from "../constants/component-types.js";
+import { HEIGHT_OPTIONS } from "../constants/height-options.js";
+export const getManifest = async (basePath) => {
+    const manifestPath = path.join(basePath || process.cwd(), "manifest.yml");
+    const searchDir = basePath || process.cwd();
     if (!(await fs.pathExists(manifestPath))) {
-        throw new Error(`No manifest.yml found at ${chalk.yellow(process.cwd())}.\n` +
+        throw new Error(`No manifest.yml found at ${chalk.yellow(searchDir)}.\n` +
             `Please run this command from your Fireberry app directory.`);
     }
     const manifestContent = await fs.readFile(manifestPath, "utf-8");
@@ -20,6 +23,82 @@ export const getManifest = async () => {
     }
     return manifest;
 };
+const validateRecordComponentSettings = (comp) => {
+    const settings = comp.settings;
+    if (!settings) {
+        throw new Error(`Component "${comp.title}" (type: ${COMPONENT_TYPE.RECORD}) is missing required settings`);
+    }
+    const requiredFields = [
+        "iconName",
+        "iconColor",
+        "objectType",
+        "height",
+    ];
+    for (const fieldName of requiredFields) {
+        if (settings[fieldName] === undefined || settings[fieldName] === null) {
+            throw new Error(`Component "${comp.title}" (type: ${COMPONENT_TYPE.RECORD}) is missing required setting: ${fieldName}`);
+        }
+    }
+    if (typeof settings.iconName !== "string") {
+        throw new Error(`Component "${comp.title}" (type: ${COMPONENT_TYPE.RECORD}) setting "iconName" must be a string`);
+    }
+    if (typeof settings.iconColor !== "string") {
+        throw new Error(`Component "${comp.title}" (type: ${COMPONENT_TYPE.RECORD}) setting "iconColor" must be a string`);
+    }
+    if (typeof settings.objectType !== "number") {
+        throw new Error(`Component "${comp.title}" (type: ${COMPONENT_TYPE.RECORD}) setting "objectType" must be a number`);
+    }
+    if (!settings.height) {
+        throw new Error(`Component "${comp.title}" (type: ${COMPONENT_TYPE.RECORD}) setting "height" must be one of: ${HEIGHT_OPTIONS.join(" | ")}`);
+    }
+    if (!HEIGHT_OPTIONS.includes(settings.height)) {
+        throw new Error(`Component "${comp.title}" (type: ${COMPONENT_TYPE.RECORD}) setting "height" must be one of: ${HEIGHT_OPTIONS.join(" | ")}`);
+    }
+};
+const validateGlobalMenuComponentSettings = (comp) => {
+    const settings = comp.settings;
+    if (!settings) {
+        throw new Error(`Component "${comp.title}" (type: ${COMPONENT_TYPE.GLOBAL_MENU}) is missing required settings`);
+    }
+    if (!settings.displayName) {
+        throw new Error(`Component "${comp.title}" (type: ${COMPONENT_TYPE.GLOBAL_MENU}) is missing required setting: displayName`);
+    }
+    if (typeof settings.displayName !== "string") {
+        throw new Error(`Component "${comp.title}" (type: ${COMPONENT_TYPE.GLOBAL_MENU}) setting "displayName" must be a string`);
+    }
+};
+const validateSideMenuComponentSettings = (comp) => {
+    const settings = comp.settings;
+    if (!settings) {
+        throw new Error(`Component "${comp.title}" (type: ${COMPONENT_TYPE.SIDE_MENU}) is missing required settings`);
+    }
+    if (!settings.icon) {
+        throw new Error(`Component "${comp.title}" (type: ${COMPONENT_TYPE.SIDE_MENU}) setting "icon" must be a string`);
+    }
+    if (!settings.width) {
+        throw new Error(`Component "${comp.title}" (type: ${COMPONENT_TYPE.SIDE_MENU}) setting "width" must be a S | M | L`);
+    }
+    if (settings.width !== "S" &&
+        settings.width !== "M" &&
+        settings.width !== "L") {
+        throw new Error(`Component "${comp.title}" (type: ${COMPONENT_TYPE.SIDE_MENU}) setting "width" must be a S | M | L`);
+    }
+};
+const validateComponentSettings = (comp) => {
+    switch (comp.type) {
+        case COMPONENT_TYPE.RECORD:
+            validateRecordComponentSettings(comp);
+            break;
+        case COMPONENT_TYPE.GLOBAL_MENU:
+            validateGlobalMenuComponentSettings(comp);
+            break;
+        case COMPONENT_TYPE.SIDE_MENU:
+            validateSideMenuComponentSettings(comp);
+            break;
+        default:
+            throw new Error(`Component "${comp.title}" has unsupported type: ${comp.type}. Supported types: ${COMPONENT_TYPE.RECORD}, ${COMPONENT_TYPE.GLOBAL_MENU}`);
+    }
+};
 export const validateComponentBuild = async (componentPath, comp) => {
     if (!(await fs.pathExists(componentPath))) {
         throw new Error(`Component "${comp.title}" path does not exist: ${chalk.yellow(componentPath)}\n` + `Make sure the path in manifest.yml is correct.`);
@@ -28,9 +107,10 @@ export const validateComponentBuild = async (componentPath, comp) => {
     if (stats.isDirectory()) {
         const files = await fs.readdir(componentPath);
         if (files.length === 0) {
-            throw new Error(`Component <${comp.key}> at: /${comp.path} not found`);
+            throw new Error(`Component <${comp.id}> at: /${comp.path} not found`);
         }
     }
+    validateComponentSettings(comp);
 };
 export const zipComponentBuild = async (componentPath, title) => {
     const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "fireberry-"));
@@ -64,23 +144,30 @@ export const zipComponentBuild = async (componentPath, title) => {
         throw error;
     }
 };
-export const handleComponents = async (manifest) => {
+export const validateManifestComponents = async (manifest) => {
     const components = manifest.components;
     if (!components || components.length === 0) {
-        return [];
+        throw new Error("No components found in manifest");
     }
-    const keys = components.map((comp) => comp.key);
-    if (new Set(keys).size !== keys.length) {
-        throw new Error("All component keys must be unique");
+    const ids = components.map((comp) => comp.id);
+    if (new Set(ids).size !== ids.length) {
+        throw new Error("All component ids must be unique");
     }
-    const zippedComponents = [];
     for (const comp of components) {
         const componentPath = path.join(process.cwd(), comp.path);
         await validateComponentBuild(componentPath, comp);
+    }
+};
+export const handleComponents = async (manifest) => {
+    await validateManifestComponents(manifest);
+    const components = manifest.components;
+    const zippedComponents = [];
+    for (const comp of components) {
+        const componentPath = path.join(process.cwd(), comp.path);
         const buildBuffer = await zipComponentBuild(componentPath, comp.title);
         zippedComponents.push({
             title: comp.title,
-            key: comp.key,
+            id: comp.id,
             build: buildBuffer,
         });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fireberry/cli",
-  "version": "0.0.5-beta.9",
+  "version": "0.2.0",
   "description": "Fireberry CLI tool",
   "type": "module",
   "author": "",

package/src/api/axios.ts

@@ -59,7 +59,7 @@ export async function sendApiRequest<T = any>(
 
       switch (status) {
         case 401:
-          console.log(error.response?.data?.message || error.message);
+          console.log(error.response?.data?.message || error.message); // TODO: remove this
           errorMessage = "Unauthorized user.";
           break;
         case 500:

package/src/api/requests.ts

@@ -1,11 +1,12 @@
 import "../config/env.js";
+import { BASE_SERVICE_URL } from "../constants/component-types.js";
 import { api } from "./axios.js";
-import type { CreateAppRequest, ZippedComponent } from "./types.js";
+import type { Manifest, ZippedComponent } from "./types.js";
 
-export const createApp = async (data: CreateAppRequest): Promise<void> => {
-  const url = "/services/developer/create";
+export const createApp = async (manifest: Manifest): Promise<void> => {
+  const url = `${BASE_SERVICE_URL}/create`;
   try {
-    await api.post<void>(url, data);
+    await api.post<void>(url, { manifest });
   } catch (error) {
     throw new Error(error instanceof Error ? error.message : "Unknown error");
   }
@@ -13,11 +14,30 @@ export const createApp = async (data: CreateAppRequest): Promise<void> => {
 
 export const pushComponents = async (
   appId: string,
-  components: ZippedComponent[]
+  components: ZippedComponent[],
+  manifest: Manifest
 ): Promise<void> => {
-  const url = `/services/developer/push`;
+  const url = `${BASE_SERVICE_URL}/push`;
   try {
-    await api.post<void>(url, { appId, components });
+    await api.post<void>(url, { appId, components, manifest });
+  } catch (error) {
+    throw new Error(error instanceof Error ? error.message : "Unknown error");
+  }
+};
+
+export const installApp = async (manifest: Manifest): Promise<void> => {
+  const url = `${BASE_SERVICE_URL}/install`;
+  try {
+    await api.post<void>(url, { manifest }, { timeout: 300000 }); // 5 minutes
+  } catch (error) {
+    throw new Error(error instanceof Error ? error.message : "Unknown error");
+  }
+};
+
+export const deleteApp = async (manifest: Manifest): Promise<void> => {
+  const url = `${BASE_SERVICE_URL}/delete`;
+  try {
+    await api.delete<void>(url, { manifest });
   } catch (error) {
     throw new Error(error instanceof Error ? error.message : "Unknown error");
   }

package/src/api/types.ts

@@ -1,5 +1,9 @@
+import { COMPONENT_TYPE } from "../constants/component-types.js";
+import { HeightOption } from "../constants/height-options.js";
+
 export interface CreateAppRequest {
   appId: string;
+  componentId: string;
 }
 
 export interface ApiError {
@@ -20,10 +24,49 @@ interface ManifestApp {
   description?: string;
 }
 
-export interface ManifestComponent {
+export interface RecordComponentSettings {
+  iconName: string;
+  iconColor: string;
+  objectType: number;
+  height: HeightOption;
+}
+
+export interface GlobalMenuComponentSettings {
+  displayName: string;
+}
+
+export interface SideMenuComponentSettings {
+  icon: string;
+  width: "S" | "M" | "L";
+}
+
+export type ComponentSettings =
+  | RecordComponentSettings
+  | GlobalMenuComponentSettings
+  | SideMenuComponentSettings;
+
+export interface BaseManifestComponent {
+  title: string;
+  id: string;
+  path: string;
+}
+
+export interface RecordComponent extends BaseManifestComponent {
+  type: typeof COMPONENT_TYPE.RECORD;
+  settings: RecordComponentSettings;
+}
+
+export interface GlobalMenuComponent extends BaseManifestComponent {
+  type: typeof COMPONENT_TYPE.GLOBAL_MENU;
+  settings: GlobalMenuComponentSettings;
+}
+
+export type ManifestComponent = RecordComponent | GlobalMenuComponent;
+
+export interface UntypedManifestComponent {
   type: string;
   title: string;
-  key: string;
+  id: string;
   path: string;
   settings?: Record<string, unknown>;
 }
@@ -35,6 +78,6 @@ export interface Manifest {
 
 export interface ZippedComponent {
   title: string;
-  key: string;
+  id: string;
   build: Buffer;
 }

package/src/bin/fireberry.ts

@@ -5,6 +5,8 @@ import { runInit } from "../commands/init.js";
 import { runCreate } from "../commands/create.js";
 import packageJson from "../../package.json" with { type: "json" };
 import { runPush } from "../commands/push.js";
+import { runInstall } from "../commands/install.js";
+import { runDelete } from "../commands/delete.js";
 
 const program = new Command();
 
@@ -37,6 +39,19 @@ program
     await runPush();
   });
 
+program.command("install")
+    .description("Install app on your Fireberry account")
+    .action(async () => {
+      await runInstall();
+    });
+
+program
+  .command("delete")
+  .description("Delete a Fireberry app")
+  .action(async () => {
+    await runDelete();
+  });
+
 program.parseAsync(process.argv).catch((err: unknown) => {
   const errorMessage = err instanceof Error 
     ? err.message

package/src/commands/create.ts

@@ -6,6 +6,7 @@ import { fileURLToPath } from "node:url";
 import ora from "ora";
 import chalk from "chalk";
 import { createApp } from "../api/requests.js";
+import { getManifest } from "../utils/components.utils.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -40,6 +41,7 @@ export async function runCreate({ name }: CreateOptions): Promise<void> {
 
   const slug = slugifyName(appName);
   const appId = uuidv4();
+  const componentId = uuidv4();
   const appDir = path.resolve(process.cwd(), slug);
 
   if (await fs.pathExists(appDir)) {
@@ -49,8 +51,6 @@ export async function runCreate({ name }: CreateOptions): Promise<void> {
   const spinner = ora(`Creating app "${chalk.cyan(appName)}"...`).start();
 
   try {
-    await createApp({ appId });
-
     await fs.ensureDir(appDir);
 
     const templatesDir = path.join(__dirname, "..", "..", "src", "templates");
@@ -65,12 +65,16 @@ export async function runCreate({ name }: CreateOptions): Promise<void> {
 
     const manifestContent = manifestTemplate
       .replace(/{{appName}}/g, appName)
-      .replace(/{{appId}}/g, appId);
+      .replace(/{{appId}}/g, appId)
+      .replace(/{{componentId}}/g, componentId);
 
     const htmlContent = htmlTemplate.replace(/{{appName}}/g, appName);
 
     await fs.writeFile(path.join(appDir, "manifest.yml"), manifestContent);
     await fs.writeFile(path.join(appDir, "index.html"), htmlContent);
+    const manifest = await getManifest(appDir);
+
+    await createApp(manifest);
 
     spinner.succeed(`Successfully created "${chalk.cyan(appName)}" app!`);
     console.log(chalk.gray(`📁 Location: ${appDir}`));

package/src/commands/delete.ts

@@ -0,0 +1,40 @@
+import ora from "ora";
+import chalk from "chalk";
+import inquirer from "inquirer";
+import { deleteApp } from "../api/requests.js";
+import { getManifest } from "../utils/components.utils.js";
+
+export async function runDelete(): Promise<void> {
+  const spinner = ora("Loading manifest...").start();
+
+  try {
+    const manifest = await getManifest();
+    spinner.stop();
+
+    const confirmAnswer = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "confirm",
+        message: `Are you sure you want to delete app ${chalk.yellow(
+          manifest.app.name
+        )} (${chalk.gray(manifest.app.id)})? This action cannot be undone.`,
+        default: false,
+      },
+    ]);
+
+    if (!confirmAnswer.confirm) {
+      console.log(chalk.gray("Delete operation cancelled."));
+      return;
+    }
+
+    spinner.start(`Deleting app "${chalk.cyan(manifest.app.name)}"...`);
+
+    await deleteApp(manifest);
+    spinner.succeed(
+      `Successfully deleted app "${chalk.cyan(manifest.app.name)}"`
+    );
+  } catch (error) {
+    spinner.fail("Failed to delete app");
+    throw error;
+  }
+}

package/src/commands/install.ts

@@ -0,0 +1,23 @@
+import ora from "ora";
+import { installApp } from "../api/requests.js";
+import {
+  getManifest,
+  validateManifestComponents,
+} from "../utils/components.utils.js";
+
+export async function runInstall(): Promise<void> {
+  const spinner = ora("Loading manifest...").start();
+
+  try {
+    const manifest = await getManifest();
+
+    await validateManifestComponents(manifest);
+
+    spinner.start("Installing app on Fireberry...");
+    await installApp(manifest);
+    spinner.succeed("App installed successfully");
+  } catch (error) {
+    spinner.fail("Installation failed");
+    throw error;
+  }
+}

package/src/commands/push.ts

@@ -24,13 +24,13 @@ export async function runPush(): Promise<void> {
       zippedComponents.forEach((comp, idx) => {
         const sizeKB = (comp.build.length / 1024).toFixed(2);
         console.log(
-          chalk.gray(`  ${idx + 1}. ${comp.title} (${comp.key}) - ${sizeKB} KB`)
+          chalk.gray(`  ${idx + 1}. ${comp.title} (${comp.id}) - ${sizeKB} KB`)
         );
       });
 
       spinner.start("Uploading to Fireberry...");
 
-      await pushComponents(manifest.app.id, zippedComponents);
+      await pushComponents(manifest.app.id, zippedComponents, manifest);
       spinner.succeed("Components pushed successfully");
     } else {
       spinner.succeed("No components to push");

package/src/constants/component-types.ts

@@ -0,0 +1,10 @@
+export const COMPONENT_TYPE = {
+  RECORD: "record",
+  GLOBAL_MENU: "global-menu",
+  SIDE_MENU: "side-menu",
+} as const;
+
+export type ComponentType =
+  (typeof COMPONENT_TYPE)[keyof typeof COMPONENT_TYPE];
+
+export const BASE_SERVICE_URL = "/services/developer/app";

package/src/constants/height-options.ts

@@ -0,0 +1,3 @@
+export const HEIGHT_OPTIONS = ["S", "M", "L", "XL"] as const;
+
+export type HeightOption = (typeof HEIGHT_OPTIONS)[number];

package/src/templates/manifest.yml

@@ -5,6 +5,10 @@ app:
 components:
   - type: record
     title: my-first-component
-    key: comp
+    id: "{{componentId}}"
     path: static/comp/build
-    settings: {}
+    settings:
+      iconName: "related-single"
+      iconColor: "#7aae7f"
+      objectType: 0
+      height: "M"

package/src/utils/components.utils.ts

@@ -4,14 +4,24 @@ import yaml from "js-yaml";
 import chalk from "chalk";
 import * as tar from "tar";
 import os from "node:os";
-import { Manifest, ManifestComponent, ZippedComponent } from "../api/types.js";
+import {
+  Manifest,
+  ZippedComponent,
+  UntypedManifestComponent,
+  RecordComponentSettings,
+  GlobalMenuComponentSettings,
+  SideMenuComponentSettings,
+} from "../api/types.js";
+import { COMPONENT_TYPE } from "../constants/component-types.js";
+import { HEIGHT_OPTIONS } from "../constants/height-options.js";
 
-export const getManifest = async (): Promise<Manifest> => {
-  const manifestPath = path.join(process.cwd(), "manifest.yml");
+export const getManifest = async (basePath?: string): Promise<Manifest> => {
+  const manifestPath = path.join(basePath || process.cwd(), "manifest.yml");
+  const searchDir = basePath || process.cwd();
 
   if (!(await fs.pathExists(manifestPath))) {
     throw new Error(
-      `No manifest.yml found at ${chalk.yellow(process.cwd())}.\n` +
+      `No manifest.yml found at ${chalk.yellow(searchDir)}.\n` +
         `Please run this command from your Fireberry app directory.`
     );
   }
@@ -33,9 +43,147 @@ export const getManifest = async (): Promise<Manifest> => {
   return manifest;
 };
 
+const validateRecordComponentSettings = (
+  comp: UntypedManifestComponent
+): void => {
+  const settings = comp.settings as
+    | Partial<RecordComponentSettings>
+    | undefined;
+
+  if (!settings) {
+    throw new Error(
+      `Component "${comp.title}" (type: ${COMPONENT_TYPE.RECORD}) is missing required settings`
+    );
+  }
+
+  const requiredFields: (keyof RecordComponentSettings)[] = [
+    "iconName",
+    "iconColor",
+    "objectType",
+    "height",
+  ];
+
+  for (const fieldName of requiredFields) {
+    if (settings[fieldName] === undefined || settings[fieldName] === null) {
+      throw new Error(
+        `Component "${comp.title}" (type: ${COMPONENT_TYPE.RECORD}) is missing required setting: ${fieldName}`
+      );
+    }
+  }
+
+  if (typeof settings.iconName !== "string") {
+    throw new Error(
+      `Component "${comp.title}" (type: ${COMPONENT_TYPE.RECORD}) setting "iconName" must be a string`
+    );
+  }
+
+  if (typeof settings.iconColor !== "string") {
+    throw new Error(
+      `Component "${comp.title}" (type: ${COMPONENT_TYPE.RECORD}) setting "iconColor" must be a string`
+    );
+  }
+
+  if (typeof settings.objectType !== "number") {
+    throw new Error(
+      `Component "${comp.title}" (type: ${COMPONENT_TYPE.RECORD}) setting "objectType" must be a number`
+    );
+  }
+  if (!settings.height) {
+    throw new Error(
+      `Component "${comp.title}" (type: ${COMPONENT_TYPE.RECORD}) setting "height" must be one of: ${HEIGHT_OPTIONS.join(" | ")}`
+    );
+  }
+
+  if (!HEIGHT_OPTIONS.includes(settings.height as any)) {
+    throw new Error(
+      `Component "${comp.title}" (type: ${COMPONENT_TYPE.RECORD}) setting "height" must be one of: ${HEIGHT_OPTIONS.join(" | ")}`
+    );
+  }
+};
+
+const validateGlobalMenuComponentSettings = (
+  comp: UntypedManifestComponent
+): void => {
+  const settings = comp.settings as
+    | Partial<GlobalMenuComponentSettings>
+    | undefined;
+
+  if (!settings) {
+    throw new Error(
+      `Component "${comp.title}" (type: ${COMPONENT_TYPE.GLOBAL_MENU}) is missing required settings`
+    );
+  }
+
+  if (!settings.displayName) {
+    throw new Error(
+      `Component "${comp.title}" (type: ${COMPONENT_TYPE.GLOBAL_MENU}) is missing required setting: displayName`
+    );
+  }
+
+  if (typeof settings.displayName !== "string") {
+    throw new Error(
+      `Component "${comp.title}" (type: ${COMPONENT_TYPE.GLOBAL_MENU}) setting "displayName" must be a string`
+    );
+  }
+};
+
+const validateSideMenuComponentSettings = (
+  comp: UntypedManifestComponent
+): void => {
+  const settings = comp.settings as
+    | Partial<SideMenuComponentSettings>
+    | undefined;
+
+  if (!settings) {
+    throw new Error(
+      `Component "${comp.title}" (type: ${COMPONENT_TYPE.SIDE_MENU}) is missing required settings`
+    );
+  }
+
+  if (!settings.icon) {
+    throw new Error(
+      `Component "${comp.title}" (type: ${COMPONENT_TYPE.SIDE_MENU}) setting "icon" must be a string`
+    );
+  }
+
+  if (!settings.width) {
+    throw new Error(
+      `Component "${comp.title}" (type: ${COMPONENT_TYPE.SIDE_MENU}) setting "width" must be a S | M | L`
+    );
+  }
+
+  if (
+    settings.width !== "S" &&
+    settings.width !== "M" &&
+    settings.width !== "L"
+  ) {
+    throw new Error(
+      `Component "${comp.title}" (type: ${COMPONENT_TYPE.SIDE_MENU}) setting "width" must be a S | M | L`
+    );
+  }
+};
+
+const validateComponentSettings = (comp: UntypedManifestComponent): void => {
+  switch (comp.type) {
+    case COMPONENT_TYPE.RECORD:
+      validateRecordComponentSettings(comp);
+      break;
+    case COMPONENT_TYPE.GLOBAL_MENU:
+      validateGlobalMenuComponentSettings(comp);
+      break;
+    case COMPONENT_TYPE.SIDE_MENU:
+      validateSideMenuComponentSettings(comp);
+      break;
+    default:
+      throw new Error(
+        `Component "${comp.title}" has unsupported type: ${comp.type}. Supported types: ${COMPONENT_TYPE.RECORD}, ${COMPONENT_TYPE.GLOBAL_MENU}`
+      );
+  }
+};
+
 export const validateComponentBuild = async (
   componentPath: string,
-  comp: ManifestComponent
+  comp: UntypedManifestComponent
 ) => {
   if (!(await fs.pathExists(componentPath))) {
     throw new Error(
@@ -49,10 +197,13 @@ export const validateComponentBuild = async (
 
   if (stats.isDirectory()) {
     const files = await fs.readdir(componentPath);
+
     if (files.length === 0) {
-      throw new Error(`Component <${comp.key}> at: /${comp.path} not found`);
+      throw new Error(`Component <${comp.id}> at: /${comp.path} not found`);
     }
   }
+
+  validateComponentSettings(comp);
 };
 
 export const zipComponentBuild = async (
@@ -102,31 +253,42 @@ export const zipComponentBuild = async (
   }
 };
 
-export const handleComponents = async (
-  manifest: Manifest
-): Promise<ZippedComponent[]> => {
-  const components = manifest.components;
+export const validateManifestComponents = async (manifest: Manifest) => {
+  const components = manifest.components as unknown as
+    | UntypedManifestComponent[]
+    | undefined;
   if (!components || components.length === 0) {
-    return [];
+    throw new Error("No components found in manifest");
+  }
+
+  const ids = components.map((comp) => comp.id);
+  if (new Set(ids).size !== ids.length) {
+    throw new Error("All component ids must be unique");
   }
 
-  const keys = components.map((comp) => comp.key);
-  if (new Set(keys).size !== keys.length) {
-    throw new Error("All component keys must be unique");
+  for (const comp of components) {
+    const componentPath = path.join(process.cwd(), comp.path);
+    await validateComponentBuild(componentPath, comp);
   }
+};
+
+export const handleComponents = async (
+  manifest: Manifest
+): Promise<ZippedComponent[]> => {
+  await validateManifestComponents(manifest);
+  const components =
+    manifest.components as unknown as UntypedManifestComponent[];
 
   const zippedComponents: ZippedComponent[] = [];
 
   for (const comp of components) {
     const componentPath = path.join(process.cwd(), comp.path);
 
-    await validateComponentBuild(componentPath, comp);
-
     const buildBuffer = await zipComponentBuild(componentPath, comp.title);
 
     zippedComponents.push({
       title: comp.title,
-      key: comp.key,
+      id: comp.id,
       build: buildBuffer,
     });
   }