@brydio/manifest 0.1.0-alpha.5 → 0.1.0-alpha.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brydio/manifest",
-  "version": "0.1.0-alpha.5",
+  "version": "0.1.0-alpha.7",
   "description": "The shape of a Brydio app's manifest, its collections' schemas, and the checks that say what is wrong with one.",
   "type": "module",
   "license": "MIT",
@@ -10,7 +10,7 @@
     "url": "https://github.com/nakel-ola/brydio-sdk",
     "directory": "packages/manifest"
   },
-  "gitHead": "f9e99418eb18cedd529d7a62fe6c037396c50e3f",
+  "gitHead": "0df91ca1c2a40d63ffcb0cad08f5f4b3278064f3",
   "exports": {
     ".": {
       "types": "./src/index.d.ts",

package/src/base.d.ts

@@ -32,6 +32,15 @@ export declare const linksSchema: z.ZodObject<{
     terms: z.ZodOptional<z.ZodString>;
     support: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
+/**
+ * One of an app's two images, in its two variants (ADR-A20): `color` for a
+ * tile and the app's own page, `mono` for the sidebar, where the theme tints
+ * it. Both are `./`-prefixed paths inside the app.
+ */
+export declare const brandImagesSchema: z.ZodObject<{
+    color: z.ZodString;
+    mono: z.ZodString;
+}, z.core.$strip>;
 export declare const requiresSchema: z.ZodObject<{
     servers: z.ZodDefault<z.ZodArray<z.ZodString>>;
     integrations: z.ZodDefault<z.ZodArray<z.ZodString>>;
@@ -57,7 +66,14 @@ export declare const baseManifestSchema: z.ZodObject<{
         terms: z.ZodOptional<z.ZodString>;
         support: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
-    icon: z.ZodOptional<z.ZodString>;
+    logo: z.ZodOptional<z.ZodObject<{
+        color: z.ZodString;
+        mono: z.ZodString;
+    }, z.core.$strip>>;
+    icon: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        color: z.ZodString;
+        mono: z.ZodString;
+    }, z.core.$strip>]>>;
     brandColor: z.ZodOptional<z.ZodString>;
     brandColorDark: z.ZodOptional<z.ZodString>;
     defaultPrompts: z.ZodOptional<z.ZodArray<z.ZodString>>;

package/src/base.js

@@ -32,6 +32,15 @@ export const linksSchema = z.object({
     terms: z.string().optional(),
     support: z.string().optional(),
 });
+/**
+ * One of an app's two images, in its two variants (ADR-A20): `color` for a
+ * tile and the app's own page, `mono` for the sidebar, where the theme tints
+ * it. Both are `./`-prefixed paths inside the app.
+ */
+export const brandImagesSchema = z.object({
+    color: z.string(),
+    mono: z.string(),
+});
 export const requiresSchema = z.object({
     servers: z.array(z.string()).default([]),
     integrations: z.array(z.string()).default([]),
@@ -49,7 +58,10 @@ export const baseManifestSchema = z.object({
     license: z.string().max(MANIFEST_LIMITS.licenseChars).optional(),
     keywords: z.array(z.string()).max(MANIFEST_LIMITS.keywords).optional(),
     links: linksSchema.optional(),
-    icon: z.string().optional(),
+    /** Required to publish (ADR-A20); optional here so every stored manifest still reads. */
+    logo: brandImagesSchema.optional(),
+    /** The two-variant icon (ADR-A20), or the one path every app had before it, still read. */
+    icon: z.union([z.string(), brandImagesSchema]).optional(),
     brandColor: z.string().optional(),
     brandColorDark: z.string().optional(),
     defaultPrompts: z.array(z.string()).max(MANIFEST_LIMITS.defaultPrompts).optional(),

package/src/bundle.d.ts

@@ -23,7 +23,14 @@ export type BundleFiles = ReadonlyMap<string, Uint8Array>;
 export declare function isBundlePath(path: string): boolean;
 /** Whether a path is a script a bundle can hold. */
 export declare const isScriptPath: (path: string) => boolean;
-/** The files the store keeps and the fingerprint covers: every one but the root manifest. */
+/**
+ * The logo and icon files the bundle's manifest names (ADR-A20), by path: the
+ * one kind of file beside code a bundle may hold, and only at those paths.
+ * Brydio keeps them with the version, never as code, so they are not in the
+ * fingerprint.
+ */
+export declare function brandOf(files: BundleFiles): BundleFiles;
+/** The files the store keeps and the fingerprint covers: every one but the root manifest and its brand images. */
 export declare function codeOf(files: BundleFiles): BundleFiles;
 /**
  * The fingerprint: sha256, lowercase hex, over the sorted list of the code

package/src/bundle.js

@@ -1,4 +1,5 @@
 import { createHash } from 'node:crypto';
+import { brandPathsOf } from "./requirements.js";
 /**
  * What a bundle may hold, and the fingerprint its code is served under
  * (contracts §11, A7-F02).
@@ -29,9 +30,32 @@ export function isBundlePath(path) {
 }
 /** Whether a path is a script a bundle can hold. */
 export const isScriptPath = (path) => isBundlePath(path) && SCRIPT.test(path);
-/** The files the store keeps and the fingerprint covers: every one but the root manifest. */
+/**
+ * The logo and icon files the bundle's manifest names (ADR-A20), by path: the
+ * one kind of file beside code a bundle may hold, and only at those paths.
+ * Brydio keeps them with the version, never as code, so they are not in the
+ * fingerprint.
+ */
+export function brandOf(files) {
+    const named = new Set(brandPathsOf(manifestIn(files)).values());
+    return new Map([...files].filter(([path]) => named.has(path)));
+}
+/** The bundle's manifest, read leniently: anything unreadable names no files. */
+function manifestIn(files) {
+    const bytes = files.get(BUNDLE_MANIFEST);
+    if (!bytes)
+        return null;
+    try {
+        return JSON.parse(new TextDecoder().decode(bytes));
+    }
+    catch {
+        return null;
+    }
+}
+/** The files the store keeps and the fingerprint covers: every one but the root manifest and its brand images. */
 export function codeOf(files) {
-    return new Map([...files].filter(([path]) => path !== BUNDLE_MANIFEST));
+    const brand = brandOf(files);
+    return new Map([...files].filter(([path]) => path !== BUNDLE_MANIFEST && !brand.has(path)));
 }
 const sha256 = (bytes) => createHash('sha256').update(bytes).digest('hex');
 /**
@@ -54,11 +78,12 @@ export function bundleHash(files) {
  * and words: every path first, then the manifest, then the code, then the size.
  */
 export function bundleProblem(files) {
+    const brand = brandOf(files);
     for (const path of files.keys()) {
         if (!isBundlePath(path)) {
             return { code: 'bundle_path_invalid', message: `"${JSON.stringify(path).slice(1, -1)}" is not a path a bundle can hold.`, file: path };
         }
-        if (path !== BUNDLE_MANIFEST && !SCRIPT.test(path)) {
+        if (path !== BUNDLE_MANIFEST && !brand.has(path) && !SCRIPT.test(path)) {
             return {
                 code: 'bundle_file_not_code',
                 message: `"${path}" is not a script. A bundle holds only .js files and ${BUNDLE_MANIFEST}.`,

package/src/grants.d.ts

@@ -7,7 +7,7 @@
  * `apps/api/src/apps/publishing/app-publish.service.ts`.
  */
 /** The host grants with a name of their own. A connection's is `connection:<name>`. */
-export declare const HOST_CAPABILITIES: readonly ["navigate", "message", "members", "projects", "model"];
+export declare const HOST_CAPABILITIES: readonly ["navigate", "message", "members", "projects", "files", "chats", "model", "secrets"];
 /** The older name for `HOST_CAPABILITIES`, kept for what already imports it. */
 export declare const KNOWN_HOST_GRANTS: readonly string[];
 /** True for a host grant Brydio knows how to honour: a named capability, or one connection. */

package/src/grants.js

@@ -8,7 +8,7 @@
  */
 import { BUNDLE_MANIFEST } from "./bundle.js";
 /** The host grants with a name of their own. A connection's is `connection:<name>`. */
-export const HOST_CAPABILITIES = ['navigate', 'message', 'members', 'projects', 'model'];
+export const HOST_CAPABILITIES = ['navigate', 'message', 'members', 'projects', 'files', 'chats', 'model', 'secrets'];
 /** The older name for `HOST_CAPABILITIES`, kept for what already imports it. */
 export const KNOWN_HOST_GRANTS = HOST_CAPABILITIES;
 const CONNECTION = /^connection:[a-z0-9][a-z0-9_-]{0,59}$/;

package/src/index.d.ts

@@ -3,14 +3,15 @@
  * types, the tools Brydio generates from them, and the bundle rules. Each is
  * a copy of the server's own, so an app that passes here passes there.
  */
-export { APP_NAME_FORMAT, MANIFEST_LIMITS, SEMVER_FORMAT, baseManifestSchema } from './base.js';
-export { BUNDLE_MANIFEST, BUNDLE_MAX_BYTES, BUNDLE_PATH_MAX_CHARS, bundleBytes, bundleHash, bundleProblem, codeOf, isBundlePath, isScriptPath, sizeOf, type BundleFiles, type BundleProblem, type BundleProblemCode, } from './bundle.js';
+export { APP_NAME_FORMAT, MANIFEST_LIMITS, SEMVER_FORMAT, baseManifestSchema, brandImagesSchema } from './base.js';
+export { BRAND_FIELDS, BRAND_LIMITS, brandFilePath, brandPathsOf, brandProblems, brandShapeOf, isBrandPath, pngVerdict, svgColours, toolsProblem, type BrandField, type RequirementCode, type RequirementFiles, type RequirementProblem, } from './requirements.js';
+export { BUNDLE_MANIFEST, BUNDLE_MAX_BYTES, BUNDLE_PATH_MAX_CHARS, bundleBytes, bundleHash, brandOf, bundleProblem, codeOf, isBundlePath, isScriptPath, sizeOf, type BundleFiles, type BundleProblem, type BundleProblemCode, } from './bundle.js';
 export { COLOUR_TOKENS, FIELD_LIMITS, RESERVED_FIELDS, describeType, isSearchable, isSortable, isStructured, parseFieldType, structuredFields, valueProblem, valueSchema, FieldTypeInvalid, type DocumentOf, type FieldKind, type FieldType, type FieldValue, type FieldsOf, } from './field-types.js';
-export { appManifestSchema, collectionOf, collectionsOf, dataProblems, labelOf, manifestExtensionsSchema, storedExtensionsSchema, type AppManifestWithData, type CollectionSpec, type DataProblem, type DataProblemCode, type ManifestExtensions, } from './schema.js';
+export { appManifestSchema, collectionOf, collectionsOf, dataProblems, labelOf, manifestExtensionsSchema, MAX_APP_SECRETS, MAX_SECRET_CHARS, SECRET_NAME, storedExtensionsSchema, type AppManifestWithData, type CollectionSpec, type DataProblem, type DataProblemCode, type ManifestExtensions, type SecretSpec, } from './schema.js';
 export { DOCUMENT_LIMITS } from './document-limits.js';
 export { HOST_CAPABILITIES, KNOWN_HOST_GRANTS, isHostCapability, unknownHostGrant } from './grants.js';
 export { diffSchemas, migrationProblems, migrationSchema, migrationStepSchema, migrationsSchema, publishedMigrationProblems, schemaOf, type Migration, type MigrationCode, type MigrationProblem, type MigrationStep, type SchemaChange, } from './migrations.js';
-export { SECRET_MESSAGE, findSecrets, secretsInJson, type SecretFound } from './secrets.js';
+export { DEVELOPER_KEY_MESSAGE, SECRET_MESSAGE, developerKeyIn, findSecrets, holdsDeveloperKey, secretsInJson, type SecretFound, } from './secrets.js';
 export { compareVersions, sdkRefusal, type SdkSupport } from './sdk.js';
 export { TOOL_WRITES, generatedToolsOf, toolNames, type GeneratedTool, type ToolVerb } from './tools.js';
 export { validateManifest, validateManifestText, type ManifestProblem, type ManifestProblemCode, type ManifestValidation, } from './validate.js';

package/src/index.js

@@ -3,14 +3,15 @@
  * types, the tools Brydio generates from them, and the bundle rules. Each is
  * a copy of the server's own, so an app that passes here passes there.
  */
-export { APP_NAME_FORMAT, MANIFEST_LIMITS, SEMVER_FORMAT, baseManifestSchema } from "./base.js";
-export { BUNDLE_MANIFEST, BUNDLE_MAX_BYTES, BUNDLE_PATH_MAX_CHARS, bundleBytes, bundleHash, bundleProblem, codeOf, isBundlePath, isScriptPath, sizeOf, } from "./bundle.js";
+export { APP_NAME_FORMAT, MANIFEST_LIMITS, SEMVER_FORMAT, baseManifestSchema, brandImagesSchema } from "./base.js";
+export { BRAND_FIELDS, BRAND_LIMITS, brandFilePath, brandPathsOf, brandProblems, brandShapeOf, isBrandPath, pngVerdict, svgColours, toolsProblem, } from "./requirements.js";
+export { BUNDLE_MANIFEST, BUNDLE_MAX_BYTES, BUNDLE_PATH_MAX_CHARS, bundleBytes, bundleHash, brandOf, bundleProblem, codeOf, isBundlePath, isScriptPath, sizeOf, } from "./bundle.js";
 export { COLOUR_TOKENS, FIELD_LIMITS, RESERVED_FIELDS, describeType, isSearchable, isSortable, isStructured, parseFieldType, structuredFields, valueProblem, valueSchema, FieldTypeInvalid, } from "./field-types.js";
-export { appManifestSchema, collectionOf, collectionsOf, dataProblems, labelOf, manifestExtensionsSchema, storedExtensionsSchema, } from "./schema.js";
+export { appManifestSchema, collectionOf, collectionsOf, dataProblems, labelOf, manifestExtensionsSchema, MAX_APP_SECRETS, MAX_SECRET_CHARS, SECRET_NAME, storedExtensionsSchema, } from "./schema.js";
 export { DOCUMENT_LIMITS } from "./document-limits.js";
 export { HOST_CAPABILITIES, KNOWN_HOST_GRANTS, isHostCapability, unknownHostGrant } from "./grants.js";
 export { diffSchemas, migrationProblems, migrationSchema, migrationStepSchema, migrationsSchema, publishedMigrationProblems, schemaOf, } from "./migrations.js";
-export { SECRET_MESSAGE, findSecrets, secretsInJson } from "./secrets.js";
+export { DEVELOPER_KEY_MESSAGE, SECRET_MESSAGE, developerKeyIn, findSecrets, holdsDeveloperKey, secretsInJson, } from "./secrets.js";
 export { compareVersions, sdkRefusal } from "./sdk.js";
 export { TOOL_WRITES, generatedToolsOf, toolNames } from "./tools.js";
 export { validateManifest, validateManifestText, } from "./validate.js";

package/src/requirements.d.ts

@@ -0,0 +1,122 @@
+/**
+ * Two things every app must have before it is published (owner decisions of
+ * 22 September 2026), checked the same way by `brydio validate` and by
+ * `POST /apps/publish`.
+ *
+ * - **A logo and an icon, each in colour and in one colour** (ADR-A20). The
+ *   manifest names four image files, and a package missing any of them is
+ *   refused.
+ * - **Something for the assistant to call** (ADR-A19): generated tools from a
+ *   collection, a custom tool, an MCP server or an integration.
+ *
+ * A copy of Brydio's `apps/api/src/apps/manifest/requirements.ts`, the
+ * checks `POST /apps/publish` runs. Nothing here imports anything, so the
+ * copy is the file: not even `node:zlib`, which a PNG is inflated with, since
+ * a screen may bundle `@brydio/manifest` and a worker has none.
+ * `test/requirements.test.ts` asks Brydio the same questions whenever a
+ * checkout is beside this one.
+ *
+ * ## What "one colour" means
+ *
+ * The mono variant is drawn tinted by the theme, so it must be a shape and
+ * nothing else: one colour on transparency.
+ *
+ * - An **SVG** is read for every colour it paints with: `fill`, `stroke`,
+ *   `stop-color`, `flood-color` and `color`, as attributes and inside `style`.
+ *   `none`, `transparent`, `inherit` and `currentColor` are not colours.
+ *   A shape with no fill of its own paints in the default black, unless the
+ *   root `<svg>` or a `<g>` sets one. More than one distinct colour is
+ *   refused, and so is an embedded `<image>`, which could be anything.
+ * - A **PNG** is decoded, and every pixel at least 1/16 opaque must be within
+ *   32 of one colour on each channel, so anti-aliased edges of a black glyph
+ *   (black at partial alpha) pass and a two-colour picture does not. A PNG
+ *   with no transparent pixel at all is a solid block and is refused too.
+ * - A **JPEG** has no transparency, and a **WebP** is not decoded here, so
+ *   neither can be the one-colour variant. Both are fine in colour.
+ *
+ * ## Sizes
+ *
+ * - An **icon** is square: from 48 to 1,024 pixels across as a raster, and a
+ *   square view box as an SVG.
+ * - A **logo** may be wider than it is tall, never taller: from 48 to 1,024
+ *   pixels tall, at most 2,048 wide, and at most four times as wide as it is
+ *   tall. An SVG's view box is held to the same proportions.
+ * - Every file is at most 512 KB.
+ */
+export declare const BRAND_LIMITS: {
+    readonly bytes: number;
+    readonly iconMinSide: 48;
+    readonly iconMaxSide: 1024;
+    readonly logoMinHeight: 48;
+    readonly logoMaxHeight: 1024;
+    readonly logoMaxWidth: 2048;
+    /** Width over height, at most. */
+    readonly logoMaxRatio: 4;
+};
+/** The two images, and the two variants each one comes in. */
+export declare const BRAND_FIELDS: readonly ["logo.color", "logo.mono", "icon.color", "icon.mono"];
+export type BrandField = (typeof BRAND_FIELDS)[number];
+export type RequirementCode = 'brand_logo_missing' | 'brand_icon_missing' | 'brand_path_invalid' | 'brand_file_missing' | 'brand_file_too_large' | 'brand_file_unreadable' | 'brand_icon_shape' | 'brand_logo_shape' | 'brand_mono_type' | 'brand_mono_colours' | 'app_has_no_tools';
+export interface RequirementProblem {
+    code: RequirementCode;
+    message: string;
+    /** The manifest field, like `icon.mono`. */
+    path: string;
+}
+/** The files a check can see, by their path inside the package with no `./`. */
+export type RequirementFiles = ReadonlyMap<string, Uint8Array>;
+export type BrandImageType = 'image/png' | 'image/jpeg' | 'image/webp' | 'image/svg+xml';
+/** A path the manifest wrote, as a bundle names the file: no `./`, forward slashes. */
+export declare const brandFilePath: (declared: string) => string;
+/**
+ * Whether a declared brand path is one Brydio will follow: `./`-prefixed,
+ * relative, inside the package, and a name a bundle can hold.
+ */
+export declare function isBrandPath(declared: unknown): declared is string;
+/**
+ * The brand files a manifest names, by field, as bundle paths. Only fields
+ * written in the two-variant shape; a legacy `icon: "./icon.png"` names none.
+ */
+export declare function brandPathsOf(manifest: unknown): Map<BrandField, string>;
+/**
+ * Everything wrong with an app's logo and icon.
+ *
+ * `required` is off only where a package is read that is not being published
+ * (an import of somebody's plugin with no screens): the images it does name
+ * are still checked, and the ones it leaves out are not asked for.
+ */
+export declare function brandProblems(manifest: Record<string, unknown>, files: RequirementFiles, options?: {
+    required?: boolean;
+}): RequirementProblem[];
+/**
+ * Whether the assistant has anything to call in this app (ADR-A19).
+ *
+ * `parts` counts what the package bundles beside the manifest: the servers in
+ * its `servers.json` and the files in its `integrations/`. Where they can't
+ * be seen (a published bundle holds only code), `requires` still counts.
+ */
+export declare function toolsProblem(manifest: Record<string, unknown>, parts?: {
+    servers?: number;
+    integrations?: number;
+}): RequirementProblem | null;
+export interface BrandShape {
+    type: BrandImageType;
+    width: number;
+    height: number;
+}
+/** What an image is and how big, from its bytes, or null for anything else. */
+export declare function brandShapeOf(bytes: Uint8Array): BrandShape | null;
+/** No script, no event handler, no `javascript:` and no reference that leaves the file. */
+export declare function svgIsInert(svg: string): boolean;
+/**
+ * Every distinct colour an SVG paints with, normalised, or null when it
+ * embeds a raster whose colours can't be read from the markup.
+ */
+export declare function svgColours(svg: string): string[] | null;
+/**
+ * What a PNG's pixels say about being one colour.
+ *
+ * Decodes the image (non-interlaced, every colour type and bit depth) and
+ * compares every pixel at least 1/16 opaque with the most opaque one.
+ */
+export declare function pngVerdict(bytes: Uint8Array): 'one' | 'colours' | 'opaque' | 'unreadable';