@klingis/cli 0.1.0

package/dist/commands/init.d.ts

@@ -0,0 +1 @@
+export declare function initCommand(): Promise<void>;

package/dist/commands/init.js

@@ -0,0 +1,107 @@
+import chalk from "chalk";
+import ora from "ora";
+import prompts from "prompts";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { loginCommand } from "./login.js";
+import { loadUserConfig, writeEnvLocal, ensureGitignore, } from "../lib/config.js";
+import { detectFramework, detectPackageManager, frameworkLabel, installCommand, } from "../lib/detect.js";
+import { getTemplateFiles } from "../templates/index.js";
+const LOGO = `
+  ${chalk.hex("#A56CFE").bold("██╗  ██╗██╗     ██╗███╗   ██╗ ██████╗")}
+  ${chalk.hex("#A56CFE").bold("██║ ██╔╝██║     ██║████╗  ██║██╔════╝")}
+  ${chalk.hex("#A56CFE").bold("█████╔╝ ██║     ██║██╔██╗ ██║██║  ███╗")}
+  ${chalk.hex("#A56CFE").bold("██╔═██╗ ██║     ██║██║╚██╗██║██║   ██║")}
+  ${chalk.hex("#A56CFE").bold("██║  ██╗███████╗██║██║ ╚████║╚██████╔╝")}
+  ${chalk.hex("#A56CFE").bold("╚═╝  ╚═╝╚══════╝╚═╝╚═╝  ╚═══╝ ╚═════╝")}
+`;
+export async function initCommand() {
+    const startTime = Date.now();
+    console.log(LOGO);
+    console.log(chalk.dim("  Payments for Iceland\n"));
+    // Step 1: Authenticate
+    let config = loadUserConfig();
+    if (config) {
+        console.log(chalk.dim(`  Already connected as merchant ${config.merchant_id.slice(0, 8)}...`));
+        console.log(chalk.dim(`  Using API key: ${config.api_key.slice(0, 16)}...\n`));
+    }
+    else {
+        config = await loginCommand({});
+        if (!config) {
+            console.log(chalk.red("\n  Could not connect. Run `kling login` to try again.\n"));
+            process.exit(1);
+        }
+    }
+    // Step 2: Detect environment
+    const framework = detectFramework();
+    const pm = detectPackageManager();
+    if (framework !== "unknown") {
+        console.log(chalk.dim(`  Detected: ${frameworkLabel(framework)} project (${pm})\n`));
+    }
+    // Step 3: Choose what to build
+    const { useCase } = await prompts({
+        type: "select",
+        name: "useCase",
+        message: "What are you building?",
+        choices: [
+            { title: "One-time payments (checkout)", value: "checkout" },
+            { title: "Subscription billing", value: "subscriptions" },
+            { title: "Payment links", value: "payment-links" },
+            { title: "Just give me the API key", value: "key-only" },
+        ],
+    });
+    if (!useCase) {
+        // User cancelled
+        process.exit(0);
+    }
+    // Step 4: Write .env.local
+    const envSpinner = ora("Writing .env.local...").start();
+    writeEnvLocal(config.api_key, config.api_url);
+    ensureGitignore();
+    envSpinner.succeed("Written .env.local");
+    if (useCase === "key-only") {
+        printSummary(config.api_key, startTime);
+        return;
+    }
+    // Step 5: Suggest SDK install
+    console.log();
+    console.log(chalk.dim(`  To install the Kling SDK:\n  ${chalk.white(installCommand(pm, "@klingis/sdk"))}\n`));
+    // Step 6: Generate starter code
+    const templateFiles = getTemplateFiles(framework, config.api_key);
+    if (templateFiles.length > 0) {
+        const fileSpinner = ora("Creating starter files...").start();
+        const created = [];
+        for (const file of templateFiles) {
+            const fullPath = join(process.cwd(), file.path);
+            // Don't overwrite existing files
+            if (existsSync(fullPath)) {
+                continue;
+            }
+            mkdirSync(dirname(fullPath), { recursive: true });
+            writeFileSync(fullPath, file.content, "utf-8");
+            created.push(file.path);
+        }
+        if (created.length > 0) {
+            fileSpinner.succeed(`Created ${created.length} file${created.length > 1 ? "s" : ""}`);
+            console.log();
+            for (const f of created) {
+                console.log(chalk.dim(`    ${f}`));
+            }
+        }
+        else {
+            fileSpinner.info("All template files already exist, skipping");
+        }
+    }
+    printSummary(config.api_key, startTime);
+}
+function printSummary(apiKey, startTime) {
+    const elapsed = ((Date.now() - startTime) / 1000).toFixed(0);
+    console.log();
+    console.log(chalk.bold("  Next steps:"));
+    console.log(chalk.dim("    1. Check .env.local for your API key"));
+    console.log(chalk.dim("    2. Read the docs: https://kling.is/docs"));
+    console.log(chalk.dim("    3. Visit your dashboard: https://kling.is/dashboard"));
+    console.log();
+    console.log(chalk.hex("#A56CFE")(`  ⚡ Setup completed in ${elapsed} seconds`));
+    console.log();
+}

