@archal/cli 0.2.0 → 0.3.1

package/dist/chunk-4FTU232H.js

@@ -0,0 +1,191 @@
+// src/api-client.ts
+function normalizeBaseUrl(value, fallback) {
+  const trimmed = value.trim().replace(/\/+$/, "");
+  const normalized = trimmed.endsWith("/api") ? trimmed.slice(0, -4) : trimmed;
+  return normalized.length > 0 ? normalized : fallback;
+}
+var DEFAULT_BASE_URL = "https://archal.ai";
+var AUTH_BASE_URL = normalizeBaseUrl(process.env["ARCHAL_AUTH_URL"] ?? DEFAULT_BASE_URL, DEFAULT_BASE_URL);
+var API_BASE_URL = normalizeBaseUrl(process.env["ARCHAL_API_URL"] ?? AUTH_BASE_URL, AUTH_BASE_URL);
+var REQUEST_TIMEOUT_MS = 8e3;
+var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([408, 425, 429, 500, 502, 503, 504]);
+var RETRYABLE_NETWORK_CODES = /* @__PURE__ */ new Set([
+  "ECONNABORTED",
+  "ECONNREFUSED",
+  "ECONNRESET",
+  "ENETDOWN",
+  "ENETUNREACH",
+  "ENOTFOUND",
+  "ETIMEDOUT"
+]);
+function parseBoundedInt(value, fallback, min, max) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed)) {
+    return fallback;
+  }
+  if (parsed < min || parsed > max) {
+    return fallback;
+  }
+  return parsed;
+}
+var MAX_RETRIES = parseBoundedInt(process.env["ARCHAL_API_MAX_RETRIES"], 3, 0, 10);
+var RETRY_BASE_DELAY_MS = parseBoundedInt(process.env["ARCHAL_API_RETRY_BASE_MS"], 250, 25, 1e4);
+var RETRY_MAX_DELAY_MS = parseBoundedInt(process.env["ARCHAL_API_RETRY_MAX_MS"], 3e3, RETRY_BASE_DELAY_MS, 2e4);
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function retryDelayMs(attempt, retryAfter) {
+  if (retryAfter) {
+    const retrySeconds = Number(retryAfter);
+    if (Number.isFinite(retrySeconds) && retrySeconds > 0) {
+      return Math.min(RETRY_MAX_DELAY_MS, Math.floor(retrySeconds * 1e3));
+    }
+    const retryAtMs = Date.parse(retryAfter);
+    if (Number.isFinite(retryAtMs)) {
+      const deltaMs = retryAtMs - Date.now();
+      if (deltaMs > 0) {
+        return Math.min(RETRY_MAX_DELAY_MS, Math.floor(deltaMs));
+      }
+    }
+  }
+  const exponential = Math.min(
+    RETRY_MAX_DELAY_MS,
+    RETRY_BASE_DELAY_MS * Math.pow(2, Math.max(0, attempt - 1))
+  );
+  const jitter = Math.floor(Math.random() * RETRY_BASE_DELAY_MS);
+  return Math.min(RETRY_MAX_DELAY_MS, exponential + jitter);
+}
+function normalizeErrorCode(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  return value.toUpperCase();
+}
+function isRetryableNetworkError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const normalized = message.toLowerCase();
+  if (normalized.includes("fetch") || normalized.includes("timeout") || normalized.includes("abort") || normalized.includes("econnrefused") || normalized.includes("enotfound") || normalized.includes("econnreset") || normalized.includes("temporarily unavailable")) {
+    return true;
+  }
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const topLevel = error;
+  const directCode = normalizeErrorCode(topLevel.code) ?? normalizeErrorCode(topLevel.errno);
+  if (directCode && RETRYABLE_NETWORK_CODES.has(directCode)) {
+    return true;
+  }
+  if (!topLevel.cause || typeof topLevel.cause !== "object") {
+    return false;
+  }
+  const cause = topLevel.cause;
+  const causeCode = normalizeErrorCode(cause.code) ?? normalizeErrorCode(cause.errno);
+  return Boolean(causeCode && RETRYABLE_NETWORK_CODES.has(causeCode));
+}
+function resolveBaseUrl(path) {
+  return path.startsWith("/auth/") ? AUTH_BASE_URL : API_BASE_URL;
+}
+async function request(method, path, token, body) {
+  const url = `${resolveBaseUrl(path)}${path}`;
+  const headers = {
+    "content-type": "application/json",
+    "user-agent": "archal-cli/0.1.0"
+  };
+  if (token) {
+    headers["authorization"] = `Bearer ${token}`;
+  }
+  const retriesAllowed = method !== "POST" || path.endsWith("/evidence/finalize");
+  const attempts = retriesAllowed ? MAX_RETRIES + 1 : 1;
+  let lastError = "request failed";
+  let lastOffline = false;
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    try {
+      const response = await fetch(url, {
+        method,
+        headers,
+        body: body ? JSON.stringify(body) : void 0,
+        signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+      });
+      if (!response.ok) {
+        const text = await response.text().catch(() => "");
+        const retryable = retriesAllowed && attempt < attempts && RETRYABLE_STATUS_CODES.has(response.status);
+        if (retryable) {
+          await sleep(retryDelayMs(attempt, response.headers.get("retry-after")));
+          continue;
+        }
+        return { ok: false, error: `HTTP ${response.status}: ${text}`, offline: false };
+      }
+      if (response.status === 204) {
+        return { ok: true, data: void 0 };
+      }
+      const data = await response.json();
+      return { ok: true, data };
+    } catch (error) {
+      const offline = isRetryableNetworkError(error);
+      lastError = error instanceof Error ? error.message : String(error);
+      lastOffline = offline;
+      if (retriesAllowed && offline && attempt < attempts) {
+        await sleep(retryDelayMs(attempt, null));
+        continue;
+      }
+      return { ok: false, error: lastError, offline };
+    }
+  }
+  return { ok: false, error: lastError, offline: lastOffline };
+}
+function fetchAuthMe(token) {
+  return request("GET", "/auth/me", token);
+}
+function fetchTwinsCatalog(token) {
+  return request("GET", "/api/twins", token);
+}
+function updateTwinSelection(token, twinIds) {
+  return request("POST", "/api/twins/select", token, { twinIds });
+}
+function startSession(token, body) {
+  return request("POST", "/api/sessions", token, body);
+}
+function endSession(token, sessionId) {
+  return request("DELETE", `/api/sessions/${encodeURIComponent(sessionId)}`, token);
+}
+function getSessionHealth(token, sessionId) {
+  return request(
+    "GET",
+    `/api/sessions/${encodeURIComponent(sessionId)}/health`,
+    token
+  );
+}
+function getSessionStatus(token, sessionId) {
+  return request(
+    "GET",
+    `/api/sessions/${encodeURIComponent(sessionId)}`,
+    token
+  );
+}
+function finalizeSessionEvidence(token, sessionId, body) {
+  return request(
+    "POST",
+    `/api/sessions/${encodeURIComponent(sessionId)}/evidence/finalize`,
+    token,
+    body ?? {}
+  );
+}
+function getSessionEvidence(token, sessionId) {
+  return request(
+    "GET",
+    `/api/sessions/${encodeURIComponent(sessionId)}/evidence`,
+    token
+  );
+}
+
+export {
+  fetchAuthMe,
+  fetchTwinsCatalog,
+  updateTwinSelection,
+  startSession,
+  endSession,
+  getSessionHealth,
+  getSessionStatus,
+  finalizeSessionEvidence,
+  getSessionEvidence
+};