@fireberry/cli 0.0.4 → 0.0.5-beta.10

package/.github/workflows/main.yml

@@ -3,14 +3,23 @@ name: Publish Fireberry CLI to npm
 on:
   workflow_dispatch:
     inputs:
-      version:
-        description: "Version to publish (e.g., 0.0.4)"
+      type:
+        description: "Publish type"
         required: true
         type: choice
         options:
+          - beta
+          - production
+      version:
+        description: "Version bump (for production only)"
+        required: false
+        type: choice
+        options:
+          - prerelease
           - patch
           - minor
           - major
+        default: patch
 
 jobs:
   publish:
@@ -18,6 +27,9 @@ jobs:
     permissions:
       contents: read
       id-token: write
+    environment:
+      name: npm
+      url: https://www.npmjs.com/package/@fireberry/cli/v/${{ github.event.inputs.version }}
 
     steps:
       - name: Checkout repository
@@ -34,7 +46,18 @@ jobs:
       - name: Install dependencies
         run: npm ci
 
-      - name: Update version
+      - name: Update version (Beta)
+        if: github.event.inputs.type == 'beta'
+        run: |
+          CURRENT_VERSION=$(node -p "require('./package.json').version")
+          if [[ $CURRENT_VERSION == *"-beta."* ]]; then
+            npm version prerelease --preid=beta --no-git-tag-version
+          else
+            npm version prepatch --preid=beta --no-git-tag-version
+          fi
+
+      - name: Update version (Production)
+        if: github.event.inputs.type == 'production'
         run: npm version ${{ github.event.inputs.version }} --no-git-tag-version
 
       - name: Build package
@@ -43,7 +66,13 @@ jobs:
       - name: Run tests
         run: npm test
 
-      - name: Publish to npm
-        run: npm publish --provenance --access public
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+      - name: Update npm to latest version
+        run: npm install -g npm@latest
+
+      - name: Publish to npm (Beta)
+        if: github.event.inputs.type == 'beta'
+        run: npm publish --tag beta --provenance --access public
+
+      - name: Publish to npm (Production)
+        if: github.event.inputs.type == 'production'
+        run: npm publish --tag latest --provenance --access public

package/dist/api/axios.d.ts

@@ -0,0 +1,12 @@
+import "../config/env.js";
+import { AxiosInstance, AxiosRequestConfig } from "axios";
+declare const fbApi: AxiosInstance;
+export declare function sendApiRequest<T = any>(config: AxiosRequestConfig): Promise<T>;
+export declare const api: {
+    get: <T = any>(url: string, config?: AxiosRequestConfig) => Promise<T>;
+    post: <T = any>(url: string, data?: any, config?: AxiosRequestConfig) => Promise<T>;
+    put: <T = any>(url: string, data?: any, config?: AxiosRequestConfig) => Promise<T>;
+    patch: <T = any>(url: string, data?: any, config?: AxiosRequestConfig) => Promise<T>;
+    delete: <T = any>(url: string, data?: any, config?: AxiosRequestConfig) => Promise<T>;
+};
+export default fbApi;

package/dist/api/axios.js

