ima2-gen 1.1.13 → 1.1.16

package/lib/grokProxyLauncher.js

@@ -0,0 +1,105 @@
+import { dirname, join, delimiter } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnBin } from "../bin/lib/platform.js";
+import { config } from "../config.js";
+import { findAvailablePort } from "./runtimePorts.js";
+const rootDir = dirname(fileURLToPath(import.meta.url)).replace(/\/lib$/, "");
+function parseListeningUrl(line) {
+    const match = String(line || "").match(/https?:\/\/(?:127\.0\.0\.1|localhost):(\d+)\/v1/i);
+    if (!match)
+        return null;
+    const port = Number(match[1]);
+    return Number.isFinite(port) ? { url: match[0], port } : null;
+}
+function localBinPath() {
+    return join(rootDir, "node_modules", ".bin");
+}
+export async function startGrokProxy(options = {}) {
+    const host = options.host ?? config.grokProvider.proxyHost;
+    const requestedPort = options.port ?? config.grokProvider.proxyPort;
+    const restartDelayMs = options.restartDelayMs ?? config.grokProvider.restartDelayMs;
+    let currentChild = null;
+    let stopping = false;
+    let restartTimer = null;
+    const scheduleRestart = () => {
+        restartTimer = setTimeout(() => {
+            void spawnProxy();
+        }, restartDelayMs);
+    };
+    const spawnProxy = async () => {
+        let port;
+        try {
+            port = await findAvailablePort(requestedPort, { host });
+        }
+        catch (err) {
+            const e = err;
+            console.error(`[grok] failed to select progrok port: ${e.message || e}`);
+            if (!stopping) {
+                console.log(`[grok] retrying port selection in ${Math.round(restartDelayMs / 1000)}s...`);
+                scheduleRestart();
+            }
+            return;
+        }
+        if (port !== requestedPort) {
+            console.log(`[grok] requested port ${requestedPort}, actual port ${port}`);
+        }
+        options.onPortSelected?.({ host, port, requestedPort, url: `http://${host}:${port}/v1` });
+        console.log(`Starting bundled progrok proxy for Grok images at http://${host}:${port}/v1 (managed by ima2 serve)...`);
+        const child = spawnBin("progrok", ["proxy", "--host", host, "--port", String(port)], {
+            stdio: ["ignore", "pipe", "pipe"],
+            env: {
+                ...process.env,
+                PATH: `${localBinPath()}${delimiter}${process.env.PATH || ""}`,
+            },
+        });
+        currentChild = child;
+        child.stdout?.on("data", (d) => {
+            const msg = d.toString().trim();
+            if (!msg)
+                return;
+            console.log(`[grok] ${msg}`);
+            for (const line of msg.split(/\r?\n/)) {
+                const ready = parseListeningUrl(line);
+                if (!ready)
+                    continue;
+                console.log(`[grok] ready for ima2 Grok provider at ${ready.url}`);
+                options.onReady?.({ url: ready.url, port: ready.port, requestedPort });
+            }
+        });
+        child.stderr?.on("data", (d) => {
+            const msg = d.toString().trim();
+            if (msg)
+                console.error(`[grok] ${msg}`);
+        });
+        child.on("error", (err) => {
+            console.error(`[grok] failed to start progrok proxy: ${err.message}`);
+        });
+        child.on("exit", (code) => {
+            if (currentChild === child)
+                currentChild = null;
+            if (stopping)
+                return;
+            options.onExit?.({ code });
+            console.log(`[grok] exited with code ${code}, restarting in ${Math.round(restartDelayMs / 1000)}s...`);
+            scheduleRestart();
+        });
+    };
+    await spawnProxy();
+    return {
+        get child() {
+            return currentChild;
+        },
+        kill(signal = "SIGTERM") {
+            this.stop(signal);
+        },
+        stop(signal = "SIGTERM") {
+            stopping = true;
+            if (restartTimer)
+                clearTimeout(restartTimer);
+            try {
+                currentChild?.kill(signal);
+            }
+            catch { }
+        },
+    };
+}

package/lib/grokProxyLauncher.ts

