@polderlabs/bizar 6.2.5 → 6.3.0

package/packages/sdk/src/client.ts

@@ -1,188 +0,0 @@
-/**
- * BizarHarness SDK client factory.
- *
- * Mirrors the cline SDK pattern: a single `createBizarClient(config)`
- * call returns a typed client with resource-grouped methods. The client
- * handles auth header injection, response unwrapping, and error mapping
- * via the discriminated BizarError union.
- *
- * Reference: https://docs.cline.bot/docs/sdk/ (createClineClient).
- */
-
-import {
-  apiErrorFrom,
-  connectionErrorFrom,
-  dashboardErrorFrom,
-  type BizarError,
-} from "./errors.js";
-import { subscribeEvents, type EventSubscription } from "./events.js";
-import type {
-  DashboardEvent,
-  Health,
-  Plan,
-  Project,
-  Session,
-  SessionCreate,
-  SessionListQuery,
-} from "./types.js";
-
-export interface BizarClientConfig {
-  baseUrl: string;
-  password: string;
-  /** Injectable fetch for testing. Defaults to global `fetch`. */
-  fetch?: typeof fetch;
-  /** When true, errors are thrown. Default false (return BizarError). */
-  throwOnError?: boolean;
-  /** Extra headers to attach to every request. */
-  headers?: Record<string, string>;
-}
-
-export interface SessionsResource {
-  list(query?: SessionListQuery): Promise<Session[] | BizarError>;
-  get(input: { sessionId: string }): Promise<Session | BizarError>;
-  create(input: SessionCreate): Promise<Session | BizarError>;
-  abort(input: { sessionId: string }): Promise<null | BizarError>;
-}
-
-export interface ProjectsResource {
-  list(): Promise<Project[] | BizarError>;
-}
-
-export interface PlansResource {
-  list(): Promise<Plan[] | BizarError>;
-}
-
-export interface EventsResource {
-  subscribe(opts?: { signal?: AbortSignal; since?: number }): Promise<EventSubscription>;
-  publish(event: DashboardEvent): Promise<null | BizarError>;
-}
-
-export interface HealthResource {
-  check(): Promise<Health | BizarError>;
-}
-
-export interface BizarClient {
-  sessions: SessionsResource;
-  projects: ProjectsResource;
-  plans: PlansResource;
-  events: EventsResource;
-  health: HealthResource;
-  /** Change the base URL after the client was created. */
-  setBaseUrl(url: string): void;
-}
-
-export function createBizarClient(config: BizarClientConfig): BizarClient {
-  const fetchImpl = config.fetch ?? fetch;
-  const authHeader = makeAuthHeader(config.password);
-  const baseHeaders: Record<string, string> = {
-    Authorization: authHeader,
-    Accept: "application/json",
-    ...(config.headers ?? {}),
-  };
-
-  async function request<T>(
-    method: string,
-    path: string,
-    init?: { body?: unknown; query?: Record<string, string | number | undefined> },
-  ): Promise<T | BizarError> {
-    const url = new URL(path, config.baseUrl);
-    if (init?.query) {
-      for (const [k, v] of Object.entries(init.query)) {
-        if (v !== undefined) url.searchParams.set(k, String(v));
-      }
-    }
-
-    const headers: Record<string, string> = { ...baseHeaders };
-    let body: string | undefined;
-    if (init?.body !== undefined) {
-      headers["Content-Type"] = "application/json";
-      body = JSON.stringify(init.body);
-    }
-
-    let response: Response;
-    try {
-      response = await fetchImpl(url.toString(), {
-        method,
-        headers,
-        body,
-      });
-    } catch (err) {
-      const error = connectionErrorFrom(err);
-      if (config.throwOnError) throw error;
-      return error;
-    }
-
-    if (response.status === 204) {
-      return null as T;
-    }
-
-    const text = await response.text();
-
-    if (!response.ok) {
-      // 5xx and 429 → APIError (retryable); everything else → DashboardError.
-      const error =
-        response.status >= 500 || response.status === 429
-          ? apiErrorFrom(response.status, text)
-          : dashboardErrorFrom(response.status, text);
-      if (config.throwOnError) throw error;
-      return error;
-    }
-
-    try {
-      return JSON.parse(text) as T;
-    } catch {
-      // Empty body or non-JSON; return null for caller to handle.
-      return null as T;
-    }
-  }
-
-  return {
-    sessions: {
-      list: (query) =>
-        request<Session[]>("GET", "/sessions", { query: query as Record<string, string | number | undefined> }),
-      get: ({ sessionId }) =>
-        request<Session>("GET", `/sessions/${encodeURIComponent(sessionId)}`),
-      create: (input) => request<Session>("POST", "/sessions", { body: input }),
-      abort: ({ sessionId }) =>
-        request<null>("DELETE", `/sessions/${encodeURIComponent(sessionId)}`),
-    },
-    projects: {
-      list: () => request<Project[]>("GET", "/projects"),
-    },
-    plans: {
-      list: () => request<Plan[]>("GET", "/plans"),
-    },
-    events: {
-      subscribe: (opts) => subscribeEvents(config.baseUrl, authHeader, opts, fetchImpl),
-      publish: (event) => request<null>("POST", "/event", { body: event }),
-    },
-    health: {
-      check: async () => {
-        const url = new URL("/health", config.baseUrl);
-        try {
-          const r = await fetchImpl(url.toString(), { method: "GET" });
-          if (!r.ok) return dashboardErrorFrom(r.status, await r.text());
-          return (await r.json()) as Health;
-        } catch (err) {
-          const e = connectionErrorFrom(err);
-          if (config.throwOnError) throw e;
-          return e;
-        }
-      },
-    },
-    setBaseUrl(url: string) {
-      config.baseUrl = url;
-    },
-  };
-}
-
-/**
- * Build the `Authorization: Basic …` header value.
- * Username is `cline` per the cline convention used by BizarHarness.
- */
-function makeAuthHeader(password: string): string {
-  const credentials = `cline:${password}`;
-  // Buffer.from is available in both Node (≥ 16) and Bun.
-  const encoded = Buffer.from(credentials, "utf-8").toString("base64");
-  return `Basic ${encoded}`;
-}

