@warmdrift/kgauto-compiler 2.0.0-alpha.8 → 2.0.0-alpha.81

package/dist/chunk-NBO4R5PC.mjs

@@ -0,0 +1,313 @@
+// src/glassbox/types.ts
+var GLASSBOX_STREAM_TTL_MS = 6e4;
+
+// src/glassbox/pubsub-upstash.ts
+var UpstashPubSub = class {
+  url;
+  token;
+  fetchImpl;
+  blockMs;
+  maxLen;
+  constructor(cfg) {
+    this.url = cfg.url.replace(/\/$/, "");
+    this.token = cfg.token;
+    this.fetchImpl = cfg.fetchImpl ?? globalThis.fetch.bind(globalThis);
+    this.blockMs = cfg.blockMs ?? 100;
+    this.maxLen = cfg.maxLen ?? 100;
+  }
+  async publish(channelKey, event) {
+    const key = channelKey;
+    const payload = JSON.stringify(event);
+    await this.cmd([
+      "XADD",
+      key,
+      "MAXLEN",
+      "~",
+      String(this.maxLen),
+      "*",
+      "event",
+      payload
+    ]);
+    await this.cmd(["EXPIRE", key, String(Math.ceil(GLASSBOX_STREAM_TTL_MS / 1e3))]);
+  }
+  subscribe(channelKey) {
+    const key = channelKey;
+    const self = this;
+    let cursor = "$";
+    let cancelled = false;
+    let ttlDeadline = Date.now() + GLASSBOX_STREAM_TTL_MS;
+    return new ReadableStream({
+      async start(controller) {
+        try {
+          while (!cancelled && Date.now() < ttlDeadline) {
+            const resp = await self.cmd([
+              "XREAD",
+              "BLOCK",
+              String(self.blockMs),
+              "STREAMS",
+              key,
+              cursor
+            ]);
+            if (cancelled) break;
+            const parsed = parseXReadResult(resp.result);
+            if (parsed.entries.length === 0) {
+              continue;
+            }
+            for (const entry of parsed.entries) {
+              const evt = decodeEvent(entry.fields);
+              if (evt) {
+                try {
+                  controller.enqueue(evt);
+                } catch {
+                  cancelled = true;
+                  break;
+                }
+              }
+              cursor = entry.id;
+            }
+            ttlDeadline = Date.now() + GLASSBOX_STREAM_TTL_MS;
+          }
+        } catch (err) {
+          if (!cancelled) {
+            try {
+              controller.error(err);
+            } catch {
+            }
+            return;
+          }
+        }
+        try {
+          controller.close();
+        } catch {
+        }
+      },
+      cancel() {
+        cancelled = true;
+      }
+    });
+  }
+  async cmd(args) {
+    const res = await this.fetchImpl(this.url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(args)
+    });
+    if (!res.ok) {
+      throw new Error(`Upstash ${args[0]} failed: HTTP ${res.status}`);
+    }
+    const json = await res.json();
+    if (json.error) {
+      throw new Error(`Upstash ${args[0]} failed: ${json.error}`);
+    }
+    return json;
+  }
+};
+function traceChannel(traceId) {
+  return `glassbox:trace:${traceId}`;
+}
+function appChannel(appId) {
+  return `glassbox:app:${appId}`;
+}
+function decodeEvent(fields) {
+  const raw = fields["event"];
+  if (!raw) return void 0;
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.kind === "string" && typeof parsed.at === "number") {
+      return parsed;
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function parseXReadResult(raw) {
+  if (!Array.isArray(raw)) return { entries: [] };
+  const entries = [];
+  for (const stream of raw) {
+    if (!Array.isArray(stream) || stream.length < 2) continue;
+    const streamEntries = stream[1];
+    if (!Array.isArray(streamEntries)) continue;
+    for (const entry of streamEntries) {
+      if (!Array.isArray(entry) || entry.length < 2) continue;
+      const id = String(entry[0]);
+      const flat = entry[1];
+      if (!Array.isArray(flat)) continue;
+      const fields = {};
+      for (let i = 0; i < flat.length; i += 2) {
+        const k = flat[i];
+        const v = flat[i + 1];
+        if (typeof k === "string") fields[k] = String(v ?? "");
+      }
+      entries.push({ id, fields });
+    }
+  }
+  return { entries };
+}
+
+// src/glassbox/pubsub-memory.ts
+var MemoryPubSub = class {
+  subscribers = /* @__PURE__ */ new Map();
+  async publish(channelKey, event) {
+    const subs = this.subscribers.get(channelKey);
+    if (!subs || subs.size === 0) return;
+    for (const sub of subs) {
+      if (sub.closed) continue;
+      try {
+        sub.controller.enqueue(event);
+      } catch {
+        sub.closed = true;
+        continue;
+      }
+      this.refreshTtl(channelKey, sub);
+    }
+  }
+  subscribe(channelKey) {
+    const self = this;
+    let sub;
+    return new ReadableStream({
+      start(controller) {
+        sub = {
+          controller,
+          ttlTimer: setTimeout(() => {
+            self.closeSubscriber(channelKey, sub);
+          }, GLASSBOX_STREAM_TTL_MS),
+          closed: false
+        };
+        let set = self.subscribers.get(channelKey);
+        if (!set) {
+          set = /* @__PURE__ */ new Set();
+          self.subscribers.set(channelKey, set);
+        }
+        set.add(sub);
+      },
+      cancel() {
+        if (sub) self.removeSubscriber(channelKey, sub);
+      }
+    });
+  }
+  /**
+   * Refresh the rolling TTL for a subscriber after an event lands. Replaces
+   * the existing timer with a fresh 60s one.
+   */
+  refreshTtl(channelKey, sub) {
+    clearTimeout(sub.ttlTimer);
+    sub.ttlTimer = setTimeout(() => {
+      this.closeSubscriber(channelKey, sub);
+    }, GLASSBOX_STREAM_TTL_MS);
+  }
+  /**
+   * Close the subscriber's stream cleanly and remove from the fan-out set.
+   * Idempotent — safe to call multiple times.
+   */
+  closeSubscriber(channelKey, sub) {
+    if (sub.closed) return;
+    sub.closed = true;
+    clearTimeout(sub.ttlTimer);
+    try {
+      sub.controller.close();
+    } catch {
+    }
+    this.removeSubscriber(channelKey, sub);
+  }
+  removeSubscriber(channelKey, sub) {
+    clearTimeout(sub.ttlTimer);
+    const set = this.subscribers.get(channelKey);
+    if (!set) return;
+    set.delete(sub);
+    if (set.size === 0) this.subscribers.delete(channelKey);
+  }
+  /**
+   * Test-only reset. Tears down all subscribers, clears all state. Calling
+   * outside of tests is harmless but cancels every active stream.
+   */
+  _reset() {
+    for (const [, set] of this.subscribers) {
+      for (const sub of set) {
+        this.closeSubscriber("", sub);
+      }
+    }
+    this.subscribers.clear();
+  }
+};
+
+// src/glassbox/emit.ts
+var activePubSub;
+function getPubSub() {
+  if (activePubSub) return activePubSub;
+  const url = readEnv("UPSTASH_REDIS_URL");
+  const token = readEnv("UPSTASH_REDIS_TOKEN");
+  if (url && token) {
+    activePubSub = new UpstashPubSub({ url, token });
+  } else {
+    activePubSub = new MemoryPubSub();
+  }
+  return activePubSub;
+}
+function readEnv(key) {
+  try {
+    if (typeof process !== "undefined" && process.env) {
+      const v = process.env[key];
+      return v && v.trim() !== "" ? v : void 0;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function emitGlassboxEvent(traceId, appId, kind, data) {
+  if (!traceId) return;
+  const event = { kind, at: Date.now(), data };
+  const ps = getPubSub();
+  try {
+    const p1 = ps.publish(traceChannel(traceId), event);
+    if (p1 && typeof p1.then === "function") {
+      p1.catch(() => {
+      });
+    }
+  } catch {
+  }
+  if (appId) {
+    try {
+      const p2 = ps.publish(appChannel(appId), event);
+      if (p2 && typeof p2.then === "function") {
+        p2.catch(() => {
+        });
+      }
+    } catch {
+    }
+  }
+}
+function emitCompileStart(traceId, appId, data) {
+  emitGlassboxEvent(traceId, appId, "compile.start", data);
+}
+function emitCompileDone(traceId, appId, data) {
+  emitGlassboxEvent(traceId, appId, "compile.done", data);
+}
+function emitExecuteAttempt(traceId, appId, data) {
+  emitGlassboxEvent(traceId, appId, "execute.attempt", data);
+}
+function emitExecuteSuccess(traceId, appId, data) {
+  emitGlassboxEvent(traceId, appId, "execute.success", data);
+}
+function emitAdvisoryFired(traceId, appId, data) {
+  emitGlassboxEvent(traceId, appId, "advisory.fired", data);
+}
+function emitFallbackWalked(traceId, appId, data) {
+  emitGlassboxEvent(traceId, appId, "fallback.walked", data);
+}
+
+export {
+  GLASSBOX_STREAM_TTL_MS,
+  traceChannel,
+  appChannel,
+  getPubSub,
+  emitCompileStart,
+  emitCompileDone,
+  emitExecuteAttempt,
+  emitExecuteSuccess,
+  emitAdvisoryFired,
+  emitFallbackWalked
+};

package/dist/chunk-OZNAGO4U.mjs

@@ -0,0 +1,219 @@
+// src/version.ts
+var LIBRARY_VERSION = "2.0.0-alpha.81";
+
+// src/key-health.ts
+var JSON_HEADERS = { "Content-Type": "application/json" };
+var KEY_FINGERPRINT_DOMAIN = "kgauto-key-fingerprint-v1:";
+var KEY_FINGERPRINT_LENGTH = 12;
+async function keyFingerprint(key) {
+  const trimmed = key?.trim();
+  if (!trimmed) return void 0;
+  const subtle = globalThis.crypto?.subtle;
+  if (!subtle) return void 0;
+  const bytes = new TextEncoder().encode(KEY_FINGERPRINT_DOMAIN + trimmed);
+  const digest = await subtle.digest("SHA-256", bytes);
+  return [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, "0")).join("").slice(0, KEY_FINGERPRINT_LENGTH);
+}
+function jsonResponse(status, body) {
+  return new Response(JSON.stringify(body), { status, headers: JSON_HEADERS });
+}
+function bearerOf(req) {
+  const header = req.headers.get("Authorization") ?? "";
+  const match = /^Bearer\s+(.+)$/i.exec(header);
+  return match?.[1]?.trim() ?? "";
+}
+function requireString(name, value) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`createKeyHealthRoute: ${name} is required`);
+  }
+  return value;
+}
+function envKey(env, name) {
+  const v = env[name];
+  if (typeof v !== "string") return void 0;
+  const trimmed = v.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+var PROBE_SPECS = [
+  {
+    provider: "anthropic",
+    canonicalEnvName: "ANTHROPIC_API_KEY",
+    buildRequest: (key) => ({
+      url: "https://api.anthropic.com/v1/models?limit=1",
+      headers: { "x-api-key": key, "anthropic-version": "2023-06-01" }
+    })
+  },
+  {
+    provider: "deepseek",
+    canonicalEnvName: "DEEPSEEK_API_KEY",
+    buildRequest: (key) => ({
+      url: "https://api.deepseek.com/user/balance",
+      headers: { Authorization: `Bearer ${key}` }
+    }),
+    parseBalanceUsd: (body) => {
+      const infos = body?.balance_infos;
+      if (!Array.isArray(infos) || infos.length === 0) return void 0;
+      const first = infos[0];
+      if (first?.currency !== "USD") return void 0;
+      const n = Number(first.total_balance);
+      return Number.isFinite(n) ? n : void 0;
+    }
+  },
+  {
+    provider: "moonshot",
+    canonicalEnvName: "MOONSHOT_API_KEY",
+    buildRequest: (key) => ({
+      url: "https://api.moonshot.ai/v1/models",
+      headers: { Authorization: `Bearer ${key}` }
+    })
+  },
+  {
+    provider: "google",
+    canonicalEnvName: "GEMINI_API_KEY",
+    buildRequest: (key) => ({
+      url: `https://generativelanguage.googleapis.com/v1beta/models?pageSize=1&key=${encodeURIComponent(key)}`,
+      headers: {}
+    })
+  },
+  {
+    provider: "openai",
+    canonicalEnvName: "OPENAI_API_KEY",
+    buildRequest: (key) => ({
+      url: "https://api.openai.com/v1/models",
+      headers: { Authorization: `Bearer ${key}` }
+    })
+  }
+];
+function createKeyHealthRoute(config) {
+  const appId = requireString("appId", config.appId);
+  const ingestSecret = requireString("ingestSecret", config.ingestSecret);
+  const fetchFn = config.fetchImpl ?? fetch;
+  const timeoutMs = config.timeoutMs ?? 3e3;
+  async function probeProvider(spec, env) {
+    let key;
+    let envName = spec.canonicalEnvName;
+    if (spec.provider === "google") {
+      const gemini = envKey(env, "GEMINI_API_KEY");
+      const google = envKey(env, "GOOGLE_API_KEY");
+      const aiSdk = envKey(env, "GOOGLE_GENERATIVE_AI_API_KEY");
+      key = gemini ?? google ?? aiSdk;
+      envName = gemini ? "GEMINI_API_KEY" : google ? "GOOGLE_API_KEY" : aiSdk ? "GOOGLE_GENERATIVE_AI_API_KEY" : "GEMINI_API_KEY";
+    } else if (spec.provider === "moonshot") {
+      const moonshot = envKey(env, "MOONSHOT_API_KEY");
+      const kimi = envKey(env, "KIMI_API_KEY");
+      key = moonshot ?? kimi;
+      envName = moonshot ? "MOONSHOT_API_KEY" : kimi ? "KIMI_API_KEY" : "MOONSHOT_API_KEY";
+    } else {
+      key = envKey(env, spec.canonicalEnvName);
+    }
+    if (!key) {
+      return {
+        provider: spec.provider,
+        env: envName,
+        present: false,
+        valid: null,
+        detail: "key_absent"
+      };
+    }
+    const fingerprint = await keyFingerprint(key);
+    const base = {
+      provider: spec.provider,
+      env: envName,
+      present: true,
+      valid: null,
+      ...fingerprint ? { key_fingerprint: fingerprint } : {}
+    };
+    const { url, headers } = spec.buildRequest(key);
+    const started = Date.now();
+    let res;
+    try {
+      res = await fetchFn(url, {
+        method: "GET",
+        headers,
+        signal: AbortSignal.timeout(timeoutMs)
+      });
+    } catch (err) {
+      const isTimeout = err instanceof Error && (err.name === "TimeoutError" || err.name === "AbortError");
+      return {
+        ...base,
+        latency_ms: Date.now() - started,
+        // NEVER echo err.message — provider errors could theoretically carry
+        // request context; a fixed vocabulary keeps key material impossible.
+        detail: isTimeout ? "timeout" : "network_error"
+      };
+    }
+    const latencyMs = Date.now() - started;
+    if (res.ok) {
+      const result = {
+        ...base,
+        valid: true,
+        status: res.status,
+        latency_ms: latencyMs
+      };
+      if (spec.parseBalanceUsd) {
+        try {
+          const body = await res.json();
+          const balance = spec.parseBalanceUsd(body);
+          if (balance !== void 0) result.balance_usd = balance;
+        } catch {
+        }
+      }
+      return result;
+    }
+    if (res.status === 401 || res.status === 403) {
+      return { ...base, valid: false, status: res.status, latency_ms: latencyMs };
+    }
+    return {
+      ...base,
+      valid: null,
+      status: res.status,
+      latency_ms: latencyMs,
+      detail: `http_${res.status}`
+    };
+  }
+  async function handle(req) {
+    try {
+      if (req.method !== "GET") {
+        return jsonResponse(405, { error: "method_not_allowed" });
+      }
+      if (bearerOf(req) !== ingestSecret) {
+        return jsonResponse(401, { error: "unauthorized" });
+      }
+      const env = config.env ?? process.env;
+      const settled = await Promise.allSettled(
+        PROBE_SPECS.map((spec) => probeProvider(spec, env))
+      );
+      const keys = settled.map((s, i) => {
+        if (s.status === "fulfilled") return s.value;
+        const spec = PROBE_SPECS[i];
+        return {
+          provider: spec.provider,
+          env: spec.canonicalEnvName,
+          present: true,
+          valid: null,
+          detail: "probe_failed"
+        };
+      });
+      keys.sort((a, b) => a.provider.localeCompare(b.provider));
+      const body = {
+        app_id: appId,
+        checked_at: (/* @__PURE__ */ new Date()).toISOString(),
+        library_version: LIBRARY_VERSION,
+        keys
+      };
+      return jsonResponse(200, body);
+    } catch (err) {
+      void err;
+      return jsonResponse(500, { error: "key_health_internal_error" });
+    }
+  }
+  return { handle };
+}
+
+export {
+  LIBRARY_VERSION,
+  KEY_FINGERPRINT_DOMAIN,
+  KEY_FINGERPRINT_LENGTH,
+  keyFingerprint,
+  createKeyHealthRoute
+};

package/dist/chunk-P3TOAEG4.mjs

@@ -0,0 +1,56 @@
+// src/glassbox-routes/format.ts
+function formatAgo(iso, now = Date.now()) {
+  const t = Date.parse(iso);
+  if (Number.isNaN(t)) return iso;
+  const sec = Math.max(0, Math.floor((now - t) / 1e3));
+  if (sec < 60) return `${sec}s ago`;
+  if (sec < 3600) return `${Math.floor(sec / 60)}m ago`;
+  if (sec < 86400) return `${Math.floor(sec / 3600)}h ago`;
+  return `${Math.floor(sec / 86400)}d ago`;
+}
+function shortTraceId(traceId) {
+  return traceId.slice(-6);
+}
+function formatCost(usd) {
+  if (usd === void 0 || usd === null || Number.isNaN(usd)) return "\u2014";
+  if (usd === 0) return "$0.0000";
+  if (usd < 0.01) return `$${usd.toFixed(4)}`;
+  return `$${usd.toFixed(3)}`;
+}
+function formatMs(ms) {
+  if (ms === void 0 || ms === null) return "\u2014";
+  if (ms < 1e3) return `${ms}ms`;
+  return `${(ms / 1e3).toFixed(1)}s`;
+}
+function formatOrDash(v) {
+  if (v === void 0 || v === null) return "\u2014";
+  if (typeof v === "number") return v.toLocaleString();
+  return v;
+}
+function inputRatioLabel(status) {
+  switch (status) {
+    case "green":
+      return "healthy";
+    case "yellow":
+      return "borderline";
+    case "red":
+      return "input-heavy";
+  }
+}
+function formatMutation(mutation) {
+  const m = /^(.*)-(\d+)-to-(\d+)$/.exec(mutation);
+  if (m) {
+    return `${m[1]} (${m[2]} \u2192 ${m[3]})`;
+  }
+  return mutation;
+}
+
+export {
+  formatAgo,
+  shortTraceId,
+  formatCost,
+  formatMs,
+  formatOrDash,
+  inputRatioLabel,
+  formatMutation
+};

package/dist/chunk-RO22VFIF.mjs

@@ -0,0 +1,29 @@
+import {
+  appChannel,
+  getPubSub,
+  traceChannel
+} from "./chunk-NBO4R5PC.mjs";
+
+// src/glassbox/subscribe.ts
+function emptyStream() {
+  return new ReadableStream({
+    start(controller) {
+      controller.close();
+    }
+  });
+}
+function subscribe(traceId) {
+  if (!traceId) return emptyStream();
+  return getPubSub().subscribe(traceChannel(traceId));
+}
+function subscribeApp({
+  appId
+}) {
+  if (!appId) return emptyStream();
+  return getPubSub().subscribe(appChannel(appId));
+}
+
+export {
+  subscribe,
+  subscribeApp
+};