cartethyia 2.7.4 → 2.7.5

package/src/console/backup/store.ts

@@ -38,6 +38,7 @@ import { appendFile, mkdir } from "node:fs/promises";
 import { getTableColumns, type Column, type SQL, type Table } from "drizzle-orm";
 import type { CartethyiaDatabase } from "../../persistence/db-handle";
 import { decryptCredentialToString, encryptCredential } from "../../security/crypto";
+import { asConsoleDb } from "../shared/transaction";
 import {
   apiKeys,
   cliToolMappings,
@@ -75,7 +76,7 @@ import {
   tableName,
   type BackupBytes,
   type BackupDate,
-  type BackupExportResult,
+  type BackupPayloadExport,
   type BackupPayload,
   type BackupRow,
   type ValidatedRestore,
@@ -187,11 +188,15 @@ function decodeCell(value: unknown, dataType: string): unknown {
 }
 
 /** Column name → the object key Drizzle uses for it, and its data type. */
+const COLUMN_INDEX_CACHE = new WeakMap<Table, ReadonlyMap<string, { key: string; dataType: string }>>();
 function columnIndex(table: Table): ReadonlyMap<string, { key: string; dataType: string }> {
+  const cached = COLUMN_INDEX_CACHE.get(table);
+  if (cached) return cached;
   const out = new Map<string, { key: string; dataType: string }>();
   for (const [key, column] of Object.entries(getTableColumns(table))) {
     out.set(column.name, { key, dataType: column.dataType });
   }
+  COLUMN_INDEX_CACHE.set(table, out);
   return out;
 }
 
@@ -386,13 +391,6 @@ async function* pagedTelemetryEvents(
   }
 }
 
-/**
- * Streams the payload document: the requested tables, grouped into their
- * sections, written membrane-incrementally so the process never holds a table
- * — let alone every table and a second JSON copy — in memory. Consumed
- * chunks concatenated are exactly the JSON the buffered variant used to
- * stringify in one piece.
- */
 /**
  * Streams the payload document: the requested tables, grouped into their
  * sections, written incrementally so the process never holds a table — let
@@ -571,7 +569,7 @@ export async function exportBackup(
   db: CartethyiaDatabase,
   tables: readonly Table[],
   tenantId: string,
-): Promise<BackupExportResult> {
+): Promise<BackupPayloadExport> {
   const stream = exportBackupStream(db, tables, tenantId);
   let document = "";
   for await (const chunk of stream.jsonChunks) document += chunk;
@@ -618,7 +616,7 @@ export async function compressBackupStream(chunks: AsyncGenerator<string, void,
 const GZIP_MAGIC = [0x1f, 0x8b] as const;
 
 /** Whether `bytes` starts with the gzip magic. */
-export function isGzipBytes(bytes: Uint8Array): boolean {
+function isGzipBytes(bytes: Uint8Array): boolean {
   return GZIP_MAGIC.every((byte, index) => bytes[index] === byte);
 }
 
@@ -722,7 +720,6 @@ function createdAtIso(value: unknown): string {
  * timestamps are normalised in SQL to the same ISO spelling the payload uses,
  * so the two sides are comparable regardless of how the driver types them.
  */
-/** Natural keys already present in the event file, so a re-import skips them. */
 async function existingEventFileKeys(db: CartethyiaDatabase, tenantId: string, rows: readonly BackupRow[]): Promise<Set<string>> {
   const wanted = new Set(rows.map((row) => row.request_id).filter((id): id is string => typeof id === "string"));
   if (wanted.size === 0) return new Set();
@@ -894,9 +891,8 @@ async function insertRows(
       // stays writable and the per-row path can isolate the offending row.
       const count = await tx.transaction(async (innerTx) => {
         // Drizzle types the nested transaction callback with the dialect's
-        // own transaction handle; cast once to a named local with a reason,
-        // never inline on member access.
-        const inner = innerTx as unknown as CartethyiaDatabase; // nested-tx handle; mirrors applyRestore's outer `scoped` cast on line 607.
+        // own transaction handle; normalize once via the shared helper.
+        const inner = asConsoleDb(innerTx);
         const statement = inner.insert(table).values(chunk as never);
         if (options.ignoreConflicts) {
           if (options.conflictTarget === undefined) {
@@ -1003,22 +999,46 @@ export async function normalizeShareChildPolicy(
   db: CartethyiaDatabase,
   tenantId: string,
 ): Promise<void> {
+  // Template policy columns are nulled on every child so auth reads the full
+  // policy from the parent (`policy = parent ?? row`). The exception is a
+  // `per_key` concurrency child: it carries its own cap (copied at issue) and
+  // its own admission identity, so `concurrency_scope` and
+  // `max_concurrent_requests` are preserved for those rows.
+  const policyNulls = {
+    notesTitle: null,
+    notesSubtitle: null,
+    notesBody: null,
+    requestsPerMinute: null,
+    dailyTokenLimit: null,
+    monthlyTokenLimit: null,
+    lifetimeTokenBudget: null,
+    modelPrefix: null,
+    modelList: null,
+    clientRouterDenylist: null,
+  };
   await db
     .update(apiKeys)
     .set({
-      notesTitle: null,
-      notesSubtitle: null,
-      notesBody: null,
-      requestsPerMinute: null,
-      dailyTokenLimit: null,
-      monthlyTokenLimit: null,
-      lifetimeTokenBudget: null,
+      ...policyNulls,
       maxConcurrentRequests: null,
-      modelPrefix: null,
-      modelList: null,
-      clientRouterDenylist: null,
     })
-    .where(and(eq(apiKeys.tenantId, tenantId), isNotNull(apiKeys.parentKeyId)));
+    .where(
+      and(
+        eq(apiKeys.tenantId, tenantId),
+        isNotNull(apiKeys.parentKeyId),
+        sql`${apiKeys.concurrencyScope} <> 'per_key'`,
+      ),
+    );
+  await db
+    .update(apiKeys)
+    .set(policyNulls)
+    .where(
+      and(
+        eq(apiKeys.tenantId, tenantId),
+        isNotNull(apiKeys.parentKeyId),
+        eq(apiKeys.concurrencyScope, "per_key"),
+      ),
+    );
 }
 
 /**
@@ -1046,7 +1066,7 @@ export async function applyRestore(
   const skipped: Record<string, number> = {};
 
   await db.transaction(async (tx) => {
-    const scoped = tx as unknown as CartethyiaDatabase;
+    const scoped = asConsoleDb(tx);
 
     // The tenant row is ensured, never replaced: it almost always exists, and
     // its PK is `id`, so a conflict means "already there" rather than an error.
@@ -1199,7 +1219,7 @@ export async function deleteAll(
   const apiKeyIds: string[] = [];
 
   await db.transaction(async (tx) => {
-    const scoped = tx as unknown as CartethyiaDatabase;
+    const scoped = asConsoleDb(tx);
     const remove = async (table: Table, filter: SQL, name = tableName(table)): Promise<void> => {
       const rows = await scoped.delete(table).where(filter).returning();
       if (rows.length > 0) deleted[name] = (deleted[name] ?? 0) + rows.length;
@@ -1241,5 +1261,3 @@ export async function deleteAll(
 
   return { deleted, apiKeyIds };
 }
-
-export { and, eq };

package/src/console/backup/validate.ts

@@ -101,12 +101,17 @@ function normalizeLegacyCiphertext(table: Table, row: Record<string, unknown>):
   return normalized;
 }
 
+const COLUMN_TYPES_CACHE = new WeakMap<Table, ReadonlyMap<string, string>>();
+
 /** Column name → its Drizzle data type, so validation knows what may nest. */
 function columnTypes(table: Table): ReadonlyMap<string, string> {
+  const cached = COLUMN_TYPES_CACHE.get(table);
+  if (cached) return cached;
   const out = new Map<string, string>();
   for (const column of Object.values(getTableColumns(table))) {
     out.set(column.name, column.dataType);
   }
+  COLUMN_TYPES_CACHE.set(table, out);
   return out;
 }
 
@@ -122,7 +127,11 @@ function columnTypes(table: Table): ReadonlyMap<string, string> {
  * would write a row the operator never had, and guessing wrong on a credential
  * column is worse than not restoring that one row.
  */
+const REQUIRED_COLUMNS_CACHE = new WeakMap<Table, ReadonlySet<string>>();
+
 function requiredColumns(table: Table): ReadonlySet<string> {
+  const cached = REQUIRED_COLUMNS_CACHE.get(table);
+  if (cached) return cached;
   const out = new Set<string>();
   for (const column of Object.values(getTableColumns(table))) {
     if (!column.notNull || column.hasDefault) continue;
@@ -132,11 +141,12 @@ function requiredColumns(table: Table): ReadonlySet<string> {
     if (column.name === "tenant_id") continue;
     out.add(column.name);
   }
+  REQUIRED_COLUMNS_CACHE.set(table, out);
   return out;
 }
 
 /** Detection outcome for an uploaded file. */
-export type DetectedFormat =
+type DetectedFormat =
   | { readonly kind: "native"; readonly payload: Record<string, unknown> }
   | { readonly kind: "nine_router"; readonly payload: Record<string, unknown> }
   | { readonly kind: "unknown"; readonly reason: string };

package/src/console/cli-tools/contracts.ts

@@ -19,13 +19,13 @@ import { ensureV1Suffix } from "./fs-ops";
  * sibling project used `openai-chat | openai-responses | anthropic-messages`;
  * Cartethyia's canonical surface vocabulary is the shorter form.
  */
-export type CliToolSurface = "chat" | "responses" | "messages";
+type CliToolSurface = "chat" | "responses" | "messages";
 
 /** How the tool's config is managed. */
-export type ConfigType = "env" | "custom" | "guide";
+type ConfigType = "env" | "custom" | "guide";
 
 /** A native model slot exposed by a CLI tool. */
-export interface ToolModelDef {
+interface ToolModelDef {
   readonly id: string;
   readonly name: string;
   readonly alias: string;
@@ -63,13 +63,13 @@ export interface CliMappingSettings {
 }
 
 /** A note shown in the tool card UI. */
-export interface ToolNote {
+interface ToolNote {
   readonly type: "info" | "warning" | "error";
   readonly text: string;
 }
 
 /** A guide step for guide-only tools. */
-export interface GuideStep {
+interface GuideStep {
   readonly step: number;
   readonly title: string;
   readonly desc?: string;
@@ -78,7 +78,7 @@ export interface GuideStep {
 }
 
 /** A code block for guide-only tools. */
-export interface GuideCodeBlock {
+interface GuideCodeBlock {
   readonly language: string;
   readonly code: string;
 }
@@ -235,7 +235,7 @@ export interface ToolInjector {
 export type AllStatusesResult = Readonly<Record<string, ToolStatus>>;
 
 /** Status details extracted from a tool's configuration file(s). */
-export interface StatusDetails {
+interface StatusDetails {
   readonly configured: boolean;
   readonly currentEndpoint?: string | null | undefined;
   readonly currentApiKeyPrefix?: string | null | undefined;

package/src/console/cli-tools/injectors/cline.ts

@@ -1,110 +1,110 @@
-import type {} from "../contracts";
-import { homeDir, isLocalEndpoint, readJsonFile, stripV1Suffix, writeJsonFile } from "../fs-ops";
-import type { InjectorSpec } from "../contracts";
-
-
-// Cline injector spec.
-interface ClineGlobalState {
-  actModeApiProvider?: string;
-  planModeApiProvider?: string;
-  openAiBaseUrl?: string;
-  openAiModelId?: string;
-  planModeOpenAiModelId?: string;
-  [key: string]: unknown;
-}
-
-interface ClineSecrets {
-  openAiApiKey?: string;
-  [key: string]: unknown;
-}
-
-const clineSecretsPath = () => `${homeDir()}/.cline/data/secrets.json`;
-
-export const clineSpec: InjectorSpec = {
-  toolId: "cline",
-  displayName: "Cline",
-  binary: "cline",
-  resolvePath: () => `${homeDir()}/.cline/data/globalState.json`,
-  resolveDir: () => `${homeDir()}/.cline/data`,
-
-  async readStatus(path) {
-    const state = (await readJsonFile(path)) as ClineGlobalState | null;
-    const secrets = (await readJsonFile(clineSecretsPath())) as ClineSecrets | null;
-    const endpoint = state?.openAiBaseUrl ?? null;
-    const models = [state?.openAiModelId, state?.planModeOpenAiModelId].filter(
-      (m): m is string => typeof m === "string",
-    );
-    const configured = state?.actModeApiProvider === "openai" && isLocalEndpoint(endpoint);
-    return {
-      configured,
-      currentEndpoint: endpoint,
-      rawApiKey: secrets?.openAiApiKey ?? null,
-      currentModels: models.length > 0 ? models : null,
-    };
-  },
-
-  async apply(input, path) {
-    const model = input.activeModel ?? input.modelIds[0] ?? "";
-    const baseUrl = stripV1Suffix(input.endpoint);
-
-    const state = ((await readJsonFile(path)) as ClineGlobalState | null) ?? {};
-    state.actModeApiProvider = "openai";
-    state.planModeApiProvider = "openai";
-    state.openAiBaseUrl = baseUrl;
-    state.openAiModelId = model;
-    state.planModeOpenAiModelId = model;
-    await writeJsonFile(path, state);
-
-    const secrets = ((await readJsonFile(clineSecretsPath())) as ClineSecrets | null) ?? {};
-    secrets.openAiApiKey = input.apiKey;
-    await writeJsonFile(clineSecretsPath(), secrets);
-  },
-
-  async reset(path) {
-    const state = (await readJsonFile(path)) as ClineGlobalState | null;
-    if (!state) return false;
-
-    if (state.actModeApiProvider === "openai") {
-      delete state.openAiBaseUrl;
-      delete state.openAiModelId;
-      delete state.planModeOpenAiModelId;
-      state.actModeApiProvider = "cline";
-      state.planModeApiProvider = "cline";
-    }
-    await writeJsonFile(path, state);
-
-    const secrets = (await readJsonFile(clineSecretsPath())) as ClineSecrets | null;
-    if (secrets?.openAiApiKey) {
-      delete secrets.openAiApiKey;
-      await writeJsonFile(clineSecretsPath(), secrets);
-    }
-  },
-
-  download(input) {
-    const model = input.activeModel ?? input.modelIds[0] ?? "";
-    const baseUrl = stripV1Suffix(input.endpoint);
-    const globalState = JSON.stringify(
-      {
-        actModeApiProvider: "openai",
-        planModeApiProvider: "openai",
-        openAiBaseUrl: baseUrl,
-        openAiModelId: model,
-        planModeOpenAiModelId: model,
-      },
-      null,
-      2,
-    );
-    const secrets = JSON.stringify({ openAiApiKey: input.apiKey }, null, 2);
-    return {
-      content: `# ~/.cline/data/globalState.json\n${globalState}\n\n# ~/.cline/data/secrets.json\n${secrets}\n`,
-      filename: "cline-config.txt",
-      mimeType: "text/plain",
-    };
-  },
-
-  messages: {
-    applied: "Cline settings applied successfully",
-    reset: "Cartethyia settings removed from Cline",
-  },
-};
-
+import type {} from "../contracts";
+import { homeDir, isLocalEndpoint, readJsonFile, stripV1Suffix, writeJsonFile } from "../fs-ops";
+import type { InjectorSpec } from "../contracts";
+
+
+// Cline injector spec.
+interface ClineGlobalState {
+  actModeApiProvider?: string;
+  planModeApiProvider?: string;
+  openAiBaseUrl?: string;
+  openAiModelId?: string;
+  planModeOpenAiModelId?: string;
+  [key: string]: unknown;
+}
+
+interface ClineSecrets {
+  openAiApiKey?: string;
+  [key: string]: unknown;
+}
+
+const clineSecretsPath = () => `${homeDir()}/.cline/data/secrets.json`;
+
+export const clineSpec: InjectorSpec = {
+  toolId: "cline",
+  displayName: "Cline",
+  binary: "cline",
+  resolvePath: () => `${homeDir()}/.cline/data/globalState.json`,
+  resolveDir: () => `${homeDir()}/.cline/data`,
+
+  async readStatus(path) {
+    const state = (await readJsonFile(path)) as ClineGlobalState | null;
+    const secrets = (await readJsonFile(clineSecretsPath())) as ClineSecrets | null;
+    const endpoint = state?.openAiBaseUrl ?? null;
+    const models = [state?.openAiModelId, state?.planModeOpenAiModelId].filter(
+      (m): m is string => typeof m === "string",
+    );
+    const configured = state?.actModeApiProvider === "openai" && isLocalEndpoint(endpoint);
+    return {
+      configured,
+      currentEndpoint: endpoint,
+      rawApiKey: secrets?.openAiApiKey ?? null,
+      currentModels: models.length > 0 ? models : null,
+    };
+  },
+
+  async apply(input, path) {
+    const model = input.activeModel ?? input.modelIds[0] ?? "";
+    const baseUrl = stripV1Suffix(input.endpoint);
+
+    const state = ((await readJsonFile(path)) as ClineGlobalState | null) ?? {};
+    state.actModeApiProvider = "openai";
+    state.planModeApiProvider = "openai";
+    state.openAiBaseUrl = baseUrl;
+    state.openAiModelId = model;
+    state.planModeOpenAiModelId = model;
+    await writeJsonFile(path, state);
+
+    const secrets = ((await readJsonFile(clineSecretsPath())) as ClineSecrets | null) ?? {};
+    secrets.openAiApiKey = input.apiKey;
+    await writeJsonFile(clineSecretsPath(), secrets);
+  },
+
+  async reset(path) {
+    const state = (await readJsonFile(path)) as ClineGlobalState | null;
+    if (!state) return false;
+
+    if (state.actModeApiProvider === "openai") {
+      delete state.openAiBaseUrl;
+      delete state.openAiModelId;
+      delete state.planModeOpenAiModelId;
+      state.actModeApiProvider = "cline";
+      state.planModeApiProvider = "cline";
+    }
+    await writeJsonFile(path, state);
+
+    const secrets = (await readJsonFile(clineSecretsPath())) as ClineSecrets | null;
+    if (secrets?.openAiApiKey) {
+      delete secrets.openAiApiKey;
+      await writeJsonFile(clineSecretsPath(), secrets);
+    }
+  },
+
+  download(input) {
+    const model = input.activeModel ?? input.modelIds[0] ?? "";
+    const baseUrl = stripV1Suffix(input.endpoint);
+    const globalState = JSON.stringify(
+      {
+        actModeApiProvider: "openai",
+        planModeApiProvider: "openai",
+        openAiBaseUrl: baseUrl,
+        openAiModelId: model,
+        planModeOpenAiModelId: model,
+      },
+      null,
+      2,
+    );
+    const secrets = JSON.stringify({ openAiApiKey: input.apiKey }, null, 2);
+    return {
+      content: `# ~/.cline/data/globalState.json\n${globalState}\n\n# ~/.cline/data/secrets.json\n${secrets}\n`,
+      filename: "cline-config.txt",
+      mimeType: "text/plain",
+    };
+  },
+
+  messages: {
+    applied: "Cline settings applied successfully",
+    reset: "Cartethyia settings removed from Cline",
+  },
+};
+