@rohitaryal/whisk-api 3.0.0 → 3.0.1

package/dist/Cli.d.ts

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

package/dist/Cli.js

@@ -0,0 +1,270 @@
+#!/usr/bin/env node
+import yargs from "yargs";
+import { hideBin } from 'yargs/helpers';
+import { Whisk } from "./Whisk.js";
+import { imageToBase64 } from "./Utils.js";
+import { ImageAspectRatio, ImageGenerationModel, VideoGenerationModel } from "./Constants.js";
+const y = yargs(hideBin(process.argv));
+await y
+    .scriptName("whisk")
+    .usage('$0 <cmd> [args]')
+    .command("generate", "Generate new images using a temporary project", (yargs) => {
+    return yargs
+        .option("prompt", {
+        alias: "p",
+        describe: "Description of the image",
+        type: "string",
+        demandOption: true,
+    })
+        .option("model", {
+        alias: "m",
+        describe: "Image generation model",
+        type: "string",
+        default: "IMAGEN_3_5",
+        choices: Object.keys(ImageGenerationModel)
+    })
+        .option("aspect", {
+        alias: "a",
+        describe: "Aspect ratio",
+        type: "string",
+        default: "LANDSCAPE",
+        choices: ["SQUARE", "PORTRAIT", "LANDSCAPE"]
+    })
+        .option("seed", {
+        alias: "s",
+        describe: "Seed value (0 for random)",
+        type: "number",
+        default: 0,
+    })
+        .option("dir", {
+        alias: "d",
+        describe: "Output directory",
+        type: "string",
+        default: "./output",
+    })
+        .option("cookie", {
+        alias: "c",
+        describe: "Google account cookie",
+        type: "string",
+        demandOption: true,
+    });
+}, async (argv) => {
+    const whisk = new Whisk(argv.cookie);
+    await whisk.account.refresh();
+    console.log(whisk.account.toString());
+    console.log("[*] Initializing session...");
+    const project = await whisk.newProject(`CLI-Gen-${Date.now()}`);
+    console.log(`[*] Created temporary workflow: ${project.projectId}`);
+    try {
+        console.log("[*] Generating image...");
+        const aspectKey = argv.aspect;
+        const aspectVal = ImageAspectRatio[aspectKey];
+        const media = await project.generateImage({
+            prompt: argv.prompt,
+            model: ImageGenerationModel[argv.model],
+            aspectRatio: aspectVal,
+            seed: argv.seed
+        });
+        const savedPath = media.save(argv.dir);
+        console.log(`[+] Image generated successfully!`);
+        console.log(`[+] Saved to: ${savedPath}`);
+        console.log(`[+] ID: ${media.mediaGenerationId}`);
+    }
+    catch (error) {
+        console.error("[!] Generation failed:", error);
+    }
+})
+    .command("animate <mediaId>", "Animate an existing landscape image into a video", (yargs) => {
+    return yargs
+        .positional("mediaId", {
+        describe: "The ID of the image to animate",
+        type: "string",
+        demandOption: true
+    })
+        .option("script", {
+        alias: "s",
+        describe: "Prompt/Script for the video animation",
+        type: "string",
+        demandOption: true
+    })
+        .option("model", {
+        alias: "m",
+        describe: "Video generation model",
+        type: "string",
+        default: "VEO_FAST_3_1",
+        choices: Object.keys(VideoGenerationModel)
+    })
+        .option("dir", {
+        alias: "d",
+        describe: "Output directory",
+        type: "string",
+        default: "./output",
+    })
+        .option("cookie", {
+        alias: "c",
+        describe: "Google account cookie",
+        type: "string",
+        demandOption: true,
+    });
+}, async (argv) => {
+    const whisk = new Whisk(argv.cookie);
+    await whisk.account.refresh();
+    console.log(whisk.account.toString());
+    console.log("[*] Fetching original media...");
+    try {
+        const originalMedia = await Whisk.getMedia(argv.mediaId, whisk.account);
+        console.log("[*] Requesting animation (this takes time)...");
+        const videoMedia = await originalMedia.animate(argv.script, VideoGenerationModel[argv.model]);
+        const savedPath = videoMedia.save(argv.dir);
+        console.log(`[+] Video generated successfully!`);
+        console.log(`[+] Saved to: ${savedPath}`);
+    }
+    catch (error) {
+        console.error("[!] Animation failed:", error);
+    }
+})
+    .command("refine <mediaId>", "Edit/Refine an existing image", (yargs) => {
+    return yargs
+        .positional("mediaId", {
+        describe: "The ID of the image to refine",
+        type: "string",
+        demandOption: true
+    })
+        .option("prompt", {
+        alias: "p",
+        describe: "Instruction for editing (e.g., 'Make it snowy')",
+        type: "string",
+        demandOption: true
+    })
+        .option("dir", {
+        alias: "d",
+        describe: "Output directory",
+        type: "string",
+        default: "./output",
+    })
+        .option("cookie", {
+        alias: "c",
+        describe: "Google account cookie",
+        type: "string",
+        demandOption: true,
+    });
+}, async (argv) => {
+    const whisk = new Whisk(argv.cookie);
+    await whisk.account.refresh();
+    console.log(whisk.account.toString());
+    console.log("[*] Fetching original media...");
+    try {
+        const originalMedia = await Whisk.getMedia(argv.mediaId, whisk.account);
+        console.log("[*] Refining image...");
+        const refinedMedia = await originalMedia.refine(argv.prompt);
+        const savedPath = refinedMedia.save(argv.dir);
+        console.log(`[+] Image refined successfully!`);
+        console.log(`[+] Saved to: ${savedPath}`);
+    }
+    catch (error) {
+        console.error("[!] Refinement failed:", error);
+    }
+})
+    .command("caption", "Generate captions for a local image file", (yargs) => {
+    return yargs
+        .option("file", {
+        alias: "f",
+        describe: "Path to local image file",
+        type: "string",
+        demandOption: true
+    })
+        .option("count", {
+        alias: "n",
+        describe: "Number of captions",
+        type: "number",
+        default: 1
+    })
+        .option("cookie", {
+        alias: "c",
+        describe: "Google account cookie",
+        type: "string",
+        demandOption: true,
+    });
+}, async (argv) => {
+    const whisk = new Whisk(argv.cookie);
+    await whisk.account.refresh();
+    console.log(whisk.account.toString());
+    console.log("[*] Reading file and generating captions...");
+    try {
+        const base64 = await imageToBase64(argv.file);
+        // Split at the comma to get the raw base64 string
+        const rawBase64 = base64.split(",")[1];
+        const captions = await Whisk.generateCaption(rawBase64, whisk.account, argv.count);
+        console.log("\n--- Captions ---");
+        captions.forEach((cap, i) => {
+            console.log(`[${i + 1}] ${cap}`);
+        });
+    }
+    catch (error) {
+        console.error("[!] Captioning failed:", error);
+    }
+})
+    .command("fetch <mediaId>", "Download an existing generated media by ID", (yargs) => {
+    return yargs
+        .positional("mediaId", {
+        describe: "Unique ID of generated media",
+        type: "string",
+        demandOption: true,
+    })
+        .option("dir", {
+        alias: "d",
+        describe: "Output directory",
+        type: "string",
+        default: "./output",
+    })
+        .option("cookie", {
+        alias: "c",
+        describe: "Google account cookie",
+        type: "string",
+        demandOption: true,
+    });
+}, async (argv) => {
+    const whisk = new Whisk(argv.cookie);
+    await whisk.account.refresh();
+    console.log(whisk.account.toString());
+    try {
+        console.log(`[*] Fetching media info for ${argv.mediaId}...`);
+        const media = await Whisk.getMedia(argv.mediaId, whisk.account);
+        const savedPath = media.save(argv.dir);
+        console.log(`[+] Downloaded successfully to: ${savedPath}`);
+    }
+    catch (error) {
+        console.error("[!] Fetch failed:", error);
+    }
+})
+    .command("delete <mediaId>", "Delete a generated media from the cloud", (yargs) => {
+    return yargs
+        .positional("mediaId", {
+        describe: "Unique ID of generated media to delete",
+        type: "string",
+        demandOption: true,
+    })
+        .option("cookie", {
+        alias: "c",
+        describe: "Google account cookie",
+        type: "string",
+        demandOption: true,
+    });
+}, async (argv) => {
+    const whisk = new Whisk(argv.cookie);
+    await whisk.account.refresh();
+    console.log(whisk.account.toString());
+    try {
+        console.log(`[*] Deleting media ${argv.mediaId}...`);
+        await Whisk.deleteMedia(argv.mediaId, whisk.account);
+        console.log(`[+] Media deleted.`);
+    }
+    catch (error) {
+        console.error("[!] Delete failed:", error);
+    }
+})
+    .demandCommand(1, "You need to provide a command")
+    .strict()
+    .help()
+    .alias("help", "h")
+    .parse();