@@ -0,0 +1,70 @@
+import "../config/env.js";
+import axios from "axios";
+import { getApiToken } from "./config.js";
+import packageJson from "../../package.json" with { type: "json" };
+const getDefaultApiUrl = () => {
+    if (process.env.FIREBERRY_API_URL) {
+        return process.env.FIREBERRY_API_URL;
+    }
+    const isBeta = packageJson.version.includes("beta");
+    if (isBeta) {
+        return process.env.FIREBERRY_STAGING_URL || "https://dev.fireberry.com/api/v3";
+    }
+    return "https://api.fireberry.com/api/v3";
+};
+const BASE_URL = getDefaultApiUrl();
+const fbApi = axios.create({
+    baseURL: BASE_URL,
+    timeout: 30000,
+    headers: {
+        "Content-Type": "application/json",
+        "User-Agent": `@fireberry/cli@${packageJson.version}`,
+    },
+});
+fbApi.interceptors.request.use(async (config) => {
+    try {
+        const token = await getApiToken();
+        if (token) {
+            config.headers.tokenId = token;
+        }
+    }
+    catch (error) {
+        console.warn("Failed to get API token:", error);
+    }
+    return config;
+}, (error) => {
+    return Promise.reject(error);
+});
+export async function sendApiRequest(config) {
+    try {
+        const response = await fbApi.request(config);
+        return response.data;
+    }
+    catch (error) {
+        if (axios.isAxiosError(error)) {
+            const status = error.response?.status;
+            let errorMessage;
+            switch (status) {
+                case 401:
+                    console.log(error.response?.data?.message || error.message); // TODO: remove this
+                    errorMessage = "Unauthorized user.";
+                    break;
+                case 500:
+                    errorMessage = "Internal server error.";
+                    break;
+                default:
+                    errorMessage = error.response?.data?.message || error.message;
+            }
+            throw new Error(`Error: ${errorMessage}`);
+        }
+        throw error;
+    }
+}
+export const api = {
+    get: (url, config) => sendApiRequest({ ...config, method: "GET", url }),
+    post: (url, data, config) => sendApiRequest({ ...config, method: "POST", url, data }),
+    put: (url, data, config) => sendApiRequest({ ...config, method: "PUT", url, data }),
+    patch: (url, data, config) => sendApiRequest({ ...config, method: "PATCH", url, data }),
+    delete: (url, data, config) => sendApiRequest({ ...config, method: "DELETE", url, data }),
+};
+export default fbApi;

package/dist/api/config.d.ts

@@ -0,0 +1 @@
+export declare function getApiToken(): Promise<string | null>;

package/dist/api/config.js

@@ -0,0 +1,18 @@
+import envPaths from "env-paths";
+import path from "node:path";
+import fs from "fs-extra";
+export async function getApiToken() {
+    try {
+        const paths = envPaths("Fireberry CLI", { suffix: "" });
+        const configFile = path.join(paths.config, "config.json");
+        if (!(await fs.pathExists(configFile))) {
+            return null;
+        }
+        const config = await fs.readJson(configFile);
+        return config.apiToken || null;
+    }
+    catch (error) {
+        console.warn("Failed to read config file:", error);
+        return null;
+    }
+}

package/dist/api/requests.d.ts

@@ -0,0 +1,4 @@
+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>;

package/dist/api/requests.js

@@ -0,0 +1,20 @@
+import "../config/env.js";
+import { api } from "./axios.js";
+export const createApp = async (data) => {
+    const url = "/services/developer/create";
+    try {
+        await api.post(url, data);
+    }
+    catch (error) {
+        throw new Error(error instanceof Error ? error.message : "Unknown error");
+    }
+};
+export const pushComponents = async (appId, components) => {
+    const url = `/services/developer/push`;
+    try {
+        await api.post(url, { appId, components });
+    }
+    catch (error) {
+        throw new Error(error instanceof Error ? error.message : "Unknown error");
+    }
+};

package/dist/api/types.d.ts

@@ -0,0 +1,35 @@
+export interface CreateAppRequest {
+    appId: string;
+}
+export interface ApiError {
+    message: string;
+    code?: string;
+    details?: any;
+}
+export interface ApiResponse<T> {
+    data: T;
+    success: boolean;
+    message?: string;
+}
+interface ManifestApp {
+    id: string;
+    name: string;
+    description?: string;
+}
+export interface ManifestComponent {
+    type: string;
+    title: string;
+    key: string;
+    path: string;
+    settings?: Record<string, unknown>;
+}
+export interface Manifest {
+    app: ManifestApp;
+    components?: ManifestComponent[];
+}
+export interface ZippedComponent {
+    title: string;
+    key: string;
+    build: Buffer;
+}
+export {};

package/dist/api/types.js

@@ -0,0 +1 @@
+export {};

package/dist/bin/fireberry.js

