memes-business 0.0.1

package/dist/commands/memes.js

@@ -0,0 +1,236 @@
+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 { confirm } from "@inquirer/prompts";
+import { apiRequest } from "../lib/api.js";
+import { getApiKey, getApiUrl } from "../lib/config.js";
+/**
+ * Check if a path is a directory
+ */
+async function isDirectory(path) {
+    try {
+        const stats = await stat(path);
+        return stats.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Download an image from URL
+ */
+async function downloadImage(imageUrl, savePath, memeId) {
+    const baseUrl = await getApiUrl();
+    const apiKey = await getApiKey();
+    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}`);
+    }
+    // Resolve the save path (handle directory case)
+    let resolvedPath = savePath;
+    if (await isDirectory(savePath)) {
+        const filename = memeId ? `${memeId}.png` : `meme-${Date.now()}.png`;
+        resolvedPath = join(savePath, filename);
+    }
+    const buffer = await response.arrayBuffer();
+    await writeFile(resolvedPath, Buffer.from(buffer));
+    return resolvedPath;
+}
+export function createMemesCommand() {
+    const memes = new Command("library")
+        .description("Manage your saved memes");
+    // List subcommand
+    memes
+        .command("list")
+        .description("List your saved memes")
+        .option("-p, --page <number>", "page number", "1")
+        .option("-l, --limit <number>", "results per page", "10")
+        .option("--json", "output as JSON for scripting")
+        .action(async (options) => {
+        const page = parseInt(options.page, 10);
+        const limit = parseInt(options.limit, 10);
+        if (isNaN(page) || page < 1) {
+            console.error(chalk.red("Error: --page must be a positive number"));
+            process.exit(1);
+        }
+        if (isNaN(limit) || limit < 1) {
+            console.error(chalk.red("Error: --limit must be a positive number"));
+            process.exit(1);
+        }
+        const spinner = options.json ? null : ora("Fetching memes...").start();
+        const result = await apiRequest(`/api/memes?page=${page}&perPage=${limit}`);
+        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?.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 memesList = response.data;
+        const { pagination } = response.meta;
+        if (memesList.length === 0) {
+            console.log(chalk.yellow("No memes found."));
+            return;
+        }
+        console.log(chalk.bold(`Your Memes (Page ${pagination.currentPage}/${pagination.totalPages})`));
+        console.log(chalk.dim(`Showing ${memesList.length} of ${pagination.totalItems} total`));
+        console.log();
+        memesList.forEach((meme, index) => {
+            const num = chalk.dim(`${((pagination.currentPage - 1) * pagination.perPage + index + 1).toString().padStart(2)}.`);
+            const title = chalk.bold(meme.title);
+            const vis = meme.isPublic ? chalk.green("public") : chalk.dim("private");
+            const date = new Date(meme.createdAt).toLocaleDateString();
+            console.log(`${num} ${title} ${vis}`);
+            console.log(chalk.dim(`    ID: ${meme.id}`));
+            if (meme.templateName)
+                console.log(chalk.dim(`    Template: ${meme.templateName}`));
+            console.log(chalk.dim(`    Created: ${date}`));
+            console.log();
+        });
+        if (pagination.hasNext) {
+            console.log(chalk.dim(`Next page: memes library list --page ${pagination.currentPage + 1}`));
+        }
+    });
+    // Show subcommand
+    memes
+        .command("show")
+        .description("Show details of a specific meme")
+        .argument("<id>", "meme ID")
+        .option("--json", "output as JSON for scripting")
+        .action(async (id, options) => {
+        const spinner = options.json ? null : ora("Fetching meme details...").start();
+        const result = await apiRequest(`/api/memes/${id}`);
+        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 meme = result.data;
+        if (!meme) {
+            if (spinner)
+                spinner.fail(chalk.red("Meme not found"));
+            if (options.json)
+                console.log(JSON.stringify({ error: { message: "Meme not found" } }, null, 2));
+            process.exit(1);
+        }
+        if (spinner)
+            spinner.stop();
+        if (options.json) {
+            console.log(JSON.stringify(meme, null, 2));
+            return;
+        }
+        console.log(chalk.bold(meme.title));
+        console.log();
+        console.log(`  ${chalk.dim("ID:")}       ${meme.id}`);
+        if (meme.description)
+            console.log(`  ${chalk.dim("Desc:")}     ${meme.description}`);
+        console.log(`  ${chalk.dim("Image:")}    ${meme.imageUrl}`);
+        if (meme.templateName)
+            console.log(`  ${chalk.dim("Template:")} ${meme.templateName}`);
+        console.log(`  ${chalk.dim("Visibility:")} ${meme.isPublic ? chalk.green("public") : chalk.dim("private")}`);
+        if (meme.width && meme.height)
+            console.log(`  ${chalk.dim("Size:")}     ${meme.width}x${meme.height}`);
+        if (meme.fileSize)
+            console.log(`  ${chalk.dim("File:")}     ${(meme.fileSize / 1024).toFixed(1)} KB`);
+        console.log(`  ${chalk.dim("Created:")}  ${new Date(meme.createdAt).toLocaleString()}`);
+        console.log(`  ${chalk.dim("Updated:")}  ${new Date(meme.updatedAt).toLocaleString()}`);
+    });
+    // Download subcommand
+    memes
+        .command("download")
+        .description("Download a meme image to disk")
+        .argument("<id>", "meme ID")
+        .argument("[path]", "output file path", "./meme.png")
+        .action(async (id, savePath) => {
+        const spinner = ora("Fetching meme info...").start();
+        const result = await apiRequest(`/api/memes/${id}`);
+        if (result.error) {
+            spinner.fail(chalk.red(result.error.message));
+            process.exit(1);
+        }
+        const meme = result.data;
+        if (!meme) {
+            spinner.fail(chalk.red("Meme not found"));
+            process.exit(1);
+        }
+        spinner.text = "Downloading image...";
+        try {
+            const resolvedPath = await downloadImage(meme.imageUrl, savePath, meme.id);
+            spinner.succeed(chalk.green(`Saved to ${resolvedPath}`));
+            console.log(chalk.dim(`  Title: ${meme.title}`));
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : "Unknown error";
+            spinner.fail(chalk.red(`Failed to download: ${msg}`));
+            process.exit(1);
+        }
+    });
+    // Delete subcommand
+    memes
+        .command("delete")
+        .description("Delete a meme")
+        .argument("<id>", "meme ID")
+        .option("-y, --yes", "skip confirmation prompt")
+        .action(async (id, options) => {
+        // First fetch the meme to show what we're deleting
+        const infoSpinner = ora("Fetching meme info...").start();
+        const infoResult = await apiRequest(`/api/memes/${id}`);
+        if (infoResult.error) {
+            infoSpinner.fail(chalk.red(infoResult.error.message));
+            process.exit(1);
+        }
+        const meme = infoResult.data;
+        if (!meme) {
+            infoSpinner.fail(chalk.red("Meme not found"));
+            process.exit(1);
+        }
+        infoSpinner.stop();
+        console.log(chalk.yellow(`About to delete: ${chalk.bold(meme.title)}`));
+        console.log(chalk.dim(`  ID: ${meme.id}`));
+        console.log();
+        // Confirm deletion unless --yes flag provided
+        if (!options.yes) {
+            const confirmed = await confirm({
+                message: "Are you sure you want to delete this meme?",
+                default: false,
+            });
+            if (!confirmed) {
+                console.log(chalk.dim("Cancelled."));
+                return;
+            }
+        }
+        const deleteSpinner = ora("Deleting meme...").start();
+        const deleteResult = await apiRequest(`/api/memes/${id}`, {
+            method: "DELETE",
+        });
+        if (deleteResult.error) {
+            deleteSpinner.fail(chalk.red(deleteResult.error.message));
+            process.exit(1);
+        }
+        deleteSpinner.succeed(chalk.green("Meme deleted successfully!"));
+    });
+    return memes;
+}

package/dist/commands/search.d.ts

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

package/dist/commands/search.js

@@ -0,0 +1,68 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { apiRequest } from "../lib/api.js";
+export function createSearchCommand() {
+    const search = new Command("search")
+        .description("Search for meme templates")
+        .argument("<query>", "search query")
+        .option("-l, --limit <number>", "maximum number of results", "10")
+        .option("--json", "output as JSON for scripting")
+        .action(async (query, options) => {
+        const limit = parseInt(options.limit, 10);
+        if (isNaN(limit) || limit < 1) {
+            console.error(chalk.red("Error: --limit must be a positive number"));
+            process.exit(1);
+        }
+        const spinner = options.json ? null : ora("Searching templates...").start();
+        const result = await apiRequest(`/api/templates/search?q=${encodeURIComponent(query)}&limit=${limit}`);
+        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();
+        // JSON output for scripting
+        if (options.json) {
+            console.log(JSON.stringify(response, null, 2));
+            return;
+        }
+        // Human-readable output
+        const templates = response.data;
+        if (templates.length === 0) {
+            console.log(chalk.yellow(`No templates found for "${query}"`));
+            return;
+        }
+        console.log(chalk.bold(`Found ${response.meta.totalResults} template${response.meta.totalResults !== 1 ? "s" : ""} for "${query}"`));
+        console.log();
+        templates.forEach((template, index) => {
+            const num = chalk.dim(`${(index + 1).toString().padStart(2)}.`);
+            const name = chalk.bold(template.name);
+            const score = chalk.cyan(`${(template.similarity * 100).toFixed(1)}%`);
+            const boxes = chalk.dim(`(${template.numTextBoxes} text box${template.numTextBoxes !== 1 ? "es" : ""})`);
+            console.log(`${num} ${name} ${boxes} ${score}`);
+            if (template.description) {
+                const desc = template.description.length > 80
+                    ? template.description.slice(0, 77) + "..."
+                    : template.description;
+                console.log(chalk.dim(`    ${desc}`));
+            }
+            console.log(chalk.dim(`    ID: ${template.id}`));
+            console.log();
+        });
+    });
+    return search;
+}

package/dist/commands/status.d.ts

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

package/dist/commands/status.js

@@ -0,0 +1,89 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import open from "open";
+import { apiRequest } from "../lib/api.js";
+import { getApiKey, getApiUrl } from "../lib/config.js";
+export function createStatusCommand() {
+    const status = new Command("status")
+        .description("Show subscription status and usage")
+        .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 = options.json ? null : ora("Fetching usage status...").start();
+        const result = await apiRequest("/api/generations/remaining");
+        if (result.error) {
+            if (spinner)
+                spinner.fail(chalk.red(result.error.message));
+            if (options.json) {
+                console.log(JSON.stringify({ error: result.error }));
+            }
+            process.exit(1);
+        }
+        if (spinner)
+            spinner.stop();
+        const data = result.data?.data;
+        if (!data) {
+            if (spinner)
+                spinner.fail(chalk.red("Invalid response from server"));
+            if (options.json) {
+                console.log(JSON.stringify({ error: { message: "Invalid response" } }));
+            }
+            process.exit(1);
+        }
+        if (options.json) {
+            console.log(JSON.stringify(data, null, 2));
+            return;
+        }
+        const remaining = data.generationLimit - data.currentGenerations;
+        const planType = data.generationLimit > 10 ? "Pro" : "Free";
+        console.log(chalk.bold("Subscription Status"));
+        console.log();
+        console.log(`  ${chalk.dim("Plan:")}        ${planType === "Pro" ? chalk.green(planType) : chalk.yellow(planType)}`);
+        console.log(`  ${chalk.dim("Generations:")} ${data.currentGenerations} / ${data.generationLimit} used`);
+        console.log(`  ${chalk.dim("Remaining:")}   ${remaining > 0 ? chalk.green(remaining) : chalk.red(remaining)}`);
+        console.log();
+        if (remaining <= 0) {
+            console.log(chalk.yellow("You've used all your generations for this period."));
+            console.log(chalk.dim("Run 'memes upgrade' to get more generations."));
+        }
+        else if (remaining <= 5) {
+            console.log(chalk.yellow(`Only ${remaining} generation(s) remaining.`));
+        }
+    });
+    return status;
+}
+export function createUpgradeCommand() {
+    const upgrade = new Command("upgrade")
+        .description("Open billing page to upgrade or manage subscription")
+        .action(async () => {
+        const apiKey = await getApiKey();
+        if (!apiKey) {
+            console.log(chalk.yellow("Not logged in."));
+            console.log(chalk.dim("Run 'memes login --api-key <key>' to authenticate."));
+            process.exit(1);
+        }
+        const baseUrl = await getApiUrl();
+        const accountUrl = `${baseUrl}/account`;
+        console.log(chalk.dim(`Opening ${accountUrl}...`));
+        try {
+            await open(accountUrl);
+            console.log(chalk.green("Opened billing page in your browser."));
+        }
+        catch {
+            console.log(chalk.yellow("Could not open browser automatically."));
+            console.log(chalk.dim(`Visit: ${accountUrl}`));
+        }
+    });
+    return upgrade;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { createLoginCommand, createLogoutCommand, createWhoamiCommand, } from "./commands/auth.js";
+import { createFavoriteCommand, createFavoritesCommand } from "./commands/favorites.js";
+import { createGenerateCommand } from "./commands/generate.js";
+import { createSearchCommand } from "./commands/search.js";
+import { createMemesCommand } from "./commands/memes.js";
+import { createStatusCommand, createUpgradeCommand } from "./commands/status.js";
+const program = new Command();
+program
+    .name("memes")
+    .description("CLI for memes.business")
+    .version("0.0.1");
+// Auth commands
+program.addCommand(createLoginCommand());
+program.addCommand(createLogoutCommand());
+program.addCommand(createWhoamiCommand());
+// Search command
+program.addCommand(createSearchCommand());
+// Generate command
+program.addCommand(createGenerateCommand());
+// Favorites commands
+program.addCommand(createFavoritesCommand());
+program.addCommand(createFavoriteCommand());
+// Memes library command
+program.addCommand(createMemesCommand());
+// Status commands
+program.addCommand(createStatusCommand());
+program.addCommand(createUpgradeCommand());
+program.parse();

package/dist/lib/api.d.ts

@@ -0,0 +1,45 @@
+export interface ApiError {
+    error: {
+        code: string;
+        message: string;
+        details?: Record<string, unknown>;
+    };
+}
+export interface ApiResponse<T> {
+    data?: T;
+    error?: ApiError["error"];
+}
+export interface User {
+    id: string;
+    name: string;
+    email: string;
+    emailVerified: boolean;
+    image?: string | null;
+    role?: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface Session {
+    id: string;
+    userId: string;
+    token: string;
+    expiresAt: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface SessionResponse {
+    user: User;
+    session: Session;
+}
+/**
+ * Make an authenticated API request
+ */
+export declare function apiRequest<T>(path: string, options?: RequestInit): Promise<ApiResponse<T>>;
+/**
+ * Get the current user session
+ */
+export declare function getCurrentSession(): Promise<ApiResponse<SessionResponse>>;
+/**
+ * Verify if an API key is valid by attempting to get session
+ */
+export declare function verifyApiKey(apiKey: string): Promise<ApiResponse<SessionResponse>>;

package/dist/lib/api.js

@@ -0,0 +1,127 @@
+import { getApiKey, getApiUrl } from "./config.js";
+/**
+ * Create headers for API requests with authentication
+ */
+async function createHeaders() {
+    const headers = new Headers({
+        "Content-Type": "application/json",
+    });
+    const apiKey = await getApiKey();
+    if (apiKey) {
+        // better-auth API key plugin expects the key in x-api-key header
+        headers.set("x-api-key", apiKey);
+    }
+    return headers;
+}
+/**
+ * Make an authenticated API request
+ */
+export async function apiRequest(path, options = {}) {
+    const baseUrl = await getApiUrl();
+    const url = `${baseUrl}${path}`;
+    const headers = await createHeaders();
+    // Merge provided headers with auth headers
+    if (options.headers) {
+        const providedHeaders = new Headers(options.headers);
+        providedHeaders.forEach((value, key) => {
+            headers.set(key, value);
+        });
+    }
+    try {
+        const response = await fetch(url, {
+            ...options,
+            headers,
+        });
+        const contentType = response.headers.get("content-type");
+        if (!contentType?.includes("application/json")) {
+            if (!response.ok) {
+                return {
+                    error: {
+                        code: "HTTP_ERROR",
+                        message: `HTTP ${response.status}: ${response.statusText}`,
+                    },
+                };
+            }
+            return { data: undefined };
+        }
+        const data = (await response.json());
+        if (!response.ok) {
+            if (data.error) {
+                return { error: data.error };
+            }
+            return {
+                error: {
+                    code: "HTTP_ERROR",
+                    message: `HTTP ${response.status}: ${response.statusText}`,
+                },
+            };
+        }
+        return { data };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        return {
+            error: {
+                code: "NETWORK_ERROR",
+                message: `Failed to connect: ${message}`,
+            },
+        };
+    }
+}
+/**
+ * Get the current user session
+ */
+export async function getCurrentSession() {
+    return apiRequest("/api/auth/get-session");
+}
+/**
+ * Verify if an API key is valid by attempting to get session
+ */
+export async function verifyApiKey(apiKey) {
+    const baseUrl = await getApiUrl();
+    const url = `${baseUrl}/api/auth/get-session`;
+    try {
+        const response = await fetch(url, {
+            headers: {
+                "Content-Type": "application/json",
+                "x-api-key": apiKey,
+            },
+        });
+        const contentType = response.headers.get("content-type");
+        if (!contentType?.includes("application/json")) {
+            if (!response.ok) {
+                return {
+                    error: {
+                        code: "HTTP_ERROR",
+                        message: `HTTP ${response.status}: ${response.statusText}`,
+                    },
+                };
+            }
+            return {
+                error: {
+                    code: "INVALID_API_KEY",
+                    message: "Invalid API key or API key not found",
+                },
+            };
+        }
+        const data = (await response.json());
+        if (!response.ok || !data?.user) {
+            return {
+                error: {
+                    code: "INVALID_API_KEY",
+                    message: "Invalid API key or API key not found",
+                },
+            };
+        }
+        return { data: data };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        return {
+            error: {
+                code: "NETWORK_ERROR",
+                message: `Failed to connect: ${message}`,
+            },
+        };
+    }
+}

package/dist/lib/config.d.ts

@@ -0,0 +1,36 @@
+export interface Config {
+    apiKey?: string;
+    apiUrl?: string;
+}
+declare const CONFIG_DIR: string;
+declare const CONFIG_FILE: string;
+/**
+ * Load configuration from disk
+ */
+export declare function loadConfig(): Promise<Config>;
+/**
+ * Save configuration to disk
+ * Sets restrictive permissions (0600) since config contains API keys
+ */
+export declare function saveConfig(config: Config): Promise<void>;
+/**
+ * Get the API key from config
+ */
+export declare function getApiKey(): Promise<string | undefined>;
+/**
+ * Set the API key in config
+ */
+export declare function setApiKey(apiKey: string): Promise<void>;
+/**
+ * Clear the API key from config
+ */
+export declare function clearApiKey(): Promise<void>;
+/**
+ * Get the API URL from config
+ */
+export declare function getApiUrl(): Promise<string>;
+/**
+ * Check if user is authenticated
+ */
+export declare function isAuthenticated(): Promise<boolean>;
+export { CONFIG_DIR, CONFIG_FILE };