package/dist/Constants.d.ts

@@ -0,0 +1,37 @@
+export declare const ImageExtension: Readonly<{
+    readonly JPG: "jpg";
+    readonly JPEG: "jpeg";
+    readonly PNG: "png";
+    readonly GIF: "gif";
+    readonly WEBP: "webp";
+    readonly AVIF: "avif";
+    readonly HEIC: "heic";
+    readonly HEIF: "heif";
+    readonly BMP: "bmp";
+    readonly TIF: "tif";
+    readonly TIFF: "tiff";
+    readonly SVG: "svg";
+    readonly ICO: "ico";
+}>;
+export declare const ImageAspectRatio: Readonly<{
+    readonly SQUARE: "IMAGE_ASPECT_RATIO_SQUARE";
+    readonly PORTRAIT: "IMAGE_ASPECT_RATIO_PORTRAIT";
+    readonly LANDSCAPE: "IMAGE_ASPECT_RATIO_LANDSCAPE";
+    readonly UNSPECIFIED: "IMAGE_ASPECT_RATIO_UNSPECIFIED";
+}>;
+export declare const VideoAspectRatio: Readonly<{
+    readonly SQUARE: "VIDEO_ASPECT_RATIO_SQUARE";
+    readonly PORTRAIT: "VIDEO_ASPECT_RATIO_PORTRAIT";
+    readonly LANDSCAPE: "VIDEO_ASPECT_RATIO_LANDSCAPE";
+    readonly UNSPECIFIED: "VIDEO_ASPECT_RATIO_UNSPECIFIED";
+}>;
+export declare const ImageGenerationModel: Readonly<{
+    readonly IMAGEN_3_5: "IMAGEN_3_5";
+}>;
+export declare const ImageRefinementModel: Readonly<{
+    GEM_PIX: "GEM_PIX";
+}>;
+export declare const VideoGenerationModel: Readonly<{
+    readonly VEO_3_1: "VEO_3_1_I2V_12STEP";
+    readonly VEO_FAST_3_1: "veo_3_1_i2v_s_fast";
+}>;

