@byfungsi/funforge 0.1.0

package/dist/mcp.js

@@ -0,0 +1,480 @@
+#!/usr/bin/env node
+/**
+ * FunForge MCP Server
+ *
+ * Model Context Protocol server for editor integration.
+ * Exposes FunForge CLI functionality as MCP tools.
+ *
+ * Usage in claude_desktop_config.json:
+ * {
+ *   "mcpServers": {
+ *     "funforge": {
+ *       "command": "npx",
+ *       "args": ["@byfungsi/funforge-mcp"]
+ *     }
+ *   }
+ * }
+ */
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { ApiError, apiRequest, createApp, createDeployment, getUploadUrl, listApps, uploadTarball, } from "./api.js";
+import { getCredentials, isAuthenticated } from "./credentials.js";
+import { getLinkedAppId, readConfig } from "./project-config.js";
+import { createTarball, formatSize, readTarball } from "./tarball.js";
+// ============================================
+// TOOL DEFINITIONS
+// ============================================
+const TOOLS = [
+    {
+        name: "funforge_whoami",
+        description: "Show the currently authenticated FunForge user. Returns email and user ID.",
+        inputSchema: {
+            type: "object",
+            properties: {},
+            required: [],
+        },
+    },
+    {
+        name: "funforge_apps_list",
+        description: "List all apps owned by the authenticated user. Returns app names, IDs, and slugs.",
+        inputSchema: {
+            type: "object",
+            properties: {},
+            required: [],
+        },
+    },
+    {
+        name: "funforge_apps_create",
+        description: "Create a new FunForge app.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                    description: "Name of the app",
+                },
+                slug: {
+                    type: "string",
+                    description: "Custom slug/subdomain (optional, auto-generated if not provided)",
+                },
+            },
+            required: ["name"],
+        },
+    },
+    {
+        name: "funforge_status",
+        description: "Get the deployment status for the linked app in the current directory. Shows current and active deployments.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                directory: {
+                    type: "string",
+                    description: "Directory to check (defaults to current working directory)",
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: "funforge_deploy",
+        description: "Deploy the current directory to FunForge. Creates a tarball of project files, uploads to R2, and triggers deployment. The directory must be linked to an app via funforge.json.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                directory: {
+                    type: "string",
+                    description: "Directory to deploy (defaults to current working directory)",
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: "funforge_env_list",
+        description: "List environment variables for the linked app. Shows both app-level and user-level (inherited) env vars.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                directory: {
+                    type: "string",
+                    description: "Directory with funforge.json (defaults to cwd)",
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: "funforge_env_set",
+        description: "Set environment variables for the linked app. Changes take effect on next deployment.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                directory: {
+                    type: "string",
+                    description: "Directory with funforge.json (defaults to cwd)",
+                },
+                envVars: {
+                    type: "object",
+                    description: "Key-value pairs of environment variables to set",
+                    additionalProperties: { type: "string" },
+                },
+            },
+            required: ["envVars"],
+        },
+    },
+    {
+        name: "funforge_env_unset",
+        description: "Remove environment variables from the linked app.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                directory: {
+                    type: "string",
+                    description: "Directory with funforge.json (defaults to cwd)",
+                },
+                keys: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "List of environment variable keys to remove",
+                },
+            },
+            required: ["keys"],
+        },
+    },
+    {
+        name: "funforge_domains_list",
+        description: "List custom domains configured for the linked app.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                directory: {
+                    type: "string",
+                    description: "Directory with funforge.json (defaults to cwd)",
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: "funforge_domains_add",
+        description: "Add a custom domain to the linked app. Returns DNS configuration instructions.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                directory: {
+                    type: "string",
+                    description: "Directory with funforge.json (defaults to cwd)",
+                },
+                domain: {
+                    type: "string",
+                    description: "Domain name to add (e.g., example.com)",
+                },
+                verificationMethod: {
+                    type: "string",
+                    enum: ["cname", "txt"],
+                    description: "DNS verification method (default: cname)",
+                },
+            },
+            required: ["domain"],
+        },
+    },
+];
+async function handleToolCall(name, args) {
+    try {
+        switch (name) {
+            case "funforge_whoami":
+                return await handleWhoami();
+            case "funforge_apps_list":
+                return await handleAppsList();
+            case "funforge_apps_create":
+                return await handleAppsCreate(args.name, args.slug);
+            case "funforge_status":
+                return await handleStatus(args.directory);
+            case "funforge_deploy":
+                return await handleDeploy(args.directory);
+            case "funforge_env_list":
+                return await handleEnvList(args.directory);
+            case "funforge_env_set":
+                return await handleEnvSet(args.directory, args.envVars);
+            case "funforge_env_unset":
+                return await handleEnvUnset(args.directory, args.keys);
+            case "funforge_domains_list":
+                return await handleDomainsList(args.directory);
+            case "funforge_domains_add":
+                return await handleDomainsAdd(args.directory, args.domain, args.verificationMethod);
+            default:
+                return errorResult(`Unknown tool: ${name}`);
+        }
+    }
+    catch (error) {
+        return errorResult(formatError(error));
+    }
+}
+// ============================================
+// HANDLER IMPLEMENTATIONS
+// ============================================
+async function handleWhoami() {
+    if (!isAuthenticated()) {
+        return errorResult("Not authenticated. User needs to run `funforge login` in their terminal first.");
+    }
+    const creds = getCredentials();
+    return successResult({
+        authenticated: true,
+        email: creds.email,
+        userId: creds.userId,
+        authenticatedAt: creds.savedAt,
+    });
+}
+async function handleAppsList() {
+    requireAuth();
+    const { apps } = await listApps();
+    return successResult({
+        count: apps.length,
+        apps: apps.map((app) => ({
+            id: app.id,
+            name: app.name,
+            slug: app.slug,
+            sourceType: app.sourceType,
+            createdAt: app.createdAt,
+        })),
+    });
+}
+async function handleAppsCreate(name, slug) {
+    requireAuth();
+    const { app } = await createApp({ name, slug });
+    return successResult({
+        message: `App "${app.name}" created successfully`,
+        app: {
+            id: app.id,
+            name: app.name,
+            slug: app.slug,
+        },
+    });
+}
+async function handleStatus(directory) {
+    requireAuth();
+    const dir = directory || process.cwd();
+    const appId = await getLinkedAppId(dir);
+    if (!appId) {
+        return errorResult(`No app linked in ${dir}. Create funforge.json with an appId or run \`funforge link\` command.`);
+    }
+    const status = await apiRequest(`/api/cli/apps/${appId}/status`);
+    return successResult({
+        app: status.app,
+        currentDeployment: status.currentDeployment,
+        activeDeployment: status.activeDeployment,
+        url: status.app.subdomain
+            ? `https://${status.app.subdomain}.funforge.app`
+            : null,
+    });
+}
+async function handleDeploy(directory) {
+    requireAuth();
+    const dir = directory || process.cwd();
+    const config = await readConfig(dir);
+    if (!config?.appId) {
+        return errorResult(`No app linked in ${dir}. Create funforge.json with an appId or run \`funforge link\` command.`);
+    }
+    // 1. Create tarball
+    const tarballResult = await createTarball(dir);
+    // Check size limit (50MB)
+    const MAX_SIZE = 50 * 1024 * 1024;
+    if (tarballResult.size > MAX_SIZE) {
+        return errorResult(`Package too large: ${formatSize(tarballResult.size)} (max ${formatSize(MAX_SIZE)}). Add patterns to .funforgeignore to reduce size.`);
+    }
+    // 2. Get upload URL
+    const uploadInfo = await getUploadUrl(config.appId, {
+        filename: "context.tar.gz",
+        contentLength: tarballResult.size,
+        sha256: tarballResult.sha256,
+    });
+    // 3. Upload tarball
+    const tarballBuffer = await readTarball(tarballResult.path);
+    await uploadTarball(uploadInfo.uploadUrl, tarballBuffer);
+    // 4. Trigger deployment
+    const deployResult = await createDeployment(config.appId, {
+        sourceId: uploadInfo.sourceId,
+    });
+    return successResult({
+        message: "Deployment started successfully",
+        deployment: {
+            id: deployResult.deployment.id,
+            status: deployResult.deployment.status,
+            createdAt: deployResult.deployment.createdAt,
+        },
+        package: {
+            files: tarballResult.fileCount,
+            size: formatSize(tarballResult.size),
+        },
+        tip: "Use funforge_status to check deployment progress",
+    });
+}
+async function handleEnvList(directory) {
+    requireAuth();
+    const dir = directory || process.cwd();
+    const appId = await getLinkedAppId(dir);
+    if (!appId) {
+        return errorResult(`No app linked in ${dir}.`);
+    }
+    const { appEnvVars, userEnvVars } = await apiRequest(`/api/cli/apps/${appId}/env`);
+    return successResult({
+        appEnvVars,
+        userEnvVars,
+        note: "User env vars are inherited but can be overridden by app env vars",
+    });
+}
+async function handleEnvSet(directory, envVars) {
+    requireAuth();
+    const dir = directory || process.cwd();
+    const appId = await getLinkedAppId(dir);
+    if (!appId) {
+        return errorResult(`No app linked in ${dir}.`);
+    }
+    await apiRequest(`/api/cli/apps/${appId}/env`, {
+        method: "PATCH",
+        body: { envVars },
+    });
+    return successResult({
+        message: `Set ${Object.keys(envVars).length} environment variable(s)`,
+        keys: Object.keys(envVars),
+        note: "Changes take effect on next deployment",
+    });
+}
+async function handleEnvUnset(directory, keys) {
+    requireAuth();
+    const dir = directory || process.cwd();
+    const appId = await getLinkedAppId(dir);
+    if (!appId) {
+        return errorResult(`No app linked in ${dir}.`);
+    }
+    const envVars = {};
+    for (const key of keys) {
+        envVars[key] = null;
+    }
+    await apiRequest(`/api/cli/apps/${appId}/env`, {
+        method: "PATCH",
+        body: { envVars },
+    });
+    return successResult({
+        message: `Removed ${keys.length} environment variable(s)`,
+        keys,
+        note: "Changes take effect on next deployment",
+    });
+}
+async function handleDomainsList(directory) {
+    requireAuth();
+    const dir = directory || process.cwd();
+    const appId = await getLinkedAppId(dir);
+    if (!appId) {
+        return errorResult(`No app linked in ${dir}.`);
+    }
+    const { domains } = await apiRequest(`/api/cli/apps/${appId}/domains`);
+    return successResult({
+        count: domains.length,
+        domains: domains.map((d) => ({
+            id: d.id,
+            domain: d.domain,
+            verified: d.verified,
+            sslStatus: d.sslStatus,
+        })),
+    });
+}
+async function handleDomainsAdd(directory, domain, verificationMethod) {
+    requireAuth();
+    const dir = directory || process.cwd();
+    const appId = await getLinkedAppId(dir);
+    if (!appId) {
+        return errorResult(`No app linked in ${dir}.`);
+    }
+    // Normalize domain
+    const cleanDomain = domain
+        .replace(/^https?:\/\//, "")
+        .replace(/\/.*$/, "")
+        .toLowerCase();
+    const result = await apiRequest(`/api/cli/apps/${appId}/domains`, {
+        method: "POST",
+        body: {
+            domain: cleanDomain,
+            verificationMethod: verificationMethod || "cname",
+        },
+    });
+    return successResult({
+        message: `Domain ${cleanDomain} added`,
+        domain: result.domain,
+        dnsConfiguration: {
+            recordType: result.verification.type.toUpperCase(),
+            name: result.verification.name,
+            value: result.verification.value,
+        },
+        nextStep: "Add the DNS record above, then verify with funforge domains verify command",
+    });
+}
+// ============================================
+// HELPERS
+// ============================================
+function requireAuth() {
+    if (!isAuthenticated()) {
+        throw new Error("Not authenticated. User needs to run `funforge login` in their terminal first.");
+    }
+}
+function successResult(data) {
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify(data, null, 2),
+            },
+        ],
+    };
+}
+function errorResult(message) {
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({ error: message }, null, 2),
+            },
+        ],
+        isError: true,
+    };
+}
+function formatError(error) {
+    if (error instanceof ApiError) {
+        const body = error.body;
+        const message = body?.message || body?.error?.message || error.message;
+        return `API Error ${error.statusCode}: ${message}`;
+    }
+    return error instanceof Error ? error.message : String(error);
+}
+// ============================================
+// SERVER SETUP
+// ============================================
+async function main() {
+    const server = new Server({
+        name: "funforge",
+        version: "0.1.0",
+    }, {
+        capabilities: {
+            tools: {},
+        },
+    });
+    // Register tool listing handler
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        return { tools: TOOLS };
+    });
+    // Register tool call handler
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        return handleToolCall(name, args ?? {});
+    });
+    // Connect via stdio
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    // Log to stderr (stdout is for MCP protocol)
+    console.error("FunForge MCP server started");
+}
+main().catch((error) => {
+    console.error("Failed to start MCP server:", error);
+    process.exit(1);
+});

