@byfungsi/funforge 0.1.0

package/dist/commands/config.js

@@ -0,0 +1,287 @@
+/**
+ * Config Commands
+ *
+ * Sync build settings between local funforge.json and server.
+ *
+ * Commands:
+ * - funforge config push  - Push local settings to server
+ * - funforge config pull  - Pull server settings to local file
+ * - funforge config show  - Show comparison between local and server
+ */
+import chalk from "chalk";
+import ora from "ora";
+import { ApiError, getAppDetails, updateApp, } from "../api.js";
+import { isAuthenticated } from "../credentials.js";
+import { readConfig, updateConfig, } from "../project-config.js";
+/**
+ * Extract build settings from funforge.json config
+ */
+function extractBuildSettings(config) {
+    const settings = {};
+    if (config.port !== undefined) {
+        settings.port = config.port;
+    }
+    if (config.build) {
+        if (config.build.buildCommand !== undefined) {
+            settings.buildCommand = config.build.buildCommand || null;
+        }
+        if (config.build.installCommand !== undefined) {
+            settings.installCommand = config.build.installCommand || null;
+        }
+        if (config.build.startCommand !== undefined) {
+            settings.startCommand = config.build.startCommand || null;
+        }
+        if (config.build.nodeVersion !== undefined) {
+            const version = config.build.nodeVersion;
+            if (version === "18" || version === "20" || version === "22") {
+                settings.nodeVersion = version;
+            }
+            else if (!version) {
+                settings.nodeVersion = null;
+            }
+        }
+    }
+    return settings;
+}
+/**
+ * Format a setting value for display
+ */
+function formatValue(value) {
+    if (value === null || value === undefined || value === "") {
+        return chalk.gray("(not set)");
+    }
+    return chalk.cyan(String(value));
+}
+/**
+ * Check if two values are different (for highlighting changes)
+ */
+function isDifferent(local, server) {
+    const normalizedLocal = local ?? null;
+    const normalizedServer = server ?? null;
+    return normalizedLocal !== normalizedServer;
+}
+/**
+ * funforge config push
+ *
+ * Push local funforge.json build settings to server.
+ * Local settings overwrite server settings.
+ */
+export async function configPushCommand() {
+    requireAuth();
+    // Read local config
+    const config = await readConfig();
+    if (!config?.appId) {
+        console.log(chalk.red("Not linked to an app."));
+        console.log(chalk.gray("Run `funforge link <app-id>` first."));
+        process.exit(1);
+    }
+    // Extract build settings from local config
+    const settings = extractBuildSettings(config);
+    if (Object.keys(settings).length === 0) {
+        console.log(chalk.yellow("No build settings found in funforge.json"));
+        console.log(chalk.gray("Add a 'build' section or 'port' to funforge.json:"));
+        console.log(chalk.gray(`
+{
+  "appId": "${config.appId}",
+  "build": {
+    "buildCommand": "npm run build",
+    "installCommand": "npm ci",
+    "startCommand": "npm start",
+    "nodeVersion": "20"
+  },
+  "port": 3000
+}
+`));
+        process.exit(0);
+    }
+    console.log(chalk.bold(`Pushing config for ${config.appName ?? config.appSlug ?? "app"}...`));
+    console.log();
+    // Show what will be pushed
+    console.log(chalk.gray("Settings to push:"));
+    if (settings.port !== undefined) {
+        console.log(`  Port: ${formatValue(settings.port)}`);
+    }
+    if (settings.buildCommand !== undefined) {
+        console.log(`  Build command: ${formatValue(settings.buildCommand)}`);
+    }
+    if (settings.installCommand !== undefined) {
+        console.log(`  Install command: ${formatValue(settings.installCommand)}`);
+    }
+    if (settings.startCommand !== undefined) {
+        console.log(`  Start command: ${formatValue(settings.startCommand)}`);
+    }
+    if (settings.nodeVersion !== undefined) {
+        console.log(`  Node version: ${formatValue(settings.nodeVersion)}`);
+    }
+    console.log();
+    // Push to server
+    const spinner = ora("Pushing settings to server...").start();
+    try {
+        await updateApp(config.appId, settings);
+        spinner.succeed("Settings pushed successfully");
+        console.log();
+        console.log(chalk.green("Local funforge.json settings are now synced to server."));
+        console.log(chalk.gray("These settings will be used for the next deployment."));
+    }
+    catch (error) {
+        spinner.fail("Failed to push settings");
+        handleError(error);
+    }
+}
+/**
+ * funforge config pull
+ *
+ * Pull server build settings to local funforge.json.
+ * Server settings are written to local file.
+ */
+export async function configPullCommand() {
+    requireAuth();
+    // Read local config
+    const config = await readConfig();
+    if (!config?.appId) {
+        console.log(chalk.red("Not linked to an app."));
+        console.log(chalk.gray("Run `funforge link <app-id>` first."));
+        process.exit(1);
+    }
+    console.log(chalk.bold(`Pulling config for ${config.appName ?? config.appSlug ?? "app"}...`));
+    console.log();
+    // Fetch from server
+    const spinner = ora("Fetching settings from server...").start();
+    try {
+        const { app } = await getAppDetails(config.appId);
+        spinner.succeed("Settings fetched");
+        console.log();
+        // Build the updated config
+        const updatedConfig = {};
+        // Always sync port if set
+        if (app.port !== undefined) {
+            updatedConfig.port = app.port;
+        }
+        // Build build settings object
+        const build = {};
+        let hasBuildSettings = false;
+        if (app.buildCommand) {
+            build.buildCommand = app.buildCommand;
+            hasBuildSettings = true;
+        }
+        if (app.installCommand) {
+            build.installCommand = app.installCommand;
+            hasBuildSettings = true;
+        }
+        if (app.startCommand) {
+            build.startCommand = app.startCommand;
+            hasBuildSettings = true;
+        }
+        if (app.nodeVersion) {
+            build.nodeVersion = app.nodeVersion;
+            hasBuildSettings = true;
+        }
+        if (hasBuildSettings) {
+            updatedConfig.build = build;
+        }
+        // Show what will be written
+        console.log(chalk.gray("Settings from server:"));
+        console.log(`  Port: ${formatValue(app.port)}`);
+        console.log(`  Build command: ${formatValue(app.buildCommand)}`);
+        console.log(`  Install command: ${formatValue(app.installCommand)}`);
+        console.log(`  Start command: ${formatValue(app.startCommand)}`);
+        console.log(`  Node version: ${formatValue(app.nodeVersion)}`);
+        console.log();
+        // Write to local file
+        await updateConfig(updatedConfig);
+        console.log(chalk.green("funforge.json updated with server settings."));
+    }
+    catch (error) {
+        spinner.fail("Failed to pull settings");
+        handleError(error);
+    }
+}
+/**
+ * funforge config show
+ *
+ * Show comparison between local funforge.json and server settings.
+ */
+export async function configShowCommand() {
+    requireAuth();
+    // Read local config
+    const config = await readConfig();
+    if (!config?.appId) {
+        console.log(chalk.red("Not linked to an app."));
+        console.log(chalk.gray("Run `funforge link <app-id>` first."));
+        process.exit(1);
+    }
+    console.log(chalk.bold(`Config comparison for ${config.appName ?? config.appSlug ?? "app"}`));
+    console.log();
+    // Fetch from server
+    const spinner = ora("Fetching server settings...").start();
+    try {
+        const { app } = await getAppDetails(config.appId);
+        spinner.stop();
+        // Local values
+        const localPort = config.port;
+        const localBuildCommand = config.build?.buildCommand;
+        const localInstallCommand = config.build?.installCommand;
+        const localStartCommand = config.build?.startCommand;
+        const localNodeVersion = config.build?.nodeVersion;
+        // Server values
+        const serverPort = app.port;
+        const serverBuildCommand = app.buildCommand;
+        const serverInstallCommand = app.installCommand;
+        const serverStartCommand = app.startCommand;
+        const serverNodeVersion = app.nodeVersion;
+        // Table header
+        console.log(chalk.gray("Setting".padEnd(20)) +
+            chalk.gray("Local".padEnd(30)) +
+            chalk.gray("Server"));
+        console.log(chalk.gray("-".repeat(80)));
+        // Helper to print a row
+        const printRow = (name, local, server) => {
+            const different = isDifferent(local, server);
+            const marker = different ? chalk.yellow("*") : " ";
+            const localStr = formatValue(local).padEnd(30);
+            const serverStr = formatValue(server);
+            console.log(`${marker}${name.padEnd(19)}${localStr}${serverStr}`);
+        };
+        printRow("Port", localPort, serverPort);
+        printRow("Build command", localBuildCommand, serverBuildCommand);
+        printRow("Install command", localInstallCommand, serverInstallCommand);
+        printRow("Start command", localStartCommand, serverStartCommand);
+        printRow("Node version", localNodeVersion, serverNodeVersion);
+        console.log();
+        console.log(chalk.gray("* = differs between local and server"));
+        console.log();
+        console.log(chalk.gray("Use `funforge config push` to sync local → server"));
+        console.log(chalk.gray("Use `funforge config pull` to sync server → local"));
+    }
+    catch (error) {
+        spinner.fail("Failed to fetch server settings");
+        handleError(error);
+    }
+}
+/**
+ * Check if user is authenticated, exit if not
+ */
+function requireAuth() {
+    if (!isAuthenticated()) {
+        console.log(chalk.red("Not authenticated."));
+        console.log(chalk.gray("Run `funforge login` first."));
+        process.exit(1);
+    }
+}
+/**
+ * Handle API errors
+ */
+function handleError(error) {
+    if (error instanceof ApiError) {
+        console.error(chalk.red(`Error ${error.statusCode}: ${error.message}`));
+        if (error.body &&
+            typeof error.body === "object" &&
+            "message" in error.body) {
+            console.error(chalk.gray(error.body.message));
+        }
+    }
+    else {
+        console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+    }
+    process.exit(1);
+}