@@ -2,7 +2,9 @@
 import { Command } from "commander";
 import chalk from "chalk";
 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";
 const program = new Command();
 program
     .name("fireberry")
@@ -15,12 +17,27 @@ program
     .action(async (tokenid) => {
     await runInit({ tokenid });
 });
+program
+    .command("create")
+    .argument("[name...]", "App name")
+    .description("Create a new Fireberry app")
+    .action(async (nameArgs) => {
+    const name = nameArgs ? nameArgs.join("-") : undefined;
+    await runCreate({ name });
+});
+program
+    .command("push")
+    .description("Push app to Fireberry")
+    .action(async () => {
+    await runPush();
+});
 program.parseAsync(process.argv).catch((err) => {
     const errorMessage = err instanceof Error
         ? err.message
         : typeof err === 'string'
             ? err
             : 'Unexpected error';
-    console.error(chalk.red(errorMessage));
+    const formattedError = errorMessage.startsWith('Error:') ? errorMessage : `Error: ${errorMessage}`;
+    console.error(chalk.red(formattedError));
     process.exit(1);
 });

package/dist/commands/create.d.ts

@@ -0,0 +1,5 @@
+interface CreateOptions {
+    name?: string;
+}
+export declare function runCreate({ name }: CreateOptions): Promise<void>;
+export {};

package/dist/commands/create.js

@@ -0,0 +1,59 @@
+import inquirer from "inquirer";
+import path from "node:path";
+import fs from "fs-extra";
+import { v4 as uuidv4 } from "uuid";
+import { fileURLToPath } from "node:url";
+import ora from "ora";
+import chalk from "chalk";
+import { createApp } from "../api/requests.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+function slugifyName(name) {
+    const validPattern = /^[a-zA-Z0-9_-]+$/;
+    if (!validPattern.test(name)) {
+        throw new Error(`Invalid app name: "${name}". Only alphanumeric characters, underscores, and hyphens are allowed.`);
+    }
+    return name;
+}
+export async function runCreate({ name }) {
+    let appName = name;
+    if (!appName) {
+        const answers = await inquirer.prompt([
+            { type: "input", name: "name", message: "App name" },
+        ]);
+        appName = (answers.name || "").trim();
+    }
+    if (!appName) {
+        throw new Error("Missing name.");
+    }
+    const slug = slugifyName(appName);
+    const appId = 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);
+        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);
+        spinner.succeed(`Successfully created "${chalk.cyan(appName)}" app!`);
+        console.log(chalk.gray(`📁 Location: ${appDir}`));
+        console.log(chalk.gray(`App ID: ${appId}`));
+        console.log(chalk.green("\n🎉 Your app is ready! Next steps:"));
+        console.log(chalk.white(`   cd ${slug}`));
+        console.log(chalk.white("   # Start developing your Fireberry app"));
+    }
+    catch (error) {
+        spinner.fail(`Failed to create app "${chalk.cyan(appName)}"`);
+        throw error;
+    }
+}

package/dist/commands/init.d.ts

@@ -1,5 +1,9 @@
 interface InitOptions {
     tokenid?: string;
 }
+export interface Config {
+    apiToken: string;
+    createdAt: string;
+}
 export declare function runInit({ tokenid }?: InitOptions): Promise<void>;
 export {};

package/dist/commands/init.js