package/packages/sdk/src/cline-events.ts

@@ -1,134 +0,0 @@
-/**
- * SSE event iteration helper for the cline serve child.
- *
- * Subscribes to the cline SSE stream at `/event?directory=…`, filters
- * by `sessionID` when provided, and yields parsed typed events.
- *
- * This module is consumed by the SDK's `events.subscribe()` and by the
- * dashboard's chat SSE bridge.
- */
-
-import { parseSseStream } from "./events.js";
-import type { EventSubscription } from "./events.js";
-
-/**
- * Options for subscribing to the cline event stream.
- */
-export interface ClineEventSubscribeOptions {
-  /** AbortSignal to cancel the subscription early. */
-  signal?: AbortSignal;
-  /**
-   * When provided, only events whose `sessionID` matches are yielded.
-   * When omitted, all events are yielded.
-   */
-  sessionID?: string;
-  /**
-   * Optional baseUrl override (defaults to the SDK's configured baseUrl).
-   */
-  baseUrl?: string;
-  /**
-   * Optional auth header override.
-   */
-  authHeader?: string;
-  /**
-   * Injectable fetch. Defaults to global `fetch`.
-   */
-  fetch?: typeof fetch;
-}
-
-/**
- * A single parsed cline SSE event envelope.
- */
-export interface ClineEventEnvelope {
-  type: string;
-  sessionID?: string;
-  messageID?: string;
-  part?: object;
-  data?: object;
-}
-
-/**
- * Subscribe to cline's SSE `/event` endpoint.
- *
- * @param baseUrl  e.g. "http://127.0.0.1:4097"
- * @param authHeader  `Authorization: Basic …` value
- * @param opts
- */
-export async function subscribeClineEvents(
-  baseUrl: string,
-  authHeader: string,
-  opts: ClineEventSubscribeOptions = {},
-): Promise<EventSubscription> {
-  const fetchImpl = opts.fetch ?? fetch;
-  const controller = new AbortController();
-  if (opts.signal) {
-    opts.signal.addEventListener("abort", () => controller.abort(), { once: true });
-  }
-
-  const url = new URL("/event", baseUrl);
-
-  const response = await fetchImpl(url.toString(), {
-    method: "GET",
-    headers: {
-      Authorization: authHeader,
-      Accept: "text/event-stream",
-    },
-    signal: controller.signal,
-  });
-
-  if (!response.ok || !response.body) {
-    throw new Error(`cline event subscribe failed: ${response.status} ${response.statusText}`);
-  }
-
-  // Cast through unknown so the AsyncIterable<ClineEventEnvelope> satisfies
-  // the AsyncIterable<DashboardEvent> constraint from the existing EventSubscription type.
-  // The actual events flowing through are ClineEventEnvelope-shaped.
-  const filteredStream = filterClineSseStream(response.body, controller, opts.sessionID);
-  return {
-    stream: filteredStream as unknown as EventSubscription["stream"],
-    close: () => controller.abort(),
-  };
-}
-
-/**
- * Wrap `parseSseStream` with optional sessionID filtering.
- */
-async function* filterClineSseStream(
-  body: ReadableStream<Uint8Array>,
-  controller: AbortController,
-  sessionID?: string,
-): AsyncIterable<ClineEventEnvelope> {
-  for await (const raw of parseSseStream<ClineEventEnvelope>(body, controller)) {
-    if (!raw || typeof raw !== "object") continue;
-    const evt = raw as unknown as Record<string, unknown>;
-    // Unwrap sync envelope if present (mirrors serve-info.mjs:unwrapClineSseEvent)
-    let unwrapped = evt;
-    if (evt.type === "sync" && evt.syncEvent && typeof evt.syncEvent === "object") {
-      const se = evt.syncEvent as Record<string, unknown>;
-      if (typeof se.type === "string") {
-        if (se.data && typeof se.data === "object") {
-          unwrapped = se.data as Record<string, unknown>;
-        }
-      }
-    }
-    const type = typeof unwrapped.type === "string" ? unwrapped.type : null;
-    if (!type) continue;
-    const evtSessionID = pickString(unwrapped, ["sessionID", "sessionId", "session_id"]);
-    if (sessionID && evtSessionID !== sessionID) continue;
-    yield {
-      type,
-      sessionID: evtSessionID,
-      messageID: pickString(unwrapped, ["messageID", "messageId", "message_id"]),
-      part: unwrapped.part && typeof unwrapped.part === "object" ? (unwrapped.part as object) : undefined,
-      data: unwrapped,
-    };
-  }
-}
-
-function pickString(obj: Record<string, unknown>, keys: string[]): string | undefined {
-  for (const k of keys) {
-    const v = obj[k];
-    if (typeof v === "string" && v.length > 0) return v;
-  }
-  return undefined;
-}