@@ -0,0 +1,129 @@
+import type { ChildProcess } from "node:child_process";
+import { dirname, join, delimiter } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnBin } from "../bin/lib/platform.js";
+import { config } from "../config.js";
+import { findAvailablePort } from "./runtimePorts.js";
+
+const rootDir = dirname(fileURLToPath(import.meta.url)).replace(/\/lib$/, "");
+
+type GrokProxyReadyInfo = {
+  url: string;
+  port: number;
+  requestedPort: number;
+};
+
+type GrokProxyPortInfo = {
+  host: string;
+  port: number;
+  requestedPort: number;
+  url: string;
+};
+
+type GrokProxyOptions = {
+  host?: string;
+  port?: number;
+  restartDelayMs?: number;
+  onPortSelected?: (info: GrokProxyPortInfo) => void;
+  onReady?: (info: GrokProxyReadyInfo) => void;
+  onExit?: (info: { code: number | null }) => void;
+};
+
+function parseListeningUrl(line: string): { url: string; port: number } | null {
+  const match = String(line || "").match(/https?:\/\/(?:127\.0\.0\.1|localhost):(\d+)\/v1/i);
+  if (!match) return null;
+  const port = Number(match[1]);
+  return Number.isFinite(port) ? { url: match[0], port } : null;
+}
+
+function localBinPath(): string {
+  return join(rootDir, "node_modules", ".bin");
+}
+
+export async function startGrokProxy(options: GrokProxyOptions = {}) {
+  const host = options.host ?? config.grokProvider.proxyHost;
+  const requestedPort = options.port ?? config.grokProvider.proxyPort;
+  const restartDelayMs = options.restartDelayMs ?? config.grokProvider.restartDelayMs;
+  let currentChild: ChildProcess | null = null;
+  let stopping = false;
+  let restartTimer: NodeJS.Timeout | null = null;
+
+  const scheduleRestart = () => {
+    restartTimer = setTimeout(() => {
+      void spawnProxy();
+    }, restartDelayMs);
+  };
+
+  const spawnProxy = async () => {
+    let port: number;
+    try {
+      port = await findAvailablePort(requestedPort, { host });
+    } catch (err) {
+      const e = err as Error & { message?: string };
+      console.error(`[grok] failed to select progrok port: ${e.message || e}`);
+      if (!stopping) {
+        console.log(`[grok] retrying port selection in ${Math.round(restartDelayMs / 1000)}s...`);
+        scheduleRestart();
+      }
+      return;
+    }
+    if (port !== requestedPort) {
+      console.log(`[grok] requested port ${requestedPort}, actual port ${port}`);
+    }
+    options.onPortSelected?.({ host, port, requestedPort, url: `http://${host}:${port}/v1` });
+    console.log(`Starting bundled progrok proxy for Grok images at http://${host}:${port}/v1 (managed by ima2 serve)...`);
+    const child = spawnBin("progrok", ["proxy", "--host", host, "--port", String(port)], {
+      stdio: ["ignore", "pipe", "pipe"],
+      env: {
+        ...process.env,
+        PATH: `${localBinPath()}${delimiter}${process.env.PATH || ""}`,
+      },
+    });
+    currentChild = child;
+
+    child.stdout?.on("data", (d) => {
+      const msg = d.toString().trim();
+      if (!msg) return;
+      console.log(`[grok] ${msg}`);
+      for (const line of msg.split(/\r?\n/)) {
+        const ready = parseListeningUrl(line);
+        if (!ready) continue;
+        console.log(`[grok] ready for ima2 Grok provider at ${ready.url}`);
+        options.onReady?.({ url: ready.url, port: ready.port, requestedPort });
+      }
+    });
+
+    child.stderr?.on("data", (d) => {
+      const msg = d.toString().trim();
+      if (msg) console.error(`[grok] ${msg}`);
+    });
+
+    child.on("error", (err) => {
+      console.error(`[grok] failed to start progrok proxy: ${err.message}`);
+    });
+
+    child.on("exit", (code) => {
+      if (currentChild === child) currentChild = null;
+      if (stopping) return;
+      options.onExit?.({ code });
+      console.log(`[grok] exited with code ${code}, restarting in ${Math.round(restartDelayMs / 1000)}s...`);
+      scheduleRestart();
+    });
+  };
+
+  await spawnProxy();
+
+  return {
+    get child() {
+      return currentChild;
+    },
+    kill(signal: NodeJS.Signals = "SIGTERM") {
+      this.stop(signal);
+    },
+    stop(signal: NodeJS.Signals = "SIGTERM") {
+      stopping = true;
+      if (restartTimer) clearTimeout(restartTimer);
+      try { currentChild?.kill(signal); } catch {}
+    },
+  };
+}