@@ -5,7 +5,7 @@ import fs from "fs-extra";
 import ora from "ora";
 import chalk from "chalk";
 export async function runInit({ tokenid } = {}) {
-    let token = tokenid;
+    let token = tokenid?.trim();
     if (!token) {
         const answers = await inquirer.prompt([
             {

package/dist/commands/push.d.ts

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

package/dist/commands/push.js

@@ -0,0 +1,32 @@
+import ora from "ora";
+import chalk from "chalk";
+import { getManifest, handleComponents } from "../utils/components.utils.js";
+import { pushComponents } from "../api/requests.js";
+export async function runPush() {
+    const spinner = ora("Checking manifest...").start();
+    try {
+        const manifest = await getManifest();
+        spinner.succeed("Manifest loaded successfully");
+        spinner.start("Validating and zipping components...");
+        const zippedComponents = await handleComponents(manifest);
+        const count = zippedComponents.length;
+        if (count > 0) {
+            spinner.succeed(`${count} component${count > 1 ? "s" : ""} validated and zipped`);
+            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`));
+            });
+            spinner.start("Uploading to Fireberry...");
+            await pushComponents(manifest.app.id, zippedComponents);
+            spinner.succeed("Components pushed successfully");
+        }
+        else {
+            spinner.succeed("No components to push");
+        }
+    }
+    catch (error) {
+        spinner.fail("Push failed");
+        throw error;
+    }
+}

package/dist/config/env.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/config/env.js

@@ -0,0 +1,8 @@
+import { config } from "dotenv";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const projectRoot = path.resolve(__dirname, "..", "..");
+const envPath = path.join(projectRoot, ".env");
+config({ path: envPath, quiet: true });

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

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

package/dist/utils/components.utils.js

@@ -0,0 +1,88 @@
+import path from "node:path";
+import fs from "fs-extra";
+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");
+    if (!(await fs.pathExists(manifestPath))) {
+        throw new Error(`No manifest.yml found at ${chalk.yellow(process.cwd())}.\n` +
+            `Please run this command from your Fireberry app directory.`);
+    }
+    const manifestContent = await fs.readFile(manifestPath, "utf-8");
+    const manifest = yaml.load(manifestContent);
+    if (!manifest || !manifest.app) {
+        throw new Error("manifest.yml must contain an 'app' section");
+    }
+    if (!manifest.app.id || !manifest.app.name) {
+        throw new Error("manifest.yml app section must contain 'id' and 'name' fields");
+    }
+    return manifest;
+};
+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.`);
+    }
+    const stats = await fs.stat(componentPath);
+    if (stats.isDirectory()) {
+        const files = await fs.readdir(componentPath);
+        if (files.length === 0) {
+            throw new Error(`Component <${comp.key}> at: /${comp.path} not found`);
+        }
+    }
+};
+export const zipComponentBuild = async (componentPath, title) => {
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "fireberry-"));
+    const tarballPath = path.join(tmpDir, `${title}.tar.gz`);
+    try {
+        const stats = await fs.stat(componentPath);
+        if (stats.isDirectory()) {
+            await tar.create({
+                gzip: true,
+                file: tarballPath,
+                cwd: componentPath,
+            }, ["."]);
+        }
+        else {
+            const tempBuildDir = path.join(tmpDir, "build");
+            await fs.ensureDir(tempBuildDir);
+            const fileName = path.basename(componentPath);
+            await fs.copy(componentPath, path.join(tempBuildDir, fileName));
+            await tar.create({
+                gzip: true,
+                file: tarballPath,
+                cwd: tempBuildDir,
+            }, ["."]);
+        }
+        const buffer = await fs.readFile(tarballPath);
+        await fs.remove(tmpDir);
+        return buffer;
+    }
+    catch (error) {
+        await fs.remove(tmpDir);
+        throw error;
+    }
+};
+export const handleComponents = async (manifest) => {
+    const components = manifest.components;
+    if (!components || components.length === 0) {
+        return [];
+    }
+    const keys = components.map((comp) => comp.key);
+    if (new Set(keys).size !== keys.length) {
+        throw new Error("All component keys must be unique");
+    }
+    const zippedComponents = [];
+    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,
+            build: buildBuffer,
+        });
+    }
+    return zippedComponents;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fireberry/cli",
-  "version": "0.0.4",
+  "version": "0.0.5-beta.10",
   "description": "Fireberry CLI tool",
   "type": "module",
   "author": "",
@@ -14,11 +14,15 @@
   "scripts": {
     "start": "node dist/bin/fireberry.js",
     "build": "tsc",
+    "build:dev": "npm run clean && tsc && npm link && chmod +x dist/bin/fireberry.js",
     "dev": "tsc --watch",
     "clean": "rm -rf dist",
     "prebuild": "npm run clean",
     "prepare": "npm run build",
-    "test": "node test/smoke.test.js"
+    "test": "node test/smoke.test.js",
+    "version:beta": "npm version prerelease --preid=beta",
+    "publish:beta": "npm run version:beta && npm publish --tag beta",
+    "publish:prod": "npm publish --tag latest"
   },
   "keywords": [
     "cli",
@@ -27,7 +31,7 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/fireberry-crm/cli"
+    "url": "git+https://github.com/fireberry-crm/cli.git"
   },
   "bugs": {
     "url": "https://github.com/fireberry-crm/cli/issues"
@@ -37,17 +41,24 @@
     "access": "public"
   },
   "dependencies": {
+    "axios": "^1.12.2",
     "chalk": "^5.3.0",
     "commander": "^12.1.0",
+    "dotenv": "^17.2.3",
     "env-paths": "^3.0.0",
     "fs-extra": "^11.2.0",
     "inquirer": "^9.2.12",
-    "ora": "^8.0.1"
+    "js-yaml": "^4.1.0",
+    "ora": "^8.0.1",
+    "tar": "^7.5.1",
+    "uuid": "^13.0.0"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",
     "@types/inquirer": "^9.0.7",
+    "@types/js-yaml": "^4.0.9",
     "@types/node": "^20.11.24",
+    "@types/uuid": "^10.0.0",
     "typescript": "^5.3.3"
   }
 }

