memes-business 0.0.1

package/README.md

@@ -0,0 +1,134 @@
+# memes-business
+
+CLI for [memes.business](https://memes.business) — generate memes from your terminal.
+
+## Installation
+
+```bash
+npm install -g memes-business
+```
+
+## Authentication
+
+Get your API key from [memes.business/settings](https://memes.business/settings), then:
+
+```bash
+memes login --api-key <your-api-key>
+```
+
+Verify you're logged in:
+
+```bash
+memes whoami
+```
+
+## Usage
+
+### Generate Memes with AI
+
+```bash
+memes generate --ai "make a meme about Monday meetings"
+```
+
+Save the generated meme to a file:
+
+```bash
+memes generate --ai "distracted boyfriend meme about coding vs debugging" --save meme.png
+```
+
+### Generate Memes Manually
+
+Search for a template:
+
+```bash
+memes search "drake"
+```
+
+Generate with specific text:
+
+```bash
+memes generate <template-id> --text "Top text" --text "Bottom text"
+```
+
+### Manage Your Memes
+
+List your saved memes:
+
+```bash
+memes library list
+```
+
+Show details of a specific meme:
+
+```bash
+memes library show <meme-id>
+```
+
+Download a meme:
+
+```bash
+memes library download <meme-id> ./my-meme.png
+```
+
+### Favorites
+
+List your favorites:
+
+```bash
+memes favorites
+memes favorites --templates  # only templates
+memes favorites --memes      # only memes
+```
+
+Toggle favorite on a template:
+
+```bash
+memes favorite <template-id>
+```
+
+### Account Status
+
+Check your usage and subscription:
+
+```bash
+memes status
+```
+
+Open billing page:
+
+```bash
+memes upgrade
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `memes login --api-key <key>` | Authenticate with your API key |
+| `memes logout` | Remove stored credentials |
+| `memes whoami` | Display current user info |
+| `memes search <query>` | Search for meme templates |
+| `memes generate --ai <prompt>` | Generate meme with AI |
+| `memes generate <id> --text <text>` | Generate meme from template |
+| `memes library list` | List your saved memes |
+| `memes library show <id>` | Show meme details |
+| `memes library download <id> [path]` | Download meme image |
+| `memes favorites` | List favorited items |
+| `memes favorite <template-id>` | Toggle favorite on template |
+| `memes status` | Show subscription status |
+| `memes upgrade` | Open billing page |
+
+## JSON Output
+
+Most commands support `--json` for scripting:
+
+```bash
+memes search "cat" --json | jq '.data[0].id'
+memes status --json
+memes whoami --json
+```
+
+## License
+
+MIT
+

package/dist/commands/auth.d.ts

@@ -0,0 +1,4 @@
+import { Command } from "commander";
+export declare function createLoginCommand(): Command;
+export declare function createLogoutCommand(): Command;
+export declare function createWhoamiCommand(): Command;

package/dist/commands/auth.js

@@ -0,0 +1,92 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { setApiKey, clearApiKey, getApiKey, CONFIG_DIR } from "../lib/config.js";
+import { getCurrentSession, verifyApiKey } from "../lib/api.js";
+export function createLoginCommand() {
+    const login = new Command("login")
+        .description("Authenticate with memes.business")
+        .option("--api-key <key>", "API key for authentication")
+        .action(async (options) => {
+        if (!options.apiKey) {
+            console.log(chalk.yellow("Please provide an API key:"));
+            console.log(chalk.dim("  memes login --api-key <your-api-key>"));
+            console.log();
+            console.log(chalk.dim("Get your API key at: https://memes.business/settings"));
+            process.exit(1);
+        }
+        const spinner = ora("Validating API key...").start();
+        const result = await verifyApiKey(options.apiKey);
+        if (result.error) {
+            spinner.fail(chalk.red(result.error.message));
+            process.exit(1);
+        }
+        await setApiKey(options.apiKey);
+        spinner.succeed(chalk.green("Logged in successfully!"));
+        console.log();
+        console.log(chalk.dim(`  User: ${result.data?.user.name}`));
+        console.log(chalk.dim(`  Email: ${result.data?.user.email}`));
+        console.log();
+        console.log(chalk.dim(`Credentials saved to ${CONFIG_DIR}`));
+    });
+    return login;
+}
+export function createLogoutCommand() {
+    const logout = new Command("logout")
+        .description("Clear stored credentials")
+        .action(async () => {
+        const apiKey = await getApiKey();
+        if (!apiKey) {
+            console.log(chalk.yellow("Not currently logged in."));
+            return;
+        }
+        const spinner = ora("Logging out...").start();
+        await clearApiKey();
+        spinner.succeed(chalk.green("Logged out successfully!"));
+        console.log(chalk.dim(`Credentials cleared from ${CONFIG_DIR}`));
+    });
+    return logout;
+}
+export function createWhoamiCommand() {
+    const whoami = new Command("whoami")
+        .description("Display current user info")
+        .option("--json", "Output as JSON")
+        .action(async (options) => {
+        const apiKey = await getApiKey();
+        if (!apiKey) {
+            if (options.json) {
+                console.log(JSON.stringify({ error: "Not logged in" }));
+            }
+            else {
+                console.log(chalk.yellow("Not logged in."));
+                console.log(chalk.dim("Run 'memes login --api-key <key>' to authenticate."));
+            }
+            process.exit(1);
+        }
+        const spinner = ora("Fetching user info...").start();
+        const result = await getCurrentSession();
+        if (result.error) {
+            spinner.fail(chalk.red(result.error.message));
+            if (options.json) {
+                console.log(JSON.stringify({ error: result.error }));
+            }
+            process.exit(1);
+        }
+        spinner.stop();
+        const user = result.data?.user;
+        if (options.json) {
+            console.log(JSON.stringify(user, null, 2));
+            return;
+        }
+        console.log(chalk.bold("Current User"));
+        console.log();
+        console.log(`  ${chalk.dim("Name:")}  ${user?.name}`);
+        console.log(`  ${chalk.dim("Email:")} ${user?.email}`);
+        console.log(`  ${chalk.dim("ID:")}    ${user?.id}`);
+        if (user?.role) {
+            console.log(`  ${chalk.dim("Role:")}  ${user.role}`);
+        }
+        console.log(`  ${chalk.dim("Verified:")} ${user?.emailVerified ? chalk.green("Yes") : chalk.yellow("No")}`);
+    });
+    return whoami;
+}

package/dist/commands/favorites.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function createFavoritesCommand(): Command;
+export declare function createFavoriteCommand(): Command;

package/dist/commands/favorites.js

@@ -0,0 +1,102 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { apiRequest } from "../lib/api.js";
+export function createFavoritesCommand() {
+    const favorites = new Command("favorites")
+        .description("List favorited templates and memes")
+        .option("--templates", "show only templates")
+        .option("--memes", "show only memes")
+        .option("--json", "output as JSON for scripting")
+        .action(async (options) => {
+        // Check for mutually exclusive flags
+        if (options.templates && options.memes) {
+            const errorMessage = "Error: --templates and --memes are mutually exclusive. Use one or the other.";
+            if (options.json) {
+                console.log(JSON.stringify({ error: { message: errorMessage } }, null, 2));
+            }
+            else {
+                console.error(chalk.red(errorMessage));
+            }
+            process.exit(1);
+        }
+        const spinner = options.json ? null : ora("Fetching favorites...").start();
+        const params = new URLSearchParams();
+        if (options.templates)
+            params.set("entity_type", "template");
+        if (options.memes)
+            params.set("entity_type", "user_meme");
+        const queryString = params.toString();
+        const path = `/api/favorites/list${queryString ? `?${queryString}` : ""}`;
+        const result = await apiRequest(path);
+        if (result.error) {
+            if (spinner)
+                spinner.fail(chalk.red(result.error.message));
+            if (options.json) {
+                console.log(JSON.stringify({ error: result.error }, null, 2));
+            }
+            process.exit(1);
+        }
+        const response = result.data;
+        if (!response || !response.data) {
+            if (spinner)
+                spinner.fail(chalk.red("Invalid response from server"));
+            if (options.json) {
+                console.log(JSON.stringify({ error: { message: "Invalid response" } }, null, 2));
+            }
+            process.exit(1);
+        }
+        if (spinner)
+            spinner.stop();
+        if (options.json) {
+            console.log(JSON.stringify(response, null, 2));
+            return;
+        }
+        const items = response.data;
+        if (items.length === 0) {
+            const filter = options.templates ? "templates" : options.memes ? "memes" : "items";
+            console.log(chalk.yellow(`No favorited ${filter} found.`));
+            return;
+        }
+        console.log(chalk.bold(`${response.meta.total_count} favorite${response.meta.total_count !== 1 ? "s" : ""}`));
+        console.log();
+        items.forEach((item, index) => {
+            const num = chalk.dim(`${(index + 1).toString().padStart(2)}.`);
+            const name = chalk.bold(item.name);
+            const type = chalk.cyan(`[${item.type}]`);
+            console.log(`${num} ${name} ${type}`);
+            console.log(chalk.dim(`    ID: ${item.id}`));
+            console.log();
+        });
+    });
+    return favorites;
+}
+export function createFavoriteCommand() {
+    const favorite = new Command("favorite")
+        .description("Toggle favorite status on a template")
+        .argument("<template-id>", "template ID to favorite/unfavorite")
+        .action(async (templateId) => {
+        const spinner = ora("Toggling favorite...").start();
+        const result = await apiRequest("/api/favorites", {
+            method: "POST",
+            body: JSON.stringify({ entity_type: "template", entity_id: templateId }),
+        });
+        if (result.error) {
+            spinner.fail(chalk.red(result.error.message));
+            process.exit(1);
+        }
+        const response = result.data;
+        if (!response || !response.data) {
+            spinner.fail(chalk.red("Invalid response from server"));
+            process.exit(1);
+        }
+        const { isFavorited, message } = response.data;
+        if (isFavorited) {
+            spinner.succeed(chalk.green(message || `Added template ${templateId} to favorites`));
+        }
+        else {
+            spinner.succeed(chalk.yellow(message || `Removed template ${templateId} from favorites`));
+        }
+    });
+    return favorite;
+}

package/dist/commands/generate.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function createGenerateCommand(): Command;

package/dist/commands/generate.js

@@ -0,0 +1,312 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { writeFile, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { apiRequest } from "../lib/api.js";
+import { getApiKey, getApiUrl } from "../lib/config.js";
+/**
+ * Make a streaming request for AI generation
+ */
+async function streamAIGeneration(prompt, onMeme, onError) {
+    const baseUrl = await getApiUrl();
+    const apiKey = await getApiKey();
+    if (!apiKey) {
+        throw new Error("Not authenticated. Run 'memes login' first.");
+    }
+    const response = await fetch(`${baseUrl}/api/generate`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "x-api-key": apiKey,
+        },
+        body: JSON.stringify({ request: prompt }),
+    });
+    if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new Error(errorData.error?.message ||
+            `HTTP ${response.status}: ${response.statusText}`);
+    }
+    const reader = response.body?.getReader();
+    if (!reader) {
+        throw new Error("No response body");
+    }
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            try {
+                let jsonStr;
+                // Handle server's numbered format: "0: {...}"
+                const numberedMatch = line.match(/^\d+:\s*(.+)$/);
+                if (numberedMatch) {
+                    jsonStr = numberedMatch[1];
+                }
+                else if (line.startsWith("data:")) {
+                    // Handle SSE format: "data: {...}"
+                    jsonStr = line.slice(5).trim();
+                }
+                else {
+                    continue;
+                }
+                if (!jsonStr || jsonStr === "[DONE]")
+                    continue;
+                const event = JSON.parse(jsonStr);
+                // Handle server's generatedMeme format
+                if (event.generatedMeme) {
+                    const meme = event.generatedMeme;
+                    onMeme({
+                        name: meme.title || meme.template_name || "Meme",
+                        texts: meme.generation_data?.texts || [],
+                        imageUrl: `${baseUrl}/api/memes/${meme.id}/image`,
+                        templateId: meme.generation_data?.template_id,
+                        memeId: meme.id,
+                    });
+                }
+                // Handle legacy SSE format
+                else if (event.type === "meme" && (event.data || event.meme)) {
+                    onMeme(event.data || event.meme);
+                }
+                else if (event.type === "error" || event.error) {
+                    onError(event.error || "Unknown error");
+                }
+            }
+            catch {
+                // Skip unparseable lines
+            }
+        }
+    }
+    // Process any remaining content in buffer after stream ends
+    if (buffer.trim()) {
+        try {
+            let jsonStr;
+            // Handle server's numbered format: "0: {...}"
+            const numberedMatch = buffer.match(/^\d+:\s*(.+)$/);
+            if (numberedMatch) {
+                jsonStr = numberedMatch[1];
+            }
+            else if (buffer.startsWith("data:")) {
+                // Handle SSE format: "data: {...}"
+                jsonStr = buffer.slice(5).trim();
+            }
+            else {
+                jsonStr = "";
+            }
+            if (jsonStr && jsonStr !== "[DONE]") {
+                const event = JSON.parse(jsonStr);
+                // Handle server's generatedMeme format
+                if (event.generatedMeme) {
+                    const meme = event.generatedMeme;
+                    onMeme({
+                        name: meme.title || meme.template_name || "Meme",
+                        texts: meme.generation_data?.texts || [],
+                        imageUrl: `${baseUrl}/api/memes/${meme.id}/image`,
+                        templateId: meme.generation_data?.template_id,
+                        memeId: meme.id,
+                    });
+                }
+                // Handle legacy SSE format
+                else if (event.type === "meme" && (event.data || event.meme)) {
+                    onMeme(event.data || event.meme);
+                }
+                else if (event.type === "error" || event.error) {
+                    onError(event.error || "Unknown error");
+                }
+            }
+        }
+        catch {
+            // Skip unparseable content
+        }
+    }
+}
+/**
+ * Check if a path is a directory
+ */
+async function isDirectory(path) {
+    try {
+        const stats = await stat(path);
+        return stats.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get file extension from content type
+ */
+function getExtensionFromContentType(contentType) {
+    if (!contentType)
+        return ".jpg";
+    if (contentType.includes("png"))
+        return ".png";
+    if (contentType.includes("gif"))
+        return ".gif";
+    if (contentType.includes("webp"))
+        return ".webp";
+    return ".jpg";
+}
+/**
+ * Download an image from URL
+ */
+async function downloadImage(imageUrl, savePath, memeId) {
+    const baseUrl = await getApiUrl();
+    const apiKey = await getApiKey();
+    // Handle relative URLs
+    const fullUrl = imageUrl.startsWith("http")
+        ? imageUrl
+        : `${baseUrl}${imageUrl}`;
+    const response = await fetch(fullUrl, {
+        headers: apiKey ? { "x-api-key": apiKey } : {},
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to download: ${response.statusText}`);
+    }
+    const contentType = response.headers.get("content-type");
+    const ext = getExtensionFromContentType(contentType);
+    // Resolve the save path (handle directory case)
+    let resolvedPath = savePath;
+    if (await isDirectory(savePath)) {
+        const filename = memeId ? `${memeId}${ext}` : `meme-${Date.now()}${ext}`;
+        resolvedPath = join(savePath, filename);
+    }
+    const buffer = await response.arrayBuffer();
+    await writeFile(resolvedPath, Buffer.from(buffer));
+    return resolvedPath;
+}
+export function createGenerateCommand() {
+    const generate = new Command("generate")
+        .description("Generate a meme from a template or AI prompt")
+        .argument("[template]", "template ID (for manual generation)")
+        .option("-t, --text <text...>", "text for each text box (manual mode)")
+        .option("-a, --ai <prompt>", "AI prompt for generation")
+        .option("-s, --save <path>", "save the meme image to a file")
+        .action(async (template, options) => {
+        const { text, ai, save } = options;
+        // Validate arguments
+        if (!template && !ai) {
+            console.log(chalk.red("Error: Provide a template ID or use --ai"));
+            console.log();
+            console.log(chalk.dim("Manual: memes generate <template-id> --text \"Top\" --text \"Bottom\""));
+            console.log(chalk.dim("AI:     memes generate --ai \"make a meme about Monday\""));
+            process.exit(1);
+        }
+        if (template && ai) {
+            console.log(chalk.red("Error: Cannot use both template and --ai"));
+            process.exit(1);
+        }
+        if (ai) {
+            await handleAIGeneration(ai, save);
+        }
+        else {
+            await handleManualGeneration(template, text || [], save);
+        }
+    });
+    return generate;
+}
+async function handleManualGeneration(templateId, texts, savePath) {
+    if (texts.length === 0) {
+        console.log(chalk.red("Error: At least one --text is required"));
+        process.exit(1);
+    }
+    const spinner = ora("Generating meme...").start();
+    const result = await apiRequest("/api/memes", {
+        method: "POST",
+        body: JSON.stringify({
+            templateId,
+            texts,
+        }),
+    });
+    if (result.error) {
+        spinner.fail(chalk.red(result.error.message));
+        process.exit(1);
+    }
+    const meme = result.data?.data;
+    if (!meme) {
+        spinner.fail(chalk.red("No meme data in response"));
+        process.exit(1);
+    }
+    spinner.succeed(chalk.green("Meme generated!"));
+    console.log();
+    console.log(`  ${chalk.dim("Title:")} ${meme.title}`);
+    console.log(`  ${chalk.dim("URL:")}   ${meme.imageUrl}`);
+    if (savePath) {
+        const saveSpinner = ora("Saving image...").start();
+        try {
+            const resolvedPath = await downloadImage(meme.imageUrl, savePath, meme.id);
+            saveSpinner.succeed(chalk.green(`Saved to ${resolvedPath}`));
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : "Unknown error";
+            saveSpinner.fail(chalk.red(`Failed to save: ${msg}`));
+        }
+    }
+}
+async function handleAIGeneration(prompt, savePath) {
+    const spinner = ora("Generating meme with AI...").start();
+    const memes = [];
+    let hasError = false;
+    let errorMsg = "";
+    try {
+        await streamAIGeneration(prompt, (meme) => {
+            memes.push(meme);
+            spinner.text = `Generated ${memes.length} meme(s)...`;
+        }, (error) => {
+            hasError = true;
+            errorMsg = error;
+        });
+    }
+    catch (err) {
+        spinner.fail(chalk.red(err instanceof Error ? err.message : "Generation failed"));
+        process.exit(1);
+    }
+    if (hasError) {
+        spinner.fail(chalk.red(errorMsg));
+        process.exit(1);
+    }
+    if (memes.length === 0) {
+        spinner.fail(chalk.red("No memes generated"));
+        process.exit(1);
+    }
+    spinner.succeed(chalk.green(`Generated ${memes.length} meme(s)!`));
+    console.log();
+    for (const meme of memes) {
+        console.log(`  ${chalk.bold(meme.name)}`);
+        console.log(`  ${chalk.dim("Texts:")} ${meme.texts.join(" | ")}`);
+        console.log(`  ${chalk.dim("URL:")}   ${meme.imageUrl}`);
+        console.log();
+    }
+    // Save memes if --save is provided
+    if (savePath && memes.length > 0) {
+        const isDir = await isDirectory(savePath);
+        const memesToSave = isDir ? memes : [memes[0]];
+        const saveSpinner = ora(`Saving ${memesToSave.length} image(s)...`).start();
+        const savedPaths = [];
+        const errors = [];
+        for (const meme of memesToSave) {
+            try {
+                const resolvedPath = await downloadImage(meme.imageUrl, savePath, meme.memeId);
+                savedPaths.push(resolvedPath);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : "Unknown error";
+                errors.push(`${meme.name}: ${msg}`);
+            }
+        }
+        if (savedPaths.length > 0) {
+            saveSpinner.succeed(chalk.green(`Saved ${savedPaths.length} image(s) to ${isDir ? savePath : savedPaths[0]}`));
+        }
+        if (errors.length > 0) {
+            for (const error of errors) {
+                console.log(chalk.red(`  ✖ ${error}`));
+            }
+        }
+    }
+}

package/dist/commands/memes.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function createMemesCommand(): Command;