@agent-native/core 0.198.3 → 0.198.5

package/dist/icon-assets/svg.js

@@ -0,0 +1,146 @@
+import { XMLParser, XMLValidator } from "fast-xml-parser";
+const ELEMENTS = new Set([
+    "svg",
+    "g",
+    "path",
+    "rect",
+    "circle",
+    "ellipse",
+    "line",
+    "polyline",
+    "polygon",
+    "defs",
+    "linearGradient",
+    "radialGradient",
+    "stop",
+    "clipPath",
+]);
+const ATTRIBUTES = new Set([
+    "xmlns",
+    "viewBox",
+    "width",
+    "height",
+    "x",
+    "y",
+    "x1",
+    "x2",
+    "y1",
+    "y2",
+    "cx",
+    "cy",
+    "r",
+    "rx",
+    "ry",
+    "d",
+    "points",
+    "fill",
+    "stroke",
+    "stroke-width",
+    "stroke-linecap",
+    "stroke-linejoin",
+    "stroke-miterlimit",
+    "stroke-dasharray",
+    "stroke-dashoffset",
+    "fill-rule",
+    "clip-rule",
+    "opacity",
+    "fill-opacity",
+    "stroke-opacity",
+    "transform",
+    "id",
+    "gradientUnits",
+    "gradientTransform",
+    "offset",
+    "stop-color",
+    "stop-opacity",
+    "clip-path",
+    "preserveAspectRatio",
+]);
+const COLOR = /^(?:none|currentColor|transparent|#[0-9a-fA-F]{3,8}|[a-zA-Z]+|url\(#[A-Za-z][\w.-]*\))$/;
+const NUMERIC = /^[\d\s.,+\-eE%]*$/;
+const PATH = /^[\d\s.,+\-eEa-zA-Z]*$/;
+const TRANSFORM = /^(?:\s*(?:matrix|translate|scale|rotate|skewX|skewY)\([\d\s.,+\-eE]+\)\s*)+$/;
+function escapeAttribute(value) {
+    return value
+        .replaceAll("&", "&")
+        .replaceAll('"', """)
+        .replaceAll("<", "&lt;");
+}
+function safeAttribute(name, value) {
+    if (!ATTRIBUTES.has(name) || value.length > 100_000)
+        return false;
+    if (name === "xmlns")
+        return value === "http://www.w3.org/2000/svg";
+    if (name === "id")
+        return /^[A-Za-z][\w.-]*$/.test(value);
+    if (["fill", "stroke", "stop-color"].includes(name))
+        return COLOR.test(value);
+    if (name === "clip-path")
+        return /^url\(#[A-Za-z][\w.-]*\)$/.test(value);
+    if (name === "transform" || name === "gradientTransform")
+        return TRANSFORM.test(value);
+    if ([
+        "stroke-linecap",
+        "stroke-linejoin",
+        "fill-rule",
+        "clip-rule",
+        "gradientUnits",
+        "preserveAspectRatio",
+    ].includes(name)) {
+        return /^[A-Za-z\s]+$/.test(value);
+    }
+    if (name === "d")
+        return PATH.test(value);
+    return NUMERIC.test(value);
+}
+function serializeNode(node) {
+    const entries = Object.entries(node).filter(([name]) => name !== ":@");
+    if (entries.length !== 1)
+        throw new Error("SVG contains unsupported markup");
+    const [name, children] = entries[0];
+    if (!ELEMENTS.has(name) || !Array.isArray(children)) {
+        throw new Error("SVG contains unsupported markup");
+    }
+    const attributes = (node[":@"] ?? {});
+    let opening = `<${name}`;
+    for (const [rawName, value] of Object.entries(attributes)) {
+        const attribute = rawName.startsWith("@_") ? rawName.slice(2) : rawName;
+        if (typeof value !== "string" || !safeAttribute(attribute, value)) {
+            throw new Error("SVG contains an unsafe attribute");
+        }
+        opening += ` ${attribute}="${escapeAttribute(value)}"`;
+    }
+    const body = children
+        .map((child) => {
+        if ("#text" in child) {
+            if (typeof child["#text"] !== "string" || child["#text"].trim()) {
+                throw new Error("SVG contains unsupported text");
+            }
+            return "";
+        }
+        return serializeNode(child);
+    })
+        .join("");
+    return `${opening}>${body}</${name}>`;
+}
+/** Canonicalize the small SVG icon vocabulary before bytes reach storage. */
+export function sanitizeIconSvg(data) {
+    const source = new TextDecoder("utf-8", { fatal: true }).decode(data).trim();
+    if (!source.startsWith("<svg") || /<!|<\?/.test(source)) {
+        throw new Error("Invalid SVG icon");
+    }
+    if (XMLValidator.validate(source) !== true)
+        throw new Error("Invalid SVG icon");
+    const nodes = new XMLParser({
+        ignoreAttributes: false,
+        preserveOrder: true,
+        processEntities: false,
+        parseTagValue: false,
+        parseAttributeValue: false,
+        trimValues: false,
+    }).parse(source);
+    if (nodes.length !== 1 || !Object.hasOwn(nodes[0], "svg")) {
+        throw new Error("Invalid SVG icon");
+    }
+    return new TextEncoder().encode(serializeNode(nodes[0]));
+}

package/dist/icon-assets/workspace-transport.d.ts

@@ -0,0 +1,20 @@
+import type { H3Event } from "h3";
+export interface WorkspaceIconAuthority {
+    identityAuthority: string | null;
+    identityId: string | null;
+    allowedDomain: string | null;
+}
+export declare function uploadFederatedWorkspaceIcon(event: H3Event, authority: WorkspaceIconAuthority, email: string, file: {
+    data: Uint8Array;
+    mimeType: string;
+    filename: string;
+}): Promise<string>;
+export declare function verifyFederatedWorkspaceIconOwner(event: H3Event, authority: WorkspaceIconAuthority, email: string, assetId: string): Promise<boolean>;
+export declare function readFederatedWorkspaceIcon(event: H3Event, authority: WorkspaceIconAuthority, email: string, assetId: string): Promise<{
+    data: Uint8Array;
+    mimeType: string;
+} | null>;
+export declare function listFederatedWorkspaceIconsForOwner(authority: WorkspaceIconAuthority, email: string): Promise<Array<{
+    id: string;
+    filename?: string;
+}>>;

package/dist/icon-assets/workspace-transport.js

@@ -0,0 +1,122 @@
+import { canonicalA2AAudience, signA2AToken } from "../a2a/index.js";
+import { resolveVercelDeploymentProtectionHeaders } from "../server/credential-provider.js";
+import { CANONICAL_IDENTITY_SSO_HUB_URL, NETLIFY_PREVIEW_IDENTITY_SSO_HUB_URL, getIdentityHubUrl, } from "../server/identity-sso-store.js";
+import { resolveIdentityHubUrl } from "../server/identity-sso.js";
+function dispatchUrl(event, authority) {
+    if (!authority.identityId || !authority.identityAuthority) {
+        throw new Error("Workspace icon identity authority is unavailable.");
+    }
+    const linked = new URL(authority.identityAuthority);
+    const hubs = event
+        ? [resolveIdentityHubUrl(event)]
+        : [
+            getIdentityHubUrl(),
+            CANONICAL_IDENTITY_SSO_HUB_URL,
+            NETLIFY_PREVIEW_IDENTITY_SSO_HUB_URL,
+        ];
+    const hub = hubs.find((candidate) => {
+        if (!candidate)
+            return false;
+        const expected = new URL(candidate);
+        return (linked.origin === expected.origin &&
+            linked.pathname.replace(/\/+$/, "") ===
+                expected.pathname.replace(/\/+$/, ""));
+    });
+    if (!hub) {
+        throw new Error("Workspace icon identity authority does not match this deployment.");
+    }
+    return hub.replace(/\/+$/, "");
+}
+async function dispatchRequest(event, authority, email, scope, assetId, file) {
+    const hub = dispatchUrl(event, authority);
+    const token = await signA2AToken(email, authority.allowedDomain ?? undefined, undefined, {
+        preferGlobalSecret: true,
+        audience: canonicalA2AAudience(hub, "/private-icon"),
+        expiresIn: "2m",
+        extraClaims: {
+            scope,
+            org_id: authority.identityId,
+            ...(assetId ? { asset_id: assetId } : {}),
+        },
+    });
+    const body = file ? new FormData() : undefined;
+    if (file) {
+        body.set("file", new Blob([new Uint8Array(file.data)], { type: file.mimeType }), file.filename);
+    }
+    const url = `${hub}/_agent-native/private-icons${assetId ? `/${encodeURIComponent(assetId)}` : ""}`;
+    return fetch(url, {
+        method: file
+            ? "POST"
+            : scope === "private-icon:verify-owner"
+                ? "HEAD"
+                : "GET",
+        headers: {
+            Authorization: `Bearer ${token}`,
+            ...resolveVercelDeploymentProtectionHeaders(url),
+        },
+        body,
+        redirect: "manual",
+        signal: AbortSignal.timeout(10_000),
+    });
+}
+export async function uploadFederatedWorkspaceIcon(event, authority, email, file) {
+    const response = await dispatchRequest(event, authority, email, "private-icon:upload", undefined, file);
+    if (!response.ok)
+        throw new Error(`Workspace icon upload failed (${response.status}).`);
+    const result = await response.json();
+    if (!result ||
+        typeof result !== "object" ||
+        !("id" in result) ||
+        typeof result.id !== "string") {
+        throw new Error("Workspace icon upload returned an invalid asset ID.");
+    }
+    return result.id;
+}
+export async function verifyFederatedWorkspaceIconOwner(event, authority, email, assetId) {
+    const response = await dispatchRequest(event, authority, email, "private-icon:verify-owner", assetId);
+    if (response.status === 404)
+        return false;
+    if (!response.ok)
+        throw new Error(`Workspace icon ownership check failed (${response.status}).`);
+    return true;
+}
+export async function readFederatedWorkspaceIcon(event, authority, email, assetId) {
+    const response = await dispatchRequest(event, authority, email, "private-icon:read", assetId);
+    if (response.status === 404)
+        return null;
+    if (!response.ok)
+        throw new Error(`Workspace icon read failed (${response.status}).`);
+    const mimeType = response.headers
+        .get("content-type")
+        ?.split(";", 1)[0]
+        ?.trim();
+    if (!mimeType?.startsWith("image/"))
+        throw new Error("Workspace icon response is not an image.");
+    return { data: new Uint8Array(await response.arrayBuffer()), mimeType };
+}
+export async function listFederatedWorkspaceIconsForOwner(authority, email) {
+    const response = await dispatchRequest(undefined, authority, email, "private-icon:list");
+    if (!response.ok)
+        throw new Error(`Workspace icon list failed (${response.status}).`);
+    const body = await response.json();
+    if (!body ||
+        typeof body !== "object" ||
+        !("assets" in body) ||
+        !Array.isArray(body.assets)) {
+        throw new Error("Workspace icon list returned an invalid response.");
+    }
+    return body.assets.map((asset) => {
+        if (!asset ||
+            typeof asset !== "object" ||
+            !("id" in asset) ||
+            typeof asset.id !== "string") {
+            throw new Error("Workspace icon list returned an invalid asset.");
+        }
+        return {
+            id: asset.id,
+            filename: "filename" in asset && typeof asset.filename === "string"
+                ? asset.filename
+                : undefined,
+        };
+    });
+}

package/dist/identity/rekey.js

@@ -55,6 +55,7 @@ export const IDENTITY_REKEY_COLUMNS = [
     { table: "integration_remote_devices", column: "owner_email" },
     { table: "agent_harness_sessions", column: "owner_email" },
     { table: "workspace_apps", column: "owner_email" },
+    { table: "private_icon_assets", column: "owner_email" },
     { table: "application_state", column: "session_id", mode: "state-session" },
     { table: "oauth_tokens", column: "owner", mode: "unsupported-oauth" },
     { table: "workspace_connections", column: "owner_email" },

package/dist/jobs/actions/manage-recurring-job.d.ts

@@ -11,9 +11,9 @@ declare const _default: import("../../action.js").ActionDefinition<{
     enabled?: undefined;
     nextRun?: undefined;
 } | {
+    deleted?: undefined;
     name: string;
     enabled: boolean;
     nextRun: string;
-    deleted?: undefined;
 }>;
 export default _default;

package/dist/labs/actions/get-lab-states.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../../action.js").ActionDefinition<Record<string, never>, Record<string, import("../store.js").UserLabState>>;
+export default _default;

package/dist/labs/actions/get-lab-states.js

@@ -0,0 +1,14 @@
+import { z } from "zod";
+import { defineAction, fail } from "../../action.js";
+import { getUserLabStates } from "../store.js";
+export default defineAction({
+    description: "Return each registered lab's effective state, including whether it comes from a saved choice or inherited feature flags.",
+    schema: z.object({}),
+    http: { method: "GET" },
+    run: async (_args, ctx) => {
+        const email = ctx?.userEmail;
+        if (!email)
+            fail("Not authenticated.", { statusCode: 401 });
+        return getUserLabStates(email, { orgId: ctx?.orgId });
+    },
+});

package/dist/labs/actions/get-labs.js

@@ -2,13 +2,13 @@ import { z } from "zod";
 import { defineAction, fail } from "../../action.js";
 import { getUserLabs } from "../store.js";
 export default defineAction({
-    description: "Return every registered lab and the current user's enabled state. Unset preferences use each lab's app-defined default.",
+    description: "Return every registered lab and the current user's effective enabled state. Unset preferences inherit declared legacy flags or use the app-defined default.",
     schema: z.object({}),
     http: { method: "GET" },
     run: async (_args, ctx) => {
         const email = ctx?.userEmail;
         if (!email)
             fail("Not authenticated.", { statusCode: 401 });
-        return getUserLabs(email);
+        return getUserLabs(email, { orgId: ctx?.orgId });
     },
 });

package/dist/labs/actions/set-lab.js

@@ -7,7 +7,7 @@ const schema = z.object({
     enabled: z.boolean().describe("Whether the current user opts into it."),
 });
 export default defineAction({
-    description: "Opt the current user into or out of one registered lab. Unset preferences use the app-defined default; labs may expose new or unstable features.",
+    description: "Opt the current user into or out of one registered lab. Unset preferences inherit declared legacy flags or use the app-defined default; labs may expose new or unstable features.",
     schema,
     http: { method: "POST" },
     run: async (args, ctx) => {
@@ -17,7 +17,9 @@ export default defineAction({
         if (!getLabDefinition(args.key)) {
             fail(`Unknown lab: ${args.key}`, { statusCode: 404 });
         }
-        const values = await setUserLab(email, args.key, args.enabled);
+        const values = await setUserLab(email, args.key, args.enabled, {
+            orgId: ctx?.orgId,
+        });
         return { key: args.key, enabled: values[args.key] === true, values };
     },
 });

package/dist/labs/index.d.ts

@@ -1 +1 @@
-export { defineLab, defineLabs, getLabDefinition, listLabs, registerLabs, type LabDefinition, } from "./registry.js";
+export { defineLab, defineLabs, getLabDefinition, getLabForLegacyFlag, listLabs, registerLabs, type LabDefinition, } from "./registry.js";

package/dist/labs/index.js

@@ -1 +1 @@
-export { defineLab, defineLabs, getLabDefinition, listLabs, registerLabs, } from "./registry.js";
+export { defineLab, defineLabs, getLabDefinition, getLabForLegacyFlag, listLabs, registerLabs, } from "./registry.js";

package/dist/labs/registry.d.ts

@@ -1,6 +1,8 @@
 export interface LabDefinition {
     key: string;
     defaultEnabled?: boolean;
+    legacyFlagKeys?: readonly string[];
+    inheritedMixedDescription?: string;
     displayName?: string;
     description?: string;
     keywords?: string;
@@ -10,4 +12,5 @@ export declare function defineLabs(definitions: readonly LabDefinition[]): reado
 export declare function registerLabs(definitions: readonly LabDefinition[]): void;
 export declare function listLabs(): readonly LabDefinition[];
 export declare function getLabDefinition(key: string): LabDefinition | null;
+export declare function getLabForLegacyFlag(key: string): LabDefinition | null;
 export declare function _resetLabRegistryForTests(): void;

package/dist/labs/registry.js

@@ -12,6 +12,12 @@ function normalizeDefinition(definition) {
         ...(definition.defaultEnabled !== undefined && {
             defaultEnabled: definition.defaultEnabled,
         }),
+        ...(definition.legacyFlagKeys?.length && {
+            legacyFlagKeys: Object.freeze([...new Set(definition.legacyFlagKeys)]),
+        }),
+        ...(definition.inheritedMixedDescription?.trim() && {
+            inheritedMixedDescription: definition.inheritedMixedDescription.trim(),
+        }),
         ...(definition.displayName?.trim() && {
             displayName: definition.displayName.trim(),
         }),
@@ -46,6 +52,10 @@ export function registerLabs(definitions) {
             continue;
         }
         if (existing.defaultEnabled !== definition.defaultEnabled ||
+            JSON.stringify(existing.legacyFlagKeys) !==
+                JSON.stringify(definition.legacyFlagKeys) ||
+            existing.inheritedMixedDescription !==
+                definition.inheritedMixedDescription ||
             existing.displayName !== definition.displayName ||
             existing.description !== definition.description ||
             existing.keywords !== definition.keywords) {
@@ -59,6 +69,10 @@ export function listLabs() {
 export function getLabDefinition(key) {
     return registry.get(key) ?? null;
 }
+export function getLabForLegacyFlag(key) {
+    return ([...registry.values()].find((lab) => lab.legacyFlagKeys?.includes(key)) ??
+        null);
+}
 export function _resetLabRegistryForTests() {
     registry.clear();
 }

package/dist/labs/server.d.ts

@@ -1,2 +1,2 @@
 export { createLabsPlugin } from "./plugin.js";
-export { getUserLabs } from "./store.js";
+export { getUserLabEnabled, getUserLabState, getUserLabStates, getUserLabs, type UserLabState, } from "./store.js";

package/dist/labs/server.js

@@ -1,2 +1,2 @@
 export { createLabsPlugin } from "./plugin.js";
-export { getUserLabs } from "./store.js";
+export { getUserLabEnabled, getUserLabState, getUserLabStates, getUserLabs, } from "./store.js";

package/dist/labs/store.d.ts

@@ -1,4 +1,15 @@
+import { type FeatureFlagScope } from "../feature-flags/store.js";
+import { type LabDefinition } from "./registry.js";
 export declare const LABS_SETTING_KEY = "labs";
+export interface UserLabState {
+    enabled: boolean;
+    source: "choice" | "legacy" | "default";
+    legacyValues?: Record<string, boolean>;
+    mixed: boolean;
+}
+export declare function getUserLabStates(email: string, scope?: FeatureFlagScope): Promise<Record<string, UserLabState>>;
+export declare function getUserLabState(email: string, lab: string | LabDefinition, scope?: FeatureFlagScope): Promise<UserLabState>;
+export declare function getUserLabEnabled(email: string, lab: string | LabDefinition, scope?: FeatureFlagScope): Promise<boolean>;
 export declare function normalizeLabValues(stored: Record<string, unknown> | null | undefined): Record<string, boolean>;
-export declare function getUserLabs(email: string): Promise<Record<string, boolean>>;
-export declare function setUserLab(email: string, key: string, enabled: boolean): Promise<Record<string, boolean>>;
+export declare function getUserLabs(email: string, scope?: FeatureFlagScope): Promise<Record<string, boolean>>;
+export declare function setUserLab(email: string, key: string, enabled: boolean, scope?: FeatureFlagScope): Promise<Record<string, boolean>>;

package/dist/labs/store.js

@@ -1,13 +1,123 @@
+import { defaultFeatureFlagRules, evaluateFeatureFlagRules, normalizeFeatureFlagRules, } from "../feature-flags/store.js";
+import { getOrgSetting } from "../settings/org-settings.js";
+import { getSetting } from "../settings/store.js";
 import { getUserSetting, mutateUserSetting, } from "../settings/user-settings.js";
 import { getLabDefinition, listLabs } from "./registry.js";
 export const LABS_SETTING_KEY = "labs";
 const LEGACY_LABS_SETTING_KEY = "experiments";
+function validLabSetting(key, value) {
+    if (value !== null && (typeof value !== "object" || Array.isArray(value))) {
+        throw new Error(`Invalid saved lab setting: ${key}`);
+    }
+    return value;
+}
 async function getStoredLabs(email) {
     const [labs, legacy] = await Promise.all([
         getUserSetting(email, LABS_SETTING_KEY),
         getUserSetting(email, LEGACY_LABS_SETTING_KEY),
     ]);
-    return labs || legacy ? { ...(legacy ?? {}), ...(labs ?? {}) } : null;
+    const current = validLabSetting(LABS_SETTING_KEY, labs);
+    const previous = validLabSetting(LEGACY_LABS_SETTING_KEY, legacy);
+    return current || previous
+        ? { ...(previous ?? {}), ...(current ?? {}) }
+        : null;
+}
+function parseLegacyRules(key, value) {
+    if (value === null)
+        return defaultFeatureFlagRules();
+    if (typeof value !== "object" ||
+        Array.isArray(value) ||
+        !["off", "on", "rules"].includes(value.mode) ||
+        (value.emails !== undefined &&
+            (!Array.isArray(value.emails) ||
+                !value.emails.every((item) => typeof item === "string"))) ||
+        (value.orgIds !== undefined &&
+            (!Array.isArray(value.orgIds) ||
+                !value.orgIds.every((item) => typeof item === "string"))) ||
+        (value.percentage !== undefined &&
+            (typeof value.percentage !== "number" ||
+                !Number.isFinite(value.percentage) ||
+                value.percentage < 0 ||
+                value.percentage > 100))) {
+        throw new Error(`Invalid legacy feature flag rules: ${key}`);
+    }
+    return normalizeFeatureFlagRules(value);
+}
+async function getLegacyRules(key, scope) {
+    const settingKey = `feature-flag:${key}`;
+    const orgId = scope.orgId?.trim();
+    const [global, org] = await Promise.all([
+        getSetting(settingKey, { transaction: scope.transaction }),
+        orgId
+            ? getOrgSetting(orgId, settingKey, { transaction: scope.transaction })
+            : Promise.resolve(null),
+    ]);
+    return parseLegacyRules(key, org ?? global);
+}
+export async function getUserLabStates(email, scope = {}) {
+    const stored = await getStoredLabs(email);
+    return resolveStoredLabStates(email, stored, scope);
+}
+async function resolveStoredLabStates(email, stored, scope) {
+    const definitions = listLabs();
+    for (const { key } of definitions) {
+        if (stored &&
+            Object.hasOwn(stored, key) &&
+            typeof stored[key] !== "boolean") {
+            throw new Error(`Invalid saved lab choice: ${key}`);
+        }
+    }
+    const unresolved = definitions.filter(({ key, legacyFlagKeys }) => typeof stored?.[key] !== "boolean" && legacyFlagKeys?.length);
+    const legacyKeys = [
+        ...new Set(unresolved.flatMap((lab) => lab.legacyFlagKeys ?? [])),
+    ];
+    const evaluationScope = { ...scope, userEmail: email };
+    const rules = new Map(await Promise.all(legacyKeys.map(async (key) => [key, await getLegacyRules(key, evaluationScope)])));
+    return Object.fromEntries(definitions.map((lab) => {
+        const choice = stored?.[lab.key];
+        if (typeof choice === "boolean") {
+            return [lab.key, { enabled: choice, source: "choice", mixed: false }];
+        }
+        if (lab.legacyFlagKeys?.length) {
+            const legacyValues = Object.fromEntries(lab.legacyFlagKeys.map((key) => {
+                const flagRules = rules.get(key);
+                if (!flagRules)
+                    throw new Error(`Unknown legacy feature flag: ${key}`);
+                return [
+                    key,
+                    evaluateFeatureFlagRules(key, flagRules, evaluationScope),
+                ];
+            }));
+            const values = Object.values(legacyValues);
+            return [
+                lab.key,
+                {
+                    enabled: values.every(Boolean),
+                    source: "legacy",
+                    legacyValues,
+                    mixed: values.some(Boolean) && !values.every(Boolean),
+                },
+            ];
+        }
+        return [
+            lab.key,
+            {
+                enabled: lab.defaultEnabled === true,
+                source: "default",
+                mixed: false,
+            },
+        ];
+    }));
+}
+export async function getUserLabState(email, lab, scope = {}) {
+    const key = typeof lab === "string" ? lab : lab.key;
+    const state = (await getUserLabStates(email, scope))[key];
+    if (!state)
+        throw new Error(`Unknown lab: ${key}`);
+    return state;
+}
+export async function getUserLabEnabled(email, lab, scope = {}) {
+    return (await getUserLabState(email, lab, scope)).enabled;
 }
 export function normalizeLabValues(stored) {
     return Object.fromEntries(listLabs().map(({ key, defaultEnabled }) => [
@@ -16,18 +126,25 @@ export function normalizeLabValues(stored) {
             (stored?.[key] === undefined && defaultEnabled === true),
     ]));
 }
-export async function getUserLabs(email) {
-    return normalizeLabValues(await getStoredLabs(email));
+export async function getUserLabs(email, scope = {}) {
+    const states = await getUserLabStates(email, scope);
+    return Object.fromEntries(Object.entries(states).map(([key, state]) => [key, state.enabled]));
 }
-export async function setUserLab(email, key, enabled) {
+export async function setUserLab(email, key, enabled, scope = {}) {
     if (!getLabDefinition(key)) {
         throw new Error(`Unknown lab: ${key}`);
     }
-    const stored = await mutateUserSetting(email, LABS_SETTING_KEY, async (current) => {
+    let effectiveValues;
+    await mutateUserSetting(email, LABS_SETTING_KEY, async (current) => {
+        validLabSetting(LABS_SETTING_KEY, current);
         const legacy = current === null
             ? await getUserSetting(email, LEGACY_LABS_SETTING_KEY)
             : null;
-        return { ...(legacy ?? {}), ...(current ?? {}), [key]: enabled };
+        validLabSetting(LEGACY_LABS_SETTING_KEY, legacy);
+        const next = { ...(legacy ?? {}), ...(current ?? {}), [key]: enabled };
+        const states = await resolveStoredLabStates(email, next, scope);
+        effectiveValues = Object.fromEntries(Object.entries(states).map(([labKey, state]) => [labKey, state.enabled]));
+        return next;
     });
-    return normalizeLabValues(stored);
+    return effectiveValues;
 }

package/dist/localization/default-messages.d.ts

@@ -3,7 +3,9 @@ declare const messages: {
         allCategories: string;
         loadError: string;
         saveError: string;
+        uploadFailed: string;
         uploadTooLarge: string;
+        uploadUnsupportedType: string;
         retry: string;
         uploadHint: string;
         colorNames: {

package/dist/localization/default-messages.js

@@ -1416,7 +1416,7 @@ const messages = {
             gong: {
                 description: "Search Gong calls and generate account and deal insights.",
                 useCase: "Sales calls, transcripts, deal insights, account summaries",
-                setupNote: "Gong requires a tech admin to create an MCP integration and choose personal or shared authorization. The generated client ID and secret must be configured before connecting.",
+                setupNote: "A Gong tech admin must create an MCP integration with personal or shared authorization. For Manual registration, save the generated client ID and secret as workspace secrets `GONG_MCP_CLIENT_ID` and `GONG_MCP_CLIENT_SECRET`; Automatic registration needs no client credentials.",
             },
             semgrep: {
                 description: "Scan code for security findings.",