package/lib/grokRuntime.js

@@ -0,0 +1,18 @@
+const DEFAULT_GROK_PROXY_HOST = "127.0.0.1";
+const DEFAULT_GROK_PROXY_PORT = 18645;
+function normalizeBaseUrl(url) {
+    return url.replace(/\/v1\/?$/, "").replace(/\/$/, "");
+}
+export function getGrokProxyBaseUrl(ctx = {}) {
+    const grokCfg = ctx.config?.grokProvider || {};
+    const explicitUrl = ctx.grokUrl;
+    if (explicitUrl)
+        return normalizeBaseUrl(explicitUrl);
+    const host = grokCfg.proxyHost || DEFAULT_GROK_PROXY_HOST;
+    const port = ctx.grokActualPort || grokCfg.proxyPort || DEFAULT_GROK_PROXY_PORT;
+    return `http://${host}:${port}`;
+}
+export function getGrokProxyUrl(ctx = {}, path = "/v1") {
+    const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+    return `${getGrokProxyBaseUrl(ctx)}${normalizedPath}`;
+}

package/lib/grokRuntime.ts

@@ -0,0 +1,23 @@
+import type { RouteRuntimeContext } from "./runtimeContext.js";
+
+const DEFAULT_GROK_PROXY_HOST = "127.0.0.1";
+const DEFAULT_GROK_PROXY_PORT = 18645;
+
+function normalizeBaseUrl(url: string): string {
+  return url.replace(/\/v1\/?$/, "").replace(/\/$/, "");
+}
+
+export function getGrokProxyBaseUrl(ctx: RouteRuntimeContext = {}): string {
+  const grokCfg = (ctx.config as any)?.grokProvider || {};
+  const explicitUrl = (ctx as { grokUrl?: string }).grokUrl;
+  if (explicitUrl) return normalizeBaseUrl(explicitUrl);
+
+  const host = grokCfg.proxyHost || DEFAULT_GROK_PROXY_HOST;
+  const port = (ctx as { grokActualPort?: number }).grokActualPort || grokCfg.proxyPort || DEFAULT_GROK_PROXY_PORT;
+  return `http://${host}:${port}`;
+}
+
+export function getGrokProxyUrl(ctx: RouteRuntimeContext = {}, path = "/v1"): string {
+  const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+  return `${getGrokProxyBaseUrl(ctx)}${normalizedPath}`;
+}

package/lib/grokSizeMapper.js

@@ -0,0 +1,63 @@
+const SUPPORTED_ASPECTS = [
+    "1:1",
+    "16:9",
+    "9:16",
+    "4:3",
+    "3:4",
+    "3:2",
+    "2:3",
+    "2:1",
+    "1:2",
+    "19.5:9",
+    "9:19.5",
+    "20:9",
+    "9:20",
+];
+const PRESET_MAP = {
+    "1024x1024": { aspect_ratio: "1:1", resolution: "1k" },
+    "1536x1024": { aspect_ratio: "3:2", resolution: "1k" },
+    "1024x1536": { aspect_ratio: "2:3", resolution: "1k" },
+    "1360x1024": { aspect_ratio: "4:3", resolution: "1k" },
+    "1024x1360": { aspect_ratio: "3:4", resolution: "1k" },
+    "1824x1024": { aspect_ratio: "16:9", resolution: "1k" },
+    "1024x1824": { aspect_ratio: "9:16", resolution: "1k" },
+    "2048x2048": { aspect_ratio: "1:1", resolution: "2k" },
+    "2048x1152": { aspect_ratio: "16:9", resolution: "2k" },
+    "1152x2048": { aspect_ratio: "9:16", resolution: "2k" },
+    "3840x2160": { aspect_ratio: "16:9", resolution: "2k" },
+    "2160x3840": { aspect_ratio: "9:16", resolution: "2k" },
+};
+function parseSize(size) {
+    const match = /^(\d+)x(\d+)$/.exec(size);
+    if (!match)
+        return null;
+    const w = Number(match[1]);
+    const h = Number(match[2]);
+    return Number.isFinite(w) && Number.isFinite(h) && w > 0 && h > 0 ? { w, h } : null;
+}
+function aspectValue(aspect) {
+    const [w, h] = aspect.split(":").map(Number);
+    return w / h;
+}
+function closestAspect(w, h) {
+    const target = w / h;
+    return SUPPORTED_ASPECTS.reduce((best, aspect) => {
+        const bestDistance = Math.abs(Math.log(target / aspectValue(best)));
+        const distance = Math.abs(Math.log(target / aspectValue(aspect)));
+        return distance < bestDistance ? aspect : best;
+    }, "1:1");
+}
+export function mapSizeToGrokImageParams(size) {
+    if (!size || size === "auto")
+        return { aspect_ratio: "auto" };
+    const preset = PRESET_MAP[size];
+    if (preset)
+        return preset;
+    const parsed = parseSize(size);
+    if (!parsed)
+        return { aspect_ratio: "auto" };
+    return {
+        aspect_ratio: closestAspect(parsed.w, parsed.h),
+        resolution: Math.max(parsed.w, parsed.h) >= 2048 || parsed.w * parsed.h >= 2_000_000 ? "2k" : "1k",
+    };
+}