package/src/api/axios.ts

@@ -0,0 +1,95 @@
+import "../config/env.js";
+import axios, { AxiosInstance, AxiosRequestConfig } from "axios";
+import { getApiToken } from "./config.js";
+import packageJson from "../../package.json" with { type: "json" };
+
+const getDefaultApiUrl = () => {
+  if (process.env.FIREBERRY_API_URL) {
+    return process.env.FIREBERRY_API_URL;
+  }
+  
+  const isBeta = packageJson.version.includes("beta");
+  
+  if (isBeta) {
+    return process.env.FIREBERRY_STAGING_URL || "https://dev.fireberry.com/api/v3";
+  }
+  
+  return "https://api.fireberry.com/api/v3";
+};
+
+const BASE_URL = getDefaultApiUrl();
+
+const fbApi: AxiosInstance = axios.create({
+  baseURL: BASE_URL,
+  timeout: 30000,
+  headers: {
+    "Content-Type": "application/json",
+    "User-Agent": `@fireberry/cli@${packageJson.version}`,
+  },
+});
+
+fbApi.interceptors.request.use(
+  async (config) => {
+    try {
+      const token = await getApiToken();
+      if (token) {
+        config.headers.tokenId = token;
+      }
+    } catch (error) {
+      console.warn("Failed to get API token:", error);
+    }
+    return config;
+  },
+  (error) => {
+    return Promise.reject(error);
+  }
+);
+
+export async function sendApiRequest<T = any>(
+  config: AxiosRequestConfig
+): Promise<T> {
+  try {
+    const response = await fbApi.request<T>(config);
+
+    return response.data;
+  } catch (error) {
+    if (axios.isAxiosError(error)) {
+      const status = error.response?.status;
+      let errorMessage:string;
+
+      switch (status) {
+        case 401:
+          console.log(error.response?.data?.message || error.message); // TODO: remove this
+          errorMessage = "Unauthorized user.";
+          break;
+        case 500:
+          errorMessage = "Internal server error.";
+          break;
+        default:
+          errorMessage = error.response?.data?.message || error.message;
+      }
+
+      throw new Error(`Error: ${errorMessage}`);
+    }
+    throw error;
+  }
+}
+
+export const api = {
+  get: <T = any>(url: string, config?: AxiosRequestConfig) =>
+    sendApiRequest<T>({ ...config, method: "GET", url }),
+
+  post: <T = any>(url: string, data?: any, config?: AxiosRequestConfig) =>
+    sendApiRequest<T>({ ...config, method: "POST", url, data }),
+
+  put: <T = any>(url: string, data?: any, config?: AxiosRequestConfig) =>
+    sendApiRequest<T>({ ...config, method: "PUT", url, data }),
+
+  patch: <T = any>(url: string, data?: any, config?: AxiosRequestConfig) =>
+    sendApiRequest<T>({ ...config, method: "PATCH", url, data }),
+
+  delete: <T = any>(url: string, data?: any, config?: AxiosRequestConfig) =>
+    sendApiRequest<T>({ ...config, method: "DELETE", url, data }),
+};
+
+export default fbApi;

