heyhank 0.1.0

package/server/google-media.ts

@@ -0,0 +1,342 @@
+// ─── Google Media APIs ───────────────────────────────────────────────────────
+// Image generation (Imagen 4 + Gemini) and Video generation (Veo) via Google AI APIs
+
+import { mkdirSync, writeFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { HEYHANK_HOME } from "./paths.js";
+import { getSettings } from "./settings-manager.js";
+
+// ─── Constants ───────────────────────────────────────────────────────────────
+
+const MEDIA_DIR = join(HEYHANK_HOME, "media");
+const API_KEY = () => getSettings().geminiApiKey || process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY || "";
+
+// Models that use the predict endpoint (Imagen)
+const PREDICT_MODELS = new Set([
+  "imagen-4.0-generate-001",
+  "imagen-4.0-ultra-generate-001",
+  "imagen-4.0-fast-generate-001",
+]);
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export interface ImageGenerationResult {
+  filename: string;
+  path: string;
+  mimeType: string;
+  prompt: string;
+  model: string;
+}
+
+export interface VideoGenerationResult {
+  operationName: string;
+  status: "pending" | "completed" | "failed";
+  prompt: string;
+  model: string;
+  videoPath?: string;
+}
+
+// ─── Image Generation ────────────────────────────────────────────────────────
+
+/**
+ * Generate an image. Dispatches to the right API based on model:
+ * - imagen-4.0-*: uses predict endpoint
+ * - gemini-*: uses generateContent with IMAGE modality
+ */
+export async function generateImage(
+  prompt: string,
+  opts?: {
+    model?: string;
+    aspectRatio?: string;
+    numberOfImages?: number;
+  },
+): Promise<ImageGenerationResult[]> {
+  const apiKey = API_KEY();
+  if (!apiKey) throw new Error("GOOGLE_API_KEY not configured");
+
+  mkdirSync(MEDIA_DIR, { recursive: true });
+
+  const model = opts?.model || "imagen-4.0-fast-generate-001";
+
+  if (PREDICT_MODELS.has(model)) {
+    return generateImageImagen(prompt, model, apiKey, opts);
+  }
+  return generateImageGemini(prompt, model, apiKey);
+}
+
+/** Imagen 4.0 via predict endpoint */
+async function generateImageImagen(
+  prompt: string,
+  model: string,
+  apiKey: string,
+  opts?: { aspectRatio?: string; numberOfImages?: number },
+): Promise<ImageGenerationResult[]> {
+  const response = await fetch(
+    `https://generativelanguage.googleapis.com/v1beta/models/${model}:predict?key=${apiKey}`,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        instances: [{ prompt }],
+        parameters: {
+          sampleCount: opts?.numberOfImages || 1,
+          aspectRatio: opts?.aspectRatio || "1:1",
+        },
+      }),
+    },
+  );
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Imagen API error ${response.status}: ${text}`);
+  }
+
+  const data = await response.json() as {
+    predictions?: Array<{
+      bytesBase64Encoded?: string;
+      mimeType?: string;
+    }>;
+  };
+
+  const results: ImageGenerationResult[] = [];
+  for (const pred of data.predictions || []) {
+    if (pred.bytesBase64Encoded) {
+      const mime = pred.mimeType || "image/png";
+      const ext = mime.includes("png") ? "png" : "jpg";
+      const filename = `img_${Date.now()}_${Math.random().toString(36).slice(2, 8)}.${ext}`;
+      const filepath = join(MEDIA_DIR, filename);
+      writeFileSync(filepath, Buffer.from(pred.bytesBase64Encoded, "base64"));
+      results.push({ filename, path: filepath, mimeType: mime, prompt, model });
+    }
+  }
+
+  if (results.length === 0) throw new Error("No image generated by Imagen");
+  return results;
+}
+
+/** Gemini models with IMAGE response modality */
+async function generateImageGemini(
+  prompt: string,
+  model: string,
+  apiKey: string,
+): Promise<ImageGenerationResult[]> {
+  const response = await fetch(
+    `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${apiKey}`,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        contents: [{ parts: [{ text: `Generate an image: ${prompt}` }] }],
+        generationConfig: { responseModalities: ["TEXT", "IMAGE"] },
+      }),
+    },
+  );
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Gemini image API error ${response.status}: ${text}`);
+  }
+
+  const data = await response.json() as {
+    candidates?: Array<{
+      content?: {
+        parts?: Array<{
+          text?: string;
+          inlineData?: { mimeType: string; data: string };
+        }>;
+      };
+    }>;
+  };
+
+  const results: ImageGenerationResult[] = [];
+  for (const candidate of data.candidates || []) {
+    for (const part of candidate.content?.parts || []) {
+      if (part.inlineData) {
+        const ext = part.inlineData.mimeType === "image/png" ? "png" : "jpg";
+        const filename = `img_${Date.now()}_${Math.random().toString(36).slice(2, 8)}.${ext}`;
+        const filepath = join(MEDIA_DIR, filename);
+        writeFileSync(filepath, Buffer.from(part.inlineData.data, "base64"));
+        results.push({ filename, path: filepath, mimeType: part.inlineData.mimeType, prompt, model });
+      }
+    }
+  }
+
+  if (results.length === 0) {
+    const textResponse = data.candidates?.[0]?.content?.parts?.find(p => p.text)?.text;
+    throw new Error(
+      textResponse
+        ? `Model returned text instead of image: ${textResponse.slice(0, 200)}`
+        : "No image generated",
+    );
+  }
+
+  return results;
+}
+
+// ─── Video Generation (Veo) ──────────────────────────────────────────────────
+
+/**
+ * Start video generation using Google's Veo model.
+ * Returns an operation that can be polled for completion.
+ */
+export async function generateVideo(
+  prompt: string,
+  opts?: {
+    model?: string;
+    durationSeconds?: number;
+    aspectRatio?: string;
+    imageUri?: string;
+  },
+): Promise<VideoGenerationResult> {
+  const apiKey = API_KEY();
+  if (!apiKey) throw new Error("GOOGLE_API_KEY not configured");
+
+  mkdirSync(MEDIA_DIR, { recursive: true });
+
+  const model = opts?.model || "veo-3.1-fast-generate-preview";
+
+  const requestBody: Record<string, unknown> = {
+    instances: [
+      {
+        prompt,
+        ...(opts?.imageUri ? { image: { gcsUri: opts.imageUri } } : {}),
+      },
+    ],
+    parameters: {
+      aspectRatio: opts?.aspectRatio || "16:9",
+      durationSeconds: opts?.durationSeconds || 5,
+      sampleCount: 1,
+      personGeneration: "allow_adult",
+    },
+  };
+
+  const response = await fetch(
+    `https://generativelanguage.googleapis.com/v1beta/models/${model}:predictLongRunning?key=${apiKey}`,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(requestBody),
+    },
+  );
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Veo API error ${response.status}: ${text}`);
+  }
+
+  const data = await response.json() as {
+    name?: string;
+    done?: boolean;
+    error?: { message: string };
+  };
+
+  if (data.error) {
+    throw new Error(`Veo error: ${data.error.message}`);
+  }
+
+  return {
+    operationName: data.name || "unknown",
+    status: data.done ? "completed" : "pending",
+    prompt,
+    model,
+  };
+}
+
+/**
+ * Poll a Veo video generation operation for completion.
+ */
+export async function pollVideoOperation(
+  operationName: string,
+): Promise<VideoGenerationResult & { videoData?: string }> {
+  const apiKey = API_KEY();
+  if (!apiKey) throw new Error("GOOGLE_API_KEY not configured");
+
+  const response = await fetch(
+    `https://generativelanguage.googleapis.com/v1beta/${operationName}?key=${apiKey}`,
+  );
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Poll error ${response.status}: ${text}`);
+  }
+
+  const data = await response.json() as {
+    name: string;
+    done?: boolean;
+    error?: { message: string };
+    response?: {
+      // Veo format: generateVideoResponse with download URIs
+      generateVideoResponse?: {
+        generatedSamples?: Array<{
+          video?: { uri?: string; encoding?: string };
+        }>;
+      };
+      // Legacy format: predictions with base64
+      predictions?: Array<{
+        bytesBase64Encoded?: string;
+        mimeType?: string;
+      }>;
+    };
+  };
+
+  if (data.error) {
+    return { operationName, status: "failed", prompt: "", model: "" };
+  }
+
+  if (!data.done) {
+    return { operationName, status: "pending", prompt: "", model: "" };
+  }
+
+  mkdirSync(MEDIA_DIR, { recursive: true });
+  let videoPath: string | undefined;
+
+  // Try Veo format first (download URI)
+  const sample = data.response?.generateVideoResponse?.generatedSamples?.[0];
+  if (sample?.video?.uri) {
+    const apiKey = API_KEY();
+    const videoUrl = sample.video.uri.includes("?")
+      ? `${sample.video.uri}&key=${apiKey}`
+      : `${sample.video.uri}?key=${apiKey}`;
+    const videoResponse = await fetch(videoUrl);
+    if (videoResponse.ok) {
+      const buffer = Buffer.from(await videoResponse.arrayBuffer());
+      const filename = `vid_${Date.now()}_${Math.random().toString(36).slice(2, 8)}.mp4`;
+      videoPath = join(MEDIA_DIR, filename);
+      writeFileSync(videoPath, buffer);
+    }
+  }
+
+  // Fallback: predictions with base64
+  if (!videoPath) {
+    const prediction = data.response?.predictions?.[0];
+    if (prediction?.bytesBase64Encoded) {
+      const ext = prediction.mimeType === "video/webm" ? "webm" : "mp4";
+      const filename = `vid_${Date.now()}_${Math.random().toString(36).slice(2, 8)}.${ext}`;
+      videoPath = join(MEDIA_DIR, filename);
+      writeFileSync(videoPath, Buffer.from(prediction.bytesBase64Encoded, "base64"));
+    }
+  }
+
+  return {
+    operationName,
+    status: "completed",
+    prompt: "",
+    model: "",
+    videoPath,
+    videoData: videoPath ? "(saved to disk)" : undefined,
+  };
+}
+
+/** List generated media files. */
+export function listMedia(): Array<{ filename: string; path: string }> {
+  mkdirSync(MEDIA_DIR, { recursive: true });
+  try {
+    const files = readdirSync(MEDIA_DIR) as string[];
+    return files.map((f: string) => ({
+      filename: f,
+      path: join(MEDIA_DIR, f),
+    }));
+  } catch {
+    return [];
+  }
+}

package/server/image-pull-manager.ts

@@ -0,0 +1,279 @@
+import { join, dirname } from "node:path";
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { containerManager, ContainerManager } from "./container-manager.js";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface ImagePullState {
+  image: string;
+  status: "idle" | "pulling" | "ready" | "error";
+  /** Last N lines of pull/build output (ring buffer) */
+  progress: string[];
+  error?: string;
+  startedAt?: number;
+  completedAt?: number;
+}
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+const MAX_PROGRESS_LINES = 50;
+const WEB_DIR = dirname(fileURLToPath(import.meta.url));
+
+// ---------------------------------------------------------------------------
+// ImagePullManager — singleton that tracks background image pulls
+// ---------------------------------------------------------------------------
+
+type ReadyListener = () => void;
+
+class ImagePullManager {
+  private states = new Map<string, ImagePullState>();
+  /** Listeners waiting for a specific image to become ready */
+  private readyListeners = new Map<string, ReadyListener[]>();
+
+  /**
+   * Get the current state for an image.
+   * If the image exists locally and we have no tracking entry, return "ready".
+   */
+  getState(image: string): ImagePullState {
+    const existing = this.states.get(image);
+    if (existing) return existing;
+
+    // Check if already available locally
+    const ready = containerManager.imageExists(image);
+    return {
+      image,
+      status: ready ? "ready" : "idle",
+      progress: [],
+    };
+  }
+
+  /** Quick check: is the image available locally right now? */
+  isReady(image: string): boolean {
+    return this.getState(image).status === "ready";
+  }
+
+  /**
+   * Ensure the image is available. Starts a background pull if missing.
+   * No-op if already pulling or ready.
+   */
+  ensureImage(image: string): void {
+    const state = this.getState(image);
+    if (state.status === "ready" || state.status === "pulling") return;
+    this.startPull(image);
+  }
+
+  /**
+   * Wait for an image that is currently pulling to become ready.
+   * Resolves true if ready, false if pull failed or timed out.
+   * If image is already ready, resolves immediately.
+   */
+  waitForReady(image: string, timeoutMs = 300_000): Promise<boolean> {
+    const state = this.getState(image);
+    if (state.status === "ready") return Promise.resolve(true);
+    if (state.status === "error") return Promise.resolve(false);
+    if (state.status === "idle") {
+      // Not pulling yet — start it
+      this.startPull(image);
+    }
+
+    return new Promise<boolean>((resolve) => {
+      let settled = false;
+      const done = (result: boolean) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        // Clean up the listener to avoid memory leaks
+        const arr = this.readyListeners.get(image);
+        if (arr) {
+          const idx = arr.indexOf(listener);
+          if (idx >= 0) arr.splice(idx, 1);
+          if (arr.length === 0) this.readyListeners.delete(image);
+        }
+        resolve(result);
+      };
+
+      const timer = setTimeout(() => done(false), timeoutMs);
+
+      const listener: ReadyListener = () => {
+        const s = this.getState(image);
+        if (s.status === "ready") done(true);
+        else if (s.status === "error") done(false);
+        // else still pulling — keep waiting
+      };
+
+      const listeners = this.readyListeners.get(image) ?? [];
+      listeners.push(listener);
+      this.readyListeners.set(image, listeners);
+
+      // Re-check after registering the listener to catch races where
+      // the pull completed synchronously before the listener was added.
+      const currentState = this.getState(image);
+      if (currentState.status === "ready") done(true);
+      else if (currentState.status === "error") done(false);
+    });
+  }
+
+  /**
+   * Trigger a pull even if image is already present (for updates).
+   */
+  pull(image: string): void {
+    const state = this.getState(image);
+    if (state.status === "pulling") return; // already in progress
+    this.startPull(image);
+  }
+
+  /**
+   * Subscribe to progress lines for a specific image.
+   * Returns an unsubscribe function.
+   * The callback fires for each new progress line while pulling.
+   */
+  onProgress(image: string, cb: (line: string) => void): () => void {
+    const key = `progress:${image}`;
+    const listeners = (this.progressListeners.get(key) ?? []);
+    listeners.push(cb);
+    this.progressListeners.set(key, listeners);
+    return () => {
+      const arr = this.progressListeners.get(key);
+      if (arr) {
+        const idx = arr.indexOf(cb);
+        if (idx >= 0) arr.splice(idx, 1);
+      }
+    };
+  }
+  private progressListeners = new Map<string, Array<(line: string) => void>>();
+
+  /**
+   * On server startup, check all environments and pre-pull missing images.
+   * Environments no longer carry Docker fields — this is now a no-op stub
+   * kept for backwards compatibility with callers.
+   */
+  initFromEnvironments(): void {
+    // Environments no longer have imageTag/baseImage (moved to Sandboxes).
+    // Nothing to pre-pull from envs.
+  }
+
+  // ─── Internal ─────────────────────────────────────────────────────────────
+
+  private startPull(image: string): void {
+    const state: ImagePullState = {
+      image,
+      status: "pulling",
+      progress: [],
+      startedAt: Date.now(),
+    };
+    this.states.set(image, state);
+
+    // Determine if we can pull from registry
+    const registryImage = ContainerManager.getRegistryImage(image);
+
+    if (registryImage) {
+      this.doPullFromRegistry(image, registryImage);
+    } else {
+      // No registry mapping — mark as error since we can't pull custom images
+      this.markError(image, `No registry mapping for image "${image}". Build it from a Dockerfile instead.`);
+    }
+  }
+
+  private async doPullFromRegistry(localTag: string, registryImage: string): Promise<void> {
+    try {
+      const pulled = await containerManager.pullImage(registryImage, localTag, (line) => {
+        this.appendProgress(localTag, line);
+      });
+
+      if (pulled) {
+        this.markReady(localTag);
+      } else {
+        // Pull failed — try local build for default image
+        if (localTag === "the-companion:latest") {
+          this.appendProgress(localTag, "Pull failed, falling back to local build...");
+          await this.doLocalBuild(localTag);
+        } else {
+          this.markError(localTag, "Pull failed from registry");
+        }
+      }
+    } catch (e) {
+      const reason = e instanceof Error ? e.message : String(e);
+      // Try local build fallback for default image
+      if (localTag === "the-companion:latest") {
+        this.appendProgress(localTag, `Pull error (${reason}), falling back to local build...`);
+        await this.doLocalBuild(localTag);
+      } else {
+        this.markError(localTag, reason);
+      }
+    }
+  }
+
+  private async doLocalBuild(localTag: string): Promise<void> {
+    const dockerfilePath = join(WEB_DIR, "docker", "Dockerfile.the-companion");
+    if (!existsSync(dockerfilePath)) {
+      this.markError(localTag, `Dockerfile not found at ${dockerfilePath}`);
+      return;
+    }
+
+    try {
+      this.appendProgress(localTag, `Building ${localTag} from local Dockerfile...`);
+      containerManager.buildImage(dockerfilePath, localTag);
+      this.markReady(localTag);
+    } catch (e) {
+      const reason = e instanceof Error ? e.message : String(e);
+      this.markError(localTag, `Build failed: ${reason}`);
+    }
+  }
+
+  private appendProgress(image: string, line: string): void {
+    const state = this.states.get(image);
+    if (!state) return;
+    state.progress.push(line);
+    if (state.progress.length > MAX_PROGRESS_LINES) {
+      state.progress.splice(0, state.progress.length - MAX_PROGRESS_LINES);
+    }
+
+    // Notify progress listeners
+    const key = `progress:${image}`;
+    const listeners = this.progressListeners.get(key);
+    if (listeners) {
+      for (const cb of listeners) {
+        try { cb(line); } catch { /* ignore */ }
+      }
+    }
+  }
+
+  private markReady(image: string): void {
+    const state = this.states.get(image);
+    if (state) {
+      state.status = "ready";
+      state.completedAt = Date.now();
+      this.appendProgress(image, "Image ready");
+    }
+    this.notifyListeners(image);
+  }
+
+  private markError(image: string, error: string): void {
+    const state = this.states.get(image);
+    if (state) {
+      state.status = "error";
+      state.error = error;
+      state.completedAt = Date.now();
+      this.appendProgress(image, `Error: ${error}`);
+    }
+    this.notifyListeners(image);
+  }
+
+  private notifyListeners(image: string): void {
+    const listeners = this.readyListeners.get(image);
+    if (listeners) {
+      for (const listener of listeners) {
+        try { listener(); } catch { /* ignore */ }
+      }
+      this.readyListeners.delete(image);
+    }
+  }
+}
+
+// Singleton export
+export const imagePullManager = new ImagePullManager();