package/dist/project-config.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Project Configuration (funforge.json)
+ *
+ * Handles reading and writing funforge.json config files.
+ */
+export interface FunForgeConfig {
+    /** App ID this directory is linked to */
+    appId?: string;
+    /** App name (for display) */
+    appName?: string;
+    /** App slug (subdomain) */
+    appSlug?: string;
+    /** Build settings */
+    build?: {
+        /** Custom build command */
+        buildCommand?: string;
+        /** Custom install command */
+        installCommand?: string;
+        /** Custom start command */
+        startCommand?: string;
+        /** Node.js version */
+        nodeVersion?: string;
+    };
+    /** Port the app listens on */
+    port?: number;
+}
+/**
+ * Check if funforge.json exists in the directory
+ */
+export declare function configExists(dir?: string): Promise<boolean>;
+/**
+ * Read funforge.json from directory
+ */
+export declare function readConfig(dir?: string): Promise<FunForgeConfig | null>;
+/**
+ * Write funforge.json to directory
+ */
+export declare function writeConfig(config: FunForgeConfig, dir?: string): Promise<void>;
+/**
+ * Update funforge.json (merge with existing)
+ */
+export declare function updateConfig(updates: Partial<FunForgeConfig>, dir?: string): Promise<FunForgeConfig>;
+/**
+ * Get linked app ID from config
+ */
+export declare function getLinkedAppId(dir?: string): Promise<string | null>;
+//# sourceMappingURL=project-config.d.ts.map