package/dist/commands/login.d.ts

@@ -0,0 +1,4 @@
+import { type UserConfig } from "../lib/config.js";
+export declare function loginCommand(options: {
+    apiKey?: string;
+}): Promise<UserConfig | null>;

package/dist/commands/login.js

@@ -0,0 +1,67 @@
+import chalk from "chalk";
+import ora from "ora";
+import open from "open";
+import { startDeviceAuth, waitForAuth } from "../lib/api.js";
+import { saveUserConfig, getApiUrl } from "../lib/config.js";
+const VERSION = "0.1.0";
+export async function loginCommand(options) {
+    // Direct API key mode (for CI/CD)
+    if (options.apiKey) {
+        const config = {
+            api_key: options.apiKey,
+            merchant_id: "",
+            merchant_name: "",
+            user_id: "",
+            api_url: getApiUrl(),
+            authorized_at: new Date().toISOString(),
+        };
+        saveUserConfig(config);
+        console.log(chalk.green("  API key saved."));
+        return config;
+    }
+    // Device auth flow
+    console.log();
+    const spinner = ora("Starting device authorization...").start();
+    let auth;
+    try {
+        auth = await startDeviceAuth(`Kling CLI v${VERSION}`);
+    }
+    catch (err) {
+        spinner.fail(`Failed to connect: ${err.message}`);
+        return null;
+    }
+    spinner.stop();
+    console.log(chalk.bold("  Your pairing code is: ") +
+        chalk.bgWhite.black.bold(` ${auth.user_code} `));
+    console.log(chalk.dim("  Verify this code matches in your browser.\n"));
+    // Open browser
+    try {
+        await open(auth.verification_url);
+        console.log(chalk.dim(`  Opened ${auth.verification_url}`));
+    }
+    catch {
+        console.log(chalk.yellow(`  Open this URL in your browser:\n  ${auth.verification_url}`));
+    }
+    console.log();
+    const pollSpinner = ora("Waiting for confirmation...").start();
+    const result = await waitForAuth(auth.device_code, auth.poll_interval, auth.expires_in);
+    if (!result) {
+        pollSpinner.fail("Authorization was denied or expired.");
+        return null;
+    }
+    pollSpinner.succeed("Connected!");
+    const config = {
+        api_key: result.apiKey,
+        merchant_id: result.merchantId,
+        merchant_name: "",
+        user_id: result.userId,
+        api_url: getApiUrl(),
+        authorized_at: new Date().toISOString(),
+    };
+    saveUserConfig(config);
+    console.log();
+    console.log(chalk.dim(`  API Key: ${result.apiKey.slice(0, 16)}...`));
+    console.log(chalk.dim(`  Merchant: ${result.merchantId}`));
+    console.log();
+    return config;
+}

package/dist/commands/logout.d.ts

@@ -0,0 +1 @@
+export declare function logoutCommand(): Promise<void>;

package/dist/commands/logout.js

@@ -0,0 +1,11 @@
+import chalk from "chalk";
+import { clearUserConfig } from "../lib/config.js";
+export async function logoutCommand() {
+    const cleared = clearUserConfig();
+    if (cleared) {
+        console.log(chalk.green("\n  Logged out. Credentials removed.\n"));
+    }
+    else {
+        console.log(chalk.dim("\n  Not logged in.\n"));
+    }
+}

package/dist/commands/status.d.ts

@@ -0,0 +1 @@
+export declare function statusCommand(): Promise<void>;

package/dist/commands/status.js