package/src/api/config.ts

@@ -0,0 +1,21 @@
+import envPaths from "env-paths";
+import path from "node:path";
+import fs from "fs-extra";
+import type { Config } from "../commands/init.js";
+
+export async function getApiToken(): Promise<string | null> {
+  try {
+    const paths = envPaths("Fireberry CLI", { suffix: "" });
+    const configFile = path.join(paths.config, "config.json");
+
+    if (!(await fs.pathExists(configFile))) {
+      return null;
+    }
+
+    const config: Config = await fs.readJson(configFile);
+    return config.apiToken || null;
+  } catch (error) {
+    console.warn("Failed to read config file:", error);
+    return null;
+  }
+}

package/src/api/requests.ts

@@ -0,0 +1,24 @@
+import "../config/env.js";
+import { api } from "./axios.js";
+import type { CreateAppRequest, ZippedComponent } from "./types.js";
+
+export const createApp = async (data: CreateAppRequest): Promise<void> => {
+  const url = "/services/developer/create";
+  try {
+    await api.post<void>(url, data);
+  } catch (error) {
+    throw new Error(error instanceof Error ? error.message : "Unknown error");
+  }
+};
+
+export const pushComponents = async (
+  appId: string,
+  components: ZippedComponent[]
+): Promise<void> => {
+  const url = `/services/developer/push`;
+  try {
+    await api.post<void>(url, { appId, components });
+  } catch (error) {
+    throw new Error(error instanceof Error ? error.message : "Unknown error");
+  }
+};

package/src/api/types.ts

@@ -0,0 +1,40 @@
+export interface CreateAppRequest {
+  appId: string;
+}
+
+export interface ApiError {
+  message: string;
+  code?: string;
+  details?: any;
+}
+
+export interface ApiResponse<T> {
+  data: T;
+  success: boolean;
+  message?: string;
+}
+
+interface ManifestApp {
+  id: string;
+  name: string;
+  description?: string;
+}
+
+export interface ManifestComponent {
+  type: string;
+  title: string;
+  key: string;
+  path: string;
+  settings?: Record<string, unknown>;
+}
+
+export interface Manifest {
+  app: ManifestApp;
+  components?: ManifestComponent[];
+}
+
+export interface ZippedComponent {
+  title: string;
+  key: string;
+  build: Buffer;
+}

package/src/bin/fireberry.ts

@@ -2,7 +2,9 @@
 import { Command } from "commander";
 import chalk from "chalk";
 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";
 
 const program = new Command();
 
@@ -19,12 +21,30 @@ program
     await runInit({ tokenid });
   });
 
+program
+  .command("create")
+  .argument("[name...]", "App name")
+  .description("Create a new Fireberry app")
+  .action(async (nameArgs?: string[]) => {
+    const name = nameArgs ? nameArgs.join("-") : undefined;
+        await runCreate({ name });
+  });
+
+program
+  .command("push")
+  .description("Push app to Fireberry")
+  .action(async () => {
+    await runPush();
+  });
+
 program.parseAsync(process.argv).catch((err: unknown) => {
   const errorMessage = err instanceof Error 
     ? err.message
     : typeof err === 'string' 
       ? err 
       : 'Unexpected error';
-  console.error(chalk.red(errorMessage));
+  
+  const formattedError = errorMessage.startsWith('Error:') ? errorMessage : `Error: ${errorMessage}`;
+  console.error(chalk.red(formattedError));
   process.exit(1);
 });

