cartethyia 2.7.1 → 2.7.3

package/src/console/system-prompt/contracts.ts

@@ -0,0 +1,102 @@
+// Tenant system-prompt injection contracts.
+//
+// Shared by the console API, the persistence store, and the dispatch-path
+// transform — all Elysia-free so the dashboard bundle can import the types.
+
+/**
+ * One scope's prompt configuration. `enabled` is the master switch for the
+ * scope; `mode` decides how the text meets existing system content.
+ */
+export interface PromptSetting {
+  readonly enabled: boolean;
+  readonly mode: PromptMode;
+  readonly text: string;
+}
+
+export const PROMPT_MODES = ["append", "override"] as const;
+export type PromptMode = (typeof PROMPT_MODES)[number];
+
+/** Per-provider entry: follow the tenant's global prompt, or carry a custom one. */
+export interface ProviderPromptEntry {
+  readonly followGlobal: boolean;
+  /** Present and used only when `followGlobal` is false. */
+  readonly setting?: PromptSetting;
+}
+
+/** The full per-tenant configuration, one row in `tenant_system_prompts`. */
+export interface TenantSystemPrompts {
+  /** `null` = never configured — distinct from an explicit disabled setting. */
+  readonly global: PromptSetting | null;
+  /** providerId → entry */
+  readonly providers: Readonly<Record<string, ProviderPromptEntry>>;
+  /** `${providerId}::${modelId}` → setting */
+  readonly models: Readonly<Record<string, PromptSetting>>;
+}
+
+/** Empty configuration: nothing configured anywhere. */
+export const EMPTY_TENANT_SYSTEM_PROMPTS: TenantSystemPrompts = {
+  global: null,
+  providers: {},
+  models: {},
+};
+
+/** Maximum stored text per scope (5 MB). Enforced at the console API. */
+export const SYSTEM_PROMPT_TEXT_CAP_BYTES = 5_000_000;
+
+/**
+ * Marker wrapping tenant text injected into a provider wire whose upstream
+ * validates the system prompt as a channel identity (the buddy family). The
+ * fixed identity prompt stays the opener; the tenant text rides after it
+ * inside the same turn, framed so the provider's own parser is not confused.
+ */
+export const SYSTEM_PROMPT_WRAPPER_PREFIX = "<cartethyia:system-prompt>";
+export const SYSTEM_PROMPT_WRAPPER_SUFFIX = "</cartethyia:system-prompt>";
+
+/** Maximum number of per-provider entries stored for one tenant. */
+export const SYSTEM_PROMPT_PROVIDER_LIMIT = 256;
+
+/** Maximum number of per-model entries stored for one tenant. */
+export const SYSTEM_PROMPT_MODEL_LIMIT = 512;
+
+/**
+ * Providers whose upstream validates the fixed system prompt as a channel
+ * identity. Their system turn must keep the fixed prompt as the opener, so
+ * tenant text is appended after it inside the same turn, wrapped in the
+ * gateway's prefix/suffix markers (see `SYSTEM_PROMPT_WRAPPER_PREFIX`).
+ * `override` mode is not honoured for these providers — it would strip the
+ * identity and the upstream would refuse the request.
+ */
+export const WRAPPED_INJECTION_PROVIDERS: ReadonlySet<string> = new Set([
+  "cb", // CodeBuddy International
+  "cbcn", // CodeBuddy CN
+  "workbuddy",
+]);
+
+/** Whether a provider's tenant text rides wrapped after the fixed identity prompt. */
+export function isWrappedInjectionProvider(providerId: string): boolean {
+  return WRAPPED_INJECTION_PROVIDERS.has(providerId);
+}
+
+/** Model-scope key for the `models` map. */
+export function systemPromptModelKey(providerId: string, modelId: string): string {
+  return `${providerId}::${modelId}`;
+}
+
+/** Parses a model-scope key; null when the key is malformed. */
+export function parseSystemPromptModelKey(key: string): { providerId: string; modelId: string } | null {
+  const index = key.indexOf("::");
+  if (index <= 0 || index === key.length - 2) return null;
+  return { providerId: key.slice(0, index), modelId: key.slice(index + 2) };
+}
+
+/** True when the value is a well-formed prompt setting (shape only, not size). */
+export function isPromptSetting(value: unknown): value is PromptSetting {
+  if (typeof value !== "object" || value === null) return false;
+  const candidate = value as Partial<PromptSetting>;
+  return (
+    typeof candidate.enabled === "boolean" &&
+    typeof candidate.mode === "string" &&
+    (PROMPT_MODES as readonly string[]).includes(candidate.mode) &&
+    typeof candidate.text === "string"
+  );
+}

