pixelmuse 0.2.0 → 0.3.0

package/README.md

@@ -29,19 +29,14 @@
 - **Built for developer workflows.** Pipe from stdin, JSON output for scripting, watch mode for prompt iteration, MCP server for AI agents.
 - **Predictable credit pricing.** 1-3 credits per generation, no surprises. Free credits on signup.
 
-## Install
+## Get Started
 
 ```bash
 npm install -g pixelmuse
+pixelmuse setup
 ```
 
-Then authenticate:
-
-```bash
-pixelmuse login
-```
-
-Sign up at [pixelmuse.studio/sign-up](https://www.pixelmuse.studio/sign-up) — new accounts include free credits.
+The setup wizard creates your account (opens browser), configures your API key, and optionally sets up the MCP server for Claude Code, Cursor, or Windsurf. New accounts include **15 free credits**.
 
 > Requires Node.js 20+. For terminal image previews, install [chafa](https://hpjansson.org/chafa/) (`brew install chafa` / `sudo apt install chafa`).
 
@@ -212,6 +207,7 @@ Pixelmuse ships four interfaces. Pick the one that fits your workflow — they a
 
 | Command | Description |
 |---------|-------------|
+| `pixelmuse setup` | First-time setup wizard (account, MCP, defaults) |
 | `pixelmuse "prompt"` | Generate an image (default command) |
 | `pixelmuse models` | List available models with costs |
 | `pixelmuse account` | Account balance and usage stats |

package/dist/{chunk-743CKPHW.js → chunk-4DZUZTTL.js}

@@ -2,7 +2,7 @@
 import {
   pollGeneration,
   slugify
-} from "./chunk-ZVJQFWUI.js";
+} from "./chunk-H6VI5DLX.js";
 import {
   autoSave,
   imageToBuffer,

package/dist/{chunk-ZVJQFWUI.js → chunk-H6VI5DLX.js}

@@ -4,9 +4,6 @@ import {
   ensureDirs
 } from "./chunk-7ARYEFAH.js";
 
-// src/core/client.ts
-import { createRequire } from "module";
-
 // src/core/types.ts
 var ApiError = class extends Error {
   constructor(message, status, code, rateLimitRemaining, retryAfter) {
@@ -20,8 +17,7 @@ var ApiError = class extends Error {
 };
 
 // src/core/client.ts
-var require2 = createRequire(import.meta.url);
-var CLI_VERSION = require2("../../package.json").version;
+var CLI_VERSION = "0.3.0";
 var BASE_URL = "https://www.pixelmuse.studio/api/v1";
 var CLIENT_HEADERS = {
   "User-Agent": `pixelmuse-cli/${CLI_VERSION}`,

package/dist/cli.js

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 import {
   generateImage
-} from "./chunk-743CKPHW.js";
+} from "./chunk-4DZUZTTL.js";
 import {
+  CLI_VERSION,
   PixelmuseClient,
   deleteApiKey,
   extractVariables,
@@ -14,19 +15,20 @@ import {
   saveApiKey,
   saveTemplate,
   slugify
-} from "./chunk-ZVJQFWUI.js";
+} from "./chunk-H6VI5DLX.js";
 import {
   renderImageDirect
 } from "./chunk-MZZY4JXW.js";
 import {
-  readSettings
+  readSettings,
+  writeSettings
 } from "./chunk-7ARYEFAH.js";
 
 // src/cli.ts
 import meow from "meow";
 import chalk from "chalk";
 import ora from "ora";
-import { readFileSync, watchFile, unwatchFile } from "fs";
+import { readFileSync as readFileSync2, watchFile, unwatchFile } from "fs";
 import { resolve } from "path";
 
 // src/core/utils.ts
@@ -39,6 +41,128 @@ function timeAgo(date) {
   return date.toLocaleDateString();
 }
 
+// src/core/device-auth.ts
+var BASE_URL = "https://www.pixelmuse.studio/api/v1";
+async function initiateDeviceAuth() {
+  const res = await fetch(`${BASE_URL}/auth/device`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "User-Agent": `pixelmuse-cli/${CLI_VERSION}`
+    },
+    body: JSON.stringify({
+      client_info: {
+        platform: process.platform,
+        cli_version: CLI_VERSION
+      }
+    })
+  });
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new Error(`Failed to initiate device auth (HTTP ${res.status}): ${body}`);
+  }
+  const data = await res.json();
+  return {
+    deviceCode: data.device_code,
+    userCode: data.user_code,
+    verificationUri: data.verification_uri,
+    verificationUriComplete: data.verification_uri_complete,
+    expiresIn: data.expires_in,
+    interval: data.interval
+  };
+}
+async function pollForToken(deviceCode, options) {
+  const deadline = Date.now() + options.expiresIn * 1e3;
+  let intervalMs = options.interval * 1e3;
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, intervalMs));
+    options.onPoll?.();
+    try {
+      const res = await fetch(`${BASE_URL}/auth/device/token`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "User-Agent": `pixelmuse-cli/${CLI_VERSION}`
+        },
+        body: JSON.stringify({
+          device_code: deviceCode,
+          grant_type: "urn:ietf:params:oauth:grant-type:device_code"
+        })
+      });
+      const data = await res.json();
+      if (data.api_key) {
+        return {
+          apiKey: data.api_key,
+          keyPrefix: data.key_prefix
+        };
+      }
+      if (data.error === "slow_down") {
+        intervalMs = (data.interval ?? 10) * 1e3;
+        continue;
+      }
+      if (data.error === "expired_token") {
+        throw new Error("Authorization timed out. Run `pixelmuse setup` to try again.");
+      }
+      if (data.error === "access_denied") {
+        throw new Error("Authorization was denied.");
+      }
+    } catch (err) {
+      if (err instanceof Error && (err.message.includes("timed out") || err.message.includes("denied"))) {
+        throw err;
+      }
+    }
+  }
+  throw new Error("Authorization timed out. Run `pixelmuse setup` to try again.");
+}
+
+// src/core/mcp-config.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { dirname, join } from "path";
+import { homedir } from "os";
+var HOME = homedir();
+var EDITORS = [
+  {
+    name: "Claude Code",
+    id: "claude-code",
+    configPath: join(HOME, ".claude", "mcp.json")
+  },
+  {
+    name: "Cursor",
+    id: "cursor",
+    configPath: join(HOME, ".cursor", "mcp.json")
+  },
+  {
+    name: "Windsurf",
+    id: "windsurf",
+    configPath: join(HOME, ".codeium", "windsurf", "mcp_config.json")
+  }
+];
+function detectEditors() {
+  return EDITORS.map((editor) => ({
+    ...editor,
+    installed: existsSync(dirname(editor.configPath))
+  }));
+}
+function configureMcp(editor, apiKey) {
+  const entry = {
+    command: "npx",
+    args: ["-y", "pixelmuse-mcp"],
+    env: { PIXELMUSE_API_KEY: apiKey }
+  };
+  let config = {};
+  if (existsSync(editor.configPath)) {
+    try {
+      config = JSON.parse(readFileSync(editor.configPath, "utf-8"));
+    } catch {
+    }
+  } else {
+    mkdirSync(dirname(editor.configPath), { recursive: true });
+  }
+  config.mcpServers = config.mcpServers ?? {};
+  config.mcpServers.pixelmuse = entry;
+  writeFileSync(editor.configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+
 // src/cli.ts
 var cli = meow(
   `
@@ -50,6 +174,7 @@ var cli = meow(
     $ echo "prompt" | pixelmuse             Pipe from stdin
 
   ${chalk.bold("Commands")}
+    pixelmuse setup                          First-time setup wizard
     pixelmuse models                         List available models
     pixelmuse account                        View balance & usage
     pixelmuse history                        Recent generations
@@ -220,7 +345,7 @@ async function handleWatch(filePath) {
   const generate = async () => {
     if (generating) return;
     generating = true;
-    const prompt = readFileSync(absPath, "utf-8").trim();
+    const prompt = readFileSync2(absPath, "utf-8").trim();
     if (!prompt) {
       generating = false;
       return;
@@ -333,9 +458,9 @@ async function handleOpen(id) {
     if (gen.output?.[0]) {
       const { imageToBuffer: imageToBuffer2, saveImage: saveImage2 } = await import("./image-2H3GUQI6.js");
       const { PATHS: PATHS2 } = await import("./config-RMVFR3GN.js");
-      const { join } = await import("path");
+      const { join: join2 } = await import("path");
       const buf = await imageToBuffer2(gen.output[0]);
-      const path = join(PATHS2.generations, `${gen.id}.png`);
+      const path = join2(PATHS2.generations, `${gen.id}.png`);
       saveImage2(buf, path);
       const { default: open } = await import("open");
       await open(path);
@@ -349,10 +474,53 @@ async function handleOpen(id) {
   }
 }
 async function handleLogin() {
+  console.log(chalk.bold("Pixelmuse Login"));
+  console.log();
+  const spinner = ora("Preparing login...").start();
+  try {
+    const init = await initiateDeviceAuth();
+    spinner.stop();
+    console.log(`  Your code: ${chalk.bold.cyan(init.userCode)}`);
+    console.log();
+    console.log(`  Opening ${chalk.underline(init.verificationUriComplete)}`);
+    console.log(`  ${chalk.gray("Or visit")} ${chalk.underline(init.verificationUri)} ${chalk.gray("and enter the code manually")}`);
+    console.log();
+    const { default: open } = await import("open");
+    await open(init.verificationUriComplete);
+    const pollSpinner = ora("Waiting for authorization...").start();
+    let dots = 0;
+    const result = await pollForToken(init.deviceCode, {
+      interval: init.interval,
+      expiresIn: init.expiresIn,
+      onPoll: () => {
+        dots = (dots + 1) % 4;
+        pollSpinner.text = `Waiting for authorization${".".repeat(dots)}`;
+      }
+    });
+    await saveApiKey(result.apiKey);
+    pollSpinner.stop();
+    const client = new PixelmuseClient(result.apiKey);
+    const account = await client.getAccount();
+    console.log(chalk.green("\u2713") + ` Authenticated as ${chalk.bold(account.email)} (${chalk.green(`${account.credits.total} credits`)})`);
+    return result.apiKey;
+  } catch (err) {
+    spinner.stop();
+    if (err instanceof Error && !err.message.includes("timed out") && !err.message.includes("denied")) {
+      console.log(chalk.gray("Browser login unavailable. Enter your API key manually."));
+    } else if (err instanceof Error) {
+      console.log(chalk.yellow(err.message));
+    }
+    return handleManualLogin();
+  }
+}
+async function handleManualLogin() {
+  console.log();
+  console.log(`  Get your key at: ${chalk.underline("https://www.pixelmuse.studio/settings/api-keys")}`);
+  console.log();
   const { createInterface } = await import("readline");
   const rl = createInterface({ input: process.stdin, output: process.stdout });
   const key = await new Promise((resolve2) => {
-    rl.question("API key (from pixelmuse.studio/settings/api-keys): ", (answer) => {
+    rl.question("API key: ", (answer) => {
       rl.close();
       resolve2(answer.trim());
     });
@@ -367,11 +535,103 @@ async function handleLogin() {
     const account = await client.getAccount();
     await saveApiKey(key);
     spinner.succeed(`Authenticated as ${chalk.bold(account.email)} (${chalk.green(`${account.credits.total} credits`)})`);
+    return key;
   } catch (err) {
     spinner.fail(err instanceof Error ? err.message : "Authentication failed");
     process.exit(1);
   }
 }
+async function handleSetup() {
+  console.log();
+  console.log(chalk.bold("  Pixelmuse Setup"));
+  console.log(chalk.gray("  AI image generation from the terminal"));
+  console.log();
+  const existingKey = await getApiKey();
+  let apiKey;
+  if (existingKey) {
+    const spinner = ora("Checking existing credentials...").start();
+    try {
+      const client = new PixelmuseClient(existingKey);
+      const account = await client.getAccount();
+      spinner.succeed(`Already authenticated as ${chalk.bold(account.email)} (${chalk.green(`${account.credits.total} credits`)})`);
+      apiKey = existingKey;
+    } catch {
+      spinner.warn("Existing credentials invalid. Re-authenticating...");
+      apiKey = await handleLogin();
+    }
+  } else {
+    console.log(chalk.bold("Step 1:") + " Authenticate");
+    console.log();
+    apiKey = await handleLogin();
+  }
+  console.log();
+  const editors = detectEditors();
+  const available = editors.filter((e) => e.installed);
+  if (available.length > 0) {
+    console.log(chalk.bold("Step 2:") + " MCP Server (AI agent integration)");
+    console.log();
+    const { createInterface } = await import("readline");
+    for (const editor of available) {
+      const rl2 = createInterface({ input: process.stdin, output: process.stdout });
+      const answer = await new Promise((resolve2) => {
+        rl2.question(`  Configure ${chalk.bold(editor.name)}? ${chalk.gray("[Y/n]")} `, (a) => {
+          rl2.close();
+          resolve2(a.trim().toLowerCase());
+        });
+      });
+      if (answer === "" || answer === "y" || answer === "yes") {
+        configureMcp(editor, apiKey);
+        console.log(chalk.green("  \u2713") + ` ${editor.name} MCP configured`);
+      } else {
+        console.log(chalk.gray(`  Skipped ${editor.name}`));
+      }
+    }
+    console.log();
+  }
+  console.log(chalk.bold(available.length > 0 ? "Step 3:" : "Step 2:") + " Defaults");
+  console.log();
+  const { createInterface: createRl } = await import("readline");
+  const rl = createRl({ input: process.stdin, output: process.stdout });
+  const customize = await new Promise((resolve2) => {
+    rl.question(`  Customize default model and settings? ${chalk.gray("[y/N]")} `, (a) => {
+      rl.close();
+      resolve2(a.trim().toLowerCase());
+    });
+  });
+  if (customize === "y" || customize === "yes") {
+    const settings = readSettings();
+    const updated = {};
+    const models = ["nano-banana-2", "nano-banana-pro", "flux-schnell", "imagen-3", "recraft-v4", "recraft-v4-pro"];
+    const aspects = ["1:1", "16:9", "9:16", "4:3", "3:4", "21:9"];
+    const styles = ["none", "realistic", "anime", "artistic"];
+    const pick = async (label, options, current) => {
+      const { createInterface } = await import("readline");
+      const rl2 = createInterface({ input: process.stdin, output: process.stdout });
+      console.log(`  ${label}: ${options.map((o) => o === current ? chalk.bold.cyan(o) : chalk.gray(o)).join(" | ")}`);
+      const answer = await new Promise((resolve2) => {
+        rl2.question(`  Choice ${chalk.gray(`[${current}]`)}: `, (a) => {
+          rl2.close();
+          resolve2(a.trim() || current);
+        });
+      });
+      return options.includes(answer) ? answer : current;
+    };
+    updated.defaultModel = await pick("Model", models, settings.defaultModel);
+    updated.defaultAspectRatio = await pick("Aspect ratio", aspects, settings.defaultAspectRatio);
+    updated.defaultStyle = await pick("Style", styles, settings.defaultStyle);
+    writeSettings({ ...settings, ...updated });
+    console.log(chalk.green("  \u2713") + " Defaults saved");
+  } else {
+    console.log(chalk.gray("  Using defaults (nano-banana-2, 1:1, no style)"));
+  }
+  console.log();
+  console.log(chalk.green.bold("  Setup complete!"));
+  console.log();
+  console.log(`  Try it: ${chalk.cyan('pixelmuse "a cat floating through space"')}`);
+  console.log(`  TUI:    ${chalk.cyan("pixelmuse ui")}`);
+  console.log(`  Help:   ${chalk.cyan("pixelmuse --help")}`);
+  console.log();
+}
 async function handleTemplate() {
   const [, templateCmd, ...templateArgs] = cli.input;
   switch (templateCmd) {
@@ -490,8 +750,11 @@ async function main() {
         process.exit(1);
       }
       return handleOpen(rest[0]);
+    case "setup":
+      return handleSetup();
     case "login":
-      return handleLogin();
+      await handleLogin();
+      return;
     case "logout":
       await deleteApiKey();
       console.log("Logged out.");

package/dist/mcp/server.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 import {
   generateImage
-} from "../chunk-743CKPHW.js";
+} from "../chunk-4DZUZTTL.js";
 import {
   CLI_VERSION,
   PixelmuseClient,
   getApiKey
-} from "../chunk-ZVJQFWUI.js";
+} from "../chunk-H6VI5DLX.js";
 import "../chunk-MZZY4JXW.js";
 import {
   readSettings

package/dist/tui.js

@@ -11,7 +11,7 @@ import {
   pollGeneration,
   saveApiKey,
   saveTemplate
-} from "./chunk-ZVJQFWUI.js";
+} from "./chunk-H6VI5DLX.js";
 import {
   autoSave,
   hasChafa,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pixelmuse",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "AI image generation from the terminal — CLI, TUI, and MCP server for text-to-image with Flux, Imagen, Recraft, and more",
   "homepage": "https://pixelmuse.studio",
   "repository": {