@atmyapp/cli 0.0.6 → 0.0.8

package/dist/cli/utils/http.js

@@ -0,0 +1,242 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSession = resolveSession;
+exports.createAmaFetch = createAmaFetch;
+exports.projectUrl = projectUrl;
+exports.streamSse = streamSse;
+exports.encodePathSegment = encodePathSegment;
+const fetch_1 = require("@better-fetch/fetch");
+const config_1 = require("./config");
+function resolveSession(overrides = {}) {
+    var _a, _b, _c;
+    let config;
+    try {
+        config = (0, config_1.getConfig)();
+    }
+    catch (error) {
+        throw new Error("AMA session not configured. Run 'ama use' first or supply --url, --token, and --project-id options.");
+    }
+    const token = (_a = overrides.token) !== null && _a !== void 0 ? _a : config.token;
+    const projectId = (_b = overrides.projectId) !== null && _b !== void 0 ? _b : config.projectId;
+    const url = (_c = overrides.url) !== null && _c !== void 0 ? _c : config.url;
+    if (!token) {
+        throw new Error("Authentication token is missing. Run 'ama use' or provide it with --token.");
+    }
+    if (!url) {
+        throw new Error("Project URL is missing. Run 'ama use' or provide it with --url.");
+    }
+    if (!projectId) {
+        throw new Error("Project ID is missing. Ensure the URL contains /projects/{id} or pass --project-id.");
+    }
+    return {
+        token,
+        projectId,
+        url: stripTrailingSlashes(url),
+    };
+}
+function createAmaFetch(session) {
+    return (0, fetch_1.createFetch)({
+        baseURL: ensureTrailingSlash(session.url),
+        headers: {
+            Authorization: `Bearer ${session.token}`,
+        },
+        throw: false,
+    });
+}
+function projectUrl(session, subPath, query) {
+    const base = ensureTrailingSlash(session.url);
+    const cleanPath = subPath.replace(/^\/+/, "");
+    const url = new URL(cleanPath, base);
+    if (query) {
+        const params = new URLSearchParams();
+        for (const [key, value] of Object.entries(query)) {
+            if (value === undefined || value === null) {
+                continue;
+            }
+            params.append(key, typeof value === "boolean" ? String(value) : String(value));
+        }
+        const queryString = params.toString();
+        if (queryString) {
+            url.search = queryString;
+        }
+    }
+    return url.toString();
+}
+function streamSse(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const { url, onEvent, signal, fetchInit = {} } = options;
+        const { signal: initSignal, headers: initHeaders } = fetchInit, restInit = __rest(fetchInit, ["signal", "headers"]);
+        const headers = new Headers(initHeaders !== null && initHeaders !== void 0 ? initHeaders : {});
+        if (!headers.has("Accept")) {
+            headers.set("Accept", "text/event-stream");
+        }
+        const requestInit = Object.assign(Object.assign({ method: (_a = restInit.method) !== null && _a !== void 0 ? _a : "GET" }, restInit), { headers, signal: signal !== null && signal !== void 0 ? signal : initSignal });
+        const response = yield fetch(url, requestInit);
+        if (!response.ok) {
+            const errorBody = yield safeReadText(response);
+            throw new Error(`Request failed with status ${response.status}: ${errorBody !== null && errorBody !== void 0 ? errorBody : "<no body>"}`);
+        }
+        if (!response.body) {
+            throw new Error("Streaming response body is not available.");
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder("utf-8");
+        let buffer = "";
+        while (true) {
+            const { done, value } = yield reader.read();
+            if (done) {
+                break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            buffer = yield dispatchSseBuffer(buffer, onEvent);
+        }
+        buffer += decoder.decode();
+        yield dispatchSseBuffer(buffer, onEvent, true);
+    });
+}
+function encodePathSegment(path) {
+    return path
+        .split("/")
+        .map((segment) => segment === "" || segment === "." ? segment : encodeURIComponent(segment))
+        .join("/");
+}
+function stripTrailingSlashes(value) {
+    return value.replace(/\/+$/, "");
+}
+function ensureTrailingSlash(value) {
+    return value.endsWith("/") ? value : `${value}/`;
+}
+function dispatchSseBuffer(buffer_1, onEvent_1) {
+    return __awaiter(this, arguments, void 0, function* (buffer, onEvent, flush = false) {
+        let working = buffer;
+        while (true) {
+            const delimiter = nextDelimiter(working);
+            if (!delimiter) {
+                break;
+            }
+            const { index, length } = delimiter;
+            const rawEvent = working.slice(0, index);
+            working = working.slice(index + length);
+            if (!rawEvent.trim()) {
+                continue;
+            }
+            const event = parseSseEvent(rawEvent);
+            if (event) {
+                yield onEvent(event);
+            }
+        }
+        if (flush && working.trim()) {
+            const event = parseSseEvent(working);
+            if (event) {
+                yield onEvent(event);
+            }
+            return "";
+        }
+        return working;
+    });
+}
+function nextDelimiter(buffer) {
+    const lfIndex = buffer.indexOf("\n\n");
+    const crlfIndex = buffer.indexOf("\r\n\r\n");
+    if (lfIndex === -1 && crlfIndex === -1) {
+        return null;
+    }
+    if (lfIndex === -1) {
+        return { index: crlfIndex, length: 4 };
+    }
+    if (crlfIndex === -1) {
+        return { index: lfIndex, length: 2 };
+    }
+    return lfIndex < crlfIndex
+        ? { index: lfIndex, length: 2 }
+        : { index: crlfIndex, length: 4 };
+}
+function parseSseEvent(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        return null;
+    }
+    const lines = trimmed.split(/\r?\n/);
+    const dataLines = [];
+    const event = {
+        data: "",
+        raw: trimmed,
+    };
+    for (const line of lines) {
+        if (!line) {
+            continue;
+        }
+        if (line.startsWith(":")) {
+            continue;
+        }
+        const separatorIndex = line.indexOf(":");
+        const field = separatorIndex === -1 ? line : line.slice(0, separatorIndex).trim();
+        const value = separatorIndex === -1
+            ? ""
+            : line
+                .slice(separatorIndex + 1)
+                .replace(/^\s+/, "");
+        switch (field) {
+            case "event":
+                event.event = value;
+                break;
+            case "data":
+                dataLines.push(value);
+                break;
+            case "id":
+                event.id = value;
+                break;
+            case "retry":
+                {
+                    const numeric = Number(value);
+                    if (!Number.isNaN(numeric)) {
+                        event.retry = numeric;
+                    }
+                }
+                break;
+            default:
+                break;
+        }
+    }
+    event.data = dataLines.join("\n");
+    if (event.data) {
+        try {
+            event.parsed = JSON.parse(event.data);
+        }
+        catch (error) {
+            // Non-JSON payloads are expected occasionally (e.g. [DONE])
+        }
+    }
+    return event;
+}
+function safeReadText(response) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            return yield response.text();
+        }
+        catch (error) {
+            return null;
+        }
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atmyapp/cli",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
@@ -28,7 +28,7 @@
   "license": "ISC",
   "description": "",
   "devDependencies": {
-    "@atmyapp/core": "^0.0.6",
+    "@atmyapp/core": "^0.0.11",
     "@types/jest": "^29.5.14",
     "@typescript-eslint/eslint-plugin": "^8.32.1",
     "@typescript-eslint/parser": "^8.32.1",
@@ -40,6 +40,7 @@
     "typescript": "^5.8.3"
   },
   "dependencies": {
+    "@better-fetch/fetch": "^1.1.18",
     "chalk": "^4.1.2",
     "commander": "^14.0.0",
     "fast-glob": "^3.3.3",