package/dist/Constants.js

@@ -0,0 +1,37 @@
+export const ImageExtension = Object.freeze({
+    JPG: "jpg",
+    JPEG: "jpeg",
+    PNG: "png",
+    GIF: "gif",
+    WEBP: "webp",
+    AVIF: "avif",
+    HEIC: "heic",
+    HEIF: "heif",
+    BMP: "bmp",
+    TIF: "tif",
+    TIFF: "tiff",
+    SVG: "svg",
+    ICO: "ico"
+});
+export const ImageAspectRatio = Object.freeze({
+    SQUARE: "IMAGE_ASPECT_RATIO_SQUARE",
+    PORTRAIT: "IMAGE_ASPECT_RATIO_PORTRAIT",
+    LANDSCAPE: "IMAGE_ASPECT_RATIO_LANDSCAPE",
+    UNSPECIFIED: "IMAGE_ASPECT_RATIO_UNSPECIFIED",
+});
+export const VideoAspectRatio = Object.freeze({
+    SQUARE: "VIDEO_ASPECT_RATIO_SQUARE",
+    PORTRAIT: "VIDEO_ASPECT_RATIO_PORTRAIT",
+    LANDSCAPE: "VIDEO_ASPECT_RATIO_LANDSCAPE",
+    UNSPECIFIED: "VIDEO_ASPECT_RATIO_UNSPECIFIED",
+});
+export const ImageGenerationModel = Object.freeze({
+    IMAGEN_3_5: "IMAGEN_3_5",
+});
+export const ImageRefinementModel = Object.freeze({
+    GEM_PIX: "GEM_PIX",
+});
+export const VideoGenerationModel = Object.freeze({
+    VEO_3_1: "VEO_3_1_I2V_12STEP",
+    VEO_FAST_3_1: "veo_3_1_i2v_s_fast",
+});

package/dist/Media.d.ts

@@ -0,0 +1,47 @@
+import { type Account } from "./Whisk.js";
+import type { VideoAspectRatioType, ImageAspectRatioType, ImageGenerationModelType, MediaConfig, VideoGenerationModelType, ImageRefinementModelType } from "./Types.js";
+export declare class Media {
+    readonly seed: number;
+    readonly prompt: string;
+    readonly refined?: boolean;
+    readonly workflowId: string;
+    readonly encodedMedia: string;
+    readonly mediaGenerationId: string;
+    readonly mediaType: "VIDEO" | "IMAGE";
+    readonly aspectRatio: ImageAspectRatioType | VideoAspectRatioType;
+    readonly model: ImageGenerationModelType | VideoGenerationModelType | ImageRefinementModelType;
+    readonly account: Account;
+    constructor(mediaConfig: MediaConfig);
+    /**
+     * Deletes the generated media
+     */
+    deleteMedia(): Promise<void>;
+    /**
+    * Image to Text but doesn't support videos
+    *
+    * @param count Number of captions to generate (min: 1, max: 8)
+    */
+    caption(count?: number): Promise<string[]>;
+    /**
+     * Refine/Edit an image using nano banana
+     *
+     * @param edit Refinement prompt
+     * @returns Refined image
+     */
+    refine(edit: string): Promise<Media>;
+    /**
+    * Initiates video animation request
+    * Note: Only landscape images can be animated
+    *
+    * @param videoScript Video script to be followed
+    * @param model Video generation model to be used
+    */
+    animate(videoScript: string, model: VideoGenerationModelType): Promise<Media>;
+    /**
+         * Saves the media to the local disk
+         *
+         * @param directory Directory path to save the media (default: current directory)
+         * @returns The absolute path of the saved file
+         */
+    save(directory?: string): string;
+}

