agentic-documents 0.1.0 → 0.3.0

package/dist/chunk-R5XUTBC3.js

@@ -0,0 +1,177 @@
+import {
+  MAX_LIVE_BYTES
+} from "./chunk-FZA5LQV3.js";
+import {
+  AgenticDoc,
+  DOC_ERROR_CODES,
+  DocError,
+  PRINCIPAL_KINDS
+} from "./chunk-YBBQNCMC.js";
+
+// src/live.ts
+import * as Y from "yjs";
+import { SyncClient } from "agentic-realtime/client";
+async function refusal(response, fallback) {
+  const { error } = await response.json().catch(() => ({}));
+  const code = DOC_ERROR_CODES.find((known) => known === error?.code) ?? (response.status >= 500 ? "MISCONFIGURED" : "INVALID_INPUT");
+  return new DocError(code, typeof error?.message === "string" ? error.message : `${fallback} (${response.status})`);
+}
+var base = (server) => server.replace(/\/$/, "");
+async function whoAmI(server, token) {
+  const response = await fetch(`${base(server)}/api/v1/me`, { headers: { authorization: `Bearer ${token}` } }).catch((error) => {
+    throw unreachable(error);
+  });
+  if (!response.ok) {
+    if (response.status === 401 || response.status === 403) throw new DocError("FORBIDDEN", `the server refused the token (${response.status})`);
+    throw await refusal(response, "the server could not say who the token is");
+  }
+  const body = await response.json();
+  const { kind, name, scopes, role } = body;
+  if (!PRINCIPAL_KINDS.includes(kind) || typeof name !== "string" || role !== "editor" && role !== "viewer") {
+    throw new DocError("INVALID_INPUT", "the server sent an identity this client does not know");
+  }
+  const granted = Array.isArray(scopes) ? scopes.filter((s) => typeof s === "string") : [];
+  return { author: { kind, name, ...granted.length ? { scopes: granted } : {} }, role };
+}
+var LiveDoc = class _LiveDoc {
+  constructor(doc, me, client, api, refusedAtStart) {
+    this.doc = doc;
+    this.me = me;
+    this.client = client;
+    this.api = api;
+    this.refusedAtStart = refusedAtStart;
+  }
+  doc;
+  me;
+  client;
+  api;
+  refusedAtStart;
+  static async join(options) {
+    const me = await whoAmI(options.server, options.token);
+    const url = new URL(`${base(options.server)}/api/v1/docs/${encodeURIComponent(options.id)}/ws`);
+    url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+    const client = await SyncClient.connect({
+      url: url.toString(),
+      headers: { authorization: `Bearer ${options.token}` },
+      presence: { name: options.name ?? me.author.name },
+      reconnect: options.reconnect
+    });
+    const api = (path, init = {}) => fetch(`${base(options.server)}/api/v1/docs/${encodeURIComponent(options.id)}${path}`, {
+      ...init,
+      headers: { ...init.headers, authorization: `Bearer ${options.token}` }
+    });
+    try {
+      if (options.seed !== false) {
+        const stored = await api("/state");
+        if (stored.ok) {
+          const state = new Uint8Array(await stored.arrayBuffer());
+          if (state.length > MAX_LIVE_BYTES) throw new DocError("INVALID_INPUT", `the stored document is over ${MAX_LIVE_BYTES} bytes, the most a live room takes`);
+          Y.applyUpdate(client.doc, state);
+        } else if (stored.status !== 404) throw await refusal(stored, "could not read the stored document");
+        await client.flush();
+        if (me.role === "editor" && client.denied.length > 0) throw new DocError("FORBIDDEN", `the room refused the stored document: ${client.denied[0]}`);
+      }
+    } catch (error) {
+      await client.disconnect();
+      throw error instanceof DocError ? error : new DocError("INVALID_INPUT", `could not open the room: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return new _LiveDoc(new AgenticDoc(client.doc, options.doc), me, client, api, client.denied.length);
+  }
+  /** Saves the room's state to the stored document, through the Blobs port. A viewer cannot save. */
+  async save() {
+    if (this.me.role === "viewer") throw new DocError("FORBIDDEN", "this token is a viewer; it cannot change a document");
+    await this.client.flush();
+    const saved = await this.api("/checkpoint", { method: "POST", headers: { "content-type": "application/octet-stream" }, body: new Uint8Array(this.doc.encode()) });
+    if (!saved.ok) throw await refusal(saved, "the server did not save the document");
+  }
+  /** The other people and agents in the room. `machine` is true for an agent. */
+  get peers() {
+    return this.client.peers;
+  }
+  /** Why the room dropped an update, in order. */
+  get denied() {
+    return this.client.denied.slice(this.refusedAtStart);
+  }
+  /**
+   * Runs one change as the token's author and waits until the room has it. A viewer fails before the change.
+   * After a refusal from the room the local copy still holds the change. Leave and join again.
+   */
+  async edit(run) {
+    if (this.me.role === "viewer") throw new DocError("FORBIDDEN", "this token is a viewer; it cannot change a document");
+    const seen = this.denied.length;
+    const result = run(this.doc, this.me.author);
+    await this.client.flush();
+    if (this.denied.length > seen) throw new DocError("FORBIDDEN", `the room refused the edit: ${this.denied[seen]}`);
+    return result;
+  }
+  /** Waits until the room has every change made so far. */
+  flush() {
+    return this.client.flush();
+  }
+  async leave() {
+    await this.client.disconnect();
+  }
+};
+function unreachable(error) {
+  if (error instanceof DocError) return error;
+  return new DocError("MISCONFIGURED", `could not reach the live server: ${error instanceof Error ? error.message : String(error)}`);
+}
+var LiveService = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  async join(id) {
+    try {
+      return await LiveDoc.join({ ...this.options, id });
+    } catch (error) {
+      throw unreachable(error);
+    }
+  }
+  /** The room is only a copy, so a new document is made in the store. A room seeds from it on the next join. */
+  async create(id, markdown) {
+    const response = await fetch(`${base(this.options.server)}/api/v1/docs`, {
+      method: "POST",
+      headers: { authorization: `Bearer ${this.options.token}`, "content-type": "application/json" },
+      body: JSON.stringify({ id, markdown })
+    }).catch((error) => {
+      throw unreachable(error);
+    });
+    if (!response.ok) throw await refusal(response, "the server refused the request");
+  }
+  async read(id, run) {
+    const live = await this.join(id);
+    try {
+      return run(this.exists(live, id));
+    } finally {
+      await live.leave();
+    }
+  }
+  async write(id, run) {
+    const live = await this.join(id);
+    try {
+      this.exists(live, id);
+      const result = await live.edit((doc) => run(doc));
+      try {
+        await live.save();
+      } catch (error) {
+        const why = error instanceof Error ? error.message : String(error);
+        throw new DocError(error instanceof DocError ? error.code : "MISCONFIGURED", `the room has the change, but it is not saved: ${why}. Do not repeat the change.`);
+      }
+      return result;
+    } finally {
+      await live.leave();
+    }
+  }
+  // A document that nobody made has an empty room and an empty log.
+  exists(live, id) {
+    if (live.doc.edits().length === 0) throw new DocError("NO_DOCUMENT", `no document with id "${id}"`);
+    return live.doc;
+  }
+};
+
+export {
+  whoAmI,
+  LiveDoc,
+  LiveService
+};

package/dist/{chunk-BSXUNQDR.js → chunk-TFCRPEEM.js}

@@ -1,6 +1,6 @@
 import {
   DocError
-} from "./chunk-4YVWD5PH.js";
+} from "./chunk-YBBQNCMC.js";
 
 // src/adapters/file-blobs.ts
 import { createHash, randomUUID } from "crypto";