package/dist/commands/deploy.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Deploy Command
+ *
+ * Main deployment workflow:
+ * 1. Read funforge.json to get app ID
+ * 2. Create tarball of project files
+ * 3. Upload tarball to R2
+ * 4. Trigger deployment
+ * 5. Stream logs
+ */
+interface DeployOptions {
+    /** Skip confirmation prompt */
+    yes?: boolean;
+    /** Watch deployment logs */
+    watch?: boolean;
+}
+/**
+ * funforge deploy
+ *
+ * Deploy the current directory to FunForge.
+ */
+export declare function deployCommand(options?: DeployOptions): Promise<void>;
+export {};
+//# sourceMappingURL=deploy.d.ts.map

package/dist/commands/deploy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../src/commands/deploy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAeH,UAAU,aAAa;IACrB,+BAA+B;IAC/B,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,4BAA4B;IAC5B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;;;GAIG;AACH,wBAAsB,aAAa,CACjC,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC,IAAI,CAAC,CAsGf"}

package/dist/commands/deploy.js

@@ -0,0 +1,196 @@
+/**
+ * Deploy Command
+ *
+ * Main deployment workflow:
+ * 1. Read funforge.json to get app ID
+ * 2. Create tarball of project files
+ * 3. Upload tarball to R2
+ * 4. Trigger deployment
+ * 5. Stream logs
+ */
+import chalk from "chalk";
+import ora from "ora";
+import { ApiError, createDeployment, getDeployment, getUploadUrl, uploadTarball, } from "../api.js";
+import { isAuthenticated } from "../credentials.js";
+import { readConfig } from "../project-config.js";
+import { createTarball, formatSize, readTarball } from "../tarball.js";
+/**
+ * funforge deploy
+ *
+ * Deploy the current directory to FunForge.
+ */
+export async function deployCommand(options = {}) {
+    requireAuth();
+    // 1. Check project config
+    const config = await readConfig();
+    if (!config?.appId) {
+        console.log(chalk.red("Not linked to an app."));
+        console.log(chalk.gray("Run `funforge link <app-id>` first."));
+        process.exit(1);
+    }
+    console.log(chalk.bold(`Deploying ${config.appName ?? config.appSlug ?? "app"}...`));
+    console.log();
+    // 2. Create tarball
+    const tarballSpinner = ora("Creating deployment package...").start();
+    let tarballResult;
+    try {
+        tarballResult = await createTarball(process.cwd());
+        tarballSpinner.succeed(`Package created: ${tarballResult.fileCount} files, ${formatSize(tarballResult.size)}`);
+    }
+    catch (error) {
+        tarballSpinner.fail("Failed to create package");
+        console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+        process.exit(1);
+    }
+    // Check size limit (50MB)
+    const MAX_SIZE = 50 * 1024 * 1024;
+    if (tarballResult.size > MAX_SIZE) {
+        console.log(chalk.red(`Package too large: ${formatSize(tarballResult.size)} (max ${formatSize(MAX_SIZE)})`));
+        console.log(chalk.gray("Try adding more patterns to .funforgeignore"));
+        process.exit(1);
+    }
+    // 3. Get upload URL
+    const uploadSpinner = ora("Preparing upload...").start();
+    let uploadInfo;
+    try {
+        uploadInfo = await getUploadUrl(config.appId, {
+            filename: "context.tar.gz",
+            contentLength: tarballResult.size,
+            sha256: tarballResult.sha256,
+        });
+        uploadSpinner.succeed("Upload prepared");
+    }
+    catch (error) {
+        uploadSpinner.fail("Failed to prepare upload");
+        handleError(error);
+        return;
+    }
+    // 4. Upload tarball
+    const uploadingSpinner = ora("Uploading...").start();
+    try {
+        const tarballBuffer = await readTarball(tarballResult.path);
+        await uploadTarball(uploadInfo.uploadUrl, tarballBuffer);
+        uploadingSpinner.succeed(`Uploaded ${formatSize(tarballResult.size)}`);
+    }
+    catch (error) {
+        uploadingSpinner.fail("Upload failed");
+        handleError(error);
+        return;
+    }
+    // 5. Trigger deployment
+    const deploySpinner = ora("Starting deployment...").start();
+    let deployResult;
+    try {
+        deployResult = await createDeployment(config.appId, {
+            sourceId: uploadInfo.sourceId,
+        });
+        deploySpinner.succeed("Deployment started");
+    }
+    catch (error) {
+        deploySpinner.fail("Failed to start deployment");
+        handleError(error);
+        return;
+    }
+    console.log();
+    console.log(chalk.bold("Deployment:"));
+    console.log(`  ID: ${deployResult.deployment.id}`);
+    console.log(`  Status: ${formatStatus(deployResult.deployment.status)}`);
+    console.log();
+    // 6. Watch logs if requested
+    if (options.watch !== false) {
+        await watchDeployment(deployResult.deployment.id);
+    }
+    else {
+        console.log(chalk.gray("Run with --watch to follow logs"));
+    }
+}
+/**
+ * Watch deployment status until completion
+ */
+async function watchDeployment(deploymentId) {
+    console.log(chalk.gray("Watching deployment..."));
+    console.log();
+    const spinner = ora("Building...").start();
+    let lastStatus = "";
+    while (true) {
+        try {
+            const { deployment } = await getDeployment(deploymentId);
+            if (deployment.status !== lastStatus) {
+                lastStatus = deployment.status;
+                spinner.text = formatStatus(deployment.status);
+            }
+            if (deployment.status === "live") {
+                spinner.succeed(chalk.green("Deployment live!"));
+                console.log();
+                // TODO: Show deployment URL
+                return;
+            }
+            if (deployment.status === "failed" || deployment.status === "canceled") {
+                spinner.fail(chalk.red(`Deployment ${deployment.status}`));
+                process.exit(1);
+            }
+            // Poll every 2 seconds
+            await sleep(2000);
+        }
+        catch (error) {
+            spinner.fail("Failed to get deployment status");
+            handleError(error);
+            return;
+        }
+    }
+}
+/**
+ * Format deployment status for display
+ */
+function formatStatus(status) {
+    switch (status) {
+        case "pending":
+            return chalk.gray("Pending...");
+        case "queued":
+            return chalk.yellow("Queued...");
+        case "building":
+            return chalk.blue("Building...");
+        case "deploying":
+            return chalk.cyan("Deploying...");
+        case "live":
+            return chalk.green("Live");
+        case "stopped":
+            return chalk.gray("Stopped");
+        case "failed":
+            return chalk.red("Failed");
+        case "canceled":
+            return chalk.gray("Canceled");
+        default:
+            return status;
+    }
+}
+/**
+ * Check if user is authenticated, exit if not
+ */
+function requireAuth() {
+    if (!isAuthenticated()) {
+        console.log(chalk.red("Not authenticated."));
+        console.log(chalk.gray("Run `funforge login` first."));
+        process.exit(1);
+    }
+}
+/**
+ * Handle API errors
+ */
+function handleError(error) {
+    if (error instanceof ApiError) {
+        console.error(chalk.red(`Error ${error.statusCode}: ${error.message}`));
+        if (error.body &&
+            typeof error.body === "object" &&
+            "message" in error.body) {
+            console.error(chalk.gray(error.body.message));
+        }
+    }
+    else {
+        console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+    }
+    process.exit(1);
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/commands/domains.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Domain Management Commands
+ *
+ * - domains list: List custom domains
+ * - domains add: Add a custom domain
+ * - domains remove: Remove a domain
+ * - domains verify: Verify DNS and provision SSL
+ */
+/**
+ * funforge domains list
+ *
+ * List all custom domains for the linked app.
+ */
+export declare function domainsListCommand(): Promise<void>;
+/**
+ * funforge domains add <domain>
+ *
+ * Add a custom domain to the linked app.
+ */
+export declare function domainsAddCommand(domain: string, options: {
+    method?: string;
+}): Promise<void>;
+/**
+ * funforge domains remove <domain>
+ *
+ * Remove a custom domain from the linked app.
+ */
+export declare function domainsRemoveCommand(domain: string): Promise<void>;
+/**
+ * funforge domains verify <domain>
+ *
+ * Verify DNS and provision SSL for a custom domain.
+ */
+export declare function domainsVerifyCommand(domain: string): Promise<void>;
+//# sourceMappingURL=domains.d.ts.map

package/dist/commands/domains.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domains.d.ts","sourceRoot":"","sources":["../../src/commands/domains.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAqCH;;;;GAIG;AACH,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC,CA6CxD;AAED;;;;GAIG;AACH,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,MAAM,EACd,OAAO,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GAC3B,OAAO,CAAC,IAAI,CAAC,CAkDf;AAED;;;;GAIG;AACH,wBAAsB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAoCxE;AAED;;;;GAIG;AACH,wBAAsB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CA6DxE"}