package/dist/Media.js

@@ -0,0 +1,191 @@
+import fs from "fs";
+import { Whisk } from "./Whisk.js";
+import { request } from "./Utils.js";
+import { VideoGenerationModel } from "./Constants.js";
+import path from "path";
+export class Media {
+    seed;
+    prompt;
+    refined;
+    workflowId;
+    encodedMedia;
+    mediaGenerationId;
+    mediaType;
+    aspectRatio;
+    model;
+    account;
+    constructor(mediaConfig) {
+        if (!(mediaConfig.encodedMedia)?.trim?.()) {
+            throw new Error("invalid or empty media");
+        }
+        this.seed = mediaConfig.seed;
+        this.prompt = mediaConfig.prompt;
+        this.workflowId = mediaConfig.workflowId;
+        this.encodedMedia = mediaConfig.encodedMedia;
+        this.mediaGenerationId = mediaConfig.mediaGenerationId;
+        this.aspectRatio = mediaConfig.aspectRatio;
+        this.mediaType = mediaConfig.mediaType;
+        this.model = mediaConfig.model;
+        this.refined = mediaConfig.refined;
+        this.account = mediaConfig.account;
+    }
+    /**
+     * Deletes the generated media
+     */
+    async deleteMedia() {
+        await Whisk.deleteMedia(this.mediaGenerationId, this.account);
+    }
+    /**
+    * Image to Text but doesn't support videos
+    *
+    * @param count Number of captions to generate (min: 1, max: 8)
+    */
+    async caption(count = 1) {
+        if (this.mediaType === "VIDEO") {
+            throw new Error("videos can't be captioned");
+        }
+        if (count <= 0 || count > 8) {
+            throw new Error("count must be in between 0 and 9 (0 < count < 9)");
+        }
+        return await Whisk.generateCaption(this.encodedMedia, this.account, count);
+    }
+    /**
+     * Refine/Edit an image using nano banana
+     *
+     * @param edit Refinement prompt
+     * @returns Refined image
+     */
+    async refine(edit) {
+        if (this.mediaType === "VIDEO") {
+            throw new Error("can't refine a video");
+        }
+        const refinementResult = await request("https://labs.google/fx/api/trpc/backbone.editImage", {
+            headers: { cookie: this.account.getCookie() },
+            body: JSON.stringify({
+                "json": {
+                    "clientContext": {
+                        "workflowId": this.workflowId
+                    },
+                    "imageModelSettings": {
+                        "aspectRatio": this.aspectRatio,
+                        "imageModel": "GEM_PIX",
+                    },
+                    "editInput": {
+                        "caption": this.prompt,
+                        "userInstruction": edit,
+                        "seed": null,
+                        "safetyMode": null,
+                        "originalMediaGenerationId": this.mediaGenerationId,
+                        "mediaInput": {
+                            "mediaCategory": "MEDIA_CATEGORY_BOARD",
+                            "rawBytes": this.encodedMedia
+                        }
+                    }
+                },
+                "meta": {
+                    "values": {
+                        "editInput.seed": ["undefined"],
+                        "editInput.safetyMode": ["undefined"]
+                    }
+                }
+            })
+        });
+        const img = refinementResult.imagePanels[0].generatedImages[0];
+        return new Media({
+            seed: this.seed,
+            prompt: img.prompt,
+            workflowId: img.workflowId,
+            encodedMedia: img.encodedImage,
+            mediaGenerationId: this.mediaGenerationId,
+            refined: true,
+            aspectRatio: img.aspectRatio,
+            mediaType: "IMAGE",
+            model: img.imageModel,
+            account: this.account,
+        });
+    }
+    /**
+    * Initiates video animation request
+    * Note: Only landscape images can be animated
+    *
+    * @param videoScript Video script to be followed
+    * @param model Video generation model to be used
+    */
+    async animate(videoScript, model) {
+        if (this.mediaType === "VIDEO") {
+            throw new Error("can't animate a video");
+        }
+        if (this.aspectRatio !== "IMAGE_ASPECT_RATIO_LANDSCAPE") {
+            throw new Error("only landscape images can be animated");
+        }
+        if (!Object.values(VideoGenerationModel).includes(model)) {
+            throw new Error(`'${model}': invalid video generation model provided`);
+        }
+        const videoStatusResults = await request("https://aisandbox-pa.googleapis.com/v1/whisk:generateVideo", {
+            headers: {
+                "Authorization": `Bearer ${await this.account.getToken()}`
+            },
+            body: JSON.stringify({
+                "promptImageInput": {
+                    "prompt": this.prompt,
+                    "rawBytes": this.encodedMedia,
+                },
+                "modelNameType": model,
+                "modelKey": "",
+                "userInstructions": videoScript,
+                "loopVideo": false,
+                "clientContext": { "workflowId": this.workflowId },
+            })
+        });
+        let i = 0;
+        const id = videoStatusResults.operation.operation.name;
+        while (true) {
+            i++;
+            const videoResults = await request("https://aisandbox-pa.googleapis.com/v1:runVideoFxSingleClipsStatusCheck", {
+                headers: {
+                    "Authorization": `Bearer ${await this.account.getToken()}`
+                },
+                body: JSON.stringify({ "operations": [{ "operation": { "name": id } }] })
+            });
+            // Await for 2 second before each request
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            if (videoResults.status === "MEDIA_GENERATION_STATUS_SUCCESSFUL") {
+                const video = videoResults.operation.metadata.video;
+                return new Media({
+                    seed: video.seed,
+                    prompt: video.prompt,
+                    workflowId: this.workflowId,
+                    encodedMedia: videoResults.rawBytes,
+                    mediaGenerationId: videoResults.mediaGenerationId,
+                    aspectRatio: video.aspectRatio,
+                    mediaType: "VIDEO",
+                    model: video.model,
+                    account: this.account,
+                });
+            }
+            if (i >= 20) {
+                throw new Error("failed to generate video: " + videoResults);
+            }
+        }
+    }
+    /**
+         * Saves the media to the local disk
+         *
+         * @param directory Directory path to save the media (default: current directory)
+         * @returns The absolute path of the saved file
+         */
+    save(directory = ".") {
+        if (!fs.existsSync(directory)) {
+            fs.mkdirSync(directory, { recursive: true });
+        }
+        let extension = this.mediaType == "VIDEO" ? "mp4" : "png";
+        const base64Data = this.encodedMedia.replace(/^data:\w+\/\w+;base64,/, "");
+        const buffer = Buffer.from(base64Data, "base64");
+        const timestamp = Date.now();
+        const uuidShort = this.mediaGenerationId.slice(0, 4);
+        const fileName = `img_${timestamp}_${uuidShort}.${extension}`;
+        const filePath = path.resolve(directory, fileName);
+        fs.writeFileSync(filePath, buffer);
+        return filePath;
+    }
+}

