@nyte-ai/host 0.0.0-stage → 0.0.18

package/dist/chunks/canvas-preview-0cmbkp2j.js

@@ -0,0 +1,65 @@
+import {
+  parseText2,
+  parseRef2
+} from "./canvas-preview-69fkk9yn.js";
+
+// src/session-index.ts
+import { projectSessionIndex, sessionIndexRef } from "@nyte-ai/core/store";
+import { asId } from "@nyte-ai/schema";
+function sessionIndexChanges2(name, object, revision) {
+  const ref = sessionIndexRef(name);
+  if (ref === null)
+    return [];
+  const entry = projectSessionIndex(name, object);
+  if (ref.kind === "session") {
+    return entry?.kind === "session" ? [
+      {
+        text: "INSERT INTO session_index (name, session, parent, sort_at, version) VALUES (?, ?, ?, ?, ?) ON CONFLICT (name) DO UPDATE SET session = excluded.session, parent = excluded.parent, sort_at = excluded.sort_at, version = excluded.version",
+        values: [name, entry.session, entry.parent, -entry.at, revision]
+      }
+    ] : [{ text: "DELETE FROM session_index WHERE name = ?", values: [name] }];
+  }
+  return entry !== null && entry.kind !== "session" ? [
+    {
+      text: "INSERT INTO pending_work (name, session, kind) VALUES (?, ?, ?) ON CONFLICT (name) DO UPDATE SET session = excluded.session, kind = excluded.kind",
+      values: [name, entry.session, entry.kind]
+    }
+  ] : [{ text: "DELETE FROM pending_work WHERE name = ?", values: [name] }];
+}
+function sqlSessionIndex2(read) {
+  return {
+    async list({ parents, after, limit }) {
+      const conditions = [];
+      const values = [];
+      if (parents.kind === "roots")
+        conditions.push("s.parent IS NULL");
+      if (parents.kind === "children") {
+        conditions.push("s.parent = ?");
+        values.push(parents.session);
+      }
+      if (after !== undefined) {
+        conditions.push("(s.sort_at, s.session) > (?, ?)");
+        values.push(-after.at, after.id);
+      }
+      values.push(limit);
+      return (await read(`SELECT r.name, r.target, r.revision, s.version FROM session_index s JOIN refs r ON r.name = s.name${conditions.length === 0 ? "" : ` WHERE ${conditions.join(" AND ")}`} ORDER BY s.sort_at, s.session LIMIT ?`, values)).map((row) => ({
+        ref: parseRef2(row),
+        version: asId(parseText2(row.version) ?? "")
+      }));
+    },
+    async work({ after, limit }) {
+      return (await read(`SELECT r.name, r.target, r.revision FROM (SELECT DISTINCT session FROM pending_work${after === undefined ? "" : " WHERE session > ?"}) p JOIN session_index s ON s.session = p.session JOIN refs r ON r.name = s.name ORDER BY p.session LIMIT ?`, after === undefined ? [limit] : [after, limit])).map(parseRef2);
+    },
+    async pending({ kind, sessions }) {
+      if (sessions?.length === 0)
+        return [];
+      return (await read(`SELECT r.name, r.target, r.revision FROM pending_work p JOIN refs r ON r.name = p.name WHERE p.kind = ?${sessions === undefined ? "" : ` AND p.session IN (${sessions.map(() => "?").join(", ")})`} ORDER BY p.name`, [kind, ...sessions ?? []])).map(parseRef2);
+    }
+  };
+}
+function postgresSessionIndexQuery2(text) {
+  let parameter = 0;
+  return text.replaceAll("?", () => `$${++parameter}`);
+}
+
+export { sessionIndexChanges2, sqlSessionIndex2, postgresSessionIndexQuery2 };

package/dist/chunks/canvas-preview-0nq75h9k.js

@@ -0,0 +1,7 @@
+// src/hash.ts
+import { createHash } from "node:crypto";
+function sha2562(data) {
+  return createHash("sha256").update(data).digest("hex");
+}
+
+export { sha2562 };

package/dist/chunks/canvas-preview-0nrnbt76.js

