pixelmuse 0.2.0

package/dist/chunk-ZVJQFWUI.js

@@ -0,0 +1,272 @@
+#!/usr/bin/env node
+import {
+  PATHS,
+  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) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.rateLimitRemaining = rateLimitRemaining;
+    this.retryAfter = retryAfter;
+    this.name = "ApiError";
+  }
+};
+
+// src/core/client.ts
+var require2 = createRequire(import.meta.url);
+var CLI_VERSION = require2("../../package.json").version;
+var BASE_URL = "https://www.pixelmuse.studio/api/v1";
+var CLIENT_HEADERS = {
+  "User-Agent": `pixelmuse-cli/${CLI_VERSION}`,
+  "X-Client-Version": CLI_VERSION,
+  "X-Client-Platform": process.platform
+};
+var PixelmuseClient = class {
+  apiKey;
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+  }
+  async request(path, options = {}) {
+    const url = `${BASE_URL}${path}`;
+    const headers = {
+      ...CLIENT_HEADERS,
+      Authorization: `Bearer ${this.apiKey}`,
+      "Content-Type": "application/json",
+      ...options.headers
+    };
+    const res = await fetch(url, { ...options, headers });
+    const rateLimitRemaining = res.headers.get("X-RateLimit-Remaining");
+    const retryAfter = res.headers.get("Retry-After");
+    if (!res.ok) {
+      let message = `HTTP ${res.status}`;
+      let code;
+      try {
+        const body = await res.json();
+        message = body.error ?? message;
+        code = body.code;
+      } catch {
+      }
+      throw new ApiError(
+        message,
+        res.status,
+        code,
+        rateLimitRemaining ? Number(rateLimitRemaining) : void 0,
+        retryAfter ? Number(retryAfter) : void 0
+      );
+    }
+    return await res.json();
+  }
+  /** Generate an image. Uses Prefer: wait=55 for sync response. */
+  async generate(req) {
+    return this.request("/images", {
+      method: "POST",
+      headers: { Prefer: "wait=55" },
+      body: JSON.stringify(req)
+    });
+  }
+  /** Get a single generation by ID */
+  async getGeneration(id) {
+    return this.request(`/images/${encodeURIComponent(id)}`);
+  }
+  /** List generations with cursor pagination */
+  async listGenerations(params) {
+    const query = new URLSearchParams();
+    if (params?.cursor) query.set("cursor", params.cursor);
+    if (params?.limit) query.set("limit", String(params.limit));
+    if (params?.status) query.set("status", params.status);
+    const qs = query.toString();
+    return this.request(`/images${qs ? `?${qs}` : ""}`);
+  }
+  /** Delete a generation */
+  async deleteGeneration(id) {
+    await this.request(`/images/${encodeURIComponent(id)}`, { method: "DELETE" });
+  }
+  /** Get account info */
+  async getAccount() {
+    return this.request("/account");
+  }
+  /** Get usage stats for a date range */
+  async getUsage(params) {
+    const query = new URLSearchParams({ start: params.start, end: params.end });
+    return this.request(`/account/usage?${query}`);
+  }
+  /** Create a Stripe checkout session */
+  async createCheckout(req) {
+    return this.request("/billing/checkout", {
+      method: "POST",
+      body: JSON.stringify(req)
+    });
+  }
+  // ── Static methods (no auth required) ──────────────────────────────
+  /** List all available models */
+  static async listModels() {
+    const res = await fetch(`${BASE_URL}/models`, { headers: CLIENT_HEADERS });
+    if (!res.ok) throw new ApiError(`HTTP ${res.status}`, res.status);
+    const body = await res.json();
+    return body.data;
+  }
+  /** Get a single model by ID */
+  static async getModel(id) {
+    const res = await fetch(`${BASE_URL}/models/${encodeURIComponent(id)}`, { headers: CLIENT_HEADERS });
+    if (!res.ok) throw new ApiError(`HTTP ${res.status}`, res.status);
+    return await res.json();
+  }
+  /** List available credit packages */
+  static async listPackages() {
+    const res = await fetch(`${BASE_URL}/billing/packages`, { headers: CLIENT_HEADERS });
+    if (!res.ok) throw new ApiError(`HTTP ${res.status}`, res.status);
+    const body = await res.json();
+    return body.data;
+  }
+};
+
+// src/core/prompts.ts
+import { existsSync, readdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { join } from "path";
+import YAML from "yaml";
+function listTemplates() {
+  ensureDirs();
+  if (!existsSync(PATHS.prompts)) return [];
+  const files = readdirSync(PATHS.prompts).filter((f) => f.endsWith(".yaml") || f.endsWith(".yml"));
+  return files.map((f) => {
+    const raw = readFileSync(join(PATHS.prompts, f), "utf-8");
+    return YAML.parse(raw);
+  });
+}
+function getTemplate(name) {
+  const slug = slugify(name);
+  const path = join(PATHS.prompts, `${slug}.yaml`);
+  if (!existsSync(path)) return null;
+  return YAML.parse(readFileSync(path, "utf-8"));
+}
+function saveTemplate(template) {
+  ensureDirs();
+  const yaml = YAML.stringify(template);
+  YAML.parse(yaml);
+  const slug = slugify(template.name);
+  const path = join(PATHS.prompts, `${slug}.yaml`);
+  writeFileSync(path, yaml, "utf-8");
+}
+function deleteTemplate(name) {
+  const slug = slugify(name);
+  const path = join(PATHS.prompts, `${slug}.yaml`);
+  if (!existsSync(path)) return false;
+  unlinkSync(path);
+  return true;
+}
+function extractVariables(prompt) {
+  const matches = prompt.match(/\{\{(\w+)\}\}/g);
+  if (!matches) return [];
+  return [...new Set(matches.map((m) => m.slice(2, -2)))];
+}
+function interpolate(prompt, vars) {
+  return prompt.replace(/\{\{(\w+)\}\}/g, (_, key) => vars[key] ?? `{{${key}}}`);
+}
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+
+// src/core/auth.ts
+import { chmodSync, existsSync as existsSync2, readFileSync as readFileSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
+var KEY_PATTERN = /^pm_(live|test)_[0-9a-f]{32}$/;
+var SERVICE = "pixelmuse-cli";
+var ACCOUNT = "api-key";
+function isValidKeyFormat(key) {
+  return KEY_PATTERN.test(key);
+}
+async function getApiKey() {
+  const envKey = process.env["PIXELMUSE_API_KEY"];
+  if (envKey) return envKey;
+  try {
+    const { getPassword } = await import("keyring-node");
+    const keychainKey = getPassword(SERVICE, ACCOUNT);
+    if (keychainKey) return keychainKey;
+  } catch {
+  }
+  if (existsSync2(PATHS.auth)) {
+    try {
+      const data = JSON.parse(readFileSync2(PATHS.auth, "utf-8"));
+      if (data.apiKey) return data.apiKey;
+    } catch {
+    }
+  }
+  return null;
+}
+async function saveApiKey(key) {
+  ensureDirs();
+  try {
+    const { setPassword } = await import("keyring-node");
+    setPassword(SERVICE, ACCOUNT, key);
+    return;
+  } catch {
+  }
+  writeFileSync2(PATHS.auth, JSON.stringify({ apiKey: key }), "utf-8");
+  chmodSync(PATHS.auth, 384);
+}
+async function deleteApiKey() {
+  try {
+    const { deletePassword } = await import("keyring-node");
+    deletePassword(SERVICE, ACCOUNT);
+  } catch {
+  }
+  if (existsSync2(PATHS.auth)) {
+    unlinkSync2(PATHS.auth);
+  }
+}
+
+// src/core/polling.ts
+var TYPICAL_DURATIONS = {
+  "flux-schnell": 12,
+  "recraft-v4": 20,
+  "recraft-v4-pro": 25
+};
+async function pollGeneration(client, id, options = {}) {
+  const { interval = 2e3, timeout = 12e4, onProgress } = options;
+  const start = Date.now();
+  let typicalDuration = 15;
+  let currentInterval = interval;
+  let model;
+  while (true) {
+    const elapsed = (Date.now() - start) / 1e3;
+    if (Date.now() - start > timeout) {
+      throw new Error(`Generation timed out after ${timeout / 1e3}s`);
+    }
+    const gen = await client.getGeneration(id);
+    if (!model && gen.model) {
+      model = gen.model;
+      typicalDuration = TYPICAL_DURATIONS[gen.model] ?? 15;
+    }
+    if (gen.status === "succeeded") return gen;
+    if (gen.status === "failed") {
+      throw new Error(gen.error ?? "Generation failed");
+    }
+    const estimatedProgress = Math.min(elapsed / typicalDuration, 0.95);
+    onProgress?.(elapsed, estimatedProgress);
+    if (elapsed > 30) currentInterval = 5e3;
+    await new Promise((r) => setTimeout(r, currentInterval));
+  }
+}
+
+export {
+  CLI_VERSION,
+  PixelmuseClient,
+  pollGeneration,
+  listTemplates,
+  getTemplate,
+  saveTemplate,
+  deleteTemplate,
+  extractVariables,
+  interpolate,
+  slugify,
+  isValidKeyFormat,
+  getApiKey,
+  saveApiKey,
+  deleteApiKey
+};