package/dist/project-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-config.d.ts","sourceRoot":"","sources":["../src/project-config.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,MAAM,WAAW,cAAc;IAC7B,yCAAyC;IACzC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,6BAA6B;IAC7B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,2BAA2B;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,qBAAqB;IACrB,KAAK,CAAC,EAAE;QACN,2BAA2B;QAC3B,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,6BAA6B;QAC7B,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,2BAA2B;QAC3B,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,sBAAsB;QACtB,WAAW,CAAC,EAAE,MAAM,CAAC;KACtB,CAAC;IACF,8BAA8B;IAC9B,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAID;;GAEG;AACH,wBAAsB,YAAY,CAAC,GAAG,GAAE,MAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CAOtE;AAED;;GAEG;AACH,wBAAsB,UAAU,CAC9B,GAAG,GAAE,MAAY,GAChB,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CAOhC;AAED;;GAEG;AACH,wBAAsB,WAAW,CAC/B,MAAM,EAAE,cAAc,EACtB,GAAG,GAAE,MAAY,GAChB,OAAO,CAAC,IAAI,CAAC,CAGf;AAED;;GAEG;AACH,wBAAsB,YAAY,CAChC,OAAO,EAAE,OAAO,CAAC,cAAc,CAAC,EAChC,GAAG,GAAE,MAAY,GAChB,OAAO,CAAC,cAAc,CAAC,CAKzB;AAED;;GAEG;AACH,wBAAsB,cAAc,CAClC,GAAG,GAAE,MAAY,GAChB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAGxB"}