package/src/console/system-prompt/routes.ts

@@ -0,0 +1,165 @@
+// Console API for tenant system-prompt injection.
+//
+// GET    /system-prompt → the stored configuration
+// PUT    /system-prompt → replace the configuration wholesale
+// DELETE /system-prompt → clear it entirely
+//
+// The PUT replaces the row: the modal edits the whole three-scope shape at
+// once, so a PATCH surface would add states the UI never produces. Text is
+// capped at 5 MB per scope and the provider/model maps are bounded, matching
+// the store's own defensive limits.
+import { Elysia, t } from "elysia";
+import type { ConsoleAccessResolver } from "../auth/access";
+import { ConsoleDomainError, consoleErrorHandler, requireTenantScope } from "../shared/errors";
+import type { AuditSink } from "../audit/contracts";
+import type { CartethyiaDatabase } from "../../persistence/db-handle";
+import {
+  clearTenantSystemPrompts,
+  readTenantSystemPrompts,
+  writeTenantSystemPrompts,
+} from "../../persistence/system-prompt-store";
+import {
+  EMPTY_TENANT_SYSTEM_PROMPTS,
+  PROMPT_MODES,
+  SYSTEM_PROMPT_MODEL_LIMIT,
+  SYSTEM_PROMPT_PROVIDER_LIMIT,
+  SYSTEM_PROMPT_TEXT_CAP_BYTES,
+  isPromptSetting,
+  parseSystemPromptModelKey,
+  type PromptSetting,
+  type ProviderPromptEntry,
+  type TenantSystemPrompts,
+} from "./contracts";
+
+/** Route-group context injected by the composition root. */
+export interface SystemPromptRoutesConfig {
+  readonly db: CartethyiaDatabase;
+  readonly accessResolver: ConsoleAccessResolver;
+  readonly auditSink?: AuditSink;
+}
+
+/** Validates one scope setting, including the 5 MB text cap. */
+function validateSetting(value: unknown, scopeLabel: string): PromptSetting {
+  if (!isPromptSetting(value)) {
+    throw new ConsoleDomainError("invalid_request", 400, `${scopeLabel} is not a valid prompt setting`);
+  }
+  const bytes = Buffer.byteLength(value.text, "utf8");
+  if (bytes > SYSTEM_PROMPT_TEXT_CAP_BYTES) {
+    throw new ConsoleDomainError("payload_too_large", 413, `${scopeLabel} exceeds the 5 MB limit`);
+  }
+  if (!(PROMPT_MODES as readonly string[]).includes(value.mode)) {
+    throw new ConsoleDomainError("invalid_request", 400, `${scopeLabel} has an invalid mode`);
+  }
+  return value;
+}
+
+/** Validates the full PUT body into the stored shape. */
+function validateBody(value: unknown): TenantSystemPrompts {
+  if (typeof value !== "object" || value === null) {
+    throw new ConsoleDomainError("invalid_request", 400, "Body must be an object");
+  }
+  const body = value as {
+    global?: unknown;
+    providers?: unknown;
+    models?: unknown;
+  };
+
+  const global =
+    body.global === null || body.global === undefined
+      ? null
+      : validateSetting(body.global, "global");
+
+  if (body.providers !== undefined && typeof body.providers !== "object") {
+    throw new ConsoleDomainError("invalid_request", 400, "providers must be an object");
+  }
+  const rawProviders = (body.providers ?? {}) as Record<string, unknown>;
+  const providerIds = Object.keys(rawProviders);
+  if (providerIds.length > SYSTEM_PROMPT_PROVIDER_LIMIT) {
+    throw new ConsoleDomainError(
+      "invalid_request",
+      400,
+      `providers exceeds the ${SYSTEM_PROMPT_PROVIDER_LIMIT} entry limit`,
+    );
+  }
+  const providers: Record<string, ProviderPromptEntry> = {};
+  for (const providerId of providerIds) {
+    const entry = rawProviders[providerId];
+    if (typeof entry !== "object" || entry === null) {
+      throw new ConsoleDomainError("invalid_request", 400, `provider ${providerId} entry must be an object`);
+    }
+    const candidate = entry as Partial<ProviderPromptEntry>;
+    if (typeof candidate.followGlobal !== "boolean") {
+      throw new ConsoleDomainError("invalid_request", 400, `provider ${providerId} needs followGlobal`);
+    }
+    if (candidate.followGlobal) {
+      providers[providerId] = { followGlobal: true };
+    } else {
+      providers[providerId] = {
+        followGlobal: false,
+        setting: validateSetting(candidate.setting, `provider ${providerId}`),
+      };
+    }
+  }
+
+  if (body.models !== undefined && typeof body.models !== "object") {
+    throw new ConsoleDomainError("invalid_request", 400, "models must be an object");
+  }
+  const rawModels = (body.models ?? {}) as Record<string, unknown>;
+  const modelKeys = Object.keys(rawModels);
+  if (modelKeys.length > SYSTEM_PROMPT_MODEL_LIMIT) {
+    throw new ConsoleDomainError(
+      "invalid_request",
+      400,
+      `models exceeds the ${SYSTEM_PROMPT_MODEL_LIMIT} entry limit`,
+    );
+  }
+  const models: Record<string, PromptSetting> = {};
+  for (const key of modelKeys) {
+    if (parseSystemPromptModelKey(key) === null) {
+      throw new ConsoleDomainError("invalid_request", 400, `model key ${key} is malformed`);
+    }
+    models[key] = validateSetting(rawModels[key], `model ${key}`);
+  }
+
+  return { global, providers, models };
+}
+
+/**
+ * The return type is inferred rather than annotated as `Elysia`: `.error()`
+ * widens the instance type with its handler's response envelope, so the
+ * annotated base type no longer matches the chained result (same reason the
+ * remote-support routes leave it inferred).
+ */
+export function createSystemPromptRoutes(config: SystemPromptRoutesConfig) {
+  return new Elysia()
+    .error(consoleErrorHandler("System prompt settings failed"))
+    .get("/system-prompt", async ({ request }) => {
+      const access = requireTenantScope(config.accessResolver(request), "dashboard:read");
+      return await readTenantSystemPrompts(config.db, access.tenantId);
+    })
+    .put(
+      "/system-prompt",
+      { body: t.Any() },
+      async ({ request, body }) => {
+        const access = requireTenantScope(config.accessResolver(request), "dashboard:write");
+        const next = validateBody(body);
+        await writeTenantSystemPrompts(config.db, access.tenantId, next);
+        await config.auditSink?.record({
+          access,
+          action: "system_prompt.update",
+          target: "tenant_system_prompts",
+          detail: {
+            global: next.global !== null,
+            providers: Object.keys(next.providers).length,
+            models: Object.keys(next.models).length,
+          },
+        });
+        return next;
+      },
+    )
+    .delete("/system-prompt", async ({ request }) => {
+      const access = requireTenantScope(config.accessResolver(request), "dashboard:write");
+      await clearTenantSystemPrompts(config.db, access.tenantId);
+      return EMPTY_TENANT_SYSTEM_PROMPTS;
+    });
+}

package/src/main.ts

@@ -169,6 +169,17 @@ if (boot) {
     globalThis.__cartethyiaSignalsRegistered = true;
     process.on("SIGINT", () => shutdown("SIGINT"));
     process.on("SIGTERM", () => shutdown("SIGTERM"));
+    // A rejected promise nothing awaited (a sweep, a cache warm, a read whose
+    // parameters a bug elsewhere ballooned) must not kill the listener: the
+    // default is fatal exit, which turned one query fault into a systemd
+    // restart loop. Logged and absorbed — the failure stays visible, the
+    // process stays up.
+    process.on("unhandledRejection", (reason) => {
+      log.error(
+        "[process] unhandled rejection (kept alive)",
+        reason instanceof Error ? reason : new Error(String(reason)),
+      );
+    });
     // An in-place update signals SIGUSR2 before swapping the image so the old
     // process drains with the `update` reason and its callers are told the
     // replacement is seconds away instead of seeing a generic shutdown. Not