conduyt 1.2.1 → 1.4.0

package/dist/client.js

@@ -20,7 +20,14 @@ export class ConduytClient {
         const text = await res.text();
         const json = text ? safeParse(text) : null;
         if (!res.ok) {
-            const msg = json?.error || res.statusText || `HTTP ${res.status}`;
+            // Preserve structured non-2xx bodies: several endpoints return the data
+            // a caller needs to proceed IN the error body (e.g. custom-field delete
+            // 409 carries valueCount/dependencyCount for the --confirm flow).
+            // Reducing those to statusText would strand the user.
+            const structured = json && typeof json === "object" && !json.error
+                ? JSON.stringify(json)
+                : null;
+            const msg = json?.error || structured || res.statusText || `HTTP ${res.status}`;
             throw new Error(`Conduyt API ${res.status}: ${msg}`);
         }
         return json;
@@ -37,6 +44,85 @@ export class ConduytClient {
     del(path) {
         return this.request("DELETE", path);
     }
+    // Stream `ai chat`'s text/event-stream response to stdout as clean answer
+    // text. The server frames SSE records as `data: {"text":"..."}\n\n`, ends
+    // with `data: [DONE]\n\n`, and reports in-stream failures as
+    // `data: {"error":"..."}\n\n` — so we parse events (buffering across chunk
+    // splits), print only the text deltas, stop cleanly on [DONE], and THROW on
+    // an error event so the command exits non-zero instead of "succeeding" with
+    // raw protocol noise.
+    async stream(method, path, body) {
+        const url = `${this.baseUrl}${path.startsWith("/") ? path : `/${path}`}`;
+        const res = await fetch(url, {
+            method,
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+                "Content-Type": "application/json",
+                Accept: "text/event-stream",
+            },
+            body: body !== undefined ? JSON.stringify(body) : undefined,
+        });
+        if (!res.ok || !res.body) {
+            const text = await res.text();
+            const json = text ? safeParse(text) : null;
+            const msg = json?.error || res.statusText || `HTTP ${res.status}`;
+            throw new Error(`Conduyt API ${res.status}: ${msg}`);
+        }
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        let wroteAny = false;
+        const handleEvent = (payload) => {
+            if (payload === "[DONE]")
+                return "done";
+            const parsed = safeParse(payload);
+            if (parsed && typeof parsed === "object") {
+                const rec = parsed;
+                if (typeof rec.error === "string" && rec.error) {
+                    if (wroteAny)
+                        process.stdout.write("\n");
+                    throw new Error(`AI stream error: ${rec.error}`);
+                }
+                if (typeof rec.text === "string" && rec.text) {
+                    process.stdout.write(rec.text);
+                    wroteAny = true;
+                }
+            }
+            return undefined;
+        };
+        const drainBuffer = () => {
+            // SSE events are separated by a blank line; fields we care about are
+            // `data: <payload>` lines (multi-line data joins with \n per spec).
+            let sep;
+            while ((sep = buffer.indexOf("\n\n")) !== -1) {
+                const rawEvent = buffer.slice(0, sep);
+                buffer = buffer.slice(sep + 2);
+                const dataLines = rawEvent
+                    .split("\n")
+                    .filter((l) => l.startsWith("data:"))
+                    .map((l) => l.slice(5).replace(/^ /, ""));
+                if (dataLines.length === 0)
+                    continue;
+                if (handleEvent(dataLines.join("\n")) === "done")
+                    return "done";
+            }
+            return undefined;
+        };
+        outer: for (;;) {
+            const { done, value } = await reader.read();
+            if (value) {
+                buffer += decoder.decode(value, { stream: true });
+                if (drainBuffer() === "done")
+                    break outer;
+            }
+            if (done)
+                break;
+        }
+        buffer += decoder.decode();
+        drainBuffer();
+        if (wroteAny)
+            process.stdout.write("\n");
+    }
 }
 function safeParse(text) {
     try {