@codraoss/api 0.9.6 → 0.9.13

package/dist/chunk-N45ONQ2Q.js

@@ -0,0 +1,145 @@
+// src/platform/config.ts
+import { defaultRepoConfig, normalizeRepoModelConfig, repoConfigSchema } from "@codraoss/schema";
+import { REPO_CONFIG_CACHE_VERSION } from "@codraoss/schema";
+import { getRepoConfigRecord, syncRepoConfig } from "@codraoss/db/repo-configs";
+var REPO_CONFIG_CACHE_PREFIX = `config:${REPO_CONFIG_CACHE_VERSION}:db:`;
+var REPO_CONFIG_REVISION_KEY = `config:${REPO_CONFIG_CACHE_VERSION}:db_revision`;
+async function getRepoConfigCacheRevision(kv) {
+  return await kv.get(REPO_CONFIG_REVISION_KEY) ?? "0";
+}
+async function cacheKey(kv, owner, repo) {
+  const revision = await getRepoConfigCacheRevision(kv);
+  return `${REPO_CONFIG_CACHE_PREFIX}${revision}:${owner}/${repo}`;
+}
+var GLOBAL_CONFIG_KEY = "config:global_model";
+var EMPTY_GLOBAL_CONFIG = {
+  main: null,
+  fallbacks: [],
+  size_overrides: []
+};
+function hasRepoModelOverride(existing) {
+  return Boolean(
+    existing?.mainModel || Array.isArray(existing?.fallbackModels) && existing.fallbackModels.length > 0 || Array.isArray(existing?.sizeOverrides) && existing.sizeOverrides.length > 0
+  );
+}
+async function getGlobalConfig(kv) {
+  const cached = await kv.get(GLOBAL_CONFIG_KEY, "json");
+  if (cached) {
+    const parsed = repoConfigSchema.shape.model.safeParse(cached);
+    if (parsed.success) {
+      return normalizeRepoModelConfig(parsed.data);
+    }
+  }
+  return EMPTY_GLOBAL_CONFIG;
+}
+async function updateGlobalConfig(kv, config) {
+  await kv.put(GLOBAL_CONFIG_KEY, JSON.stringify(normalizeRepoModelConfig(config)));
+  await invalidateAllRepoConfigCache(kv);
+}
+async function invalidateRepoConfigCache(kv, owner, repo) {
+  await kv.delete(await cacheKey(kv, owner, repo));
+}
+async function invalidateAllRepoConfigCache(kv) {
+  await kv.put(REPO_CONFIG_REVISION_KEY, String(Date.now()));
+}
+async function loadRepoConfig(kv, db, input) {
+  const key = await cacheKey(kv, input.owner, input.repo);
+  const cached = await kv.get(key, "json");
+  if (cached) {
+    return cached;
+  }
+  const existing = await getRepoConfigRecord(db, input.owner, input.repo);
+  let parsedJson = existing?.parsedJson ?? defaultRepoConfig;
+  const enabled = existing?.enabled ?? true;
+  if (!hasRepoModelOverride(existing)) {
+    const globalModel = await getGlobalConfig(kv);
+    parsedJson = {
+      ...parsedJson,
+      model: globalModel
+    };
+  }
+  const finalConfig = {
+    parsedJson,
+    enabled
+  };
+  await kv.put(key, JSON.stringify(finalConfig), { expirationTtl: 60 * 10 });
+  if (!existing) {
+    await syncRepoConfig(db, input);
+  }
+  return finalConfig;
+}
+
+// src/platform/updates-email.ts
+var EMAILS_API_URL = "https://codra.run/api/emails";
+function updatesEmailKey(githubUserId) {
+  return `updates-email:${githubUserId}`;
+}
+async function getUpdatesEmailPreference(kv, githubUserId) {
+  return await kv.get(updatesEmailKey(githubUserId), "json");
+}
+async function hasUpdatesEmailPreference(kv, githubUserId) {
+  return Boolean(await getUpdatesEmailPreference(kv, githubUserId));
+}
+async function syncUpdatesEmail(kv, githubUserId, email) {
+  if (!email) return false;
+  if (await hasUpdatesEmailPreference(kv, githubUserId)) return false;
+  const response = await fetch(EMAILS_API_URL, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ email })
+  });
+  if (!response.ok) {
+    console.warn("Failed to sync updates email", { status: response.status, url: response.url });
+    return false;
+  }
+  const record = {
+    status: "subscribed",
+    email,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await kv.put(updatesEmailKey(githubUserId), JSON.stringify(record));
+  return true;
+}
+
+// src/platform/oauth.ts
+import { randomHex } from "@codraoss/schema/hex";
+var OAUTH_STATE_TTL_SECONDS = 60 * 10;
+function oauthStateKey(state) {
+  return `oauth-state:${state}`;
+}
+function parseAllowedUsers(input) {
+  return new Set(
+    input.split(",").map((value) => value.trim().toLowerCase()).filter(Boolean)
+  );
+}
+async function createOAuthState(kv) {
+  const state = randomHex();
+  await kv.put(
+    oauthStateKey(state),
+    JSON.stringify({ createdAt: (/* @__PURE__ */ new Date()).toISOString() }),
+    { expirationTtl: OAUTH_STATE_TTL_SECONDS }
+  );
+  return state;
+}
+async function consumeOAuthState(kv, state) {
+  const key = oauthStateKey(state);
+  const value = await kv.get(key);
+  if (!value) {
+    return false;
+  }
+  await kv.delete(key);
+  return true;
+}
+
+export {
+  getGlobalConfig,
+  updateGlobalConfig,
+  invalidateRepoConfigCache,
+  loadRepoConfig,
+  getUpdatesEmailPreference,
+  syncUpdatesEmail,
+  parseAllowedUsers,
+  createOAuthState,
+  consumeOAuthState
+};
+//# sourceMappingURL=chunk-N45ONQ2Q.js.map

