@cf-vibesdk/sdk 0.0.1

package/dist/index.js

@@ -0,0 +1,501 @@
+// @bun
+// src/http.ts
+class HttpClient {
+  opts;
+  cachedAccessToken = null;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  get baseUrl() {
+    return this.opts.baseUrl.replace(/\/$/, "");
+  }
+  get fetchFn() {
+    return this.opts.fetchFn ?? fetch;
+  }
+  getToken() {
+    return this.opts.token ?? this.cachedAccessToken?.token;
+  }
+  async ensureAccessToken() {
+    if (this.opts.token)
+      return this.opts.token;
+    if (!this.opts.apiKey)
+      return;
+    const now = Date.now();
+    const skewMs = 30000;
+    if (this.cachedAccessToken && this.cachedAccessToken.expiresAtMs - skewMs > now) {
+      return this.cachedAccessToken.token;
+    }
+    const url = `${this.baseUrl}/api/auth/exchange-api-key`;
+    const resp = await this.fetchFn(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.opts.apiKey}`
+      }
+    });
+    if (!resp.ok) {
+      const text = await resp.text().catch(() => "");
+      throw new Error(`HTTP ${resp.status} for /api/auth/exchange-api-key: ${text || resp.statusText}`);
+    }
+    const parsed = await resp.json();
+    if (!parsed.success) {
+      throw new Error(parsed.error.message);
+    }
+    const expiresAtMs = Date.parse(parsed.data.expiresAt);
+    this.cachedAccessToken = { token: parsed.data.accessToken, expiresAtMs };
+    return parsed.data.accessToken;
+  }
+  async headers(extra) {
+    const headers = new Headers({
+      ...this.opts.defaultHeaders,
+      ...extra
+    });
+    const token = await this.ensureAccessToken();
+    if (token)
+      headers.set("Authorization", `Bearer ${token}`);
+    return headers;
+  }
+  async fetchJson(path, init) {
+    const url = `${this.baseUrl}${path}`;
+    const resp = await this.fetchFn(url, init);
+    if (!resp.ok) {
+      const text = await resp.text().catch(() => "");
+      throw new Error(`HTTP ${resp.status} for ${path}: ${text || resp.statusText}`);
+    }
+    return await resp.json();
+  }
+  async fetchRaw(path, init) {
+    const url = `${this.baseUrl}${path}`;
+    const resp = await this.fetchFn(url, init);
+    if (!resp.ok) {
+      const text = await resp.text().catch(() => "");
+      throw new Error(`HTTP ${resp.status} for ${path}: ${text || resp.statusText}`);
+    }
+    return resp;
+  }
+}
+
+// src/ndjson.ts
+async function* parseNdjsonStream(stream) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder;
+  let buffer = "";
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done)
+      break;
+    buffer += decoder.decode(value, { stream: true });
+    while (true) {
+      const newlineIndex = buffer.indexOf(`
+`);
+      if (newlineIndex === -1)
+        break;
+      const line = buffer.slice(0, newlineIndex).trim();
+      buffer = buffer.slice(newlineIndex + 1);
+      if (!line)
+        continue;
+      yield JSON.parse(line);
+    }
+  }
+  const tail = buffer.trim();
+  if (tail) {
+    yield JSON.parse(tail);
+  }
+}
+
+// src/emitter.ts
+class TypedEmitter {
+  listeners = new Map;
+  anyListeners = new Set;
+  on(event, cb) {
+    const set = this.listeners.get(event) ?? new Set;
+    set.add(cb);
+    this.listeners.set(event, set);
+    return () => this.off(event, cb);
+  }
+  off(event, cb) {
+    const set = this.listeners.get(event);
+    set?.delete(cb);
+    if (set && set.size === 0)
+      this.listeners.delete(event);
+  }
+  onAny(cb) {
+    this.anyListeners.add(cb);
+    return () => {
+      this.anyListeners.delete(cb);
+    };
+  }
+  emit(event, payload) {
+    for (const cb of this.anyListeners)
+      cb(event, payload);
+    const set = this.listeners.get(event);
+    if (!set)
+      return;
+    for (const cb of set)
+      cb(payload);
+  }
+}
+
+// src/ws.ts
+function toWsCloseEvent(ev) {
+  return {
+    code: typeof ev.code === "number" ? ev.code : 1000,
+    reason: typeof ev.reason === "string" ? ev.reason : ""
+  };
+}
+function createAgentConnection(url, options = {}) {
+  const emitter = new TypedEmitter;
+  const headers = { ...options.headers ?? {} };
+  if (options.origin)
+    headers.Origin = options.origin;
+  const ws = options.webSocketFactory ? options.webSocketFactory(url, undefined, headers) : new WebSocket(url);
+  if (ws.addEventListener) {
+    ws.addEventListener("open", () => {
+      emitter.emit("ws:open", undefined);
+    });
+    ws.addEventListener("close", (ev) => {
+      emitter.emit("ws:close", toWsCloseEvent(ev));
+    });
+    ws.addEventListener("error", (ev) => {
+      emitter.emit("ws:error", { error: ev });
+    });
+    ws.addEventListener("message", (ev) => {
+      handleMessage(ev.data);
+    });
+  } else if (ws.on) {
+    ws.on("open", () => emitter.emit("ws:open", undefined));
+    ws.on("close", (code, reason) => {
+      emitter.emit("ws:close", {
+        code: typeof code === "number" ? code : 1000,
+        reason: typeof reason === "string" ? reason : ""
+      });
+    });
+    ws.on("error", (error) => emitter.emit("ws:error", { error }));
+    ws.on("message", (data) => handleMessage(data));
+  }
+  function handleMessage(data) {
+    try {
+      const parsed = JSON.parse(String(data));
+      emitter.emit("ws:message", parsed);
+      switch (parsed.type) {
+        case "agent_connected":
+          emitter.emit("connected", parsed);
+          break;
+        case "conversation_response":
+        case "conversation_state":
+          emitter.emit("conversation", parsed);
+          break;
+        case "phase_generating":
+        case "phase_generated":
+        case "phase_implementing":
+        case "phase_implemented":
+        case "phase_validating":
+        case "phase_validated":
+          emitter.emit("phase", parsed);
+          break;
+        case "file_chunk_generated":
+        case "file_generated":
+        case "file_generating":
+        case "file_regenerating":
+        case "file_regenerated":
+          emitter.emit("file", parsed);
+          break;
+        case "deployment_completed":
+        case "deployment_started":
+        case "deployment_failed":
+          emitter.emit("preview", parsed);
+          break;
+        case "error":
+          emitter.emit("error", { error: String(parsed.error ?? "Unknown error") });
+          break;
+        default:
+          break;
+      }
+    } catch (error) {
+      emitter.emit("ws:error", { error });
+    }
+  }
+  function send(msg) {
+    ws.send(JSON.stringify(msg));
+  }
+  function close() {
+    ws.close();
+  }
+  async function waitFor(event, predicate, timeoutMs = 60000) {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        unsub();
+        reject(new Error(`Timeout waiting for event: ${String(event)}`));
+      }, timeoutMs);
+      const unsub = emitter.on(event, (payload) => {
+        if (predicate && !predicate(payload))
+          return;
+        clearTimeout(timeout);
+        unsub();
+        resolve(payload);
+      });
+    });
+  }
+  return {
+    send,
+    close,
+    on: (event, cb) => emitter.on(event, cb),
+    onAny: (cb) => emitter.onAny(cb),
+    waitFor
+  };
+}
+
+// src/session.ts
+class BuildSession {
+  clientOptions;
+  init;
+  agentId;
+  websocketUrl;
+  behaviorType;
+  projectType;
+  connection = null;
+  constructor(clientOptions, start, init = {}) {
+    this.clientOptions = clientOptions;
+    this.init = init;
+    this.agentId = start.agentId;
+    this.websocketUrl = start.websocketUrl;
+    this.behaviorType = start.behaviorType;
+    this.projectType = start.projectType;
+  }
+  isConnected() {
+    return this.connection !== null;
+  }
+  connect(options = {}) {
+    if (this.connection)
+      return this.connection;
+    const origin = options.origin ?? this.clientOptions.websocketOrigin;
+    const webSocketFactory = options.webSocketFactory ?? this.clientOptions.webSocketFactory;
+    const headers = { ...options.headers ?? {} };
+    const token = this.init.getAuthToken?.();
+    if (token && !headers.Authorization) {
+      headers.Authorization = `Bearer ${token}`;
+    }
+    const connectOptions = {
+      ...options,
+      ...origin ? { origin } : {},
+      ...Object.keys(headers).length ? { headers } : {},
+      ...webSocketFactory ? { webSocketFactory } : {}
+    };
+    this.connection = createAgentConnection(this.websocketUrl, connectOptions);
+    const credentials = options.credentials ?? this.init.defaultCredentials;
+    if (credentials) {
+      this.connection.on("ws:open", () => {
+        this.connection?.send({
+          type: "session_init",
+          credentials
+        });
+      });
+    }
+    return this.connection;
+  }
+  startGeneration() {
+    this.assertConnected();
+    this.connection.send({ type: "generate_all" });
+  }
+  stop() {
+    this.assertConnected();
+    this.connection.send({ type: "stop_generation" });
+  }
+  followUp(message, options) {
+    this.assertConnected();
+    this.connection.send({
+      type: "user_suggestion",
+      message,
+      images: options?.images
+    });
+  }
+  requestConversationState() {
+    this.assertConnected();
+    this.connection.send({ type: "get_conversation_state" });
+  }
+  deployPreview() {
+    this.assertConnected();
+    this.connection.send({ type: "preview" });
+  }
+  deployCloudflare() {
+    this.assertConnected();
+    this.connection.send({ type: "deploy" });
+  }
+  async waitUntilReady(options = {}) {
+    this.assertConnected();
+    const timeoutMs = options.timeoutMs ?? 120000;
+    const behavior = this.behaviorType;
+    if (behavior === "phasic") {
+      await this.connection.waitFor("phase", (payload) => payload.type === "phase_implementing", timeoutMs);
+      return;
+    }
+    await this.connection.waitFor("conversation", (payload) => payload.type === "conversation_response", timeoutMs);
+  }
+  on = (event, cb) => {
+    this.assertConnected();
+    return this.connection.on(event, cb);
+  };
+  onAny = (cb) => {
+    this.assertConnected();
+    return this.connection.onAny(cb);
+  };
+  onMessageType(type, cb) {
+    this.assertConnected();
+    return this.connection.on("ws:message", (msg) => {
+      if (msg.type === type)
+        cb(msg);
+    });
+  }
+  async waitForMessageType(type, timeoutMs) {
+    this.assertConnected();
+    return await this.connection.waitFor("ws:message", (msg) => msg.type === type, timeoutMs);
+  }
+  close() {
+    this.connection?.close();
+    this.connection = null;
+  }
+  assertConnected() {
+    if (!this.connection) {
+      throw new Error("BuildSession is not connected. Call session.connect() first.");
+    }
+  }
+}
+
+// src/client.ts
+function toQueryString(query) {
+  const params = new URLSearchParams;
+  for (const [k, v] of Object.entries(query)) {
+    if (v === undefined)
+      continue;
+    params.set(k, String(v));
+  }
+  const s = params.toString();
+  return s ? `?${s}` : "";
+}
+
+class VibeClient {
+  options;
+  http;
+  constructor(options) {
+    this.options = options;
+    this.http = new HttpClient(options);
+  }
+  get baseUrl() {
+    return this.http.baseUrl;
+  }
+  async build(prompt, options = {}) {
+    const body = {
+      query: prompt,
+      language: options.language,
+      frameworks: options.frameworks,
+      selectedTemplate: options.selectedTemplate,
+      behaviorType: options.behaviorType,
+      projectType: options.projectType,
+      images: options.images,
+      credentials: options.credentials
+    };
+    const resp = await this.http.fetchRaw("/api/agent", {
+      method: "POST",
+      headers: await this.http.headers({ "Content-Type": "application/json" }),
+      body: JSON.stringify(body)
+    });
+    if (!resp.body) {
+      throw new Error("Missing response body from /api/agent");
+    }
+    let start = null;
+    for await (const obj of parseNdjsonStream(resp.body)) {
+      if (!start) {
+        start = obj;
+        continue;
+      }
+      const o = obj;
+      if (typeof o.chunk === "string") {
+        options.onBlueprintChunk?.(o.chunk);
+      }
+    }
+    if (!start) {
+      throw new Error("No start event received from /api/agent");
+    }
+    const session = new BuildSession(this.options, start, {
+      getAuthToken: () => this.http.getToken(),
+      ...options.credentials ? { defaultCredentials: options.credentials } : {}
+    });
+    if (options.autoConnect ?? true) {
+      session.connect();
+      if (options.autoGenerate ?? true) {
+        session.startGeneration();
+      }
+    }
+    return session;
+  }
+  async connect(agentId, options = {}) {
+    const data = await this.http.fetchJson(`/api/agent/${agentId}/connect`, { method: "GET", headers: await this.http.headers() });
+    if (!data.success) {
+      throw new Error(data.error.message);
+    }
+    const start = {
+      agentId: data.data.agentId,
+      websocketUrl: data.data.websocketUrl
+    };
+    return new BuildSession(this.options, start, {
+      getAuthToken: () => this.http.getToken(),
+      ...options.credentials ? { defaultCredentials: options.credentials } : {}
+    });
+  }
+  apps = {
+    listPublic: async (query = {}) => {
+      const qs = toQueryString({
+        limit: query.limit,
+        page: query.page,
+        sort: query.sort,
+        order: query.order,
+        period: query.period,
+        framework: query.framework,
+        search: query.search
+      });
+      return this.http.fetchJson(`/api/apps/public${qs}`, { method: "GET", headers: await this.http.headers() });
+    },
+    listMine: async () => {
+      return this.http.fetchJson("/api/apps", {
+        method: "GET",
+        headers: await this.http.headers()
+      });
+    },
+    get: async (appId) => {
+      return this.http.fetchJson(`/api/apps/${appId}`, {
+        method: "GET",
+        headers: await this.http.headers()
+      });
+    },
+    getGitCloneToken: async (appId) => {
+      return this.http.fetchJson(`/api/apps/${appId}/git/token`, {
+        method: "POST",
+        headers: await this.http.headers({ "Content-Type": "application/json" })
+      });
+    }
+  };
+}
+// src/agentic.ts
+class AgenticClient extends VibeClient {
+  constructor(options) {
+    super(options);
+  }
+  async build(prompt, options = {}) {
+    return super.build(prompt, { ...options, behaviorType: options.behaviorType ?? "agentic" });
+  }
+}
+// src/phasic.ts
+class PhasicClient extends VibeClient {
+  constructor(options) {
+    super(options);
+  }
+  async build(prompt, options = {}) {
+    return super.build(prompt, { ...options, behaviorType: options.behaviorType ?? "phasic" });
+  }
+}
+export {
+  VibeClient,
+  PhasicClient,
+  BuildSession,
+  AgenticClient
+};

package/dist/node.d.ts

@@ -0,0 +1,67 @@
+// Generated by dts-bundle-generator v9.5.1
+
+type CredentialsPayload = {
+	providers?: Record<string, {
+		apiKey: string;
+	}>;
+	aiGateway?: {
+		baseUrl: string;
+		token: string;
+	};
+};
+declare const SUPPORTED_IMAGE_MIME_TYPES: readonly [
+	"image/png",
+	"image/jpeg",
+	"image/webp"
+];
+type SupportedImageMimeType = typeof SUPPORTED_IMAGE_MIME_TYPES[number];
+interface ImageAttachment {
+	/** Unique identifier for this attachment */
+	id: string;
+	/** Original filename */
+	filename: string;
+	/** MIME type of the image */
+	mimeType: SupportedImageMimeType;
+	/** Base64-encoded image data (without data URL prefix) */
+	base64Data: string;
+	/** Size of the original file in bytes */
+	size?: number;
+	/** Optional dimensions if available */
+	dimensions?: {
+		width: number;
+		height: number;
+	};
+}
+type BehaviorType = "phasic" | "agentic";
+type ProjectType = "app" | "workflow" | "presentation" | "general";
+interface CodeGenArgs {
+	query: string;
+	language?: string;
+	frameworks?: string[];
+	selectedTemplate?: string;
+	behaviorType?: BehaviorType;
+	projectType?: ProjectType;
+	images?: ImageAttachment[];
+	/** Optional ephemeral credentials (BYOK / gateway override) for sdk */
+	credentials?: CredentialsPayload;
+}
+type Credentials = NonNullable<CodeGenArgs["credentials"]>;
+type WebSocketLike = {
+	send: (data: string) => void;
+	close: () => void;
+	addEventListener?: (type: "open" | "close" | "error" | "message", listener: (event: unknown) => void) => void;
+	on?: (type: string, listener: (...args: unknown[]) => void) => void;
+};
+type AgentConnectionOptions = {
+	/** Override Origin header for WS (browser-like security). */
+	origin?: string;
+	/** Optional per-connection ephemeral credentials (used by `session_init`). */
+	credentials?: Credentials;
+	/** Additional headers (Node/Bun via ws factory). */
+	headers?: Record<string, string>;
+	/** Optional WebSocket factory for Node/Bun runtimes. */
+	webSocketFactory?: (url: string, protocols?: string | string[], headers?: Record<string, string>) => WebSocketLike;
+};
+export declare function createNodeWebSocketFactory(): NonNullable<AgentConnectionOptions["webSocketFactory"]>;
+
+export {};

package/dist/node.js

@@ -0,0 +1,12 @@
+// @bun
+// src/node.ts
+import WebSocket from "ws";
+function createNodeWebSocketFactory() {
+  return (url, protocols, headers) => {
+    const ws = headers ? new WebSocket(url, protocols, { headers }) : new WebSocket(url, protocols);
+    return ws;
+  };
+}
+export {
+  createNodeWebSocketFactory
+};

package/package.json

@@ -0,0 +1,37 @@
+{
+	"name": "@cf-vibesdk/sdk",
+	"version": "0.0.1",
+	"type": "module",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"default": "./dist/index.js"
+		},
+		"./node": {
+			"types": "./dist/node.d.ts",
+			"default": "./dist/node.js"
+		}
+	},
+	"files": [
+		"dist"
+	],
+	"publishConfig": {
+		"access": "public"
+	},
+	"scripts": {
+		"build": "rm -rf ./dist && bun build ./src/index.ts ./src/node.ts --outdir ./dist --target bun",
+		"bundle-types": "dts-bundle-generator --export-referenced-types false --project ./tsconfig.protocol.json -o ./dist/index.d.ts ./src/index.ts && dts-bundle-generator --export-referenced-types false --project ./tsconfig.protocol.json -o ./dist/node.d.ts ./src/node.ts",
+		"typecheck": "tsc -p ./tsconfig.json --noEmit",
+		"test": "bun test",
+		"example:cli": "bun ./src/example/cli.ts"
+	},
+	"dependencies": {
+		"ws": "^8.18.3"
+	},
+	"devDependencies": {
+		"@types/ws": "^8.18.1",
+		"dts-bundle-generator": "^9.5.1",
+		"typescript": "^5.9.3"
+	}
+}
+