package/dist/Project.d.ts

@@ -0,0 +1,13 @@
+import { Media } from "./Media.js";
+import type { PromptConfig } from "./Types.js";
+import { Account } from "./Whisk.js";
+export declare class Project {
+    readonly account: Account;
+    readonly projectId: string;
+    constructor(projectId: string, account: Account);
+    generateImage(input: string | PromptConfig): Promise<Media>;
+    /**
+    * Deletes the project, clearance of your slop from the existance
+    */
+    delete(): Promise<void>;
+}

package/dist/Project.js

@@ -0,0 +1,79 @@
+import { ImageGenerationModel } from "./Constants.js";
+import { Media } from "./Media.js";
+import { request } from "./Utils.js";
+import { Account } from "./Whisk.js";
+export class Project {
+    account;
+    projectId;
+    constructor(projectId, account) {
+        if (typeof projectId !== "string" || !projectId.trim()) {
+            throw new Error("project id is either invalid or missing");
+        }
+        if (!(account instanceof Account)) {
+            throw new Error("account is invalid or missing");
+        }
+        this.projectId = projectId;
+        this.account = account;
+    }
+    async generateImage(input) {
+        if (typeof input === "string") {
+            input = {
+                seed: 0,
+                prompt: input,
+                model: "IMAGEN_3_5",
+                aspectRatio: "IMAGE_ASPECT_RATIO_LANDSCAPE"
+            };
+        }
+        if (!input.seed)
+            input.seed = 0;
+        if (!input.model)
+            input.model = "IMAGEN_3_5";
+        if (!input.aspectRatio)
+            input.aspectRatio = "IMAGE_ASPECT_RATIO_LANDSCAPE";
+        if (!input.prompt?.trim?.())
+            throw new Error("prompt is required");
+        if (!Object.values(ImageGenerationModel).includes(input.model)) {
+            throw new Error(`'${input.model}': invalid image generation model provided`);
+        }
+        const generationResponse = await request("https://aisandbox-pa.googleapis.com/v1/whisk:generateImage", {
+            headers: { authorization: `Bearer ${await this.account.getToken()}` },
+            body: JSON.stringify({
+                "clientContext": {
+                    "workflowId": this.projectId
+                },
+                "imageModelSettings": {
+                    "imageModel": input.model,
+                    "aspectRatio": input.aspectRatio
+                },
+                "seed": input.seed,
+                "prompt": input.prompt,
+                "mediaCategory": "MEDIA_CATEGORY_BOARD"
+            })
+        });
+        const img = generationResponse.imagePanels[0].generatedImages[0];
+        return new Media({
+            seed: img.seed,
+            prompt: img.prompt,
+            workflowId: img.workflowId ?? generationResponse.workflowId,
+            encodedMedia: img.encodedImage,
+            mediaGenerationId: img.mediaGenerationId,
+            aspectRatio: img.aspectRatio,
+            mediaType: "IMAGE",
+            model: img.imageModel,
+            account: this.account
+        });
+    }
+    /**
+    * Deletes the project, clearance of your slop from the existance
+    */
+    async delete() {
+        await request("https://labs.google/fx/api/trpc/media.deleteMedia", {
+            headers: { cookie: this.account.getCookie() },
+            body: JSON.stringify({
+                "json": {
+                    "parent": "userProject/", "names": [this.projectId]
+                }
+            }),
+        });
+    }
+}

