@bytesbrains/cruise 0.0.0-stage → 0.12.0

package/dist/chunk-4447IUTF.mjs

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+// Built by packages/cli/build.ts.
+
+// src/compress.ts
+var ARRAY_KEEP_HEAD = 20;
+var ARRAY_KEEP_TAIL = 10;
+var ARRAY_ELIDE_OVER = ARRAY_KEEP_HEAD + ARRAY_KEEP_TAIL + 5;

package/dist/chunk-5TVD3ZAI.mjs

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+// Built by packages/cli/build.ts.
+
+// src/keys.ts
+var NAMESPACE = "cru";
+var PUBLIC_LEN = 8;
+var SECRET_LEN = 32;
+var ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+var REJECT_AT = 248;
+var KEY_ENVIRONMENTS = ["live", "test", "demo"];
+var KEY_KINDS = [...KEY_ENVIRONMENTS, "svc"];
+var KEY_PATTERN = `cru_(${KEY_KINDS.join("|")})_[A-Za-z0-9]{${PUBLIC_LEN + SECRET_LEN}}`;
+function keyEnvironmentFor(environment) {
+  if (environment === "production" || environment === "selfhosted" || environment === "local") return "live";
+  return KEY_ENVIRONMENTS.includes(environment) ? environment : "test";
+}
+var DEMO_KEY_RATE_LIMIT_PER_MIN = 60;
+function keyRateLimitFor(environment, requested) {
+  if (environment !== "demo") return requested ?? null;
+  return requested == null ? DEMO_KEY_RATE_LIMIT_PER_MIN : Math.min(requested, DEMO_KEY_RATE_LIMIT_PER_MIN);
+}
+var CREDENTIAL_SHAPED = new RegExp(`cru_(${KEY_KINDS.join("|")})_`);
+function randomString(length) {
+  let out = "";
+  const buf = new Uint8Array(length * 2);
+  while (out.length < length) {
+    crypto.getRandomValues(buf);
+    for (const byte of buf) {
+      if (out.length === length) break;
+      if (byte < REJECT_AT) out += ALPHABET[byte % ALPHABET.length];
+    }
+  }
+  return out;
+}
+async function sha256Hex(input) {
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(input));
+  return [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function generateKey(environment) {
+  const publicPart = randomString(PUBLIC_LEN);
+  const secretPart = randomString(SECRET_LEN);
+  const key = `${NAMESPACE}_${environment}_${publicPart}${secretPart}`;
+  return { key, prefix: `${NAMESPACE}_${environment}_${publicPart}`, hash: await sha256Hex(key) };
+}
+async function generateServiceKey() {
+  const publicPart = randomString(PUBLIC_LEN);
+  const secretPart = randomString(SECRET_LEN);
+  const key = `${NAMESPACE}_svc_${publicPart}${secretPart}`;
+  return { key, prefix: `${NAMESPACE}_svc_${publicPart}`, hash: await sha256Hex(key) };
+}
+function parseKeyPrefix(presented) {
+  const parts = presented.split("_");
+  if (parts.length !== 3) return null;
+  const [namespace, environment, tail] = parts;
+  if (namespace !== NAMESPACE) return null;
+  if (environment === void 0 || !KEY_ENVIRONMENTS.includes(environment)) return null;
+  if (!tail || tail.length !== PUBLIC_LEN + SECRET_LEN) return null;
+  if (![...tail].every((c) => ALPHABET.includes(c))) return null;
+  return `${namespace}_${environment}_${tail.slice(0, PUBLIC_LEN)}`;
+}
+
+export {
+  keyEnvironmentFor,
+  keyRateLimitFor,
+  sha256Hex,
+  generateKey,
+  generateServiceKey,
+  parseKeyPrefix
+};

package/dist/chunk-7NQHBXVZ.mjs

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+// Built by packages/cli/build.ts.
+import {
+  HttpD1,
+  LocalD1
+} from "./chunk-JZPUTXM7.mjs";
+
+// scripts/cli-support.ts
+import { readFileSync } from "node:fs";
+import path from "node:path";
+
+// scripts/wrangler-config.ts
+function stripJsonc(raw) {
+  return JSON.parse(raw.replace(/(^|[^:])\/\/.*$/gm, "$1").replace(/\/\*[\s\S]*?\*\//g, ""));
+}
+function resolveScope(config, environment) {
+  const root = config;
+  const scope = environment === "top" ? root : root.env?.[environment];
+  if (!scope) throw new Error(`No such environment in wrangler.jsonc: ${environment}`);
+  return scope;
+}
+function resolveWorker(config, environment) {
+  const root = config;
+  const scope = resolveScope(config, environment);
+  const scriptName = scope.name ?? root.name;
+  if (!scriptName) throw new Error(`No worker name for environment: ${environment}`);
+  if (!root.account_id) throw new Error("No account_id in wrangler.jsonc");
+  return { accountId: root.account_id, scriptName };
+}
+function resolveDatabaseId(config, environment) {
+  const databaseId = resolveScope(config, environment).d1_databases?.[0]?.database_id;
+  if (!databaseId) throw new Error(`No d1_databases entry for environment: ${environment}`);
+  return databaseId;
+}
+
+// scripts/cli-support.ts
+function parseArgs(argv) {
+  const args = {};
+  for (let i = 0; i < argv.length; i++) {
+    const token = argv[i];
+    if (!token?.startsWith("--")) continue;
+    const name = token.slice(2);
+    const next = argv[i + 1];
+    if (next === void 0 || next.startsWith("--")) args[name] = true;
+    else {
+      args[name] = next;
+      i++;
+    }
+  }
+  return args;
+}
+function requireString(args, name) {
+  const value = args[name];
+  if (typeof value !== "string" || value.length === 0) throw new Error(`Missing required --${name}`);
+  return value;
+}
+function optionalNumber(args, name) {
+  const value = args[name];
+  if (typeof value !== "string") return null;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) throw new Error(`--${name} must be a number, got ${value}`);
+  return parsed;
+}
+function loadWranglerConfig() {
+  return stripJsonc(readFileSync(path.join(import.meta.dirname, "..", "wrangler.jsonc"), "utf8"));
+}
+function requireToken() {
+  const token = process.env.CLOUDFLARE_API_TOKEN;
+  if (!token) throw new Error("CLOUDFLARE_API_TOKEN is not set");
+  return token;
+}
+function connect(environment) {
+  if (environment === LOCAL_ENVIRONMENT) return new LocalD1();
+  const token = requireToken();
+  if (environment === CLOUDFLARE_ENVIRONMENT) {
+    const accountId2 = process.env.CRUISE_D1_ACCOUNT_ID;
+    const databaseId = process.env.CRUISE_D1_DATABASE_ID;
+    if (!accountId2 || !databaseId) throw new Error("--env cloudflare needs CRUISE_D1_ACCOUNT_ID and CRUISE_D1_DATABASE_ID");
+    return new HttpD1(accountId2, databaseId, token);
+  }
+  const config = loadWranglerConfig();
+  const { accountId } = resolveWorker(config, environment);
+  return new HttpD1(accountId, resolveDatabaseId(config, environment), token);
+}
+var LOCAL_ENVIRONMENT = "local";
+var CLOUDFLARE_ENVIRONMENT = "cloudflare";
+function environmentOf(args) {
+  return typeof args.env === "string" ? args.env : "staging";
+}
+function run(main) {
+  main().catch((error) => {
+    console.error(error instanceof Error ? error.message : error);
+    process.exitCode = 1;
+  });
+}
+
+export {
+  parseArgs,
+  requireString,
+  optionalNumber,
+  connect,
+  environmentOf,
+  run
+};

package/dist/chunk-BNP63KB2.mjs

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+// Built by packages/cli/build.ts.
+
+// src/ledger-attempts.ts
+async function rescuesBy(db, query) {
+  const scope = `(?1 = 'all' OR strftime('%Y-%m', l.at) = ?1)
+     AND (?2 IS NULL OR l.tenant_id = ?2)
+     AND (?3 IS NULL OR l.project_id = ?3)`;
+  const binds = [query.month, query.tenantId ?? null, query.projectId ?? null];
+  const [totals, rows] = await db.batch([
+    db.prepare(
+      `SELECT count(*) AS requests,
+                sum(CASE WHEN l.http_status BETWEEN 200 AND 299
+                          AND EXISTS (SELECT 1 FROM ledger_attempts a WHERE a.ledger_id = l.id) THEN 1 ELSE 0 END) AS rescued
+           FROM ledger l WHERE ${scope}`
+    ).bind(...binds),
+    // The first failure per rescued request, by the lowest position it wrote.
+    db.prepare(
+      `SELECT l.lane, a.model AS failed_model, a.upstream_id AS failed_upstream, a.http_status AS failed_status,
+                l.model AS served_model, count(*) AS rescued
+           FROM ledger l
+           JOIN ledger_attempts a ON a.ledger_id = l.id
+          WHERE ${scope}
+            AND l.http_status BETWEEN 200 AND 299
+            AND a.position = (SELECT min(position) FROM ledger_attempts f WHERE f.ledger_id = l.id)
+          GROUP BY l.lane, a.model, a.upstream_id, a.http_status, l.model
+          ORDER BY rescued DESC`
+    ).bind(...binds)
+  ]);
+  const total = totals.results[0] ?? { requests: 0, rescued: 0 };
+  const rescued = total.rescued ?? 0;
+  return {
+    requests: total.requests,
+    rescued,
+    rescued_share: total.requests === 0 ? 0 : Math.round(rescued / total.requests * 1e3) / 1e3,
+    rows: rows.results
+  };
+}
+
+export {
+  rescuesBy
+};