@agent-native/core 0.198.3 → 0.198.4

package/dist/feature-flags/actions/get-feature-flags.js

@@ -1,5 +1,7 @@
 import { z } from "zod";
 import { defineAction } from "../../action.js";
+import { getLabForLegacyFlag } from "../../labs/registry.js";
+import { getUserLabStates } from "../../labs/store.js";
 import { captureError } from "../../server/capture-error.js";
 import { listFeatureFlags } from "../registry.js";
 import { defaultFeatureFlagRules, evaluateFeatureFlagRules, getFeatureFlagRules, getFeatureFlagRulesForKeys, } from "../store.js";
@@ -38,6 +40,24 @@ export default defineAction({
                 return [key, false];
             }
         }));
+        const migratedKeys = definitions
+            .map(({ key }) => key)
+            .filter((key) => getLabForLegacyFlag(key));
+        if (migratedKeys.length === 0 || !scope.userEmail)
+            return values;
+        const labStates = await getUserLabStates(scope.userEmail, scope);
+        for (const key of migratedKeys) {
+            const lab = getLabForLegacyFlag(key);
+            if (!lab)
+                continue;
+            const state = labStates[lab.key];
+            if (!state)
+                throw new Error(`Missing migrated lab state: ${lab.key}`);
+            values[key] =
+                state.source === "choice"
+                    ? state.enabled
+                    : (state.legacyValues?.[key] ?? false);
+        }
         return values;
     },
 });

package/dist/feature-flags/actions/list-feature-flags.d.ts

@@ -19,6 +19,8 @@ declare const _default: import("../../action.js").ActionDefinition<Record<string
         defaultValue?: false;
         displayName?: string;
         description?: string;
+        movedToLab: string;
+        canManage: boolean;
         rules: import("../store.js").FeatureFlagRules;
         enabledForCurrentUser: boolean;
     }[];

package/dist/feature-flags/actions/list-feature-flags.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { defineAction } from "../../action.js";
+import { getLabForLegacyFlag } from "../../labs/registry.js";
 import { requireFeatureFlagManager } from "../permissions.js";
 import { listFeatureFlags } from "../registry.js";
 import { evaluateFeatureFlagRules, getFeatureFlagRules } from "../store.js";