package/src/commands/create.ts

@@ -0,0 +1,85 @@
+import inquirer from "inquirer";
+import path from "node:path";
+import fs from "fs-extra";
+import { v4 as uuidv4 } from "uuid";
+import { fileURLToPath } from "node:url";
+import ora from "ora";
+import chalk from "chalk";
+import { createApp } from "../api/requests.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+interface CreateOptions {
+  name?: string;
+}
+
+function slugifyName(name: string) {
+  const validPattern = /^[a-zA-Z0-9_-]+$/;
+  if (!validPattern.test(name)) {
+    throw new Error(
+      `Invalid app name: "${name}". Only alphanumeric characters, underscores, and hyphens are allowed.`
+    );
+  }
+
+  return name;
+}
+
+export async function runCreate({ name }: CreateOptions): Promise<void> {
+  let appName = name;
+
+  if (!appName) {
+    const answers = await inquirer.prompt([
+      { type: "input", name: "name", message: "App name" },
+    ]);
+    appName = (answers.name || "").trim();
+  }
+  if (!appName) {
+    throw new Error("Missing name.");
+  }
+
+  const slug = slugifyName(appName);
+  const appId = 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);
+
+    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);
+
+    spinner.succeed(`Successfully created "${chalk.cyan(appName)}" app!`);
+    console.log(chalk.gray(`📁 Location: ${appDir}`));
+    console.log(chalk.gray(`App ID: ${appId}`));
+    console.log(chalk.green("\n🎉 Your app is ready! Next steps:"));
+    console.log(chalk.white(`   cd ${slug}`));
+    console.log(chalk.white("   # Start developing your Fireberry app"));
+  } catch (error) {
+    spinner.fail(`Failed to create app "${chalk.cyan(appName)}"`);
+    throw error;
+  }
+}

package/src/commands/init.ts

@@ -9,13 +9,13 @@ interface InitOptions {
   tokenid?: string;
 }
 