@@ -0,0 +1,17 @@
+import chalk from "chalk";
+import { loadUserConfig } from "../lib/config.js";
+export async function statusCommand() {
+    const config = loadUserConfig();
+    if (!config) {
+        console.log(chalk.yellow("\n  Not connected. Run `kling login` to authenticate.\n"));
+        return;
+    }
+    console.log();
+    console.log(chalk.bold("  Kling CLI Status"));
+    console.log();
+    console.log(`  API Key:     ${chalk.dim(config.api_key.slice(0, 16) + "...")}`);
+    console.log(`  Merchant:    ${chalk.dim(config.merchant_id)}`);
+    console.log(`  API URL:     ${chalk.dim(config.api_url)}`);
+    console.log(`  Authorized:  ${chalk.dim(config.authorized_at)}`);
+    console.log();
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { initCommand } from "./commands/init.js";
+import { loginCommand } from "./commands/login.js";
+import { logoutCommand } from "./commands/logout.js";
+import { statusCommand } from "./commands/status.js";
+const program = new Command();
+program
+    .name("kling")
+    .description("Kling payments CLI — set up your integration from the terminal")
+    .version("0.1.0");
+program
+    .command("init")
+    .description("Set up Kling in your project (login + scaffold)")
+    .action(initCommand);
+program
+    .command("login")
+    .description("Authenticate with your Kling account")
+    .option("--api-key <key>", "Use an API key directly (for CI/CD)")
+    .action(async (options) => {
+    await loginCommand(options);
+});
+program
+    .command("logout")
+    .description("Clear stored credentials")
+    .action(logoutCommand);
+program
+    .command("status")
+    .description("Show current authentication state")
+    .action(statusCommand);
+program.parse();

package/dist/lib/api.d.ts

@@ -0,0 +1,40 @@
+interface DeviceAuthResponse {
+    device_code: string;
+    user_code: string;
+    verification_url: string;
+    expires_in: number;
+    poll_interval: number;
+}
+interface TokenPendingResponse {
+    status: "pending";
+}
+interface TokenAuthorizedResponse {
+    status: "authorized";
+    api_key: string;
+    merchant: {
+        id: string;
+    };
+    user: {
+        id: string;
+    };
+}
+interface TokenExpiredResponse {
+    status: "expired";
+}
+interface TokenDeniedResponse {
+    status: "denied";
+}
+type TokenResponse = TokenPendingResponse | TokenAuthorizedResponse | TokenExpiredResponse | TokenDeniedResponse;
+export declare function startDeviceAuth(clientName: string): Promise<DeviceAuthResponse>;
+export declare function pollDeviceToken(deviceCode: string): Promise<TokenResponse>;
+export interface AuthResult {
+    apiKey: string;
+    merchantId: string;
+    userId: string;
+}
+/**
+ * Poll until the device is authorized, denied, or expired.
+ * Returns the auth result on success, null on denial/expiry.
+ */
+export declare function waitForAuth(deviceCode: string, pollInterval: number, expiresIn: number): Promise<AuthResult | null>;
+export {};

package/dist/lib/api.js

@@ -0,0 +1,47 @@
+import { getApiUrl } from "./config.js";
+export async function startDeviceAuth(clientName) {
+    const res = await fetch(`${getApiUrl()}/v1/device/authorize`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ client_name: clientName }),
+    });
+    if (!res.ok) {
+        const body = await res.text();
+        throw new Error(`Failed to start device auth: ${res.status} ${body}`);
+    }
+    return res.json();
+}
+export async function pollDeviceToken(deviceCode) {
+    const res = await fetch(`${getApiUrl()}/v1/device/token?device_code=${encodeURIComponent(deviceCode)}`);
+    if (!res.ok) {
+        const body = await res.text();
+        throw new Error(`Failed to poll device token: ${res.status} ${body}`);
+    }
+    return res.json();
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Poll until the device is authorized, denied, or expired.
+ * Returns the auth result on success, null on denial/expiry.
+ */
+export async function waitForAuth(deviceCode, pollInterval, expiresIn) {
+    const deadline = Date.now() + expiresIn * 1000;
+    while (Date.now() < deadline) {
+        await sleep(pollInterval * 1000);
+        const result = await pollDeviceToken(deviceCode);
+        if (result.status === "authorized") {
+            return {
+                apiKey: result.api_key,
+                merchantId: result.merchant.id,
+                userId: result.user.id,
+            };
+        }
+        if (result.status === "denied" || result.status === "expired") {
+            return null;
+        }
+        // Still pending — continue polling
+    }
+    return null; // Timed out
+}

package/dist/lib/config.d.ts

@@ -0,0 +1,16 @@
+export interface UserConfig {
+    api_key: string;
+    merchant_id: string;
+    merchant_name: string;
+    user_id: string;
+    user_name?: string;
+    user_email?: string;
+    api_url: string;
+    authorized_at: string;
+}
+export declare function loadUserConfig(): UserConfig | null;
+export declare function saveUserConfig(config: UserConfig): void;
+export declare function clearUserConfig(): boolean;
+export declare function writeEnvLocal(apiKey: string, apiUrl: string): void;
+export declare function ensureGitignore(): void;
+export declare function getApiUrl(): string;

package/dist/lib/config.js

@@ -0,0 +1,73 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync, unlinkSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+function getConfigDir() {
+    return join(homedir(), ".config", "kling");
+}
+function getConfigPath() {
+    return join(getConfigDir(), "config.json");
+}
+export function loadUserConfig() {
+    const path = getConfigPath();
+    if (!existsSync(path))
+        return null;
+    try {
+        return JSON.parse(readFileSync(path, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function saveUserConfig(config) {
+    const dir = getConfigDir();
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(getConfigPath(), JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+export function clearUserConfig() {
+    const path = getConfigPath();
+    if (!existsSync(path))
+        return false;
+    unlinkSync(path);
+    return true;
+}
+// ---------------------------------------------------------------------------
+// Project-level env (.env.local)
+// ---------------------------------------------------------------------------
+export function writeEnvLocal(apiKey, apiUrl) {
+    const envPath = join(process.cwd(), ".env.local");
+    const lines = [
+        `# Kling API — generated by kling init`,
+        `KLING_SECRET_KEY=${apiKey}`,
+        `KLING_API_URL=${apiUrl}`,
+        "",
+    ];
+    // If file exists, merge rather than overwrite
+    if (existsSync(envPath)) {
+        const existing = readFileSync(envPath, "utf-8");
+        const existingLines = existing.split("\n");
+        // Remove any existing Kling keys
+        const filtered = existingLines.filter((l) => !l.startsWith("KLING_SECRET_KEY=") && !l.startsWith("KLING_API_URL=") && !l.startsWith("# Kling API"));
+        // Append our lines
+        const merged = [...filtered.filter((l) => l.trim() !== ""), "", ...lines];
+        writeFileSync(envPath, merged.join("\n"), "utf-8");
+    }
+    else {
+        writeFileSync(envPath, lines.join("\n"), "utf-8");
+    }
+}
+export function ensureGitignore() {
+    const gitignorePath = join(process.cwd(), ".gitignore");
+    if (!existsSync(gitignorePath))
+        return;
+    const content = readFileSync(gitignorePath, "utf-8");
+    if (content.includes(".env.local"))
+        return;
+    writeFileSync(gitignorePath, content.trimEnd() + "\n.env.local\n", "utf-8");
+}
+// ---------------------------------------------------------------------------
+// API URL resolution
+// ---------------------------------------------------------------------------
+const DEFAULT_API_URL = "https://api.kling.is";
+export function getApiUrl() {
+    return process.env.KLING_API_URL || DEFAULT_API_URL;
+}

package/dist/lib/detect.d.ts

@@ -0,0 +1,7 @@
+export type Framework = "nextjs" | "remix" | "astro" | "express" | "elysia" | "hono" | "html" | "unknown";
+export type PackageManager = "bun" | "npm" | "yarn" | "pnpm";
+export declare function detectPackageManager(): PackageManager;
+export declare function detectFramework(): Framework;
+export declare function frameworkLabel(fw: Framework): string;
+export declare function installCommand(pm: PackageManager, pkg: string): string;
+export declare function runCommand(pm: PackageManager, script: string): string;

package/dist/lib/detect.js

@@ -0,0 +1,81 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+export function detectPackageManager() {
+    const cwd = process.cwd();
+    if (existsSync(join(cwd, "bun.lock")) || existsSync(join(cwd, "bun.lockb")))
+        return "bun";
+    if (existsSync(join(cwd, "pnpm-lock.yaml")))
+        return "pnpm";
+    if (existsSync(join(cwd, "yarn.lock")))
+        return "yarn";
+    return "npm";
+}
+export function detectFramework() {
+    const cwd = process.cwd();
+    const pkgPath = join(cwd, "package.json");
+    if (!existsSync(pkgPath)) {
+        if (existsSync(join(cwd, "index.html")))
+            return "html";
+        return "unknown";
+    }
+    try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        const allDeps = {
+            ...pkg.dependencies,
+            ...pkg.devDependencies,
+        };
+        if (allDeps["next"])
+            return "nextjs";
+        if (allDeps["@remix-run/node"] || allDeps["@remix-run/react"])
+            return "remix";
+        if (allDeps["astro"])
+            return "astro";
+        if (allDeps["elysia"])
+            return "elysia";
+        if (allDeps["hono"])
+            return "hono";
+        if (allDeps["express"])
+            return "express";
+    }
+    catch {
+        // ignore parse errors
+    }
+    return "unknown";
+}
+export function frameworkLabel(fw) {
+    const labels = {
+        nextjs: "Next.js",
+        remix: "Remix",
+        astro: "Astro",
+        express: "Express",
+        elysia: "Elysia",
+        hono: "Hono",
+        html: "Plain HTML",
+        unknown: "Generic",
+    };
+    return labels[fw];
+}
+export function installCommand(pm, pkg) {
+    switch (pm) {
+        case "bun":
+            return `bun add ${pkg}`;
+        case "pnpm":
+            return `pnpm add ${pkg}`;
+        case "yarn":
+            return `yarn add ${pkg}`;
+        default:
+            return `npm install ${pkg}`;
+    }
+}
+export function runCommand(pm, script) {
+    switch (pm) {
+        case "bun":
+            return `bun run ${script}`;
+        case "pnpm":
+            return `pnpm ${script}`;
+        case "yarn":
+            return `yarn ${script}`;
+        default:
+            return `npm run ${script}`;
+    }
+}

package/dist/templates/index.d.ts

@@ -0,0 +1,6 @@
+import type { Framework } from "../lib/detect.js";
+export interface TemplateFile {
+    path: string;
+    content: string;
+}
+export declare function getTemplateFiles(framework: Framework, apiKey: string): TemplateFile[];

package/dist/templates/index.js

@@ -0,0 +1,309 @@
+export function getTemplateFiles(framework, apiKey) {
+    switch (framework) {
+        case "nextjs":
+            return nextjsTemplate(apiKey);
+        case "elysia":
+        case "hono":
+        case "express":
+            return serverTemplate(apiKey, framework);
+        case "astro":
+            return astroTemplate(apiKey);
+        default:
+            return genericTemplate(apiKey);
+    }
+}
+function nextjsTemplate(apiKey) {
+    return [
+        {
+            path: "app/api/checkout/route.ts",
+            content: `// Kling Checkout — server-side session creation
+// Docs: https://kling.is/docs/checkout
+
+export async function POST() {
+  const res = await fetch(\`\${process.env.KLING_API_URL}/v1/checkout/sessions\`, {
+    method: "POST",
+    headers: {
+      Authorization: \`Bearer \${process.env.KLING_SECRET_KEY}\`,
+      "Content-Type": "application/json",
+      "Idempotency-Key": crypto.randomUUID(),
+    },
+    body: JSON.stringify({
+      amount: 5000,
+      currency: "ISK",
+      success_url: \`\${process.env.NEXT_PUBLIC_URL || "http://localhost:3000"}/success\`,
+    }),
+  });
+
+  const session = await res.json();
+  return Response.json(session);
+}
+`,
+        },
+        {
+            path: "app/checkout/page.tsx",
+            content: `"use client";
+
+// Kling Checkout — client-side overlay
+// 1. Start your dev server
+// 2. Visit /checkout
+// 3. Click the button to open the Kling checkout overlay
+
+export default function CheckoutPage() {
+  const handleCheckout = async () => {
+    // Create a checkout session on the server
+    const res = await fetch("/api/checkout", { method: "POST" });
+    const session = await res.json();
+
+    // Open the Kling checkout overlay
+    const kling = (window as any).Kling?.init({
+      baseUrl: process.env.NEXT_PUBLIC_KLING_API_URL || "${process.env.KLING_API_URL || "https://api.kling.is"}",
+    });
+
+    if (kling) {
+      const result = await kling.checkout({ sessionId: session.id });
+      if (result.success) {
+        window.location.href = "/success";
+      }
+    } else {
+      // Fallback: redirect to hosted checkout
+      window.location.href = session.url;
+    }
+  };
+
+  return (
+    <div style={{ padding: "2rem", textAlign: "center" }}>
+      <h1>Checkout Demo</h1>
+      <p>Click below to pay 5,000 ISK</p>
+      <button
+        onClick={handleCheckout}
+        style={{
+          padding: "12px 24px",
+          fontSize: "16px",
+          background: "#A56CFE",
+          color: "white",
+          border: "2px solid #2E2211",
+          borderRadius: "8px",
+          cursor: "pointer",
+          boxShadow: "2px 2px 0 #2E2211",
+        }}
+      >
+        Pay with Kling
+      </button>
+
+      {/* Load the Kling SDK */}
+      <script src="${process.env.KLING_API_URL || "https://api.kling.is"}/v1/kling.js" />
+    </div>
+  );
+}
+`,
+        },
+    ];
+}
+function serverTemplate(apiKey, framework) {
+    if (framework === "elysia") {
+        return [
+            {
+                path: "examples/kling-checkout.ts",
+                content: `// Kling Checkout — Elysia server example
+// Run: bun run examples/kling-checkout.ts
+// Then open: http://localhost:4321
+
+import { Elysia } from "elysia";
+
+const KLING_API_URL = process.env.KLING_API_URL || "https://api.kling.is";
+const KLING_SECRET_KEY = process.env.KLING_SECRET_KEY;
+
+const app = new Elysia()
+  .post("/api/checkout", async () => {
+    const res = await fetch(\`\${KLING_API_URL}/v1/checkout/sessions\`, {
+      method: "POST",
+      headers: {
+        Authorization: \`Bearer \${KLING_SECRET_KEY}\`,
+        "Content-Type": "application/json",
+        "Idempotency-Key": crypto.randomUUID(),
+      },
+      body: JSON.stringify({
+        amount: 5000,
+        currency: "ISK",
+        success_url: "http://localhost:4321/success",
+      }),
+    });
+    return res.json();
+  })
+  .get("/", () => {
+    return new Response(checkoutHtml(KLING_API_URL), {
+      headers: { "Content-Type": "text/html" },
+    });
+  })
+  .get("/success", () => "Payment successful!")
+  .listen(4321);
+
+console.log("Checkout demo running at http://localhost:4321");
+
+function checkoutHtml(apiUrl: string) {
+  return \`<!DOCTYPE html>
+<html><head><title>Kling Checkout</title></head>
+<body style="font-family:system-ui;text-align:center;padding:4rem">
+  <h1>Checkout Demo</h1>
+  <p>Click below to pay 5,000 ISK</p>
+  <button onclick="pay()" style="padding:12px 24px;font-size:16px;background:#A56CFE;color:white;border:2px solid #2E2211;border-radius:8px;cursor:pointer;box-shadow:2px 2px 0 #2E2211">
+    Pay with Kling
+  </button>
+  <script src="\${apiUrl}/v1/kling.js"><\\/script>
+  <script>
+    async function pay() {
+      const res = await fetch('/api/checkout', { method: 'POST' });
+      const session = await res.json();
+      const kling = Kling.init({ baseUrl: '\${apiUrl}' });
+      const result = await kling.checkout({ sessionId: session.id });
+      if (result.success) window.location.href = '/success';
+    }
+  </script>
+</body></html>\`;
+}
+`,
+            },
+        ];
+    }
+    // Express / Hono — generic Node server
+    return [
+        {
+            path: "examples/kling-checkout.ts",
+            content: `// Kling Checkout — server example
+// Run: npx tsx examples/kling-checkout.ts (or bun run examples/kling-checkout.ts)
+// Then open: http://localhost:4321
+
+const KLING_API_URL = process.env.KLING_API_URL || "https://api.kling.is";
+const KLING_SECRET_KEY = process.env.KLING_SECRET_KEY;
+
+const server = Bun.serve({
+  port: 4321,
+  async fetch(req) {
+    const url = new URL(req.url);
+
+    if (url.pathname === "/api/checkout" && req.method === "POST") {
+      const res = await fetch(\`\${KLING_API_URL}/v1/checkout/sessions\`, {
+        method: "POST",
+        headers: {
+          Authorization: \`Bearer \${KLING_SECRET_KEY}\`,
+          "Content-Type": "application/json",
+          "Idempotency-Key": crypto.randomUUID(),
+        },
+        body: JSON.stringify({
+          amount: 5000,
+          currency: "ISK",
+          success_url: "http://localhost:4321/success",
+        }),
+      });
+      return new Response(await res.text(), {
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+
+    if (url.pathname === "/success") {
+      return new Response("Payment successful!", {
+        headers: { "Content-Type": "text/plain" },
+      });
+    }
+
+    return new Response(\`<!DOCTYPE html>
+<html><head><title>Kling Checkout</title></head>
+<body style="font-family:system-ui;text-align:center;padding:4rem">
+  <h1>Checkout Demo</h1>
+  <p>Click below to pay 5,000 ISK</p>
+  <button onclick="pay()" style="padding:12px 24px;font-size:16px;background:#A56CFE;color:white;border:2px solid #2E2211;border-radius:8px;cursor:pointer;box-shadow:2px 2px 0 #2E2211">
+    Pay with Kling
+  </button>
+  <script src="\${KLING_API_URL}/v1/kling.js"></script>
+  <script>
+    async function pay() {
+      const res = await fetch('/api/checkout', { method: 'POST' });
+      const session = await res.json();
+      const kling = Kling.init({ baseUrl: '\${KLING_API_URL}' });
+      const result = await kling.checkout({ sessionId: session.id });
+      if (result.success) window.location.href = '/success';
+    }
+  </script>
+</body></html>\`, { headers: { "Content-Type": "text/html" } });
+  },
+});
+
+console.log("Checkout demo running at http://localhost:4321");
+`,
+        },
+    ];
+}
+function astroTemplate(apiKey) {
+    return [
+        {
+            path: "src/pages/api/checkout.ts",
+            content: `// Kling Checkout — Astro API route
+// Docs: https://kling.is/docs/checkout
+
+import type { APIRoute } from "astro";
+
+export const POST: APIRoute = async () => {
+  const res = await fetch(\`\${import.meta.env.KLING_API_URL}/v1/checkout/sessions\`, {
+    method: "POST",
+    headers: {
+      Authorization: \`Bearer \${import.meta.env.KLING_SECRET_KEY}\`,
+      "Content-Type": "application/json",
+      "Idempotency-Key": crypto.randomUUID(),
+    },
+    body: JSON.stringify({
+      amount: 5000,
+      currency: "ISK",
+      success_url: \`\${import.meta.env.SITE || "http://localhost:4321"}/success\`,
+    }),
+  });
+
+  const session = await res.json();
+  return new Response(JSON.stringify(session), {
+    headers: { "Content-Type": "application/json" },
+  });
+};
+`,
+        },
+    ];
+}
+function genericTemplate(apiKey) {
+    return [
+        {
+            path: "examples/kling-checkout.ts",
+            content: `// Kling Checkout — quick test
+// Run: bun run examples/kling-checkout.ts (or npx tsx examples/kling-checkout.ts)
+//
+// This creates a checkout session and prints the payment URL.
+
+const KLING_API_URL = process.env.KLING_API_URL || "https://api.kling.is";
+const KLING_SECRET_KEY = process.env.KLING_SECRET_KEY;
+
+if (!KLING_SECRET_KEY) {
+  console.error("Missing KLING_SECRET_KEY — run 'kling init' first or set it in .env.local");
+  process.exit(1);
+}
+
+const res = await fetch(\`\${KLING_API_URL}/v1/checkout/sessions\`, {
+  method: "POST",
+  headers: {
+    Authorization: \`Bearer \${KLING_SECRET_KEY}\`,
+    "Content-Type": "application/json",
+    "Idempotency-Key": crypto.randomUUID(),
+  },
+  body: JSON.stringify({
+    amount: 5000,
+    currency: "ISK",
+    success_url: "https://example.com/success",
+  }),
+});
+
+const session = await res.json();
+
+console.log("\\nCheckout session created!");
+console.log(\`  ID:  \${session.id}\`);
+console.log(\`  URL: \${session.url}\`);
+console.log(\`\\nOpen the URL above to complete the payment.\\n\`);
+`,
+        },
+    ];
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@klingis/cli",
+  "version": "0.1.0",
+  "description": "Kling payments CLI — set up your integration from the terminal",
+  "type": "module",
+  "bin": {
+    "kling": "dist/index.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "commander": "^13.1.0",
+    "chalk": "^5.4.1",
+    "ora": "^8.2.0",
+    "open": "^10.1.0",
+    "prompts": "^2.4.2"
+  },
+  "devDependencies": {
+    "@types/prompts": "^2.4.9",
+    "typescript": "^5.9.3"
+  }
+}