package/dist/project-config.js

@@ -0,0 +1,55 @@
+/**
+ * Project Configuration (funforge.json)
+ *
+ * Handles reading and writing funforge.json config files.
+ */
+import { access, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+const CONFIG_FILENAME = "funforge.json";
+/**
+ * Check if funforge.json exists in the directory
+ */
+export async function configExists(dir = ".") {
+    try {
+        await access(join(dir, CONFIG_FILENAME));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Read funforge.json from directory
+ */
+export async function readConfig(dir = ".") {
+    try {
+        const content = await readFile(join(dir, CONFIG_FILENAME), "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Write funforge.json to directory
+ */
+export async function writeConfig(config, dir = ".") {
+    const content = JSON.stringify(config, null, 2) + "\n";
+    await writeFile(join(dir, CONFIG_FILENAME), content, "utf-8");
+}
+/**
+ * Update funforge.json (merge with existing)
+ */
+export async function updateConfig(updates, dir = ".") {
+    const existing = (await readConfig(dir)) ?? {};
+    const updated = { ...existing, ...updates };
+    await writeConfig(updated, dir);
+    return updated;
+}
+/**
+ * Get linked app ID from config
+ */
+export async function getLinkedAppId(dir = ".") {
+    const config = await readConfig(dir);
+    return config?.appId ?? null;
+}

package/dist/tarball.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Tarball Utilities
+ *
+ * Creates gzipped tarballs from project directories,
+ * respecting .gitignore and .funforgeignore patterns.
+ */
+export interface TarballResult {
+    /** Path to the created tarball */
+    path: string;
+    /** Size in bytes */
+    size: number;
+    /** SHA-256 hash */
+    sha256: string;
+    /** Number of files included */
+    fileCount: number;
+}
+/**
+ * Create a gzipped tarball from a project directory
+ */
+export declare function createTarball(projectDir: string): Promise<TarballResult>;
+/**
+ * Read tarball as buffer
+ */
+export declare function readTarball(tarballPath: string): Promise<Buffer>;
+/**
+ * Format file size for display
+ */
+export declare function formatSize(bytes: number): string;
+//# sourceMappingURL=tarball.d.ts.map

package/dist/tarball.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tarball.d.ts","sourceRoot":"","sources":["../src/tarball.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AA4FH,MAAM,WAAW,aAAa;IAC5B,kCAAkC;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,oBAAoB;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,mBAAmB;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,+BAA+B;IAC/B,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,wBAAsB,aAAa,CACjC,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,aAAa,CAAC,CA8CxB;AAgBD;;GAEG;AACH,wBAAsB,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAStE;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAIhD"}