@megasaver/cli 1.2.1 → 1.3.0

package/dist-bundle/mega.mjs

@@ -14,9 +14,9 @@ import 'module';
 import { homedir } from 'os';
 import { access, mkdir, writeFile, lstat, readFile, constants, stat, rename, rm, chmod, readdir } from 'fs/promises';
 import { execFileSync, spawn } from 'child_process';
+import { once } from 'events';
 import { createServer } from 'http';
 import { StringDecoder } from 'string_decoder';
-import { once } from 'events';
 
 const require$1 = createRequire(import.meta.url);
 const __filename$1 = fileURLToPath(import.meta.url);
@@ -234724,6 +234724,48 @@ function classifyObservation(input) {
   const returnedTokens = eligibility === "eligible" ? input.returnedTokens : input.rawTokens;
   return { rawTokens: input.rawTokens, returnedTokens, eligibility, mediation: input.mediation };
 }
+function sumBytesSavedSince(events, sinceMs) {
+  let total = 0;
+  for (const e2 of events) {
+    const t2 = Date.parse(e2.createdAt);
+    if (Number.isFinite(t2) && t2 >= sinceMs && Number.isFinite(e2.bytesSaved)) {
+      total += e2.bytesSaved;
+    }
+  }
+  return total;
+}
+function proxyUsageSavings(input) {
+  const saved = Math.max(0, Math.round(input.savedTokens));
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let cacheReadTokens = 0;
+  let cacheCreationTokens = 0;
+  for (const u3 of input.usage) {
+    inputTokens += u3.inputTokens;
+    outputTokens += u3.outputTokens;
+    cacheReadTokens += u3.cacheReadTokens;
+    cacheCreationTokens += u3.cacheCreationTokens;
+  }
+  const newContextTokens = inputTokens + cacheCreationTokens;
+  const totalContextTokens = newContextTokens + cacheReadTokens;
+  const shareOf = (actual) => {
+    const wouldHave = saved + actual;
+    return wouldHave === 0 ? 0 : saved / wouldHave;
+  };
+  return {
+    savedTokens: saved,
+    proxyCalls: input.usage.length,
+    inputTokens,
+    cacheCreationTokens,
+    cacheReadTokens,
+    outputTokens,
+    newContextTokens,
+    totalContextTokens,
+    savedShareOfNewContext: shareOf(newContextTokens),
+    savedShareOfTotalContext: shareOf(totalContextTokens),
+    reliable: newContextTokens > 0 && saved <= newContextTokens
+  };
+}
 
 // ../../packages/content-store/dist/index.js
 init_dist();
@@ -240563,18 +240605,413 @@ var auditSessionCommand = defineCommand({
   }
 });
 