package/dist/Types.d.ts

@@ -0,0 +1,26 @@
+import type { Account } from "./Whisk.js";
+import { ImageAspectRatio, VideoAspectRatio, ImageExtension, ImageGenerationModel, VideoGenerationModel, ImageRefinementModel } from "./Constants.js";
+export interface MediaConfig {
+    seed: number;
+    prompt: string;
+    refined?: boolean;
+    workflowId: string;
+    encodedMedia: string;
+    mediaGenerationId: string;
+    mediaType: "VIDEO" | "IMAGE";
+    aspectRatio: ImageAspectRatioType | VideoAspectRatioType;
+    model: ImageGenerationModelType | VideoGenerationModelType;
+    account: Account;
+}
+export interface PromptConfig {
+    seed?: number;
+    prompt: string;
+    aspectRatio?: ImageAspectRatioType | VideoAspectRatioType;
+    model?: ImageGenerationModelType | VideoGenerationModelType;
+}
+export type ImageAspectRatioType = typeof ImageAspectRatio[keyof typeof ImageAspectRatio];
+export type VideoAspectRatioType = typeof VideoAspectRatio[keyof typeof VideoAspectRatio];
+export type ImageExtensionTypes = typeof ImageExtension[keyof typeof ImageExtension];
+export type ImageGenerationModelType = typeof ImageGenerationModel[keyof typeof ImageGenerationModel];
+export type VideoGenerationModelType = typeof VideoGenerationModel[keyof typeof VideoGenerationModel];
+export type ImageRefinementModelType = typeof ImageRefinementModel[keyof typeof ImageRefinementModel];

package/dist/Types.js

@@ -0,0 +1 @@
+export {};

package/dist/Utils.d.ts

@@ -0,0 +1,15 @@
+import type { ImageExtensionTypes } from "./Types.js";
+/**
+ * Make a request, thats all
+ *
+ * @param input URL or Request object
+ * @param init Settings for request() method
+ */
+export declare function request<T>(input: RequestInfo | URL, init?: RequestInit): Promise<T>;
+/**
+ * Returns base64 encoded image
+ *
+ * @param imagePath Path to image file
+ * @param imageType Extension of image (if that matters)
+ */
+export declare function imageToBase64(imagePath: string, imageType?: ImageExtensionTypes): Promise<string>;

package/dist/Utils.js

@@ -0,0 +1,48 @@
+import fs from "fs";
+import path from "path";
+import { ImageExtension } from "./Constants.js";
+/**
+ * Make a request, thats all
+ *
+ * @param input URL or Request object
+ * @param init Settings for request() method
+ */
+export async function request(input, init) {
+    if (init) {
+        init.method = init.method ?? (init.body ? "POST" : "GET");
+    }
+    const request = await fetch(input, init);
+    if (!request.ok) {
+        const errorText = await request.text();
+        throw new Error(`API Error (${request.status}): ${errorText}`);
+    }
+    const json = await request.json();
+    return (json.result?.data?.json?.result || json);
+}
+/**
+ * Returns base64 encoded image
+ *
+ * @param imagePath Path to image file
+ * @param imageType Extension of image (if that matters)
+ */
+export async function imageToBase64(imagePath, imageType) {
+    if (!(imagePath?.trim?.()) || !fs.existsSync(imagePath)) {
+        throw new Error(`'${imagePath}': image not found`);
+    }
+    // Try to figure out image type from its extension
+    if (!(imageType?.trim?.())) {
+        imageType = path.extname(imagePath).slice(1);
+    }
+    // If extension not in valid extension list throw error
+    if (!Object.values(ImageExtension).includes(imageType)) {
+        throw new Error(`'${imagePath}': couldn't identify image type, please specify 'imageType'`);
+    }
+    const base64Header = `data:image/${imageType};base64,`;
+    return new Promise((resolve, reject) => {
+        fs.readFile(imagePath, (err, data) => {
+            if (err)
+                return reject(err);
+            resolve(base64Header + data.toString("base64"));
+        });
+    });
+}