@@ -40,6 +41,10 @@ export default defineAction({
             const rules = await getFeatureFlagRules(definition.key, manager);
             return {
                 ...definition,
+                ...(getLabForLegacyFlag(definition.key) && {
+                    movedToLab: getLabForLegacyFlag(definition.key)?.key,
+                    canManage: false,
+                }),
                 rules,
                 enabledForCurrentUser: evaluateFeatureFlagRules(definition.key, rules, {
                     userEmail: manager.email,

package/dist/feature-flags/actions/set-feature-flag.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { defineAction } from "../../action.js";
+import { getLabForLegacyFlag } from "../../labs/registry.js";
 import { getOrgDomain } from "../../org/context.js";
 import { requireFeatureFlagManager } from "../permissions.js";
 import { getFeatureFlagDefinition } from "../registry.js";
@@ -45,6 +46,10 @@ export default defineAction({
         if (!getFeatureFlagDefinition(args.key)) {
             throw new Error(`Unknown feature flag: ${args.key}`);
         }
+        const movedToLab = getLabForLegacyFlag(args.key);
+        if (movedToLab) {
+            throw new Error(`Feature flag ${args.key} is managed in Labs (${movedToLab.key}).`);
+        }
         const orgDomain = manager.orgId
             ? (await getOrgDomain(manager.orgId))?.trim().toLowerCase() || null
             : null;

package/dist/file-upload/actions/upload-image.d.ts

@@ -33,9 +33,9 @@ declare const _default: import("../../action.js").ActionDefinition<{
     idempotencyKey: string;
     deleted: boolean;
 } | {
-    id?: undefined;
     error: string;
     url?: undefined;
+    id?: undefined;
     provider?: undefined;
     configured?: undefined;
 } | {
@@ -45,8 +45,8 @@ declare const _default: import("../../action.js").ActionDefinition<{
     configured?: undefined;
     error?: undefined;
 } | {
-    id?: undefined;
     url?: undefined;
+    id?: undefined;
     provider?: undefined;
     error: string;
     configured: boolean;

package/dist/framework-tools.js

@@ -87,6 +87,7 @@ export const CORE_ACTION_GROUPS = {
     "list-app-permissions": "orgAdministration",
     "set-app-permission-roles": "orgAdministration",
     "list-workspace-app-access": "orgAdministration",
+    "list-workspace-icons": "orgAdministration",
     "set-workspace-app-access": "orgAdministration",
     "list-sign-in-methods": "orgAdministration",
     "explain-access": "orgAdministration",
@@ -107,6 +108,7 @@ export const CORE_ACTION_GROUPS = {
     "set-feature-flag": "featureFlags",
     "get-launchdarkly-flags": "launchDarkly",
     "get-labs": "labs",
+    "get-lab-states": "labs",
     "set-lab": "labs",
     "get-chatgpt-subscription-status": "chat",
     "disconnect-chatgpt-subscription": "chat",

package/dist/icon-assets/index.d.ts

@@ -0,0 +1,3 @@
+export { sanitizeIconSvg } from "./svg.js";
+export { getIconAsset, listIconAssets, putIconAsset, readIconAsset, readIconAssetForAuthorizedReference, type IconAsset, type IconAssetRead, type IconAssetScope, } from "./store.js";
+export { IconUploadBodyError, MAX_ICON_MULTIPART_BYTES, readIconUploadFormData, } from "./multipart.js";

package/dist/icon-assets/index.js

@@ -0,0 +1,3 @@
+export { sanitizeIconSvg } from "./svg.js";
+export { getIconAsset, listIconAssets, putIconAsset, readIconAsset, readIconAssetForAuthorizedReference, } from "./store.js";
+export { IconUploadBodyError, MAX_ICON_MULTIPART_BYTES, readIconUploadFormData, } from "./multipart.js";

package/dist/icon-assets/multipart.d.ts

@@ -0,0 +1,9 @@
+export declare const MAX_ICON_MULTIPART_BYTES: number;
+export declare class IconUploadBodyError extends Error {
+    readonly statusCode: 400 | 413;
+    readonly cause?: unknown;
+    constructor(statusCode: 400 | 413, options?: {
+        cause?: unknown;
+    });
+}
+export declare function readIconUploadFormData(request: Request): Promise<FormData>;

package/dist/icon-assets/multipart.js

@@ -0,0 +1,60 @@
+export const MAX_ICON_MULTIPART_BYTES = 5 * 1024 * 1024 + 64 * 1024;
+export class IconUploadBodyError extends Error {
+    statusCode;
+    constructor(statusCode, options) {
+        super(statusCode === 413 ? "Icon too large" : "Invalid multipart icon upload");
+        this.statusCode = statusCode;
+        this.name = "IconUploadBodyError";
+        if (options && "cause" in options) {
+            Object.defineProperty(this, "cause", {
+                value: options.cause,
+                enumerable: false,
+                configurable: true,
+                writable: true,
+            });
+        }
+    }
+}
+async function rejectOversized(cancel) {
+    try {
+        await cancel();
+    }
+    catch (cause) {
+        throw new IconUploadBodyError(413, { cause });
+    }
+    throw new IconUploadBodyError(413);
+}
+export async function readIconUploadFormData(request) {
+    const declaredLength = Number(request.headers.get("content-length"));
+    if (declaredLength > MAX_ICON_MULTIPART_BYTES) {
+        return rejectOversized(() => request.body?.cancel());
+    }
+    const reader = request.body?.getReader();
+    if (!reader)
+        throw new IconUploadBodyError(400);
+    const body = new Uint8Array(MAX_ICON_MULTIPART_BYTES);
+    let size = 0;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            if (value.byteLength > MAX_ICON_MULTIPART_BYTES - size)
+                await rejectOversized(() => reader.cancel());
+            body.set(value, size);
+            size += value.byteLength;
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    // Parse the bounded buffer, never a clone that tees and queues the live body.
+    try {
+        return await new Response(body.subarray(0, size), {
+            headers: { "content-type": request.headers.get("content-type") ?? "" },
+        }).formData();
+    }
+    catch {
+        throw new IconUploadBodyError(400);
+    }
+}

package/dist/icon-assets/schema.d.ts

@@ -0,0 +1,194 @@
+export declare const iconAssets: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "private_icon_assets";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "private_icon_assets";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        ownerEmail: import("drizzle-orm/pg-core").PgColumn<{
+            name: "owner_email";
+            tableName: "private_icon_assets";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        orgId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "org_id";
+            tableName: "private_icon_assets";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        mimeType: import("drizzle-orm/pg-core").PgColumn<{
+            name: "mime_type";
+            tableName: "private_icon_assets";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        filename: import("drizzle-orm/pg-core").PgColumn<{
+            name: "filename";
+            tableName: "private_icon_assets";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        alt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "alt";
+            tableName: "private_icon_assets";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        size: import("drizzle-orm/pg-core").PgColumn<{
+            name: "size";
+            tableName: "private_icon_assets";
+            dataType: "number";
+            columnType: "PgBigInt53";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        sha256: import("drizzle-orm/pg-core").PgColumn<{
+            name: "sha256";
+            tableName: "private_icon_assets";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        blobHandleJson: import("drizzle-orm/pg-core").PgColumn<{
+            name: "blob_handle_json";
+            tableName: "private_icon_assets";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "private_icon_assets";
+            dataType: "number";
+            columnType: "PgBigInt53";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "private_icon_assets";
+            dataType: "number";
+            columnType: "PgBigInt53";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: 'pg';
+}>;

package/dist/icon-assets/schema.js

@@ -0,0 +1,16 @@
+import { bigint, index, table, text } from "../db/schema.js";
+export const iconAssets = table("private_icon_assets", {
+    id: text("id").primaryKey(),
+    ownerEmail: text("owner_email").notNull(),
+    orgId: text("org_id"),
+    mimeType: text("mime_type").notNull(),
+    filename: text("filename"),
+    alt: text("alt"),
+    size: bigint("size", { mode: "number" }).notNull(),
+    sha256: text("sha256").notNull(),
+    blobHandleJson: text("blob_handle_json").notNull(),
+    createdAt: bigint("created_at", { mode: "number" }).notNull(),
+    updatedAt: bigint("updated_at", { mode: "number" }).notNull(),
+}, (table) => [
+    index("private_icon_assets_owner_org_created_idx").on(table.ownerEmail, table.orgId, table.createdAt),
+]);

package/dist/icon-assets/store.d.ts

@@ -0,0 +1,38 @@
+export declare const MAX_ICON_ASSET_BYTES: number;
+export interface IconAssetScope {
+    ownerEmail: string;
+    orgId?: string | null;
+}
+export interface IconAsset {
+    id: string;
+    ownerEmail: string;
+    orgId: string | null;
+    mimeType: string;
+    filename: string | null;
+    alt: string | null;
+    size: number;
+    sha256: string;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface IconAssetRead {
+    asset: IconAsset;
+    data: Uint8Array;
+    mimeType: string;
+}
+/** Uploads validated bytes and persists only the opaque private blob handle. */
+export declare function putIconAsset(input: IconAssetScope & {
+    data: Uint8Array;
+    mimeType: string;
+    filename?: string;
+    alt?: string;
+}): Promise<IconAsset>;
+export declare function getIconAsset(id: string, caller: IconAssetScope): Promise<IconAsset | null>;
+export declare function readIconAsset(id: string, caller: IconAssetScope): Promise<IconAssetRead | null>;
+/** Only call after proving the caller may read a live resource referencing this ID. */
+export declare function readIconAssetForAuthorizedReference(id: string, scope: {
+    orgId?: string | null;
+}): Promise<IconAssetRead | null>;
+export declare function listIconAssets(input: IconAssetScope & {
+    limit?: number;
+}): Promise<IconAsset[]>;

package/dist/icon-assets/store.js

@@ -0,0 +1,187 @@
+import { createHash, randomUUID } from "node:crypto";
+import { and, desc, eq, isNull } from "drizzle-orm";
+import { createGetDb } from "../db/create-get-db.js";
+import { deletePrivateBlob, putPrivateBlob, readPrivateBlob, } from "../private-blob/index.js";
+import { iconAssets } from "./schema.js";
+import { sanitizeIconSvg } from "./svg.js";
+export const MAX_ICON_ASSET_BYTES = 5 * 1024 * 1024;
+const getDb = createGetDb({ iconAssets });
+function checkedScope(scope) {
+    const ownerEmail = scope.ownerEmail?.trim().toLowerCase();
+    if (!ownerEmail)
+        throw new Error("Icon asset owner is required");
+    if (scope.orgId !== undefined &&
+        scope.orgId !== null &&
+        !scope.orgId.trim()) {
+        throw new Error("Icon asset organization is invalid");
+    }
+    return { ownerEmail, orgId: scope.orgId ?? null };
+}
+function orgCondition(orgId) {
+    return orgId ? eq(iconAssets.orgId, orgId) : isNull(iconAssets.orgId);
+}
+function metadata(row) {
+    return {
+        id: row.id,
+        ownerEmail: row.ownerEmail,
+        orgId: row.orgId,
+        mimeType: row.mimeType,
+        filename: row.filename,
+        alt: row.alt,
+        size: row.size,
+        sha256: row.sha256,
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt,
+    };
+}
+function detectMime(data) {
+    if (data.length >= 8 &&
+        [137, 80, 78, 71, 13, 10, 26, 10].every((byte, index) => data[index] === byte))
+        return "image/png";
+    if (data.length >= 3 &&
+        data[0] === 0xff &&
+        data[1] === 0xd8 &&
+        data[2] === 0xff)
+        return "image/jpeg";
+    if (data.length >= 12 &&
+        Buffer.from(data.subarray(0, 4)).toString() === "RIFF" &&
+        Buffer.from(data.subarray(8, 12)).toString() === "WEBP")
+        return "image/webp";
+    return null;
+}
+function validatedBytes(data, mimeType) {
+    if (!(data instanceof Uint8Array) ||
+        data.byteLength === 0 ||
+        data.byteLength > MAX_ICON_ASSET_BYTES) {
+        throw new Error("Icon image must be between 1 byte and 5 MiB");
+    }
+    if (mimeType === "image/svg+xml") {
+        const safe = sanitizeIconSvg(data);
+        if (safe.byteLength > MAX_ICON_ASSET_BYTES)
+            throw new Error("SVG icon exceeds 5 MiB");
+        return safe;
+    }
+    if (!["image/png", "image/jpeg", "image/webp"].includes(mimeType) ||
+        detectMime(data) !== mimeType) {
+        throw new Error("Icon image type does not match PNG, JPEG, or WebP content");
+    }
+    return data;
+}
+function parseHandle(row) {
+    const handle = JSON.parse(row.blobHandleJson);
+    if (!handle ||
+        typeof handle.id !== "string" ||
+        typeof handle.provider !== "string" ||
+        handle.opaque !== true) {
+        throw new Error("Icon asset has an invalid private blob handle");
+    }
+    return handle;
+}
+async function readRow(row) {
+    const read = await readPrivateBlob(parseHandle(row));
+    const hash = createHash("sha256").update(read.data).digest("hex");
+    if (hash !== row.sha256 || read.data.byteLength !== row.size) {
+        throw new Error("Icon asset private blob failed integrity verification");
+    }
+    return { asset: metadata(row), data: read.data, mimeType: row.mimeType };
+}
+/** Uploads validated bytes and persists only the opaque private blob handle. */
+export async function putIconAsset(input) {
+    const scope = checkedScope(input);
+    const data = validatedBytes(input.data, input.mimeType);
+    const id = randomUUID();
+    const filename = input.filename?.trim().slice(0, 255) || null;
+    const alt = input.alt?.trim().slice(0, 500) || null;
+    const handle = await putPrivateBlob({
+        data,
+        filename: `icon-${id}`,
+        mimeType: input.mimeType,
+        ownerEmail: scope.ownerEmail,
+    });
+    if (!handle)
+        throw new Error("Private icon storage is unavailable; configure a private blob provider");
+    try {
+        const read = await readPrivateBlob(handle);
+        if (!Buffer.from(read.data).equals(Buffer.from(data))) {
+            throw new Error("Private icon storage read-back did not match uploaded bytes");
+        }
+        const now = Date.now();
+        const row = {
+            id,
+            ownerEmail: scope.ownerEmail,
+            orgId: scope.orgId ?? null,
+            mimeType: input.mimeType,
+            filename,
+            alt,
+            size: data.byteLength,
+            sha256: createHash("sha256").update(data).digest("hex"),
+            blobHandleJson: JSON.stringify(handle),
+            createdAt: now,
+            updatedAt: now,
+        };
+        await getDb().insert(iconAssets).values(row);
+        return metadata(row);
+    }
+    catch (error) {
+        try {
+            const deletion = await deletePrivateBlob(handle);
+            if (!deletion.deleted)
+                throw new Error(deletion.reason ?? "blob provider refused deletion");
+        }
+        catch (cleanupError) {
+            throw new AggregateError([error, cleanupError], "Private icon upload failed and blob cleanup failed");
+        }
+        throw error;
+    }
+}
+export async function getIconAsset(id, caller) {
+    const scope = checkedScope(caller);
+    const [row] = await getDb()
+        .select()
+        .from(iconAssets)
+        .where(and(eq(iconAssets.id, id), eq(iconAssets.ownerEmail, scope.ownerEmail), orgCondition(scope.orgId)))
+        .limit(1);
+    return row ? metadata(row) : null;
+}
+export async function readIconAsset(id, caller) {
+    const scope = checkedScope(caller);
+    const [row] = await getDb()
+        .select()
+        .from(iconAssets)
+        .where(and(eq(iconAssets.id, id), eq(iconAssets.ownerEmail, scope.ownerEmail), orgCondition(scope.orgId)))
+        .limit(1);
+    return row ? readRow(row) : null;
+}
+/** Only call after proving the caller may read a live resource referencing this ID. */
+export async function readIconAssetForAuthorizedReference(id, scope) {
+    const [row] = await getDb()
+        .select()
+        .from(iconAssets)
+        .where(and(eq(iconAssets.id, id), orgCondition(scope.orgId)))
+        .limit(1);
+    return row ? readRow(row) : null;
+}
+export async function listIconAssets(input) {
+    const scope = checkedScope(input);
+    const limit = input.limit ?? 50;
+    if (!Number.isInteger(limit) || limit < 1 || limit > 100)
+        throw new Error("Icon asset limit must be between 1 and 100");
+    const rows = await getDb()
+        .select({
+        id: iconAssets.id,
+        ownerEmail: iconAssets.ownerEmail,
+        orgId: iconAssets.orgId,
+        mimeType: iconAssets.mimeType,
+        filename: iconAssets.filename,
+        alt: iconAssets.alt,
+        size: iconAssets.size,
+        sha256: iconAssets.sha256,
+        createdAt: iconAssets.createdAt,
+        updatedAt: iconAssets.updatedAt,
+    })
+        .from(iconAssets)
+        .where(and(eq(iconAssets.ownerEmail, scope.ownerEmail), orgCondition(scope.orgId)))
+        .orderBy(desc(iconAssets.createdAt))
+        .limit(limit);
+    return rows;
+}

package/dist/icon-assets/svg.d.ts

@@ -0,0 +1,2 @@
+/** Canonicalize the small SVG icon vocabulary before bytes reach storage. */
+export declare function sanitizeIconSvg(data: Uint8Array): Uint8Array;