+// ../../packages/llm-proxy/dist/index.js
+init_zod();
+var proxyUsageEventSchema = external_exports.object({
+  id: external_exports.string().min(1),
+  ts: external_exports.string().datetime({ offset: true }),
+  model: external_exports.string(),
+  inputTokens: external_exports.number().int().nonnegative(),
+  outputTokens: external_exports.number().int().nonnegative(),
+  cacheReadTokens: external_exports.number().int().nonnegative(),
+  cacheCreationTokens: external_exports.number().int().nonnegative(),
+  messageCount: external_exports.number().int().nonnegative(),
+  stream: external_exports.boolean()
+}).strict();
+function asObject(value) {
+  return typeof value === "object" && value !== null ? value : null;
+}
+function int(value) {
+  return typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.trunc(value)) : 0;
+}
+function parseJson2(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+function usageFromRaw(usage) {
+  return {
+    inputTokens: int(usage.input_tokens),
+    outputTokens: int(usage.output_tokens),
+    cacheReadTokens: int(usage.cache_read_input_tokens),
+    cacheCreationTokens: int(usage.cache_creation_input_tokens)
+  };
+}
+function countRequestMessages(bodyText) {
+  const obj = asObject(parseJson2(bodyText));
+  if (obj === null) return { model: "", messageCount: 0 };
+  const model = typeof obj.model === "string" ? obj.model : "";
+  const messageCount = Array.isArray(obj.messages) ? obj.messages.length : 0;
+  return { model, messageCount };
+}
+function parseUsageFromJson(bodyText) {
+  const obj = asObject(parseJson2(bodyText));
+  const usage = obj && asObject(obj.usage);
+  return usage ? usageFromRaw(usage) : null;
+}
+function consumeSseLine(line2, acc) {
+  const trimmed = line2.trim();
+  if (!trimmed.startsWith("data:")) return false;
+  const payload = trimmed.slice("data:".length).trim();
+  if (payload.length === 0 || payload === "[DONE]") return false;
+  const event = asObject(parseJson2(payload));
+  if (event === null) return false;
+  if (event.type === "message_start") {
+    const message = asObject(event.message);
+    const usage = message && asObject(message.usage);
+    if (usage) {
+      const u3 = usageFromRaw(usage);
+      acc.inputTokens = u3.inputTokens;
+      acc.cacheReadTokens = u3.cacheReadTokens;
+      acc.cacheCreationTokens = u3.cacheCreationTokens;
+      acc.outputTokens = u3.outputTokens;
+      return true;
+    }
+  } else if (event.type === "message_delta") {
+    const usage = asObject(event.usage);
+    if (usage) {
+      acc.outputTokens = int(usage.output_tokens);
+      return true;
+    }
+  }
+  return false;
+}
+function createSseUsageScanner() {
+  let leftover = "";
+  let seen = false;
+  const acc = {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheCreationTokens: 0
+  };
+  return {
+    push(chunk) {
+      leftover += chunk;
+      const lines = leftover.split("\n");
+      leftover = lines.pop() ?? "";
+      for (const line2 of lines) {
+        if (consumeSseLine(line2, acc)) seen = true;
+      }
+    },
+    result() {
+      if (leftover.length > 0 && consumeSseLine(leftover, acc)) seen = true;
+      leftover = "";
+      return seen ? acc : null;
+    }
+  };
+}
+var STRIP_REQUEST = /* @__PURE__ */ new Set([
+  "host",
+  "connection",
+  "content-length",
+  "transfer-encoding",
+  "keep-alive",
+  "proxy-connection"
+]);
+var STRIP_RESPONSE = /* @__PURE__ */ new Set([
+  "content-encoding",
+  "content-length",
+  "transfer-encoding",
+  "connection"
+]);
+var MAX_JSON_CAPTURE_BYTES = 5e6;
+var MAX_REQUEST_BYTES = 5e7;
+async function readBody(req) {
+  const chunks = [];
+  let total = 0;
+  for await (const chunk of req) {
+    const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    total += buf.length;
+    if (total > MAX_REQUEST_BYTES) return null;
+    chunks.push(buf);
+  }
+  return Buffer.concat(chunks);
+}
+function filterRequestHeaders(headers) {
+  const out = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (value === void 0 || STRIP_REQUEST.has(key.toLowerCase())) continue;
+    out[key] = Array.isArray(value) ? value.join(", ") : value;
+  }
+  return out;
+}
+function responseHeaders(headers) {
+  const out = {};
+  headers.forEach((value, key) => {
+    if (!STRIP_RESPONSE.has(key.toLowerCase())) out[key] = value;
+  });
+  return out;
+}
+function createProxyHandler(deps) {
+  const { upstreamBaseUrl, onUsage, now, newId } = deps;
+  const doFetch = deps.upstreamFetch ?? fetch;
+  return async (req, res) => {
+    const path2 = req.url ?? "/";
+    const method = req.method ?? "GET";
+    const bodyBuf = await readBody(req);
+    if (bodyBuf === null) {
+      res.writeHead(413, { "content-type": "text/plain; charset=utf-8" });
+      res.end("mega proxy: request body too large");
+      return;
+    }
+    const headers = filterRequestHeaders(req.headers);
+    const init2 = bodyBuf.length > 0 ? { method, headers, body: bodyBuf } : { method, headers };
+    let upstream;
+    try {
+      upstream = await doFetch(`${upstreamBaseUrl}${path2}`, init2);
+    } catch {
+      res.writeHead(502, { "content-type": "text/plain; charset=utf-8" });
+      res.end("mega proxy: upstream request failed");
+      return;
+    }
+    const respHeaders = responseHeaders(upstream.headers);
+    res.writeHead(upstream.status, respHeaders);
+    const contentType = String(respHeaders["content-type"] ?? "");
+    const stream = contentType.includes("event-stream");
+    const scanner = stream ? createSseUsageScanner() : null;
+    const decoder = new TextDecoder();
+    const jsonCaptured = [];
+    let jsonLen = 0;
+    if (upstream.body) {
+      const reader = upstream.body.getReader();
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        const buf = Buffer.from(value);
+        if (!res.write(buf)) await once(res, "drain");
+        if (scanner) {
+          scanner.push(decoder.decode(value, { stream: true }));
+        } else if (jsonLen < MAX_JSON_CAPTURE_BYTES) {
+          jsonCaptured.push(buf);
+          jsonLen += buf.length;
+        }
+      }
+    }
+    res.end();
+    try {
+      if (method === "POST" && path2.startsWith("/v1/messages") && onUsage) {
+        const { model, messageCount } = countRequestMessages(bodyBuf.toString("utf8"));
+        const usage = scanner ? scanner.result() : parseUsageFromJson(Buffer.concat(jsonCaptured).toString("utf8"));
+        if (usage) {
+          onUsage({
+            id: newId(),
+            ts: now(),
+            model,
+            inputTokens: usage.inputTokens,
+            outputTokens: usage.outputTokens,
+            cacheReadTokens: usage.cacheReadTokens,
+            cacheCreationTokens: usage.cacheCreationTokens,
+            messageCount,
+            stream
+          });
+        }
+      }
+    } catch {
+    }
+  };
+}
+var LOOPBACK_HOST = "127.0.0.1";
+function startProxyServer(opts) {
+  const host = LOOPBACK_HOST;
+  const handler = createProxyHandler({
+    upstreamBaseUrl: opts.upstreamBaseUrl,
+    ...opts.upstreamFetch ? { upstreamFetch: opts.upstreamFetch } : {},
+    ...opts.onUsage ? { onUsage: opts.onUsage } : {},
+    now: opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString()),
+    newId: opts.newId ?? (() => randomUUID())
+  });
+  const server2 = createServer((req, res) => {
+    void handler(req, res).catch(() => {
+      if (!res.headersSent) res.writeHead(502, { "content-type": "text/plain; charset=utf-8" });
+      res.end();
+    });
+  });
+  return new Promise((resolve8, reject) => {
+    server2.once("error", reject);
+    server2.listen(opts.port, host, () => {
+      server2.removeListener("error", reject);
+      const addr = server2.address();
+      const port = typeof addr === "object" && addr !== null ? addr.port : opts.port;
+      resolve8({
+        url: `http://${host}:${port}`,
+        port,
+        close: () => new Promise((res) => {
+          server2.close(() => res());
+        })
+      });
+    });
+  });
+}
+function usagePath(storeRoot) {
+  return join(storeRoot, "proxy-usage", "usage.jsonl");
+}
+function isErrno5(e2) {
+  return e2 instanceof Error && "code" in e2;
+}
+async function appendProxyUsage(input) {
+  const event = proxyUsageEventSchema.parse(input.event);
+  const path2 = usagePath(input.storeRoot);
+  mkdirSync(dirname$1(path2), { recursive: true });
+  appendFileSync(path2, `${JSON.stringify(event)}
+`);
+}
+async function listProxyUsage(input) {
+  let raw;
+  try {
+    raw = readFileSync(usagePath(input.storeRoot), "utf8");
+  } catch (e2) {
+    if (isErrno5(e2) && e2.code === "ENOENT") return [];
+    throw e2;
+  }
+  const out = [];
+  for (const line2 of raw.split("\n")) {
+    const trimmed = line2.trim();
+    if (trimmed.length === 0) continue;
+    out.push(proxyUsageEventSchema.parse(JSON.parse(trimmed)));
+  }
+  return out;
+}
+
+// src/commands/audit/usage.ts
+init_dist();
+function readWorkspaceSavedTokensSince(storeRoot, workspaceKey, sinceMs) {
+  const dir = join(storeRoot, "stats", workspaceKey);
+  let names;
+  try {
+    names = readdirSync(dir);
+  } catch {
+    return 0;
+  }
+  const events = [];
+  for (const name of names) {
+    if (!name.endsWith(".events.jsonl")) continue;
+    let raw;
+    try {
+      raw = readFileSync(join(dir, name), "utf8");
+    } catch {
+      continue;
+    }
+    for (const line2 of raw.split("\n")) {
+      const trimmed = line2.trim();
+      if (trimmed.length === 0) continue;
+      let ev;
+      try {
+        ev = JSON.parse(trimmed);
+      } catch {
+        continue;
+      }
+      if (typeof ev === "object" && ev !== null && typeof ev.createdAt === "string" && typeof ev.bytesSaved === "number") {
+        const e2 = ev;
+        events.push({ createdAt: e2.createdAt, bytesSaved: e2.bytesSaved });
+      }
+    }
+  }
+  return tokensFromBytes(sumBytesSavedSince(events, sinceMs));
+}
+function renderUsageReport(m2) {
+  const pct = (n3) => `${(n3 * 100).toFixed(1)}%`;
+  const n2 = (x2) => x2.toLocaleString("en-US");
+  if (m2.proxyCalls === 0) {
+    return [
+      "No proxy usage recorded yet.",
+      "Run `mega proxy start`, point your agent at it (export ANTHROPIC_BASE_URL),",
+      "then this reports savings against your real Claude token usage."
+    ].join("\n");
+  }
+  const rawLines = [
+    `saved (tool output):       ~${n2(m2.savedTokens)} tokens (est, bytes/4)`,
+    `real new context:           ${n2(m2.newContextTokens)} tokens (input + cache-creation)`,
+    `real cache re-reads:        ${n2(m2.cacheReadTokens)} tokens`,
+    `real output:                ${n2(m2.outputTokens)} tokens`,
+    `proxy calls:                ${n2(m2.proxyCalls)}`
+  ];
+  if (!m2.reliable) {
+    return [
+      ...rawLines,
+      "",
+      "% suppressed: not enough matched proxy coverage for a trustworthy ratio",
+      "(tokens saved exceed the new context the proxy measured \u2014 the proxy saw only",
+      "part of your traffic, so any % would overstate the saving). Route your agent",
+      "through `mega proxy` for your whole workload, then re-run for a real figure."
+    ].join("\n");
+  }
+  return [
+    ...rawLines,
+    "",
+    `saved of new context:       ${pct(m2.savedShareOfNewContext)}   (saved / (saved + new context))`,
+    `saved of total processed:   ${pct(m2.savedShareOfTotalContext)}   (adds cache re-reads)`,
+    "",
+    "Scope: savings are windowed to the period since your first recorded proxy",
+    "call, to match the usage denominator. One-shot estimate (a floor): a saved",
+    "token also avoids cache re-reads on every later turn, so real impact is larger."
+  ].join("\n");
+}
+async function runAuditUsage(input) {
+  const workspaceKey = encodeWorkspaceKey(input.cwd);
+  const readSaved = input.readSaved ?? readWorkspaceSavedTokensSince;
+  const listUsage = input.listUsage ?? listProxyUsage;
+  let usage = [];
+  try {
+    usage = await listUsage({ storeRoot: input.storeRoot });
+  } catch {
+  }
+  const sinceMs = usage.reduce((min, u3) => {
+    const t2 = Date.parse(u3.ts);
+    return Number.isFinite(t2) ? Math.min(min, t2) : min;
+  }, Number.POSITIVE_INFINITY);
+  let savedTokens = 0;
+  if (usage.length > 0) {
+    try {
+      savedTokens = readSaved(input.storeRoot, workspaceKey, sinceMs);
+    } catch {
+    }
+  }
+  const savings = proxyUsageSavings({ savedTokens, usage });
+  return input.json ? JSON.stringify(savings) : renderUsageReport(savings);
+}
+var auditUsageCommand = defineCommand({
+  meta: {
+    name: "usage",
+    description: "Estimated savings vs your real total Claude usage (needs `mega proxy`)."
+  },
+  args: {
+    store: { type: "string", description: "Override store directory." },
+    json: { type: "boolean", default: false, description: "Emit JSON output." }
+  },
+  async run({ args }) {
+    const storeEnv = readStoreEnv(typeof args.store === "string" ? args.store : void 0);
+    let storeRoot;
+    try {
+      storeRoot = resolveStorePath(storeEnv);
+    } catch {
+      storeRoot = "";
+    }
+    const out = await runAuditUsage({
+      storeRoot,
+      cwd: process.cwd(),
+      json: args.json ?? false
+    });
+    process.stdout.write(`${out}
+`);
+  }
+});
+
 // src/commands/audit/index.ts
 var auditCommand = defineCommand({
   meta: {
     name: "audit",
-    description: "Token-savings dashboard: report, last, session, export, honest."
+    description: "Token-savings dashboard: report, last, session, export, honest, usage."
   },
   subCommands: {
     report: auditReportCommand,
     last: auditLastCommand,
     session: auditSessionCommand,
     export: auditExportCommand,
-    honest: auditHonestCommand
+    honest: auditHonestCommand,
+    usage: auditUsageCommand
   }
 });
 