package/dist/Whisk.d.ts

@@ -0,0 +1,46 @@
+import { Media } from "./Media.js";
+import { Project } from "./Project.js";
+export declare class Account {
+    private cookie;
+    private authToken?;
+    private expiryDate?;
+    private userName?;
+    private userEmail?;
+    constructor(cookie: string, authToken?: string);
+    refresh(): Promise<void>;
+    getToken(): Promise<string>;
+    getCookie(): string;
+    isExpired(): boolean;
+    toString(): string;
+}
+export declare class Whisk {
+    readonly account: Account;
+    constructor(cookie: string, authToken?: string);
+    /**
+     * Delete a generated media - image, video
+     *
+     * @param mediaId Media id or list of ids to delete
+     * @param account Account{} object
+     */
+    static deleteMedia(mediaId: string | string[], account: Account): Promise<void>;
+    /**
+     * Generate caption from provided base64 image
+     *
+     * @param input base64 encoded image
+     * @param account Account{} object
+     * @param count Number of captions to generate (min: 0, max: 8)
+     */
+    static generateCaption(input: string, account: Account, count?: number): Promise<string[]>;
+    /**
+     * Tries to get media from their unique id
+     *
+     * @param mediaId Unique identifier for generated media `mediaGenerationId`
+     */
+    static getMedia(mediaId: string, account: Account): Promise<Media>;
+    /**
+    * Create a new project for your AI slop
+    *
+    * @param projectName Name of the project
+    */
+    newProject(projectName?: string): Promise<Project>;
+}

package/dist/Whisk.js

