@agent-native/core 0.79.16 → 0.79.18

package/corpus/core/src/server/email.ts

@@ -1,7 +1,7 @@
 /**
  * Email transport for system emails (password resets, invitations, notifications).
  *
- * Providers are selected by env var:
+ * Providers are selected by scoped secrets:
  *   RESEND_API_KEY    — https://resend.com
  *   SENDGRID_API_KEY  — https://sendgrid.com
  *   EMAIL_FROM        — "Name <addr@domain>" (optional; defaults to Resend's sandbox)
@@ -10,6 +10,8 @@
  * so the reset-password flow still works end-to-end for local development.
  */
 
+import { resolveSecret } from "./credential-provider.js";
+
 export type EmailProvider = "resend" | "sendgrid" | "dev";
 
 export interface EmailAttachment {
@@ -33,32 +35,65 @@ export interface SendEmailArgs {
   attachments?: EmailAttachment[];
 }
 
-export function isEmailConfigured(): boolean {
-  return !!(process.env.RESEND_API_KEY || process.env.SENDGRID_API_KEY);
+interface EmailTransportConfig {
+  provider: EmailProvider;
+  resendApiKey?: string;
+  sendgridApiKey?: string;
+  from?: string;
 }
 
-export function getEmailProvider(): EmailProvider {
-  if (process.env.RESEND_API_KEY) return "resend";
-  if (process.env.SENDGRID_API_KEY) return "sendgrid";
-  return "dev";
+async function resolveEmailTransport(): Promise<EmailTransportConfig> {
+  const [resendApiKey, sendgridApiKey, from] = await Promise.all([
+    resolveSecret("RESEND_API_KEY"),
+    resolveSecret("SENDGRID_API_KEY"),
+    resolveSecret("EMAIL_FROM"),
+  ]);
+  const resolvedFrom = from ?? undefined;
+  if (resendApiKey) {
+    return {
+      provider: "resend",
+      resendApiKey,
+      from: resolvedFrom,
+    };
+  }
+  if (sendgridApiKey) {
+    return {
+      provider: "sendgrid",
+      sendgridApiKey,
+      from: resolvedFrom,
+    };
+  }
+  return { provider: "dev", from: resolvedFrom };
 }
 
-function getFromAddress(override?: string, provider?: EmailProvider): string {
-  const explicit = override || process.env.EMAIL_FROM;
+export async function isEmailConfigured(): Promise<boolean> {
+  return (await resolveEmailTransport()).provider !== "dev";
+}
+
+export async function getEmailProvider(): Promise<EmailProvider> {
+  return (await resolveEmailTransport()).provider;
+}
+
+function getFromAddress(
+  config: EmailTransportConfig,
+  override?: string,
+): string {
+  const explicit = override || config.from;
   if (explicit) return explicit;
   // Resend lets unverified accounts send from its sandbox domain; SendGrid
   // does not, so falling back there would cause silent 403s at runtime.
-  if (provider === "sendgrid") {
+  if (config.provider === "sendgrid") {
     throw new Error(
-      "EMAIL_FROM is required when using SendGrid — set it to a verified sender address.",
+      "EMAIL_FROM is required when using SendGrid — save it as a verified sender address.",
     );
   }
   return "Agent Native <onboarding@resend.dev>";
 }
 
 export async function sendEmail(args: SendEmailArgs): Promise<void> {
-  const provider = getEmailProvider();
-  const from = getFromAddress(args.from, provider);
+  const config = await resolveEmailTransport();
+  const provider = config.provider;
+  const from = getFromAddress(config, args.from);
 
   if (provider === "resend") {
     const payload: Record<string, unknown> = {
@@ -89,7 +124,7 @@ export async function sendEmail(args: SendEmailArgs): Promise<void> {
     const res = await fetch("https://api.resend.com/emails", {
       method: "POST",
       headers: {
-        Authorization: `Bearer ${process.env.RESEND_API_KEY}`,
+        Authorization: `Bearer ${config.resendApiKey}`,
         "Content-Type": "application/json",
       },
       body: JSON.stringify(payload),
@@ -140,7 +175,7 @@ export async function sendEmail(args: SendEmailArgs): Promise<void> {
     const res = await fetch("https://api.sendgrid.com/v3/mail/send", {
       method: "POST",
       headers: {
-        Authorization: `Bearer ${process.env.SENDGRID_API_KEY}`,
+        Authorization: `Bearer ${config.sendgridApiKey}`,
         "Content-Type": "application/json",
       },
       body: JSON.stringify(sgPayload),
@@ -157,12 +192,12 @@ export async function sendEmail(args: SendEmailArgs): Promise<void> {
   // to send rather than silently leaking secrets to logs.
   if (process.env.NODE_ENV === "production") {
     throw new Error(
-      "No email provider configured. Set RESEND_API_KEY or SENDGRID_API_KEY.",
+      "No email provider configured. Save RESEND_API_KEY or SENDGRID_API_KEY in settings.",
     );
   }
   console.log(
     `\n[agent-native:email] No email provider configured. ` +
-      `Set RESEND_API_KEY or SENDGRID_API_KEY to send real emails.\n` +
+      `Save RESEND_API_KEY or SENDGRID_API_KEY in settings to send real emails.\n` +
       `---\nTo: ${args.to}\nFrom: ${from}\nSubject: ${args.subject}\n\n` +
       `${args.text || stripHtml(args.html)}\n---\n`,
   );

package/corpus/core/src/server/index.ts

@@ -1,6 +1,5 @@
 export {
   createServer,
-  upsertEnvFile,
   type CreateServerOptions,
   type EnvKeyConfig,
 } from "./create-server.js";
@@ -325,6 +324,7 @@ export {
   unregisterFileUploadProvider,
   listFileUploadProviders,
   getActiveFileUploadProvider,
+  getActiveFileUploadProviderForRequest,
   uploadFile,
   builderFileUploadProvider,
   type FileUploadInput,
@@ -381,6 +381,7 @@ export {
   resolveHasCompleteBuilderConnection,
   resolveBuilderCredentials,
   resolveBuilderCredential,
+  readDeployCredentialEnv,
   writeBuilderCredentials,
   deleteBuilderCredentials,
   resolveSecret,

package/corpus/core/src/server/scoped-key-storage.ts

@@ -0,0 +1,223 @@
+import type { H3Event } from "h3";
+
+import { getOrgContext } from "../org/context.js";
+import {
+  getRequiredSecret,
+  type RegisteredSecret,
+  type SecretScope,
+} from "../secrets/register.js";
+import { writeAppSecret } from "../secrets/storage.js";
+import { getSession } from "./auth.js";
+
+const KEY_NAME_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+
+export type ScopedKeySaveRequestScope =
+  | "app"
+  | "auto"
+  | "org"
+  | "user"
+  | "workspace"
+  | undefined;
+
+export interface ScopedKeyValue {
+  key: string;
+  value: string;
+}
+
+export interface ScopedKeySaveRow {
+  key: string;
+  scope: SecretScope;
+  scopeId: string;
+}
+
+export class ScopedKeyStorageError extends Error {
+  constructor(
+    readonly statusCode: number,
+    message: string,
+  ) {
+    super(message);
+    this.name = "ScopedKeyStorageError";
+  }
+}
+
+export function findUnsupportedScopedKeyNames(
+  vars: unknown,
+  allowedKeys: Iterable<string>,
+): string[] {
+  if (!Array.isArray(vars)) return [];
+
+  const allowed = new Set(allowedKeys);
+  const unsupported = new Set<string>();
+  for (const entry of vars) {
+    if (!entry || typeof entry !== "object") continue;
+    const key = (entry as { key?: unknown }).key;
+    const normalizedKey = typeof key === "string" ? key.trim() : "";
+    if (normalizedKey && !allowed.has(normalizedKey)) {
+      unsupported.add(normalizedKey);
+    }
+  }
+  return [...unsupported];
+}
+
+function redactSecretFromMessage(message: string, secretValue: string): string {
+  if (!message || !secretValue) return message;
+  return message.split(secretValue).join("[redacted]");
+}
+
+function normalizeKeyValueVars(vars: unknown): ScopedKeyValue[] {
+  if (!Array.isArray(vars) || vars.length === 0) {
+    throw new ScopedKeyStorageError(400, "vars array required");
+  }
+
+  const out: ScopedKeyValue[] = [];
+  for (const entry of vars) {
+    if (!entry || typeof entry !== "object") {
+      throw new ScopedKeyStorageError(400, "Each var must be an object");
+    }
+    const { key, value } = entry as { key?: unknown; value?: unknown };
+    const normalizedKey = typeof key === "string" ? key.trim() : "";
+    if (!normalizedKey || !KEY_NAME_RE.test(normalizedKey)) {
+      throw new ScopedKeyStorageError(
+        400,
+        normalizedKey
+          ? `Invalid key name "${normalizedKey}"`
+          : "Each var requires a key",
+      );
+    }
+    const normalizedValue = typeof value === "string" ? value.trim() : "";
+    if (!normalizedValue) {
+      throw new ScopedKeyStorageError(
+        400,
+        `Value for ${normalizedKey} must be non-empty`,
+      );
+    }
+    out.push({ key: normalizedKey, value: normalizedValue });
+  }
+  return out;
+}
+
+function resolveTargetScope(
+  secret: RegisteredSecret | undefined,
+  requestedScope: ScopedKeySaveRequestScope,
+): SecretScope {
+  if (secret?.kind === "api-key") return secret.scope;
+  if (requestedScope === "org") return "org";
+  if (requestedScope === "workspace" || requestedScope === "app") {
+    return "workspace";
+  }
+  return "user";
+}
+
+async function resolveScopeId(
+  event: H3Event,
+  scope: SecretScope,
+): Promise<{
+  scopeId: string;
+  orgRole: string | null;
+  orgId: string | null;
+}> {
+  const session = await getSession(event).catch(() => null);
+  const email = session?.email ?? null;
+
+  if (scope === "user") {
+    if (!email) {
+      throw new ScopedKeyStorageError(401, "Sign in to save keys");
+    }
+    return { scopeId: email, orgRole: null, orgId: null };
+  }
+
+  const orgCtx = await getOrgContext(event).catch(() => null);
+  const orgId = orgCtx?.orgId ?? null;
+  const orgRole = orgCtx?.role ?? null;
+
+  if (scope === "org") {
+    if (!orgId) {
+      throw new ScopedKeyStorageError(401, "No active organization");
+    }
+    return { scopeId: orgId, orgRole, orgId };
+  }
+
+  if (orgId) {
+    return { scopeId: orgId, orgRole, orgId };
+  }
+  if (!email) {
+    throw new ScopedKeyStorageError(401, "Sign in to save workspace keys");
+  }
+  return { scopeId: `solo:${email}`, orgRole: null, orgId: null };
+}
+
+function assertCanMutateScope(
+  scope: SecretScope,
+  scopeId: string,
+  orgRole: string | null,
+): void {
+  if (scope === "user") return;
+  if (scope === "workspace" && scopeId.startsWith("solo:")) return;
+  if (orgRole === "owner" || orgRole === "admin") return;
+  throw new ScopedKeyStorageError(
+    403,
+    scope === "org"
+      ? "Only organization owners and admins can set org-scoped keys"
+      : "Only organization owners and admins can set workspace-scoped keys",
+  );
+}
+
+async function validateRegisteredSecret(
+  secret: RegisteredSecret | undefined,
+  value: string,
+): Promise<void> {
+  if (!secret) return;
+  if (secret.kind === "oauth") {
+    throw new ScopedKeyStorageError(
+      400,
+      `"${secret.key}" is an OAuth-kind secret and must be connected via OAuth`,
+    );
+  }
+  if (!secret.validator) return;
+  try {
+    const result = await secret.validator(value);
+    const ok = typeof result === "boolean" ? result : result?.ok === true;
+    if (ok) return;
+    const error =
+      typeof result === "object" && result && result.error
+        ? String(result.error)
+        : "Validator rejected the value";
+    throw new ScopedKeyStorageError(400, redactSecretFromMessage(error, value));
+  } catch (err) {
+    if (err instanceof ScopedKeyStorageError) throw err;
+    const message =
+      err instanceof Error
+        ? `Validator threw: ${err.message}`
+        : "Validator threw";
+    throw new ScopedKeyStorageError(
+      400,
+      redactSecretFromMessage(message, value),
+    );
+  }
+}
+
+export async function saveKeyValuesToScopedSecrets(
+  event: H3Event,
+  vars: unknown,
+  requestedScope?: ScopedKeySaveRequestScope,
+): Promise<{ saved: string[]; rows: ScopedKeySaveRow[] }> {
+  const normalized = normalizeKeyValueVars(vars);
+  const rows: ScopedKeySaveRow[] = [];
+
+  for (const entry of normalized) {
+    const secret = getRequiredSecret(entry.key);
+    const scope = resolveTargetScope(secret, requestedScope);
+    const { scopeId, orgRole } = await resolveScopeId(event, scope);
+    assertCanMutateScope(scope, scopeId, orgRole);
+    await validateRegisteredSecret(secret, entry.value);
+    await writeAppSecret({
+      key: entry.key,
+      value: entry.value,
+      scope,
+      scopeId,
+    });
+    rows.push({ key: entry.key, scope, scopeId });
+  }
+
+  return { saved: rows.map((row) => row.key), rows };
+}

package/corpus/core/src/shared/agent-env.ts

@@ -1,5 +1,5 @@
 /**
- * Isomorphic Agent Env Utility
+ * Isomorphic Agent Key Utility
  *
  * Works in both browser and Node.js contexts:
  * - Browser: sends via postMessage to the parent window
@@ -18,7 +18,7 @@ const isBrowser =
   typeof window !== "undefined" && typeof window.postMessage === "function";
 
 /**
- * Send env vars to the host (Builder cloud or Claude frame).
+ * Send key/value settings to the host for scoped secret persistence.
  * Automatically detects environment (browser vs Node.js) and uses the right transport.
  */
 function setVars(vars: EnvVar[]): void {
@@ -41,6 +41,6 @@ function setVars(vars: EnvVar[]): void {
 }
 
 export const agentEnv = {
-  /** Send environment variables to the host for persistence */
+  /** Send key/value settings to the host for scoped secret persistence. */
   setVars,
 };

package/corpus/core/src/sharing/actions/share-resource.ts

@@ -262,7 +262,7 @@ export default defineAction({
     if (
       args.notify !== false &&
       args.principalType === "user" &&
-      isEmailConfigured() &&
+      (await isEmailConfigured()) &&
       !isSyntheticQaEmail(principalId)
     ) {
       try {

package/corpus/core/src/styles/agent-native.css

@@ -55,6 +55,8 @@
   --agent-native-lower-surface: hsl(
     var(--sidebar-background, var(--background))
   );
+  --agent-native-raised-surface: hsl(var(--background));
+  --agent-native-card-surface: hsl(var(--card));
   --agent-native-raised-border: hsl(var(--border));
   --agent-native-raised-radius: 8px;
   --agent-native-raised-shadow-left: -1px 0 3px rgb(0 0 0 / 0.018);
@@ -86,6 +88,16 @@
       hsl(var(--sidebar-background, var(--background))) 94%,
       black
     );
+    --agent-native-raised-surface: color-mix(
+      in srgb,
+      hsl(var(--background)) 78%,
+      hsl(var(--muted)) 22%
+    );
+    --agent-native-card-surface: color-mix(
+      in srgb,
+      var(--agent-native-raised-surface) 88%,
+      hsl(var(--muted)) 12%
+    );
   }
 }
 
@@ -107,6 +119,13 @@
   border-inline-end-color: transparent !important;
 }
 
+.agent-layout-shell
+  .agent-layout-left-drawer
+  > :where(.border-e, .border-r):first-child {
+  border-inline-end-color: transparent !important;
+  border-right-color: transparent !important;
+}
+
 .agent-sidebar-panel > .agent-sidebar-panel-inner {
   background: inherit;
 }
@@ -119,26 +138,59 @@
 .agent-sidebar-main-surface {
   position: relative;
   z-index: 1;
-  background: hsl(var(--background));
+  background: var(--agent-native-raised-surface);
   transition:
     border-radius 260ms cubic-bezier(0.32, 0.72, 0, 1),
+    border-color 260ms cubic-bezier(0.32, 0.72, 0, 1),
     box-shadow 260ms cubic-bezier(0.32, 0.72, 0, 1);
 }
 
 .agent-layout-shell
   :where(.agent-layout-main-surface, .agent-sidebar-main-surface)
   > :first-child
-  > :where(header, div).border-b:first-child,
+  > :where(header, div).border-b,
 .agent-layout-shell
   :where(.agent-layout-main-surface, .agent-sidebar-main-surface)
-  > :where(header, div).border-b:first-child,
+  > :where(header, div).border-b,
 .agent-layout-shell
   .agent-layout-left-drawer
   > :where(header, div).border-b:first-child,
+.agent-layout-shell
+  .agent-layout-left-drawer
+  > :first-child
+  > :where(header, div).border-b,
 .agent-layout-shell .agent-native-shell-topbar {
   border-bottom-color: transparent !important;
 }
 
+.agent-layout-shell
+  :where(.agent-layout-main-surface, .agent-sidebar-main-surface)
+  > :first-child
+  > :where(header, div).border-b,
+.agent-layout-shell
+  :where(.agent-layout-main-surface, .agent-sidebar-main-surface)
+  > :where(header, div).border-b {
+  background-color: var(--agent-native-raised-surface) !important;
+}
+
+.agent-layout-shell
+  :where(.agent-layout-main-surface, .agent-sidebar-main-surface)
+  > :first-child
+  > :where(header, div).border-b.h-12,
+.agent-layout-shell
+  :where(.agent-layout-main-surface, .agent-sidebar-main-surface)
+  > :where(header, div).border-b.h-12 {
+  min-height: 4rem;
+  height: 4rem;
+}
+
+.dark
+  .agent-layout-shell
+  :where(.agent-layout-main-surface, .agent-sidebar-main-surface)
+  :where(.bg-card) {
+  background-color: var(--agent-native-card-surface) !important;
+}
+
 @media (min-width: 768px) {
   .agent-layout-main-surface,
   .agent-layout-shell > .agent-sidebar-shell > .agent-sidebar-main-surface {

package/corpus/core/src/templates/workspace-root/AGENTS.md

@@ -170,7 +170,8 @@ Use the workspace root `.env` for shared identity and cross-app trust settings:
 - `WORKSPACE_OWNER_EMAIL` — initial owner/admin email for repairs and
   integration defaults.
 - `A2A_SECRET` — shared secret for cross-app A2A signing. Generate with
-  `openssl rand -hex 32` or `pnpm repair:workspace-org -- --name ...`.
+  `openssl rand -hex 32` and configure through your deployment/scoped secret
+  manager.
 
 `DISPATCH_DEFAULT_OWNER_EMAIL` is optional. Set it only for trusted,
 single-workspace deployments where unlinked integration requests should run as
@@ -183,7 +184,7 @@ When asked to repair workspace org or A2A configuration:
 1. Read `.env` first. Do not infer the organization, domain, owner email, or
    secret from old examples.
 2. Run `pnpm repair:workspace-org -- --name "<org>" --domain example.com --owner-email owner@example.com`
-   to create or update generic workspace identity values.
+   to validate generic workspace identity values without writing `.env`.
 3. Prefer the app's organization settings UI or authenticated org routes for
    changing `allowed_domain` and `a2a_secret`.
 4. If direct SQL is unavoidable, inspect the live schema first and use only

package/corpus/core/src/templates/workspace-root/README.md

@@ -97,7 +97,7 @@ cross-app trust:
 - `A2A_SECRET` — shared signing secret for cross-app A2A calls.
 
 Run `pnpm repair:workspace-org -- --name "<org>" --domain example.com --owner-email owner@example.com`
-to fill or validate those values without committing secrets. Existing
+to validate those values without writing env files. Existing
 organization rows should still be repaired through the app's org settings UI or
 authenticated org routes whenever possible.