ghostykit 0.3.2 → 0.4.0

package/dist/chunks/chunk-XZHX2NZT.js

@@ -1,375 +0,0 @@
-// src/transport/types.ts
-var PilotHttpError = class extends Error {
-  constructor(message, status, needsLogin = false) {
-    super(message);
-    this.name = "PilotHttpError";
-    this.status = status;
-    this.needsLogin = needsLogin;
-  }
-};
-
-// src/transport/postStream.ts
-async function readSse(body, onMessage, onBytes) {
-  const reader = body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  let event = "message";
-  let data = [];
-  const flush = () => {
-    if (data.length) onMessage({ event, data: data.join("\n") });
-    event = "message";
-    data = [];
-  };
-  for (; ; ) {
-    const { value, done } = await reader.read();
-    if (done) break;
-    onBytes?.();
-    buffer += decoder.decode(value, { stream: true });
-    let nl;
-    while ((nl = buffer.search(/\r\n|\r|\n/)) >= 0) {
-      const line = buffer.slice(0, nl);
-      buffer = buffer.slice(nl + (buffer[nl] === "\r" && buffer[nl + 1] === "\n" ? 2 : 1));
-      if (line === "") flush();
-      else if (line.startsWith(":")) continue;
-      else {
-        const i = line.indexOf(":");
-        const field = i < 0 ? line : line.slice(0, i);
-        const val = i < 0 ? "" : line.slice(i + 1).replace(/^ /, "");
-        if (field === "event") event = val;
-        else if (field === "data") data.push(val);
-      }
-    }
-  }
-  flush();
-}
-var TERMINAL = /* @__PURE__ */ new Set(["done", "capacity", "interrupted", "idle"]);
-function parse(raw) {
-  if (!raw) return null;
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-function defaultHistory(json) {
-  const j = json;
-  const turns = (j?.messages ?? []).filter((m) => typeof m.text === "string").map((m) => ({ role: m.role === "user" ? "user" : "assistant", text: m.text }));
-  const permissions = (j?.pending ?? []).filter((p) => typeof p === "object" && p !== null && typeof p.id === "string").map((p) => ({
-    id: p.id,
-    title: String(p.title ?? ""),
-    ...typeof p.tool === "string" ? { tool: p.tool } : {},
-    options: Array.isArray(p.options) ? p.options : [],
-    ...p.expiresAt != null ? { expiresAt: p.expiresAt } : {}
-  }));
-  return { turns, permissions };
-}
-function uuid() {
-  const c = globalThis.crypto;
-  if (c?.randomUUID) return c.randomUUID();
-  return `t-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
-}
-function createPostStreamTransport(target, options = {}) {
-  const url = typeof target === "string" ? target : target.url;
-  const opts = typeof target === "string" ? options : { ...target, ...options };
-  const doFetch = (...a) => (opts.fetch ?? fetch)(...a);
-  const credentials = opts.credentials ?? "same-origin";
-  const sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
-  const retries = opts.retries ?? 6;
-  const silenceMs = opts.silenceMs ?? 6e4;
-  const attachUrl = opts.attachUrl === void 0 ? `${url}${url.includes("?") ? "&" : "?"}attach=1` : opts.attachUrl;
-  const historyUrl = opts.historyUrl === void 0 ? url : opts.historyUrl;
-  const buildBody = opts.body ?? ((i) => ({
-    text: i.text,
-    ...i.context !== void 0 ? { context: i.context } : {},
-    turnId: i.turnId,
-    ...i.resume && i.resumeTurnId ? { continueTurnId: i.resumeTurnId } : {}
-  }));
-  let listener = null;
-  let isBusy = () => false;
-  let closed = false;
-  let current = null;
-  const emit = (name, data) => listener?.(name, data);
-  async function consume(res, ctrl) {
-    if (!res.body) return false;
-    let terminal = false;
-    let errored = false;
-    let lastByte = Date.now();
-    const watchdog = setInterval(() => {
-      if (Date.now() - lastByte > silenceMs) ctrl.abort();
-    }, Math.min(15e3, silenceMs));
-    try {
-      await readSse(
-        res.body,
-        ({ event, data }) => {
-          if (ctrl.signal.aborted) return;
-          const d = parse(data);
-          emit(event, d);
-          if (event === "error") errored = true;
-          if (TERMINAL.has(event)) terminal = true;
-        },
-        () => {
-          lastByte = Date.now();
-        }
-      );
-    } catch {
-    } finally {
-      clearInterval(watchdog);
-    }
-    if (errored && !terminal) {
-      emit("done", {});
-      return true;
-    }
-    return terminal;
-  }
-  async function attach() {
-    if (!attachUrl) return;
-    for (let attempt = 0; attempt <= retries && !closed; attempt++) {
-      const ctrl = new AbortController();
-      current?.abort();
-      current = ctrl;
-      try {
-        const res = await doFetch(attachUrl, { credentials, headers: { accept: "text/event-stream" }, signal: ctrl.signal });
-        if (res.ok && await consume(res, ctrl)) return;
-        if (ctrl.signal.aborted && current !== ctrl) return;
-      } catch {
-        if (current !== ctrl) return;
-      }
-      if (!isBusy()) return;
-      await sleep(Math.min(1e3 * 2 ** attempt, 1e4));
-    }
-  }
-  return {
-    // Sin steer: con un turno corriendo el servidor contesta 409. El composer no deja mandar.
-    steer: false,
-    // Cada turno trae su stream: no hay «conectando» que enseñar.
-    stream: "per-turn",
-    subscribe(l, sub = {}) {
-      listener = l;
-      isBusy = sub.isBusy ?? (() => false);
-      closed = false;
-      void attach();
-      return () => {
-        closed = true;
-        listener = null;
-        current?.abort();
-        current = null;
-      };
-    },
-    async history() {
-      if (!historyUrl) return { turns: [] };
-      const res = await doFetch(historyUrl, { credentials, headers: { accept: "application/json" } });
-      if (!res.ok) return { turns: [] };
-      return (opts.parseHistory ?? defaultHistory)(await res.json().catch(() => null));
-    },
-    async send(input) {
-      const turnId = (opts.newTurnId ?? uuid)();
-      const body = JSON.stringify(buildBody({ ...input, turnId }));
-      for (let attempt = 0; ; attempt++) {
-        const ctrl = new AbortController();
-        current?.abort();
-        current = ctrl;
-        const res = await doFetch(url, {
-          method: "POST",
-          credentials,
-          headers: { "content-type": "application/json", accept: "text/event-stream" },
-          body,
-          signal: ctrl.signal
-        });
-        if (res.status === 503 && attempt < retries) {
-          await sleep(Number(res.headers.get("Retry-After")) * 1e3 || 3e3);
-          continue;
-        }
-        if (!res.ok) {
-          const json = await res.json().catch(() => null);
-          const err = new PilotHttpError(json?.message ?? json?.error ?? `Error ${res.status}`, res.status, res.headers.get("X-Needs-Login") != null);
-          if (json?.error) err.code = json.error;
-          if (res.status === 409 && json?.error === "turn_busy") void attach();
-          throw err;
-        }
-        void consume(res, ctrl).then((ok) => {
-          if (!ok && current === ctrl && !closed) void attach();
-        });
-        return { turnId, state: "running" };
-      }
-    },
-    async cancel() {
-      if (opts.cancelUrl) await doFetch(opts.cancelUrl, { method: "POST", credentials }).catch(() => {
-      });
-      current?.abort();
-      current = null;
-    }
-  };
-}
-
-// src/transport/index.ts
-var SSE_EVENTS = [
-  "started",
-  "status",
-  "caps",
-  "models",
-  "chunk",
-  "thought",
-  "tool",
-  "artifact",
-  "usage",
-  "title",
-  "done",
-  "error",
-  "warning",
-  "reemplazo",
-  "permission",
-  "permission-resolved",
-  "closed",
-  "page-plan",
-  "section-building",
-  "section-update",
-  "section",
-  "page-ready",
-  "page-error",
-  "page-planning",
-  "page-drop",
-  "review",
-  "page-version",
-  "page-edit",
-  // Los de un servidor de turnos durables (EasyBits): re-enganche, sin turno, cortado, sin lugar.
-  "snapshot",
-  "idle",
-  "interrupted",
-  "capacity"
-];
-var LIFE_EVENTS = /* @__PURE__ */ new Set([
-  "started",
-  "status",
-  "chunk",
-  "thought",
-  "tool",
-  "artifact",
-  "usage",
-  "done",
-  "error",
-  "warning",
-  "reemplazo",
-  "permission",
-  "page-plan",
-  "section-building",
-  "section-update",
-  "section",
-  "page-ready",
-  "page-error",
-  "page-planning",
-  "page-drop",
-  "review",
-  "page-version",
-  "page-edit",
-  "snapshot",
-  "idle",
-  "interrupted",
-  "capacity"
-]);
-var SILENCE_MAX_MS = 11 * 6e4;
-var MISSED_BEATS = 4;
-var MIN_SILENCE_MS = 9e4;
-function parse2(raw) {
-  if (typeof raw !== "string" || !raw) return null;
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-function createSseTransport(base, opts = {}) {
-  const doFetch = (...args) => (opts.fetch ?? fetch)(...args);
-  const now = opts.now ?? Date.now;
-  const root = base.replace(/\/+$/, "");
-  let lastEventAt = now();
-  const post = (path, body) => doFetch(`${root}/${path}`, {
-    method: "POST",
-    headers: body === void 0 ? void 0 : { "content-type": "application/json" },
-    body: body === void 0 ? void 0 : JSON.stringify(body),
-    credentials: opts.withCredentials ? "include" : void 0
-  });
-  return {
-    subscribe(listener, sub = {}) {
-      const ES = opts.EventSource ?? globalThis.EventSource;
-      if (!ES) throw new Error("ghostykit: no hay EventSource en este entorno (pasa `EventSource` en las opciones)");
-      let es = null;
-      let heartbeatMs = null;
-      let closed = false;
-      const open = () => {
-        const source = new ES(`${root}/events`, { withCredentials: Boolean(opts.withCredentials) });
-        es = source;
-        const names = /* @__PURE__ */ new Set([...SSE_EVENTS, ...opts.events ?? []]);
-        for (const name of names) {
-          source.addEventListener(name, (e) => {
-            if (es !== source) return;
-            if (LIFE_EVENTS.has(name)) lastEventAt = now();
-            const raw = e.data;
-            if (name === "error" && (raw === void 0 || raw === "")) return;
-            const data = parse2(raw);
-            if (name === "started") {
-              const d = data;
-              heartbeatMs = typeof d?.latidoMs === "number" && d.latidoMs > 0 ? d.latidoMs : null;
-            }
-            listener(name, data);
-            if (name === "closed") source.close();
-          });
-        }
-      };
-      open();
-      const timer = setInterval(() => {
-        if (closed || !sub.isBusy?.()) return;
-        const cap = heartbeatMs ? Math.max(heartbeatMs * MISSED_BEATS, MIN_SILENCE_MS) : SILENCE_MAX_MS;
-        if (now() - lastEventAt < cap) return;
-        lastEventAt = now();
-        es?.close();
-        open();
-      }, opts.checkEveryMs ?? 15e3);
-      return () => {
-        closed = true;
-        clearInterval(timer);
-        es?.close();
-        es = null;
-      };
-    },
-    async send(input) {
-      lastEventAt = now();
-      const res = await post("messages", {
-        content: input.text,
-        images: input.attachments,
-        // Lo que hace que el hilo se BAUTICE al cerrar este turno.
-        primerTurno: input.firstTurn,
-        ...input.resume ? { retomar: true } : {},
-        ...input.context !== void 0 ? { context: input.context } : {}
-      });
-      if (!res.ok) {
-        const text = await res.text().catch(() => "");
-        throw new PilotHttpError(text || `Error ${res.status}`, res.status, Boolean(res.headers.get("X-Needs-Login")));
-      }
-      const r = await res.json().catch(() => ({}));
-      return { injected: r.inyectado, state: r.estado, turnId: r.turnId };
-    },
-    async cancel() {
-      await post("cancel").catch(() => {
-      });
-    },
-    async setModel(value) {
-      await post("model", { value });
-    },
-    async respondPermission(id, optionId) {
-      const res = await post("permission", { id, optionId });
-      const r = await res.json().catch(() => ({}));
-      return { resolved: Boolean(r.resuelto ?? r.resolved) };
-    }
-  };
-}
-
-export {
-  PilotHttpError,
-  readSse,
-  createPostStreamTransport,
-  SSE_EVENTS,
-  SILENCE_MAX_MS,
-  MISSED_BEATS,
-  MIN_SILENCE_MS,
-  createSseTransport
-};

package/dist/core/reconcile.d.ts

@@ -1,7 +0,0 @@
-import type { Turn } from "./types";
-/**
- * Si la copia trae MÁS mensajes del usuario que la pantalla, faltan los de otro cliente: se repinta
- * con la copia, conservando el turno vivo (pasos, segundos, uso) de cada mensaje que coincide. Con
- * los mismos mensajes del usuario no se toca nada (las burbujas en vivo son más ricas que la copia).
- */
-export declare function reconcileTurns(current: Turn[], fresh: Turn[]): Turn[];

package/dist/react/connectingGate.d.ts

@@ -1,17 +0,0 @@
-/** Sin conexión por este rato, se enseña. */
-export declare const CONNECTING_DELAY_MS = 1200;
-/** Una vez a la vista, se queda al menos esto. */
-export declare const CONNECTING_MIN_MS = 700;
-export interface ConnectingGate {
-    /** Desde cuándo está a la vista (null = oculto). */
-    shownAt: number | null;
-    /** Desde cuándo falta la conexión (null = conectado). */
-    waitingSince: number | null;
-}
-export declare const initialGate: (now: number, connected: boolean) => ConnectingGate;
-/** El estado a `now`, y cuándo volver a mirar (null = no hace falta). */
-export declare function stepGate(g: ConnectingGate, connected: boolean, now: number, delay?: number, min?: number): {
-    gate: ConnectingGate;
-    visible: boolean;
-    recheckAt: number | null;
-};

package/dist/transport/postStream.d.ts

@@ -1,44 +0,0 @@
-import type { SendInput, Turn } from "../core/types";
-import { type PilotHistory, type PilotTransport } from "./types";
-/** Un evento SSE ya separado: nombre + data crudo. */
-export interface SseMessage {
-    event: string;
-    data: string;
-}
-/**
- * Lee un stream SSE (`text/event-stream`) de un `fetch`. Llama `onMessage` por cada evento con
- * nombre y `onBytes` con CUALQUIER cosa que llegue (los comentarios `: ka` cuentan como vida).
- */
-export declare function readSse(body: ReadableStream<Uint8Array>, onMessage: (m: SseMessage) => void, onBytes?: () => void): Promise<void>;
-export interface PostStreamTransportOptions {
-    fetch?: typeof fetch;
-    /** Default `same-origin` (la cookie de sesión viaja; EasyBits rechaza cualquier Bearer). */
-    credentials?: RequestCredentials;
-    /** Cuerpo del POST. Default: el contrato de EasyBits. */
-    body?: (input: SendInput & {
-        turnId: string;
-    }) => unknown;
-    /** URL del re-enganche. Default `${url}?attach=1`; `null` = sin re-enganche. */
-    attachUrl?: string | null;
-    /** URL del historial (JSON). Default `url`; `null` = sin historial. */
-    historyUrl?: string | null;
-    /** Cómo leer el historial. Default: `{messages:[{role:"user"|"agent",text}], pending:[permission…]}`. */
-    parseHistory?: (json: unknown) => Turn[] | PilotHistory;
-    /** URL para cancelar (POST). Sin ella, «detener» sólo deja de escuchar: el turno sigue en el servidor. */
-    cancelUrl?: string;
-    /** Silencio (sin un solo byte, ni `: ka`) tras el que la conexión se da por muerta. Default 60 s. */
-    silenceMs?: number;
-    /** Reintentos de un 503 (deploy) o de un re-enganche. Default 6. */
-    retries?: number;
-    newTurnId?: () => string;
-    /** Reloj y espera inyectables (pruebas). */
-    sleep?: (ms: number) => Promise<void>;
-}
-/**
- * El transporte de «POST que devuelve el stream». Cada turno es su propio stream; si se corta sin
- * evento final (red, deploy), se re-engancha con el GET de attach y el servidor dice la verdad
- * (`snapshot` y sigue, o el evento final, o `idle`).
- */
-export declare function createPostStreamTransport(target: string | (PostStreamTransportOptions & {
-    url: string;
-}), options?: PostStreamTransportOptions): PilotTransport;

package/dist/transport/types.d.ts

@@ -1,47 +0,0 @@
-import type { PermissionRequest, SendInput, SendResult, Turn } from "../core/types";
-/** El hilo guardado y las tarjetas de permiso que siguen abiertas (EasyBits: `pending`). */
-export interface PilotHistory {
-    turns: Turn[];
-    permissions?: PermissionRequest[];
-}
-/** Un evento con nombre y su `data` ya parseado (`null` si no traía o no era JSON). */
-export type PilotListener = (name: string, data: unknown) => void;
-export interface SubscribeOptions {
-    /** ¿Hay un turno en vuelo? Con turno vivo, un silencio largo = conexión muerta → se reabre. */
-    isBusy?: () => boolean;
-}
-export interface PilotTransport {
-    /** Abre el stream de eventos. Devuelve con qué cerrarlo. */
-    subscribe(listener: PilotListener, opts?: SubscribeOptions): () => void;
-    /** Encarga un turno (o lo mete al turno en vuelo). Rechaza con `PilotHttpError` si el servidor dice que no. */
-    send(input: SendInput): Promise<SendResult>;
-    /** Detiene el turno en curso. */
-    cancel(): Promise<void>;
-    /** Cambia el modelo de la sesión (el stream confirma con `models`). */
-    setModel?(value: string): Promise<void>;
-    /** Contesta un pedido de permiso. `resolved: false` = ya no estaba abierto (se agotó el plazo). */
-    respondPermission?(id: string, optionId: string): Promise<{
-        resolved: boolean;
-    }>;
-    /**
-     * `"per-turn"`: no hay un stream vivo que esperar (cada turno trae el suyo, como el POST de
-     * EasyBits). Piloto pinta el hilo al instante y nunca enseña «conectando». Default `"live"`.
-     */
-    stream?: "live" | "per-turn";
-    /** El hilo guardado, para pintarlo al montar (si la app no pasa `initialTurns`). */
-    history?(): Promise<Turn[] | PilotHistory>;
-    /**
-     * ¿Se puede mandar un mensaje con un turno en vuelo (steer)? Default `true` (Ghosty). Con
-     * `false` (el servidor contesta 409) el composer no deja mandar hasta que el turno cierre.
-     */
-    steer?: boolean;
-}
-/** El servidor rechazó el encargo (sin saldo, sin cuenta, agente de otro). */
-export declare class PilotHttpError extends Error {
-    status: number;
-    /** El servidor pide cuenta (`X-Needs-Login`). */
-    needsLogin: boolean;
-    /** El `error` del cuerpo, si el servidor lo dio (`turn_busy`, `draining`…). */
-    code?: string;
-    constructor(message: string, status: number, needsLogin?: boolean);
-}