@@ -0,0 +1,165 @@
+import { Media } from "./Media.js";
+import { Project } from "./Project.js";
+import { request } from "./Utils.js";
+export class Account {
+    cookie;
+    authToken;
+    expiryDate;
+    userName;
+    userEmail;
+    constructor(cookie, authToken) {
+        if (typeof cookie !== 'string' || !cookie.trim()) {
+            throw new Error(`'${cookie}': is not a valid cookie`);
+        }
+        // If someone provided token but its not a string
+        if (authToken && typeof authToken !== 'string') {
+            throw new Error(`${authToken}: is not a valid auth token`);
+        }
+        this.cookie = cookie;
+        this.authToken = authToken?.trim() || undefined;
+        //  Assume it expires in 3 hours
+        this.expiryDate = new Date(Date.now() + 10800000);
+    }
+    async refresh() {
+        const session = await request("https://labs.google/fx/api/auth/session", { headers: { cookie: this.cookie } });
+        if (session.error === "ACCESS_TOKEN_REFRESH_NEEDED") {
+            throw new Error("new cookie is required");
+        }
+        this.authToken = session.access_token;
+        this.expiryDate = new Date(session.expires);
+        this.userName = session.user.name;
+        this.userEmail = session.user.email;
+    }
+    async getToken() {
+        if (this.isExpired()) {
+            await this.refresh();
+        }
+        return this.authToken;
+    }
+    getCookie() {
+        return this.cookie;
+    }
+    isExpired() {
+        if (!this.authToken || !this.expiryDate || !(this.expiryDate instanceof Date)) {
+            return true;
+        }
+        // 30 second to prevent mid-request token expiry
+        return Date.now() + 15 > this.expiryDate.getTime();
+    }
+    toString() {
+        if (this.isExpired()) {
+            return "No account found, might need a refresh.";
+        }
+        return "Username: " + this.userName + "\n" +
+            "Email: " + this.userEmail + "\n" +
+            "Cookie: " + this.cookie.slice(0, 5) + "*".repeat(10) + "\n" +
+            "Auth Token: " + this.authToken.slice(0, 5) + "*".repeat(10);
+    }
+}
+export class Whisk {
+    account;
+    constructor(cookie, authToken) {
+        this.account = new Account(cookie, authToken);
+    }
+    /**
+     * Delete a generated media - image, video
+     *
+     * @param mediaId Media id or list of ids to delete
+     * @param account Account{} object
+     */
+    static async deleteMedia(mediaId, account) {
+        if (typeof mediaId === "string") {
+            mediaId = [mediaId];
+        }
+        if (!(account instanceof Account)) {
+            throw new Error("invalid or missing account");
+        }
+        await request("https://labs.google/fx/api/trpc/media.deleteMedia", {
+            headers: { cookie: account.getCookie() },
+            body: JSON.stringify({ "json": { "names": mediaId } })
+        });
+    }
+    /**
+     * Generate caption from provided base64 image
+     *
+     * @param input base64 encoded image
+     * @param account Account{} object
+     * @param count Number of captions to generate (min: 0, max: 8)
+     */
+    static async generateCaption(input, account, count = 1) {
+        if (!(input?.trim?.())) {
+            throw new Error("input image or media id is required");
+        }
+        if (count <= 0 || count > 8) {
+            throw new Error("count must be in between 0 and 9 (0 < count < 9)");
+        }
+        if (!(account instanceof Account)) {
+            throw new Error("invalid or missing account");
+        }
+        const captionResults = await request("https://labs.google/fx/api/trpc/backbone.captionImage", {
+            headers: { cookie: account.getCookie() },
+            body: JSON.stringify({
+                "json": {
+                    "captionInput": {
+                        "candidatesCount": count,
+                        "mediaInput": {
+                            "rawBytes": input,
+                            "mediaCategory": "MEDIA_CATEGORY_SUBJECT"
+                        }
+                    }
+                }
+            })
+        });
+        return captionResults.candidates.map(item => item.output);
+    }
+    /**
+     * Tries to get media from their unique id
+     *
+     * @param mediaId Unique identifier for generated media `mediaGenerationId`
+     */
+    static async getMedia(mediaId, account) {
+        if (typeof mediaId !== "string" || !mediaId.trim()) {
+            throw new Error("invalid or missing media id");
+        }
+        if (!(account instanceof Account)) {
+            throw new Error("invalid or missing account");
+        }
+        const mediaInfo = await request(
+        // key is hardcoded in the original code too
+        `https://aisandbox-pa.googleapis.com/v1/media/${mediaId}?key=AIzaSyBtrm0o5ab1c-Ec8ZuLcGt3oJAA5VWt3pY`, {
+            headers: {
+                "Referer": "https://labs.google/", // yep this ones required
+                "Authorization": `Bearer ${await account.getToken()}`,
+            },
+        });
+        const media = mediaInfo.image ?? mediaInfo.video;
+        return new Media({
+            seed: media.seed,
+            prompt: media.prompt,
+            workflowId: media.workflowId,
+            encodedMedia: media.encodedImage ?? media.encodedVideo,
+            mediaGenerationId: media.mediaGenerationId,
+            aspectRatio: media.aspectRatio,
+            mediaType: mediaInfo.mediaGenerationId.mediaType,
+            model: media.modelNameType ?? media.model,
+            account: account,
+        });
+    }
+    /**
+    * Create a new project for your AI slop
+    *
+    * @param projectName Name of the project
+    */
+    async newProject(projectName) {
+        if (typeof projectName !== "string" || !projectName.trim()) {
+            projectName = "New Project - " + (new Date().toDateString().replace(/\s/g, "-"));
+        }
+        const projectInfo = await request("https://labs.google/fx/api/trpc/media.createOrUpdateWorkflow", {
+            headers: { cookie: this.account.getCookie() },
+            body: JSON.stringify({
+                "json": { "workflowMetadata": { "workflowName": projectName } }
+            })
+        });
+        return new Project(projectInfo.workflowId, this.account);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+export { Whisk } from "./Whisk.js";
+export { Media } from "./Media.js";
+export { Project } from "./Project.js";
+export * from "./Types.js";

package/dist/index.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+// Re-export your public API
+export { Whisk } from "./Whisk.js";
+export { Media } from "./Media.js";
+export { Project } from "./Project.js";
+export * from "./Types.js";

package/package.json

@@ -1,16 +1,20 @@
 {
     "name": "@rohitaryal/whisk-api",
-    "version": "3.0.0",
+    "version": "3.0.1",
     "type": "module",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",
     "files": [
         "dist"
     ],
+    "exports": {
+        "import": "./dist/index.js",
+        "require": "./dist/index.js"
+    },
     "private": false,
     "scripts": {
         "test": "bun test --concurrent",
-        "build": "tsc && chmod +x ./dist/index.js"
+        "build": "tsc && chmod +x ./dist/Cli.js"
     },
     "devDependencies": {
         "@types/bun": "^1.3.5",
@@ -44,9 +48,5 @@
         "url": "https://github.com/rohitaryal/whisk-api/issues"
     },
     "homepage": "https://github.com/rohitaryal/whisk-api#readme",
-    "directories": {
-        "example": "examples",
-        "test": "tests"
-    },
     "description": "Unofficial API for Whisk image generation."
 }