package/packages/sdk/src/cline-types.ts

@@ -1,66 +0,0 @@
-/**
- * Typed wrappers for cline SDK entities.
- *
- * We declare shapes structurally so that:
- *   1. The package compiles even when `@cline/sdk` is not installed.
- *   2. The shapes are stable regardless of which version of the upstream
- *      SDK is installed (the upstream types are very complex and couple us
- *      to internal class structure we don't need).
- */
-
-export interface ClineSession {
-  id: string;
-  slug?: string;
-  projectID?: string;
-  workspaceID?: string;
-  directory?: string;
-  path?: string;
-  parentID?: string;
-  title?: string;
-  agent?: string;
-  model?: {
-    id: string;
-    providerID: string;
-    variant?: string;
-  };
-  time?: {
-    created: number;
-    updated: number;
-    compacting?: number;
-    archived?: number;
-  };
-}
-
-export interface ClineMessage {
-  info?: {
-    id?: string;
-    role?: string;
-    time?: {
-      created?: number;
-    };
-  };
-  id?: string;
-  role?: string;
-  parts?: ClinePart[];
-  text?: string;
-  content?: string;
-}
-
-export type ClinePart =
-  | { type: "text"; text: string }
-  | { type: "reasoning"; text: string }
-  | { type: "tool_call"; name: string; input: unknown }
-  | { type: "tool_result"; toolCallId: string; result: unknown }
-  | { type: "agent"; text: string }
-  | { type: "subtask"; text: string }
-  | { type: "file"; path: string; content?: string }
-  | { type: "step_start" | "step_finish" | "snapshot" | "patch" | "retry" | "compaction"; [key: string]: unknown };
-
-export interface ClineEvent {
-  type: string;
-  sessionID?: string;
-  messageID?: string;
-  part?: ClinePart;
-  data?: Record<string, unknown>;
-  properties?: Record<string, unknown>;
-}