@@ -242788,20 +243225,20 @@ var TOOL_CATEGORY = {
 };
 new Set(Object.keys(TOOL_CATEGORY));
 var HOOK_LOG_RELATIVE_PATH = join(".megasaver", "hooks", "claude-tool-calls.jsonl");
-function asObject(value) {
+function asObject2(value) {
   return typeof value === "object" && value !== null ? value : null;
 }
 function asString(value) {
   return typeof value === "string" ? value : void 0;
 }
 function buildHookLine(payload, now) {
-  const record2 = asObject(payload);
+  const record2 = asObject2(payload);
   if (record2 === null) return null;
   const tool = asString(record2.tool_name);
   if (tool === void 0) return null;
   const category = TOOL_CATEGORY[tool];
   if (category === void 0) return null;
-  const input = asObject(record2.tool_input);
+  const input = asObject2(record2.tool_input);
   const filePath = input ? asString(input.file_path) ?? asString(input.path) : void 0;
   const sessionId = asString(record2.session_id);
   const line2 = {
@@ -247502,8 +247939,8 @@ var ZodNumber2 = /* @__PURE__ */ $constructor("ZodNumber", (inst, def) => {
   inst.lt = (value, params) => inst.check(_lt(value, params));
   inst.lte = (value, params) => inst.check(_lte(value, params));
   inst.max = (value, params) => inst.check(_lte(value, params));
-  inst.int = (params) => inst.check(int(params));
-  inst.safe = (params) => inst.check(int(params));
+  inst.int = (params) => inst.check(int2(params));
+  inst.safe = (params) => inst.check(int2(params));
   inst.positive = (params) => inst.check(_gt(0, params));
   inst.nonnegative = (params) => inst.check(_gte(0, params));
   inst.negative = (params) => inst.check(_lt(0, params));
@@ -247525,7 +247962,7 @@ var ZodNumberFormat = /* @__PURE__ */ $constructor("ZodNumberFormat", (inst, def
   $ZodNumberFormat.init(inst, def);
   ZodNumber2.init(inst, def);
 });
-function int(params) {
+function int2(params) {
   return _int(ZodNumberFormat, params);
 }
 var ZodBoolean2 = /* @__PURE__ */ $constructor("ZodBoolean", (inst, def) => {
@@ -257154,257 +257591,6 @@ var projectCommand = defineCommand({
   }
 });
 
-// ../../packages/llm-proxy/dist/index.js
-init_zod();
-var proxyUsageEventSchema = external_exports.object({
-  id: external_exports.string().min(1),
-  ts: external_exports.string().datetime({ offset: true }),
-  model: external_exports.string(),
-  inputTokens: external_exports.number().int().nonnegative(),
-  outputTokens: external_exports.number().int().nonnegative(),
-  cacheReadTokens: external_exports.number().int().nonnegative(),
-  cacheCreationTokens: external_exports.number().int().nonnegative(),
-  messageCount: external_exports.number().int().nonnegative(),
-  stream: external_exports.boolean()
-}).strict();
-function asObject2(value) {
-  return typeof value === "object" && value !== null ? value : null;
-}
-function int2(value) {
-  return typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.trunc(value)) : 0;
-}
-function parseJson2(text) {
-  try {
-    return JSON.parse(text);
-  } catch {
-    return null;
-  }
-}
-function usageFromRaw(usage) {
-  return {
-    inputTokens: int2(usage.input_tokens),
-    outputTokens: int2(usage.output_tokens),
-    cacheReadTokens: int2(usage.cache_read_input_tokens),
-    cacheCreationTokens: int2(usage.cache_creation_input_tokens)
-  };
-}
-function countRequestMessages(bodyText) {
-  const obj = asObject2(parseJson2(bodyText));
-  if (obj === null) return { model: "", messageCount: 0 };
-  const model = typeof obj.model === "string" ? obj.model : "";
-  const messageCount = Array.isArray(obj.messages) ? obj.messages.length : 0;
-  return { model, messageCount };
-}
-function parseUsageFromJson(bodyText) {
-  const obj = asObject2(parseJson2(bodyText));
-  const usage = obj && asObject2(obj.usage);
-  return usage ? usageFromRaw(usage) : null;
-}
-function consumeSseLine(line2, acc) {
-  const trimmed = line2.trim();
-  if (!trimmed.startsWith("data:")) return false;
-  const payload = trimmed.slice("data:".length).trim();
-  if (payload.length === 0 || payload === "[DONE]") return false;
-  const event = asObject2(parseJson2(payload));
-  if (event === null) return false;
-  if (event.type === "message_start") {
-    const message = asObject2(event.message);
-    const usage = message && asObject2(message.usage);
-    if (usage) {
-      const u3 = usageFromRaw(usage);
-      acc.inputTokens = u3.inputTokens;
-      acc.cacheReadTokens = u3.cacheReadTokens;
-      acc.cacheCreationTokens = u3.cacheCreationTokens;
-      acc.outputTokens = u3.outputTokens;
-      return true;
-    }
-  } else if (event.type === "message_delta") {
-    const usage = asObject2(event.usage);
-    if (usage) {
-      acc.outputTokens = int2(usage.output_tokens);
-      return true;
-    }
-  }
-  return false;
-}
-function createSseUsageScanner() {
-  let leftover = "";
-  let seen = false;
-  const acc = {
-    inputTokens: 0,
-    outputTokens: 0,
-    cacheReadTokens: 0,
-    cacheCreationTokens: 0
-  };
-  return {
-    push(chunk) {
-      leftover += chunk;
-      const lines = leftover.split("\n");
-      leftover = lines.pop() ?? "";
-      for (const line2 of lines) {
-        if (consumeSseLine(line2, acc)) seen = true;
-      }
-    },
-    result() {
-      if (leftover.length > 0 && consumeSseLine(leftover, acc)) seen = true;
-      leftover = "";
-      return seen ? acc : null;
-    }
-  };
-}
-var STRIP_REQUEST = /* @__PURE__ */ new Set([
-  "host",
-  "connection",
-  "content-length",
-  "transfer-encoding",
-  "keep-alive",
-  "proxy-connection"
-]);
-var STRIP_RESPONSE = /* @__PURE__ */ new Set([
-  "content-encoding",
-  "content-length",
-  "transfer-encoding",
-  "connection"
-]);
-var MAX_JSON_CAPTURE_BYTES = 5e6;
-var MAX_REQUEST_BYTES = 5e7;
-async function readBody(req) {
-  const chunks = [];
-  let total = 0;
-  for await (const chunk of req) {
-    const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-    total += buf.length;
-    if (total > MAX_REQUEST_BYTES) return null;
-    chunks.push(buf);
-  }
-  return Buffer.concat(chunks);
-}
-function filterRequestHeaders(headers) {
-  const out = {};
-  for (const [key, value] of Object.entries(headers)) {
-    if (value === void 0 || STRIP_REQUEST.has(key.toLowerCase())) continue;
-    out[key] = Array.isArray(value) ? value.join(", ") : value;
-  }
-  return out;
-}
-function responseHeaders(headers) {
-  const out = {};
-  headers.forEach((value, key) => {
-    if (!STRIP_RESPONSE.has(key.toLowerCase())) out[key] = value;
-  });
-  return out;
-}
-function createProxyHandler(deps) {
-  const { upstreamBaseUrl, onUsage, now, newId } = deps;
-  const doFetch = deps.upstreamFetch ?? fetch;
-  return async (req, res) => {
-    const path2 = req.url ?? "/";
-    const method = req.method ?? "GET";
-    const bodyBuf = await readBody(req);
-    if (bodyBuf === null) {
-      res.writeHead(413, { "content-type": "text/plain; charset=utf-8" });
-      res.end("mega proxy: request body too large");
-      return;
-    }
-    const headers = filterRequestHeaders(req.headers);
-    const init2 = bodyBuf.length > 0 ? { method, headers, body: bodyBuf } : { method, headers };
-    let upstream;
-    try {
-      upstream = await doFetch(`${upstreamBaseUrl}${path2}`, init2);
-    } catch {
-      res.writeHead(502, { "content-type": "text/plain; charset=utf-8" });
-      res.end("mega proxy: upstream request failed");
-      return;
-    }
-    const respHeaders = responseHeaders(upstream.headers);
-    res.writeHead(upstream.status, respHeaders);
-    const contentType = String(respHeaders["content-type"] ?? "");
-    const stream = contentType.includes("event-stream");
-    const scanner = stream ? createSseUsageScanner() : null;
-    const decoder = new TextDecoder();
-    const jsonCaptured = [];
-    let jsonLen = 0;
-    if (upstream.body) {
-      const reader = upstream.body.getReader();
-      for (; ; ) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        const buf = Buffer.from(value);
-        if (!res.write(buf)) await once(res, "drain");
-        if (scanner) {
-          scanner.push(decoder.decode(value, { stream: true }));
-        } else if (jsonLen < MAX_JSON_CAPTURE_BYTES) {
-          jsonCaptured.push(buf);
-          jsonLen += buf.length;
-        }
-      }
-    }
-    res.end();
-    try {
-      if (method === "POST" && path2.startsWith("/v1/messages") && onUsage) {
-        const { model, messageCount } = countRequestMessages(bodyBuf.toString("utf8"));
-        const usage = scanner ? scanner.result() : parseUsageFromJson(Buffer.concat(jsonCaptured).toString("utf8"));
-        if (usage) {
-          onUsage({
-            id: newId(),
-            ts: now(),
-            model,
-            inputTokens: usage.inputTokens,
-            outputTokens: usage.outputTokens,
-            cacheReadTokens: usage.cacheReadTokens,
-            cacheCreationTokens: usage.cacheCreationTokens,
-            messageCount,
-            stream
-          });
-        }
-      }
-    } catch {
-    }
-  };
-}
-var LOOPBACK_HOST = "127.0.0.1";
-function startProxyServer(opts) {
-  const host = LOOPBACK_HOST;
-  const handler = createProxyHandler({
-    upstreamBaseUrl: opts.upstreamBaseUrl,
-    ...opts.upstreamFetch ? { upstreamFetch: opts.upstreamFetch } : {},
-    ...opts.onUsage ? { onUsage: opts.onUsage } : {},
-    now: opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString()),
-    newId: opts.newId ?? (() => randomUUID())
-  });
-  const server2 = createServer((req, res) => {
-    void handler(req, res).catch(() => {
-      if (!res.headersSent) res.writeHead(502, { "content-type": "text/plain; charset=utf-8" });
-      res.end();
-    });
-  });
-  return new Promise((resolve8, reject) => {
-    server2.once("error", reject);
-    server2.listen(opts.port, host, () => {
-      server2.removeListener("error", reject);
-      const addr = server2.address();
-      const port = typeof addr === "object" && addr !== null ? addr.port : opts.port;
-      resolve8({
-        url: `http://${host}:${port}`,
-        port,
-        close: () => new Promise((res) => {
-          server2.close(() => res());
-        })
-      });
-    });
-  });
-}
-function usagePath(storeRoot) {
-  return join(storeRoot, "proxy-usage", "usage.jsonl");
-}
-async function appendProxyUsage(input) {
-  const event = proxyUsageEventSchema.parse(input.event);
-  const path2 = usagePath(input.storeRoot);
-  mkdirSync(dirname$1(path2), { recursive: true });
-  appendFileSync(path2, `${JSON.stringify(event)}
-`);
-}
-
 // src/commands/proxy/start.ts
 var DEFAULT_PORT = 8787;
 var DEFAULT_UPSTREAM = "https://api.anthropic.com";
@@ -259572,7 +259758,7 @@ var toolsCommand = defineCommand({
 });
 
 // src/main.ts
-var version2 = "1.2.1" ;
+var version2 = "1.3.0" ;
 var mainCommand = defineCommand({
   meta: {
     name: "mega",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@megasaver/cli",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "description": "Mega Saver CLI - the `mega` command.",
   "type": "module",
   "bin": {