package/dist/chunk-N45ONQ2Q.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/platform/config.ts","../src/platform/updates-email.ts","../src/platform/oauth.ts"],"sourcesContent":["import { defaultRepoConfig, normalizeRepoModelConfig, repoConfigSchema, type RepoConfig } from '@codraoss/schema';\nimport { REPO_CONFIG_CACHE_VERSION } from '@codraoss/schema';\nimport { getRepoConfigRecord, syncRepoConfig } from '@codraoss/db/repo-configs';\nimport type { DbEnv } from '@codraoss/db/env';\nimport type { KvCompat } from './kv';\n\nexport type { KvCompat };\n\ntype CachedConfig = {\n  parsedJson: RepoConfig;\n  enabled: boolean;\n};\n\nconst REPO_CONFIG_CACHE_PREFIX = `config:${REPO_CONFIG_CACHE_VERSION}:db:`;\nconst REPO_CONFIG_REVISION_KEY = `config:${REPO_CONFIG_CACHE_VERSION}:db_revision`;\n\nasync function getRepoConfigCacheRevision(kv: KvCompat) {\n  return (await kv.get(REPO_CONFIG_REVISION_KEY)) ?? '0';\n}\n\nasync function cacheKey(kv: KvCompat, owner: string, repo: string) {\n  const revision = await getRepoConfigCacheRevision(kv);\n  return `${REPO_CONFIG_CACHE_PREFIX}${revision}:${owner}/${repo}`;\n}\n\nconst GLOBAL_CONFIG_KEY = 'config:global_model';\n\nconst EMPTY_GLOBAL_CONFIG: RepoConfig['model'] = {\n  main: null,\n  fallbacks: [],\n  size_overrides: [],\n};\n\nfunction hasRepoModelOverride(existing: Awaited<ReturnType<typeof getRepoConfigRecord>> | null) {\n  return Boolean(\n    existing?.mainModel ||\n    (Array.isArray(existing?.fallbackModels) && existing.fallbackModels.length > 0) ||\n    (Array.isArray(existing?.sizeOverrides) && existing.sizeOverrides.length > 0),\n  );\n}\n\nexport async function getGlobalConfig(kv: KvCompat): Promise<RepoConfig['model']> {\n  const cached = await kv.get(GLOBAL_CONFIG_KEY, 'json');\n  if (cached) {\n    const parsed = repoConfigSchema.shape.model.safeParse(cached);\n    if (parsed.success) {\n      return normalizeRepoModelConfig(parsed.data);\n    }\n  }\n\n  return EMPTY_GLOBAL_CONFIG;\n}\n\nexport async function updateGlobalConfig(kv: KvCompat, config: RepoConfig['model']) {\n  await kv.put(GLOBAL_CONFIG_KEY, JSON.stringify(normalizeRepoModelConfig(config)));\n  await invalidateAllRepoConfigCache(kv);\n}\n\nexport async function invalidateRepoConfigCache(kv: KvCompat, owner: string, repo: string) {\n  await kv.delete(await cacheKey(kv, owner, repo));\n}\n\nasync function invalidateAllRepoConfigCache(kv: KvCompat) {\n  await kv.put(REPO_CONFIG_REVISION_KEY, String(Date.now()));\n}\n\n\nexport async function loadRepoConfig(\n  kv: KvCompat,\n  db: DbEnv,\n  input: { installationId: string; owner: string; repo: string },\n) {\n  const key = await cacheKey(kv, input.owner, input.repo);\n  const cached = await kv.get(key, 'json');\n  if (cached) {\n    return cached as CachedConfig;\n  }\n\n  const existing = await getRepoConfigRecord(db, input.owner, input.repo);\n\n  let parsedJson = existing?.parsedJson ?? defaultRepoConfig;\n  const enabled = existing?.enabled ?? true;\n\n  if (!hasRepoModelOverride(existing)) {\n    const globalModel = await getGlobalConfig(kv);\n    parsedJson = {\n      ...parsedJson,\n      model: globalModel\n    };\n  }\n\n  const finalConfig: CachedConfig = {\n    parsedJson,\n    enabled,\n  };\n\n  await kv.put(key, JSON.stringify(finalConfig), { expirationTtl: 60 * 10 });\n\n  if (!existing) {\n    await syncRepoConfig(db, input);\n  }\n\n  return finalConfig;\n}\n","import type { KvCompat } from './kv';\n\nconst EMAILS_API_URL = 'https://codra.run/api/emails';\n\ntype UpdatesEmailRecord = {\n  status: 'subscribed';\n  email: string;\n  updatedAt: string;\n};\n\nfunction updatesEmailKey(githubUserId: number) {\n  return `updates-email:${githubUserId}`;\n}\n\nexport async function getUpdatesEmailPreference(\n  kv: KvCompat,\n  githubUserId: number,\n) {\n  return await kv.get(updatesEmailKey(githubUserId), 'json') as UpdatesEmailRecord | null;\n}\n\nasync function hasUpdatesEmailPreference(\n  kv: KvCompat,\n  githubUserId: number,\n) {\n  return Boolean(await getUpdatesEmailPreference(kv, githubUserId));\n}\n\nexport async function syncUpdatesEmail(\n  kv: KvCompat,\n  githubUserId: number,\n  email: string | null | undefined,\n) {\n  if (!email) return false;\n\n  if (await hasUpdatesEmailPreference(kv, githubUserId)) return false;\n\n  const response = await fetch(EMAILS_API_URL, {\n    method: 'POST',\n    headers: { 'content-type': 'application/json' },\n    body: JSON.stringify({ email }),\n  });\n\n  if (!response.ok) {\n    // Need to import logger. If it doesn't exist in the current scope, add it.\n    // import { logger } from '../logger'; // Uncomment and adjust path if needed\n    console.warn('Failed to sync updates email', { status: response.status, url: response.url }); // Using console.warn as a fallback, replace with logger.warn if imported\n    return false;\n  }\n\n  const record: UpdatesEmailRecord = {\n    status: 'subscribed',\n    email,\n    updatedAt: new Date().toISOString(),\n  };\n  await kv.put(updatesEmailKey(githubUserId), JSON.stringify(record));\n\n  return true;\n}\n","import { randomHex } from '@codraoss/schema/hex';\nimport type { KvCompat } from './kv';\n\nconst OAUTH_STATE_TTL_SECONDS = 60 * 10;\n\nfunction oauthStateKey(state: string) {\n  return `oauth-state:${state}`;\n}\n\nexport function parseAllowedUsers(input: string) {\n  return new Set(\n    input\n      .split(',')\n      .map((value) => value.trim().toLowerCase())\n      .filter(Boolean),\n  );\n}\n\nexport async function createOAuthState(kv: KvCompat) {\n  const state = randomHex();\n  await kv.put(\n    oauthStateKey(state),\n    JSON.stringify({ createdAt: new Date().toISOString() }),\n    { expirationTtl: OAUTH_STATE_TTL_SECONDS },\n  );\n  return state;\n}\n\nexport async function consumeOAuthState(kv: KvCompat, state: string) {\n  const key = oauthStateKey(state);\n  const value = await kv.get(key);\n  if (!value) {\n    return false;\n  }\n\n  await kv.delete(key);\n  return true;\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-RMQQ4RZ4.js

@@ -0,0 +1,53 @@
+// src/logger.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { formatLogRecord, setLoggerSink } from "@codraoss/core/logger";
+var storage = new AsyncLocalStorage();
+var Logger = class _Logger {
+  constructor(context = {}) {
+    this.context = context;
+  }
+  withContext(newContext) {
+    return new _Logger({ ...this.context, ...newContext });
+  }
+  log(level, message, data) {
+    const store = storage.getStore() || {};
+    const output = formatLogRecord(level, message, [store, this.context], data);
+    if (level === "error") {
+      console.error(JSON.stringify(output));
+    } else if (level === "warn") {
+      console.warn(JSON.stringify(output));
+    } else {
+      console.log(JSON.stringify(output));
+    }
+  }
+  runWithContext(context, fn) {
+    return storage.run({ ...storage.getStore(), ...context }, fn);
+  }
+  info(message, data) {
+    this.log("info", message, data);
+  }
+  error(message, data) {
+    if (data instanceof Error) {
+      this.log("error", message, {
+        name: data.name,
+        message: data.message,
+        stack: data.stack
+      });
+    } else {
+      this.log("error", message, data);
+    }
+  }
+  warn(message, data) {
+    this.log("warn", message, data);
+  }
+  debug(message, data) {
+    this.log("debug", message, data);
+  }
+};
+var logger = new Logger();
+setLoggerSink(logger);
+
+export {
+  logger
+};
+//# sourceMappingURL=chunk-RMQQ4RZ4.js.map

package/dist/chunk-RMQQ4RZ4.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/logger.ts"],"sourcesContent":["import { AsyncLocalStorage } from 'node:async_hooks';\nimport { formatLogRecord, setLoggerSink } from '@codraoss/core/logger';\n\n// The request-context half of the logger. Scrubbing and record shaping live in @codraoss/core/logger;\n// this file owns everything platform-bound -- AsyncLocalStorage and the console sink -- so that\n// node:async_hooks never enters the engine package. Importing this module installs it as the sink\n// that @codraoss/core's `logger` facade delegates to (see the bottom of the file).\nconst storage = new AsyncLocalStorage<Record<string, any>>();\n\nclass Logger {\n  constructor(private context: Record<string, any> = {}) {}\n\n  withContext(newContext: Record<string, any>) {\n    return new Logger({ ...this.context, ...newContext });\n  }\n\n  private log(level: string, message: string, data?: any) {\n    const store = storage.getStore() || {};\n    const output = formatLogRecord(level, message, [store, this.context], data);\n\n    if (level === 'error') {\n      console.error(JSON.stringify(output));\n    } else if (level === 'warn') {\n      console.warn(JSON.stringify(output));\n    } else {\n      console.log(JSON.stringify(output));\n    }\n  }\n\n  runWithContext<T>(context: Record<string, any>, fn: () => T): T {\n    return storage.run({ ...storage.getStore(), ...context }, fn);\n  }\n\n  info(message: string, data?: any) {\n    this.log('info', message, data);\n  }\n\n  error(message: string, data?: any) {\n    if (data instanceof Error) {\n      this.log('error', message, {\n        name: data.name,\n        message: data.message,\n        stack: data.stack,\n      });\n    } else {\n      this.log('error', message, data);\n    }\n  }\n\n  warn(message: string, data?: any) {\n    this.log('warn', message, data);\n  }\n\n  debug(message: string, data?: any) {\n    this.log('debug', message, data);\n  }\n}\n\nexport const logger = new Logger();\n\n// Wired at import scope so engine code logging through @codraoss/core's facade lands here, with request\n// context attached, rather than in core's bare console fallback.\nsetLoggerSink(logger);\n"],"mappings":";AAAA,SAAS,yBAAyB;AAClC,SAAS,iBAAiB,qBAAqB;AAM/C,IAAM,UAAU,IAAI,kBAAuC;AAE3D,IAAM,SAAN,MAAM,QAAO;AAAA,EACX,YAAoB,UAA+B,CAAC,GAAG;AAAnC;AAAA,EAAoC;AAAA,EAExD,YAAY,YAAiC;AAC3C,WAAO,IAAI,QAAO,EAAE,GAAG,KAAK,SAAS,GAAG,WAAW,CAAC;AAAA,EACtD;AAAA,EAEQ,IAAI,OAAe,SAAiB,MAAY;AACtD,UAAM,QAAQ,QAAQ,SAAS,KAAK,CAAC;AACrC,UAAM,SAAS,gBAAgB,OAAO,SAAS,CAAC,OAAO,KAAK,OAAO,GAAG,IAAI;AAE1E,QAAI,UAAU,SAAS;AACrB,cAAQ,MAAM,KAAK,UAAU,MAAM,CAAC;AAAA,IACtC,WAAW,UAAU,QAAQ;AAC3B,cAAQ,KAAK,KAAK,UAAU,MAAM,CAAC;AAAA,IACrC,OAAO;AACL,cAAQ,IAAI,KAAK,UAAU,MAAM,CAAC;AAAA,IACpC;AAAA,EACF;AAAA,EAEA,eAAkB,SAA8B,IAAgB;AAC9D,WAAO,QAAQ,IAAI,EAAE,GAAG,QAAQ,SAAS,GAAG,GAAG,QAAQ,GAAG,EAAE;AAAA,EAC9D;AAAA,EAEA,KAAK,SAAiB,MAAY;AAChC,SAAK,IAAI,QAAQ,SAAS,IAAI;AAAA,EAChC;AAAA,EAEA,MAAM,SAAiB,MAAY;AACjC,QAAI,gBAAgB,OAAO;AACzB,WAAK,IAAI,SAAS,SAAS;AAAA,QACzB,MAAM,KAAK;AAAA,QACX,SAAS,KAAK;AAAA,QACd,OAAO,KAAK;AAAA,MACd,CAAC;AAAA,IACH,OAAO;AACL,WAAK,IAAI,SAAS,SAAS,IAAI;AAAA,IACjC;AAAA,EACF;AAAA,EAEA,KAAK,SAAiB,MAAY;AAChC,SAAK,IAAI,QAAQ,SAAS,IAAI;AAAA,EAChC;AAAA,EAEA,MAAM,SAAiB,MAAY;AACjC,SAAK,IAAI,SAAS,SAAS,IAAI;AAAA,EACjC;AACF;AAEO,IAAM,SAAS,IAAI,OAAO;AAIjC,cAAc,MAAM;","names":[]}

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import * as hono_types from 'hono/types';
 import * as hono from 'hono';
 import { MiddlewareHandler, Hono, Context } from 'hono';
-import { SessionStore, ReviewRuntime, DashboardSessionUser } from '@codraoss/core/ports';
+import { SessionStore, ReviewRuntime, DashboardSessionUser, IdentityProvider } from '@codraoss/core/ports';
 import { ApiAction } from '@codraoss/schema/api';
 import * as dbAccounts from '@codraoss/db/accounts';
 import * as dbJobs from '@codraoss/db/jobs';
@@ -12,6 +12,8 @@ import * as dbRepoConfigs from '@codraoss/db/repo-configs';
 import * as dbAppSettings from '@codraoss/db/app-settings';
 import * as dbStats from '@codraoss/db/stats';
 import * as dbWebhookDeliveries from '@codraoss/db/webhook-deliveries';
+import { DbEnv } from '@codraoss/db/env';
+import { K as KvCompat } from './kv-ByAbDUqn.js';
 
 interface RepositoriesPort {
     accounts: typeof dbAccounts;
@@ -191,4 +193,38 @@ declare const requireSession: hono.MiddlewareHandler<ApiEnv, string, {}, Respons
 
 declare const requireCsrfHeader: hono.MiddlewareHandler<ApiEnv, string, {}, Response>;
 
-export { type ApiEnv, type ApiRouterDeps, type ApiRouterOptions, type AuthorizeContext, type AuthorizeResult, type AuthzPort, type ConfigPort, type PlatformPort, type QuotaCheckInput, type QuotaResult, type RepositoriesPort, createApiRouter, requireCsrfHeader, requirePermission, requireQuota, requireSession };
+interface PlatformDeps {
+    sessionStore: SessionStore;
+    kv: KvCompat;
+    db: DbEnv;
+    identityProvider?: IdentityProvider;
+    enqueueReviewJob: (input: any) => Promise<void>;
+    terminateJobWorkflow: (job: {
+        id: string;
+        workflowInstanceId?: string | null;
+    }) => Promise<void>;
+    scheduleBestEffortJobMaintenance: (executionContext?: any) => void;
+    createReviewRuntime: () => ReviewRuntime;
+    getOrFetchRawDiffForCompletedJob: (runtime: ReviewRuntime, job: any, github: any) => Promise<string>;
+    logger: PlatformPort['logger'];
+    getSecret: (key: string) => Promise<string | null>;
+    aiBinding?: any;
+    appUrl: string;
+    botUsername: string;
+    environment: string;
+    authCallbackUrl: string;
+    githubClientId: string;
+    githubClientSecret: string;
+    githubAppSlug?: string;
+    dashboardAllowedUsers: string;
+    appPrivateKey: string;
+    githubAppId: string;
+    githubAppWebhookSecret: string;
+    llmConfigEncryptionKey: string;
+    cfApiToken?: string;
+    cfAccountId?: string;
+}
+
+declare function createSharedApiDeps(p: PlatformDeps): ApiRouterDeps;
+
+export { type ApiEnv, type ApiRouterDeps, type ApiRouterOptions, type AuthorizeContext, type AuthorizeResult, type AuthzPort, type ConfigPort, type PlatformDeps, type PlatformPort, type QuotaCheckInput, type QuotaResult, type RepositoriesPort, createApiRouter, createSharedApiDeps, requireCsrfHeader, requirePermission, requireQuota, requireSession };

package/dist/index.js

@@ -1,3 +1,17 @@
+import {
+  logger
+} from "./chunk-RMQQ4RZ4.js";
+import {
+  consumeOAuthState,
+  createOAuthState,
+  getGlobalConfig,
+  getUpdatesEmailPreference,
+  invalidateRepoConfigCache,
+  loadRepoConfig,
+  syncUpdatesEmail,
+  updateGlobalConfig
+} from "./chunk-N45ONQ2Q.js";
+
 // src/router.ts
 import { Hono as Hono9 } from "hono";
 
@@ -58,7 +72,7 @@ var requireSession = createMiddleware(async (c, next) => {
   const session = await readSession(c);
   if (!session) {
     if (wantsHtml(c.req.raw)) {
-      return c.redirect("/login");
+      return c.redirect("/");
     }
     return Response.json({ error: "Unauthorized" }, { status: 401 });
   }
@@ -80,56 +94,6 @@ var requireCsrfHeader = createMiddleware2(async (c, next) => {
   await next();
 });
 
-// src/logger.ts
-import { AsyncLocalStorage } from "async_hooks";
-import { formatLogRecord, setLoggerSink } from "@codraoss/core/logger";
-var storage = new AsyncLocalStorage();
-var Logger = class _Logger {
-  constructor(context = {}) {
-    this.context = context;
-  }
-  context;
-  withContext(newContext) {
-    return new _Logger({ ...this.context, ...newContext });
-  }
-  log(level, message, data) {
-    const store = storage.getStore() || {};
-    const output = formatLogRecord(level, message, [store, this.context], data);
-    if (level === "error") {
-      console.error(JSON.stringify(output));
-    } else if (level === "warn") {
-      console.warn(JSON.stringify(output));
-    } else {
-      console.log(JSON.stringify(output));
-    }
-  }
-  runWithContext(context, fn) {
-    return storage.run({ ...storage.getStore(), ...context }, fn);
-  }
-  info(message, data) {
-    this.log("info", message, data);
-  }
-  error(message, data) {
-    if (data instanceof Error) {
-      this.log("error", message, {
-        name: data.name,
-        message: data.message,
-        stack: data.stack
-      });
-    } else {
-      this.log("error", message, data);
-    }
-  }
-  warn(message, data) {
-    this.log("warn", message, data);
-  }
-  debug(message, data) {
-    this.log("debug", message, data);
-  }
-};
-var logger = new Logger();
-setLoggerSink(logger);
-
 // src/middleware/observability.ts
 var observability = async (c, next) => {
   const requestId = c.req.header("x-request-id") || crypto.randomUUID();
@@ -1254,8 +1218,12 @@ function createSettingsRouter() {
 async function serveIndex(c) {
   const assets = c.env.ASSETS;
   if (assets && typeof assets.fetch === "function") {
-    return assets.fetch(new Request(new URL("/", c.req.url), c.req.raw));
+    const response = await assets.fetch(new Request(new URL("/", c.req.url), c.req.raw));
+    const newResponse = new Response(response.body, { status: response.status, statusText: response.statusText, headers: response.headers });
+    newResponse.headers.set("Cache-Control", "no-cache");
+    return newResponse;
   }
+  c.header("Cache-Control", "no-cache");
   return c.text("Not Found: Please mount UI static assets handler here.", 404);
 }
 function createApiRouter(options = {}) {
@@ -1264,6 +1232,7 @@ function createApiRouter(options = {}) {
   for (const middleware of options.beforeAuth ?? []) {
     app.use("*", middleware);
   }
+  app.get("/healthz", (c) => c.json({ status: "ok", timestamp: (/* @__PURE__ */ new Date()).toISOString() }));
   app.use("/auth/logout", requireSession);
   app.use("/auth/logout", requireCsrfHeader);
   app.route("/auth", createAuthRouter());
@@ -1298,8 +1267,249 @@ function createApiRouter(options = {}) {
   options.routes?.(app);
   return app;
 }
+
+// src/create-deps.ts
+import * as dbAccounts from "@codraoss/db/accounts";
+import * as dbJobs from "@codraoss/db/jobs";
+import * as dbFileReviews from "@codraoss/db/file-reviews";
+import * as dbCommentFeedback from "@codraoss/db/comment-feedback";
+import * as dbModelConfigs from "@codraoss/db/model-configs";
+import * as dbRepoConfigs from "@codraoss/db/repo-configs";
+import * as dbAppSettings from "@codraoss/db/app-settings";
+import * as dbStats from "@codraoss/db/stats";
+import * as dbWebhookDeliveries from "@codraoss/db/webhook-deliveries";
+import { GitHubClient, normalizeGitHubWebhook } from "@codraoss/provider-github";
+import { GitHubIdentityProvider } from "@codraoss/provider-github/oauth";
+import { extractReviewRequest } from "@codraoss/core";
+import { verifyGitHubWebhookSignature } from "@codraoss/core/verify";
+import { listLlmProviderSecrets, upsertDiscoveredModelConfigs, createLlmProvider, updateLlmProvider, getResolvedModelConfig, getLlmProvider } from "@codraoss/db/model-configs";
+import { encryptLlmApiKey, decryptLlmApiKey, listProviderModels, reviewWithCloudflare, reviewWithGoogle, reviewWithVertex, reviewWithOpenAI, reviewWithAnthropic, ProviderRequestError } from "@codraoss/models";
+import { buildReviewResponseSchema } from "@codraoss/core/prompts/file-review";
+function toAppBindingsConfig(p) {
+  return {
+    APP_KV: p.kv,
+    APP_PRIVATE_KEY: p.appPrivateKey,
+    GITHUB_APP_ID: p.githubAppId,
+    BOT_USERNAME: p.botUsername,
+    GITHUB_APP_SLUG: p.githubAppSlug,
+    GITHUB_CLIENT_ID: p.githubClientId,
+    GITHUB_CLIENT_SECRET: p.githubClientSecret,
+    AUTH_CALLBACK_URL: p.authCallbackUrl
+  };
+}
+function getSecretStore(p) {
+  return { getSecret: p.getSecret };
+}
+function optionalEnv(value) {
+  try {
+    const resolved = value().trim();
+    return resolved.length > 0 ? resolved : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var githubIdentity = new GitHubIdentityProvider();
+function identityProvider(p) {
+  return p.identityProvider ?? githubIdentity;
+}
+function createSharedApiDeps(p) {
+  return {
+    repositories: {
+      accounts: dbAccounts,
+      jobs: dbJobs,
+      fileReviews: dbFileReviews,
+      commentFeedback: dbCommentFeedback,
+      modelConfigs: dbModelConfigs,
+      repoConfigs: dbRepoConfigs,
+      appSettings: dbAppSettings,
+      stats: dbStats,
+      webhookDeliveries: dbWebhookDeliveries
+    },
+    gitProvider: {
+      getAppInstallationUrl: async () => await GitHubClient.getAppInstallationUrl(toAppBindingsConfig(p)),
+      listInstallations: async () => await GitHubClient.listInstallations(toAppBindingsConfig(p)),
+      createService: (installationId) => new GitHubClient(toAppBindingsConfig(p), installationId != null ? String(installationId) : void 0)
+    },
+    config: {
+      getGlobalConfig: async () => await getGlobalConfig(p.kv),
+      updateGlobalConfig: async (config) => await updateGlobalConfig(p.kv, config),
+      loadRepoConfig: async (input) => await loadRepoConfig(p.kv, p.db, input),
+      invalidateRepoConfigCache: async (owner, repo) => await invalidateRepoConfigCache(p.kv, owner, repo)
+    },
+    modelRunner: {
+      syncProviderModelCatalog: async () => {
+        const providers = await listLlmProviderSecrets(p.db);
+        const syncErrors = [];
+        await Promise.all(providers.map(async (provider) => {
+          if (!provider.enabled) return;
+          if (provider.apiFormat !== "cloudflare-workers-ai" && !provider.encryptedApiKey) return;
+          try {
+            const apiKey = provider.encryptedApiKey ? await decryptLlmApiKey(getSecretStore(p), provider.encryptedApiKey) : void 0;
+            const modelNames = await listProviderModels({
+              apiFormat: provider.apiFormat,
+              baseUrl: provider.baseUrl,
+              apiKey,
+              cloudflareAccountId: optionalEnv(() => p.cfAccountId || ""),
+              cloudflareApiToken: optionalEnv(() => p.cfApiToken || "")
+            });
+            await upsertDiscoveredModelConfigs(p.db, {
+              providerId: provider.id,
+              providerName: provider.name,
+              apiFormat: provider.apiFormat,
+              modelNames
+            });
+          } catch (error) {
+            syncErrors.push({
+              providerId: provider.id,
+              providerName: provider.name,
+              error: error instanceof Error ? error.message : "Could not refresh provider models."
+            });
+          }
+        }));
+        return syncErrors;
+      },
+      testConnection: async (modelId) => {
+        const config = await getResolvedModelConfig(p.db, modelId);
+        if (!config) throw { isNotFoundError: true };
+        if (!config.providerEnabled) throw { isDisabledError: true, message: "Provider is disabled." };
+        try {
+          const input = {
+            systemPrompt: "You are validating connectivity. Return only the JSON object.",
+            userPrompt: 'Return an empty review: no findings, overall_correctness "patch is correct".',
+            responseSchema: buildReviewResponseSchema(1)
+          };
+          let response;
+          if (config.apiFormat === "cloudflare-workers-ai") {
+            response = await reviewWithCloudflare(p.aiBinding, config.modelName, input, void 0, config.providerName);
+          } else {
+            if (!config.encryptedApiKey) {
+              throw { isMissingKeyError: true, message: `Provider ${config.providerName} does not have a saved API key.` };
+            }
+            const apiKey = await decryptLlmApiKey(getSecretStore(p), config.encryptedApiKey);
+            switch (config.apiFormat) {
+              case "gemini":
+                response = await reviewWithGoogle({ apiKey, baseUrl: config.baseUrl, providerName: config.providerName, timeoutMs: 15e3 }, config.modelName, input);
+                break;
+              case "vertex":
+                response = await reviewWithVertex({ apiKey, baseUrl: config.baseUrl, providerName: config.providerName }, config.modelName, input);
+                break;
+              case "openai":
+                response = await reviewWithOpenAI({ apiKey, baseUrl: config.baseUrl || "https://api.openai.com/v1", providerName: config.providerName }, config.modelName, input);
+                break;
+              case "anthropic":
+                response = await reviewWithAnthropic({ apiKey, baseUrl: config.baseUrl, providerName: config.providerName }, config.modelName, input);
+                break;
+              default:
+                throw new Error(`Unsupported API format: ${config.apiFormat}`);
+            }
+          }
+          return {
+            ok: true,
+            modelUsed: response.modelUsed,
+            provider: response.provider,
+            inputTokens: response.inputTokens,
+            outputTokens: response.outputTokens,
+            ...response.degraded === "schema-dropped" ? { degraded: response.degraded, warning: "Connected, but this endpoint rejected the response grammar. Reviews will run without constrained decoding." } : {}
+          };
+        } catch (error) {
+          if (error instanceof ProviderRequestError) {
+            throw { status: error.status >= 500 ? 502 : error.status, message: error.message, originalError: error };
+          }
+          throw error;
+        }
+      },
+      createProviderWithSecret: async (input) => {
+        let encryptedApiKey;
+        try {
+          encryptedApiKey = input.apiFormat === "cloudflare-workers-ai" ? null : input.apiKey ? await encryptLlmApiKey(getSecretStore(p), input.apiKey.trim()) : null;
+        } catch (error) {
+          if (error instanceof Error && error.message.includes("LLM_CONFIG_ENCRYPTION_KEY")) {
+            throw { isEncryptionConfigError: true, message: error.message };
+          }
+          throw error;
+        }
+        if (input.enabled && input.apiFormat !== "cloudflare-workers-ai" && !encryptedApiKey) {
+          throw { isKeyRequiredError: true };
+        }
+        try {
+          return await createLlmProvider(p.db, {
+            name: input.name,
+            apiFormat: input.apiFormat,
+            baseUrl: input.apiFormat === "cloudflare-workers-ai" ? null : input.baseUrl ? input.baseUrl.replace(/\/+$/, "") : null,
+            // basic normalization
+            encryptedApiKey,
+            enabled: input.enabled
+          });
+        } catch (error) {
+          if (error?.code === "23505") throw { isUniqueNameError: true };
+          throw error;
+        }
+      },
+      updateProviderWithSecret: async (id, input) => {
+        const existing = await getLlmProvider(p.db, id);
+        if (!existing) return null;
+        let encryptedApiKey;
+        try {
+          if (input.apiFormat === "cloudflare-workers-ai") {
+            encryptedApiKey = null;
+          } else if (input.clearApiKey) {
+            encryptedApiKey = null;
+          } else if (input.apiKey) {
+            encryptedApiKey = await encryptLlmApiKey(getSecretStore(p), input.apiKey.trim());
+          } else {
+            encryptedApiKey = void 0;
+          }
+        } catch (error) {
+          if (error instanceof Error && error.message.includes("LLM_CONFIG_ENCRYPTION_KEY")) {
+            throw { isEncryptionConfigError: true, message: error.message };
+          }
+          throw error;
+        }
+        const effectiveEncryptedApiKey = encryptedApiKey !== void 0 ? encryptedApiKey : existing.encryptedApiKey;
+        if (input.enabled && input.apiFormat !== "cloudflare-workers-ai" && !effectiveEncryptedApiKey) {
+          throw { isKeyRequiredError: true };
+        }
+        try {
+          return await updateLlmProvider(p.db, id, {
+            name: input.name,
+            apiFormat: input.apiFormat,
+            baseUrl: input.apiFormat === "cloudflare-workers-ai" ? null : input.baseUrl ? input.baseUrl.replace(/\/+$/, "") : null,
+            ...encryptedApiKey !== void 0 ? { encryptedApiKey } : {},
+            enabled: input.enabled
+          });
+        } catch (error) {
+          if (error?.code === "23505") throw { isUniqueNameError: true };
+          throw error;
+        }
+      }
+    },
+    sessionStore: p.sessionStore,
+    platform: {
+      scheduleBestEffortJobMaintenance: p.scheduleBestEffortJobMaintenance,
+      createReviewRuntime: p.createReviewRuntime,
+      getUpdatesEmailPreference: async (githubUserId) => await getUpdatesEmailPreference(p.kv, githubUserId),
+      syncUpdatesEmail: async (githubUserId, email) => await syncUpdatesEmail(p.kv, githubUserId, email),
+      terminateJobWorkflow: p.terminateJobWorkflow,
+      enqueueReviewJob: p.enqueueReviewJob,
+      getOrFetchRawDiffForCompletedJob: p.getOrFetchRawDiffForCompletedJob,
+      logger: p.logger
+    },
+    authProvider: {
+      createOAuthState: async () => await createOAuthState(p.kv),
+      consumeOAuthState: async (state) => await consumeOAuthState(p.kv, state),
+      beginAuthorization: async (callbackUrl, state) => await identityProvider(p).beginAuthorization(callbackUrl, state, toAppBindingsConfig(p)),
+      completeAuthorization: async (code, state, expectedState) => await identityProvider(p).completeAuthorization(code, state, expectedState, toAppBindingsConfig(p))
+    },
+    webhook: {
+      verifySignature: async (signature, body) => await verifyGitHubWebhookSignature(p.githubAppWebhookSecret, signature, body),
+      normalizePayload: (eventName, payload) => normalizeGitHubWebhook(eventName, payload),
+      extractReviewRequest: (input) => extractReviewRequest(input)
+    }
+  };
+}
 export {
   createApiRouter,
+  createSharedApiDeps,
   requireCsrfHeader,
   requirePermission,
   requireQuota,