package/lib/grokSizeMapper.ts

@@ -0,0 +1,71 @@
+export type GrokImageSizeParams = {
+  aspect_ratio?: string;
+  resolution?: "1k" | "2k";
+};
+
+const SUPPORTED_ASPECTS = [
+  "1:1",
+  "16:9",
+  "9:16",
+  "4:3",
+  "3:4",
+  "3:2",
+  "2:3",
+  "2:1",
+  "1:2",
+  "19.5:9",
+  "9:19.5",
+  "20:9",
+  "9:20",
+] as const;
+
+const PRESET_MAP: Record<string, GrokImageSizeParams> = {
+  "1024x1024": { aspect_ratio: "1:1", resolution: "1k" },
+  "1536x1024": { aspect_ratio: "3:2", resolution: "1k" },
+  "1024x1536": { aspect_ratio: "2:3", resolution: "1k" },
+  "1360x1024": { aspect_ratio: "4:3", resolution: "1k" },
+  "1024x1360": { aspect_ratio: "3:4", resolution: "1k" },
+  "1824x1024": { aspect_ratio: "16:9", resolution: "1k" },
+  "1024x1824": { aspect_ratio: "9:16", resolution: "1k" },
+  "2048x2048": { aspect_ratio: "1:1", resolution: "2k" },
+  "2048x1152": { aspect_ratio: "16:9", resolution: "2k" },
+  "1152x2048": { aspect_ratio: "9:16", resolution: "2k" },
+  "3840x2160": { aspect_ratio: "16:9", resolution: "2k" },
+  "2160x3840": { aspect_ratio: "9:16", resolution: "2k" },
+};
+
+function parseSize(size: string): { w: number; h: number } | null {
+  const match = /^(\d+)x(\d+)$/.exec(size);
+  if (!match) return null;
+  const w = Number(match[1]);
+  const h = Number(match[2]);
+  return Number.isFinite(w) && Number.isFinite(h) && w > 0 && h > 0 ? { w, h } : null;
+}
+
+function aspectValue(aspect: string): number {
+  const [w, h] = aspect.split(":").map(Number);
+  return w / h;
+}
+
+function closestAspect(w: number, h: number): string {
+  const target = w / h;
+  return SUPPORTED_ASPECTS.reduce((best, aspect) => {
+    const bestDistance = Math.abs(Math.log(target / aspectValue(best)));
+    const distance = Math.abs(Math.log(target / aspectValue(aspect)));
+    return distance < bestDistance ? aspect : best;
+  }, "1:1");
+}
+
+export function mapSizeToGrokImageParams(size: string | null | undefined): GrokImageSizeParams {
+  if (!size || size === "auto") return { aspect_ratio: "auto" };
+  const preset = PRESET_MAP[size];
+  if (preset) return preset;
+
+  const parsed = parseSize(size);
+  if (!parsed) return { aspect_ratio: "auto" };
+
+  return {
+    aspect_ratio: closestAspect(parsed.w, parsed.h),
+    resolution: Math.max(parsed.w, parsed.h) >= 2048 || parsed.w * parsed.h >= 2_000_000 ? "2k" : "1k",
+  };
+}