@@ -0,0 +1,497 @@
+import {
+  emptyModelUsage2,
+  recordedUsage2,
+  summarizeModels2
+} from "./canvas-preview-srgfpdmf.js";
+
+// src/usage.ts
+import { Buffer } from "node:buffer";
+import { constants, existsSync } from "node:fs";
+import { lstat, open, opendir, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import process from "node:process";
+import { StringDecoder } from "node:string_decoder";
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+import { calculateCost } from "@nyte-ai/ai";
+var tokens = Type.Integer({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER });
+var envelope = Type.Object({ type: Type.String() });
+var assistantRecord = Type.Object({
+  type: Type.Literal("assistant"),
+  requestId: Type.Optional(Type.String()),
+  costUSD: Type.Optional(Type.Unknown()),
+  message: Type.Object({
+    id: Type.Optional(Type.String()),
+    model: Type.String({ minLength: 1, pattern: "\\S" }),
+    usage: Type.Object({
+      input_tokens: tokens,
+      output_tokens: tokens,
+      cache_read_input_tokens: Type.Optional(tokens),
+      cache_creation_input_tokens: Type.Optional(tokens),
+      cache_creation: Type.Optional(Type.Object({
+        ephemeral_5m_input_tokens: Type.Optional(tokens),
+        ephemeral_1h_input_tokens: Type.Optional(tokens)
+      }))
+    })
+  })
+});
+var reportedCost = Type.Number({ minimum: 0, maximum: Number.MAX_VALUE });
+function betterSnapshot(previous, next) {
+  if (previous === undefined)
+    return true;
+  const usage = next.usage;
+  return usage.totalTokens > previous.usage.totalTokens || usage.totalTokens === previous.usage.totalTokens && (usage.output > previous.usage.output || usage.output === previous.usage.output && previous.costUSD === undefined && next.costUSD !== undefined);
+}
+async function scanClaudeCodeFile(path, signal) {
+  const keyed = new Map;
+  const anonymous = [];
+  let malformedRecords = 0;
+  for await (const line of historyLines(path, signal)) {
+    signal?.throwIfAborted();
+    if (!line.text.trim())
+      continue;
+    let value;
+    try {
+      value = JSON.parse(line.text);
+    } catch {
+      if (line.terminated)
+        malformedRecords++;
+      continue;
+    }
+    if (!Value.Check(envelope, value)) {
+      malformedRecords++;
+      continue;
+    }
+    if (value.type !== "assistant")
+      continue;
+    if (!Value.Check(assistantRecord, value)) {
+      malformedRecords++;
+      continue;
+    }
+    const raw = value.message.usage;
+    const cacheWrite = raw.cache_creation_input_tokens ?? 0;
+    const cacheWrite1h = raw.cache_creation?.ephemeral_1h_input_tokens;
+    if ((cacheWrite1h ?? 0) + (raw.cache_creation?.ephemeral_5m_input_tokens ?? 0) > cacheWrite) {
+      malformedRecords++;
+      continue;
+    }
+    const usage = {
+      ...emptyModelUsage2(),
+      input: raw.input_tokens,
+      output: raw.output_tokens,
+      cacheRead: raw.cache_read_input_tokens ?? 0,
+      cacheWrite,
+      totalTokens: raw.input_tokens + raw.output_tokens + (raw.cache_read_input_tokens ?? 0) + cacheWrite
+    };
+    if (cacheWrite1h !== undefined)
+      usage.cacheWrite1h = cacheWrite1h;
+    const snapshot = {
+      model: value.message.model,
+      usage,
+      costUSD: Value.Check(reportedCost, value.costUSD) ? value.costUSD : undefined
+    };
+    const messageId = value.message.id?.trim() || null;
+    const requestId = value.requestId?.trim() || null;
+    if (messageId === null && requestId === null) {
+      anonymous.push(snapshot);
+      continue;
+    }
+    const identity = JSON.stringify([messageId, requestId]);
+    if (betterSnapshot(keyed.get(identity), snapshot))
+      keyed.set(identity, snapshot);
+  }
+  return { keyed: [...keyed], anonymous, malformedRecords };
+}
+async function scanCached(path, cache, seen, parse) {
+  seen.add(path);
+  if (cache === undefined)
+    return parse();
+  const info = await lstat(path);
+  if (!info.isFile())
+    throw new Error("History is not a regular file.");
+  const hit = cache.get(path);
+  if (hit !== undefined && hit.size === info.size && hit.mtimeMs === info.mtimeMs)
+    return hit.scan;
+  const scan = await parse();
+  cache.set(path, { size: info.size, mtimeMs: info.mtimeMs, scan });
+  return scan;
+}
+function pruneCache(cache, seen) {
+  if (cache === undefined)
+    return;
+  for (const path of cache.keys())
+    if (!seen.has(path))
+      cache.delete(path);
+}
+async function readClaudeCodeUsage2(options) {
+  options.signal?.throwIfAborted();
+  const projects = join(resolve(options.configDir ?? (process.env.CLAUDE_CONFIG_DIR?.trim() || join(homedir(), ".claude"))), "projects");
+  if (!existsSync(projects))
+    return { kind: "missing" };
+  try {
+    const root = await stat(projects);
+    options.signal?.throwIfAborted();
+    if (!root.isDirectory())
+      return { kind: "failed", message: "Claude Code history path is not a directory." };
+  } catch {
+    options.signal?.throwIfAborted();
+    return { kind: "failed", message: "Could not open Claude Code local history." };
+  }
+  const keyed = new Map;
+  const anonymous = [];
+  const seen = new Set;
+  let malformedRecords = 0;
+  let unreadableFiles = 0;
+  try {
+    const directories = [projects];
+    for (const directory of directories) {
+      options.signal?.throwIfAborted();
+      try {
+        if (directory !== projects && (await lstat(directory)).isSymbolicLink())
+          continue;
+        const entries = await opendir(directory);
+        for await (const entry of entries) {
+          options.signal?.throwIfAborted();
+          const path = join(directory, entry.name);
+          if (entry.isDirectory()) {
+            directories.push(path);
+            continue;
+          }
+          if (!entry.isFile() || !entry.name.endsWith(".jsonl"))
+            continue;
+          try {
+            const scan = await scanCached(path, options.cache, seen, () => scanClaudeCodeFile(path, options.signal));
+            malformedRecords += scan.malformedRecords;
+            anonymous.push(...scan.anonymous);
+            for (const [identity, snapshot] of scan.keyed) {
+              if (betterSnapshot(keyed.get(identity), snapshot))
+                keyed.set(identity, snapshot);
+            }
+          } catch {
+            options.signal?.throwIfAborted();
+            unreadableFiles++;
+          }
+        }
+      } catch (error) {
+        options.signal?.throwIfAborted();
+        if (directory === projects)
+          throw error;
+        unreadableFiles++;
+      }
+    }
+    options.signal?.throwIfAborted();
+    pruneCache(options.cache, seen);
+    const catalog = options.models.getModels("anthropic").filter((model) => model.provider === "anthropic");
+    const rows = [];
+    let unpricedRecords = 0;
+    for (const snapshot of [...keyed.values(), ...anonymous]) {
+      options.signal?.throwIfAborted();
+      const usage = { ...snapshot.usage, cost: { ...snapshot.usage.cost } };
+      if (snapshot.costUSD !== undefined) {
+        usage.cost.total = snapshot.costUSD;
+      } else {
+        const matches = catalog.filter((model) => model.id === snapshot.model);
+        const model = matches.length === 1 ? matches[0] : undefined;
+        if (model)
+          calculateCost(model, usage);
+        else
+          unpricedRecords++;
+      }
+      rows.push({
+        provider: "anthropic",
+        model: snapshot.model,
+        turns: 1,
+        usage: recordedUsage2(usage)
+      });
+    }
+    options.signal?.throwIfAborted();
+    return {
+      kind: "ready",
+      summary: summarizeModels2(rows),
+      unpricedRecords,
+      malformedRecords,
+      unreadableFiles
+    };
+  } catch {
+    options.signal?.throwIfAborted();
+    return { kind: "failed", message: "Could not read Claude Code local history." };
+  }
+}
+var codexTokens = Type.Object({
+  input_tokens: Type.Optional(tokens),
+  cached_input_tokens: Type.Optional(tokens),
+  cache_write_input_tokens: Type.Optional(tokens),
+  output_tokens: Type.Optional(tokens),
+  reasoning_output_tokens: Type.Optional(tokens)
+});
+var usageRecord = Type.Object({
+  type: Type.Literal("token_usage_record"),
+  payload: Type.Object({
+    response_id: Type.Optional(Type.String()),
+    usage: codexTokens
+  })
+});
+var turnContext = Type.Object({
+  type: Type.Literal("turn_context"),
+  payload: Type.Object({ model: Type.Optional(Type.String({ minLength: 1 })) })
+});
+var sessionMeta = Type.Object({
+  type: Type.Literal("session_meta"),
+  timestamp: Type.Optional(Type.String()),
+  payload: Type.Object({
+    forked_from_id: Type.Optional(Type.String()),
+    parent_thread_id: Type.Optional(Type.String())
+  })
+});
+var tokenCount = Type.Object({
+  type: Type.Literal("event_msg"),
+  timestamp: Type.Optional(Type.String()),
+  payload: Type.Object({
+    type: Type.Literal("token_count"),
+    info: Type.Object({ last_token_usage: Type.Optional(codexTokens) })
+  })
+});
+function codexUsage(raw) {
+  const input = raw.input_tokens ?? 0;
+  const cacheRead = raw.cached_input_tokens ?? 0;
+  const cacheWrite = raw.cache_write_input_tokens ?? 0;
+  const output = raw.output_tokens ?? 0;
+  const uncached = Math.max(0, input - cacheRead - cacheWrite);
+  return {
+    ...emptyModelUsage2(),
+    input: uncached,
+    output,
+    cacheRead,
+    cacheWrite,
+    reasoning: Math.min(output, raw.reasoning_output_tokens ?? 0),
+    totalTokens: uncached + output + cacheRead + cacheWrite
+  };
+}
+var FORK_COPY_MAX_GAP_MS = 1000;
+function parseMs(value) {
+  if (value === undefined)
+    return;
+  const parsed = Date.parse(value);
+  return Number.isNaN(parsed) ? undefined : parsed;
+}
+async function readCodexUsage2(options) {
+  options.signal?.throwIfAborted();
+  const home = resolve(options.homeDir ?? (process.env.CODEX_HOME?.trim() || join(homedir(), ".codex")));
+  const roots = [join(home, "sessions"), join(home, "archived_sessions")];
+  const present = [];
+  for (const root of roots) {
+    if (!existsSync(root))
+      continue;
+    try {
+      if ((await stat(root)).isDirectory())
+        present.push(root);
+    } catch {
+      options.signal?.throwIfAborted();
+      return { kind: "failed", message: "Could not open Codex local history." };
+    }
+  }
+  if (present.length === 0)
+    return { kind: "missing" };
+  const responses = new Map;
+  const legacy = [];
+  const seen = new Set;
+  let malformedRecords = 0;
+  let unreadableFiles = 0;
+  try {
+    for (const root of present) {
+      for await (const path of jsonlFiles(root, options.signal)) {
+        try {
+          const scan = await scanCached(path, options.cache, seen, () => scanCodexRollout(path, options.signal));
+          malformedRecords += scan.malformedRecords;
+          if (scan.modern.length > 0) {
+            for (const [id, row] of scan.modern)
+              if (!responses.has(id))
+                responses.set(id, row);
+          } else {
+            legacy.push(...scan.legacy);
+          }
+        } catch {
+          options.signal?.throwIfAborted();
+          unreadableFiles++;
+        }
+      }
+    }
+    options.signal?.throwIfAborted();
+    pruneCache(options.cache, seen);
+    const catalog = options.models.getModels("openai-codex").filter((model) => model.provider === "openai-codex");
+    const rows = [];
+    let unpricedRecords = 0;
+    for (const row of [...responses.values(), ...legacy]) {
+      options.signal?.throwIfAborted();
+      const usage = { ...row.usage, cost: { ...row.usage.cost } };
+      const matches = catalog.filter((model) => model.id === row.model);
+      const model = matches.length === 1 ? matches[0] : undefined;
+      if (model)
+        calculateCost(model, usage);
+      else
+        unpricedRecords++;
+      rows.push({
+        provider: "openai-codex",
+        model: row.model,
+        turns: 1,
+        usage: recordedUsage2(usage)
+      });
+    }
+    return {
+      kind: "ready",
+      summary: summarizeModels2(rows),
+      unpricedRecords,
+      malformedRecords,
+      unreadableFiles
+    };
+  } catch {
+    options.signal?.throwIfAborted();
+    return { kind: "failed", message: "Could not read Codex local history." };
+  }
+}
+async function scanCodexRollout(path, signal) {
+  const modern = new Map;
+  const legacy = [];
+  let malformedRecords = 0;
+  let model = "";
+  let sawMeta = false;
+  let signature;
+  let forkAnchorMs;
+  for await (const line of historyLines(path, signal)) {
+    signal?.throwIfAborted();
+    if (!line.text.trim())
+      continue;
+    let value;
+    try {
+      value = JSON.parse(line.text);
+    } catch {
+      if (line.terminated)
+        malformedRecords++;
+      continue;
+    }
+    if (!Value.Check(envelope, value)) {
+      malformedRecords++;
+      continue;
+    }
+    if (Value.Check(turnContext, value)) {
+      if (value.payload.model !== undefined)
+        model = value.payload.model;
+      continue;
+    }
+    if (Value.Check(sessionMeta, value)) {
+      if (sawMeta)
+        continue;
+      sawMeta = true;
+      const forked = value.payload.forked_from_id !== undefined || value.payload.parent_thread_id !== undefined;
+      if (forked)
+        forkAnchorMs = parseMs(value.timestamp);
+      continue;
+    }
+    if (Value.Check(usageRecord, value)) {
+      const id = value.payload.response_id;
+      if (id === undefined || model === "")
+        continue;
+      const usage = codexUsage(value.payload.usage);
+      if (usage.totalTokens > 0 && !modern.has(id))
+        modern.set(id, { model, usage });
+      continue;
+    }
+    if (!Value.Check(tokenCount, value))
+      continue;
+    const last = value.payload.info.last_token_usage;
+    if (last === undefined || model === "")
+      continue;
+    const next = JSON.stringify(last);
+    if (next === signature)
+      continue;
+    signature = next;
+    if (forkAnchorMs !== undefined) {
+      const at = parseMs(value.timestamp);
+      if (at !== undefined && at - forkAnchorMs < FORK_COPY_MAX_GAP_MS) {
+        forkAnchorMs = at;
+        continue;
+      }
+      forkAnchorMs = undefined;
+    }
+    const usage = codexUsage(last);
+    if (usage.totalTokens > 0)
+      legacy.push({ model, usage });
+  }
+  return { modern: [...modern], legacy, malformedRecords };
+}
+async function* jsonlFiles(root, signal) {
+  const directories = [root];
+  for (const directory of directories) {
+    signal?.throwIfAborted();
+    try {
+      if (directory !== root && (await lstat(directory)).isSymbolicLink())
+        continue;
+      for await (const entry of await opendir(directory)) {
+        signal?.throwIfAborted();
+        const path = join(directory, entry.name);
+        if (entry.isDirectory())
+          directories.push(path);
+        else if (entry.isFile() && entry.name.endsWith(".jsonl"))
+          yield path;
+      }
+    } catch (error) {
+      if (directory === root)
+        throw error;
+    }
+  }
+}
+async function* historyLines(path, signal) {
+  const file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+  try {
+    const stat = await file.stat();
+    if (!stat.isFile())
+      throw new Error("History is not a regular file.");
+    const buffer = Buffer.alloc(64 * 1024);
+    const decoder = new StringDecoder("utf8");
+    let pending = "";
+    let position = 0;
+    while (position < stat.size) {
+      signal?.throwIfAborted();
+      const { bytesRead } = await file.read(buffer, 0, Math.min(buffer.length, stat.size - position), position);
+      if (bytesRead === 0)
+        break;
+      position += bytesRead;
+      const lines = `${pending}${decoder.write(buffer.subarray(0, bytesRead))}`.split(`
+`);
+      pending = lines.pop() ?? "";
+      for (const text of lines)
+        yield { text, terminated: true };
+    }
+    pending += decoder.end();
+    if (pending)
+      yield { text: pending, terminated: false };
+  } finally {
+    await file.close();
+  }
+}
+function createUsageScanCaches2() {
+  return { claudeCode: new Map, codex: new Map };
+}
+async function readLocalUsage2(options) {
+  const failed = (message) => {
+    options.signal?.throwIfAborted();
+    return { kind: "failed", message };
+  };
+  const [claudeCode, codex] = await Promise.all([
+    readClaudeCodeUsage2({
+      models: options.models,
+      signal: options.signal,
+      cache: options.caches?.claudeCode
+    }).catch(() => failed("Could not read Claude Code history.")),
+    readCodexUsage2({
+      models: options.models,
+      signal: options.signal,
+      cache: options.caches?.codex
+    }).catch(() => failed("Could not read Codex history."))
+  ]);
+  options.signal?.throwIfAborted();
+  return { claudeCode, codex };
+}
+
+export { readClaudeCodeUsage2, readCodexUsage2, createUsageScanCaches2, readLocalUsage2 };

package/dist/chunks/canvas-preview-1sq7z9jq.js

@@ -0,0 +1,17 @@
+import {
+  sha2562
+} from "./canvas-preview-0nq75h9k.js";
+
+// src/local/identity.ts
+import { realpath, stat } from "node:fs/promises";
+import { resolve } from "node:path";
+import { asId } from "@nyte-ai/schema";
+async function folderIdentity2(path) {
+  const real = await realpath(path).catch(() => null);
+  if (real === null)
+    return asId(sha2562(resolve(path)));
+  const stats = await stat(real, { bigint: true }).catch(() => null);
+  return asId(sha2562(stats === null || stats.ino === 0n || stats.birthtimeNs === 0n ? real : `${stats.birthtimeNs}:${stats.ino}`));
+}
+
+export { folderIdentity2 };

package/dist/chunks/canvas-preview-1ta3avah.js

@@ -0,0 +1,56 @@
+import {
+  readNyteUsage2
+} from "./canvas-preview-5hxat7hh.js";
+import {
+  createUsageScanCaches2,
+  readLocalUsage2
+} from "./canvas-preview-0nrnbt76.js";
+
+// src/usage-service.ts
+import { join } from "node:path";
+import { FileModelsStore, nyteProviders } from "@nyte-ai/ai";
+import { createModels } from "@nyte-ai/ai/models";
+import { serial } from "@nyte-ai/schema/serial";
+function catalogForUsage2(models) {
+  return [...models.getModels("anthropic"), ...models.getModels("openai-codex")];
+}
+
+class UsageScanner2 {
+  home;
+  caches = createUsageScanCaches2();
+  models;
+  scans = serial();
+  constructor(home) {
+    this.home = home;
+    this.models = createModels({
+      modelsStore: new FileModelsStore(join(home, ".nyte", "models-store.json"))
+    });
+    for (const provider of nyteProviders())
+      this.models.setProvider(provider);
+  }
+  scan(request) {
+    return this.scans.run(async () => {
+      if (request.catalog === undefined)
+        await this.models.refresh({
+          providers: ["anthropic", "openai-codex"],
+          allowNetwork: false
+        });
+      const catalog = request.catalog;
+      const models = catalog === undefined ? this.models : {
+        getModels: (provider) => catalog.filter((model) => provider === undefined || model.provider === provider)
+      };
+      const local = await readLocalUsage2({ models, caches: this.caches });
+      const report = readNyteUsage2(this.home, request.window);
+      return {
+        ...report,
+        ...local,
+        nyteError: report.sources.find((source) => source.status === "failed")?.message ?? null
+      };
+    });
+  }
+  close() {
+    return this.scans.settled();
+  }
+}
+
+export { catalogForUsage2, UsageScanner2 };

package/dist/chunks/canvas-preview-2zdyh9ny.js

@@ -0,0 +1,26 @@
+// src/deploy/vercel/server/utils/repair.ts
+import { createHash, timingSafeEqual } from "node:crypto";
+import { SdkError } from "@nyte-ai/schema";
+import { encodeError, errorStatus } from "@nyte-ai/protocol";
+async function answerRepair2(request, secret, repair) {
+  if (request.method !== "GET" || new URL(request.url).pathname !== "/.nyte/repair")
+    return;
+  if (secret === undefined || secret === "")
+    return failure(new SdkError("unknown", "This deployment sets no CRON_SECRET."));
+  const given = /^Bearer\s+(\S+)\s*$/i.exec(request.headers.get("Authorization") ?? "")?.[1] ?? "";
+  if (!timingSafeEqual(digest(given), digest(secret)))
+    return failure(new SdkError("unauthenticated", "Send Authorization: Bearer <CRON_SECRET>."));
+  await repair();
+  return new Response(null, { status: 204 });
+}
+function digest(text) {
+  return createHash("sha256").update(text).digest();
+}
+function failure(error) {
+  return new Response(JSON.stringify(encodeError(error)), {
+    status: errorStatus[error.code],
+    headers: { "Content-Type": "application/json" }
+  });
+}
+
+export { answerRepair2 };