-interface Config {
+export interface Config {
   apiToken: string;
   createdAt: string;
 }
 
 export async function runInit({ tokenid }: InitOptions = {}): Promise<void> {
-  let token = tokenid;
+  let token = tokenid?.trim();
   if (!token) {
     const answers = await inquirer.prompt([
       {

package/src/commands/push.ts

@@ -0,0 +1,42 @@
+import ora from "ora";
+import chalk from "chalk";
+import { getManifest, handleComponents } from "../utils/components.utils.js";
+import { pushComponents } from "../api/requests.js";
+
+export async function runPush(): Promise<void> {
+  const spinner = ora("Checking manifest...").start();
+
+  try {
+    const manifest = await getManifest();
+    spinner.succeed("Manifest loaded successfully");
+
+    spinner.start("Validating and zipping components...");
+
+    const zippedComponents = await handleComponents(manifest);
+
+    const count = zippedComponents.length;
+    if (count > 0) {
+      spinner.succeed(
+        `${count} component${count > 1 ? "s" : ""} validated and zipped`
+      );
+
+      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`)
+        );
+      });
+
+      spinner.start("Uploading to Fireberry...");
+
+      await pushComponents(manifest.app.id, zippedComponents);
+      spinner.succeed("Components pushed successfully");
+    } else {
+      spinner.succeed("No components to push");
+    }
+  } catch (error) {
+    spinner.fail("Push failed");
+    throw error;
+  }
+}

package/src/config/env.ts

@@ -0,0 +1,10 @@
+import { config } from "dotenv";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const projectRoot = path.resolve(__dirname, "..", "..");
+const envPath = path.join(projectRoot, ".env");
+
+config({ path: envPath, quiet: true });

package/src/templates/index.html

@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>{{appName}}</title>
+</head>
+
+<body>
+    <h1>Hello World</h1>
+    <p>Welcome to {{appName}}!</p>
+</body>
+
+</html>

package/src/templates/manifest.yml

@@ -0,0 +1,10 @@
+app:
+  id: "{{appId}}"
+  name: "{{appName}}"
+  description: ""
+components:
+  - type: record
+    title: my-first-component
+    key: comp
+    path: static/comp/build
+    settings: {}

package/src/utils/components.utils.ts

@@ -0,0 +1,135 @@
+import path from "node:path";
+import fs from "fs-extra";
+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";
+
+export const getManifest = async (): Promise<Manifest> => {
+  const manifestPath = path.join(process.cwd(), "manifest.yml");
+
+  if (!(await fs.pathExists(manifestPath))) {
+    throw new Error(
+      `No manifest.yml found at ${chalk.yellow(process.cwd())}.\n` +
+        `Please run this command from your Fireberry app directory.`
+    );
+  }
+
+  const manifestContent = await fs.readFile(manifestPath, "utf-8");
+
+  const manifest = yaml.load(manifestContent) as Manifest;
+
+  if (!manifest || !manifest.app) {
+    throw new Error("manifest.yml must contain an 'app' section");
+  }
+
+  if (!manifest.app.id || !manifest.app.name) {
+    throw new Error(
+      "manifest.yml app section must contain 'id' and 'name' fields"
+    );
+  }
+
+  return manifest;
+};
+
+export const validateComponentBuild = async (
+  componentPath: string,
+  comp: ManifestComponent
+) => {
+  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.`
+    );
+  }
+
+  const stats = await fs.stat(componentPath);
+
+  if (stats.isDirectory()) {
+    const files = await fs.readdir(componentPath);
+    if (files.length === 0) {
+      throw new Error(`Component <${comp.key}> at: /${comp.path} not found`);
+    }
+  }
+};
+
+export const zipComponentBuild = async (
+  componentPath: string,
+  title: string
+): Promise<Buffer> => {
+  const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "fireberry-"));
+  const tarballPath = path.join(tmpDir, `${title}.tar.gz`);
+
+  try {
+    const stats = await fs.stat(componentPath);
+
+    if (stats.isDirectory()) {
+      await tar.create(
+        {
+          gzip: true,
+          file: tarballPath,
+          cwd: componentPath,
+        },
+        ["."]
+      );
+    } else {
+      const tempBuildDir = path.join(tmpDir, "build");
+      await fs.ensureDir(tempBuildDir);
+
+      const fileName = path.basename(componentPath);
+      await fs.copy(componentPath, path.join(tempBuildDir, fileName));
+
+      await tar.create(
+        {
+          gzip: true,
+          file: tarballPath,
+          cwd: tempBuildDir,
+        },
+        ["."]
+      );
+    }
+
+    const buffer = await fs.readFile(tarballPath);
+
+    await fs.remove(tmpDir);
+
+    return buffer;
+  } catch (error) {
+    await fs.remove(tmpDir);
+    throw error;
+  }
+};
+
+export const handleComponents = async (
+  manifest: Manifest
+): Promise<ZippedComponent[]> => {
+  const components = manifest.components;
+  if (!components || components.length === 0) {
+    return [];
+  }
+
+  const keys = components.map((comp) => comp.key);
+  if (new Set(keys).size !== keys.length) {
+    throw new Error("All component keys must be unique");
+  }
+
+  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,
+      build: buildBuffer,
+    });
+  }
+
+  return zippedComponents;
+};

package/bin/fireberry.js

@@ -1,24 +0,0 @@
-#!/usr/bin/env node
-import { Command } from "commander";
-import chalk from "chalk";
-import { runInit } from "../src/commands/init.js";
-
-const program = new Command();
-
-program
-  .name("fireberry")
-  .description("Fireberry developer CLI")
-  .version("0.0.1");
-
-program
-  .command("init")
-  .argument("[tokenid]", "Fireberry token id")
-  .description("Initiates credentials and stores token in local config")
-  .action(async (tokenid) => {
-    await runInit({ tokenid });
-  });
-
-program.parseAsync(process.argv).catch((err) => {
-  console.error(chalk.red(err?.message || "Unexpected error"));
-  process.exit(1);
-});