@brydio/manifest 0.1.0-alpha.6 → 0.1.0-alpha.61

package/src/screen-kinds.js

@@ -0,0 +1,30 @@
+/**
+ * The two kinds of screen (`tasks/app-publishing` PB27). A copy of Brydio's
+ * `apps/api/src/apps/manifest/screen-kinds.ts`.
+ *
+ * A **tree screen** is the app's elements, drawn by Brydio (PB21 to PB24). A
+ * **frame screen** is the app's own HTML and CSS, drawn in a sandboxed frame
+ * on an origin that holds only app code. The manifest says which, per screen:
+ * `{ "kind": "frame", "entry": "screens/settings.html" }`. Left out, a screen
+ * is a tree screen, so every manifest from before keeps its meaning.
+ */
+export const SCREEN_KINDS = ['tree', 'frame'];
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+/** Which kind one of the manifest's screens is; `tree` when it says nothing. */
+export function screenKindOf(manifest, screen) {
+    const screens = isRecord(manifest) && isRecord(manifest.screens) ? manifest.screens : {};
+    const declared = Object.prototype.hasOwnProperty.call(screens, screen) ? screens[screen] : undefined;
+    return isRecord(declared) && declared.kind === 'frame' ? 'frame' : 'tree';
+}
+/** The manifest's screens of one kind, by name. */
+export function screensOfKind(manifest, kind) {
+    const screens = isRecord(manifest) && isRecord(manifest.screens) ? manifest.screens : {};
+    return Object.keys(screens).filter(screen => screenKindOf(manifest, screen) === kind);
+}
+/** Every frame screen's page, by its path inside the bundle. */
+export function framePagesOf(manifest) {
+    const screens = isRecord(manifest) && isRecord(manifest.screens) ? manifest.screens : {};
+    return new Set(screensOfKind(manifest, 'frame')
+        .map(screen => screens[screen].entry)
+        .filter((entry) => typeof entry === 'string'));
+}

package/src/secrets.d.ts

@@ -30,3 +30,17 @@ export interface SecretFound {
 export declare function secretsInJson(document: unknown, at: string): SecretFound[];
 /** Every secret declared in a bundle's files, as the server finds them. */
 export declare function findSecrets(files: ReadonlyMap<string, Uint8Array>, root?: string): SecretFound[];
+/**
+ * The server's sentence for `developer_key_in_bundle` (ADR-A22), word for
+ * word: `DEVELOPER_KEY_IN_BUNDLE` in Brydio's `app-publish.service.ts`.
+ */
+export declare const DEVELOPER_KEY_MESSAGE = "That package contains a Brydio developer API key. A key belongs on your own server, never in an app: revoke it in Settings \u203A Developer, and call Brydio\u2019s model from a handler with the model grant instead.";
+/** Whether a text holds a Brydio developer API key. */
+export declare const holdsDeveloperKey: (text: string) => boolean;
+/**
+ * The first file holding a developer API key, by path, as Brydio's publish
+ * route finds it (`developerKeyIn`). Unlike the declaration scan, every file
+ * is read, scripts included: the key's shape is exact enough that a match is
+ * a key, not a guess, and no part of an app may hold one (ADR-A24).
+ */
+export declare function developerKeyIn(files: ReadonlyMap<string, Uint8Array>): string | null;

package/src/secrets.js

@@ -35,21 +35,21 @@ const isRealValue = (value) => {
         return false;
     return true;
 };
-function walk(node, at, found) {
+function walk(node, at, found, publicValue = () => false) {
     if (Array.isArray(node)) {
-        node.forEach((one, index) => walk(one, `${at}[${index}]`, found));
+        node.forEach((one, index) => walk(one, `${at}[${index}]`, found, publicValue));
         return;
     }
     if (!node || typeof node !== 'object')
         return;
     for (const [key, value] of Object.entries(node)) {
         const path = at ? `${at}.${key}` : key;
-        if (VALUE_KEYS.has(key) && isRealValue(value)) {
+        if (VALUE_KEYS.has(key) && isRealValue(value) && !publicValue(path)) {
             // Never quoted back: a report that repeated the secret would copy it somewhere else.
             found.push({ code: 'secret_in_bundle', message: SECRET_MESSAGE, path });
             continue;
         }
-        walk(value, path, found);
+        walk(value, path, found, publicValue);
     }
 }
 /**
@@ -59,9 +59,20 @@ function walk(node, at, found) {
  */
 export function secretsInJson(document, at) {
     const found = [];
-    walk(document, at, found);
+    walk(document, at, found, path => DECLARATIONS.some(declared => declared.test(path)));
     return found;
 }
+/**
+ * Names in an app.json that read like credentials but are declarations: a
+ * placement's identity, a collection's field definition (an open-schema
+ * companion must declare `key`), and a tool's input field. Their values are
+ * types and names, never secrets.
+ */
+const DECLARATIONS = [
+    /(?:^|\.)placements\[\d+\]\.key$/,
+    /(?:^|\.)data\.[^.[\]]+\.schema\.[^.[\]]+$/,
+    /(?:^|\.)tools\.custom\[\d+\]\.input\.[^.[\]]+$/,
+];
 /** Every secret declared in a bundle's files, as the server finds them. */
 export function findSecrets(files, root = '') {
     const found = [];
@@ -79,3 +90,25 @@ export function findSecrets(files, root = '') {
     }
     return found;
 }
+/**
+ * The server's sentence for `developer_key_in_bundle` (ADR-A22), word for
+ * word: `DEVELOPER_KEY_IN_BUNDLE` in Brydio's `app-publish.service.ts`.
+ */
+export const DEVELOPER_KEY_MESSAGE = 'That package contains a Brydio developer API key. A key belongs on your own server, never in an app: revoke it in Settings › Developer, and call Brydio’s model from a handler with the model grant instead.';
+/** A developer API key's exact shape, anywhere in a text. */
+const DEVELOPER_KEY = /bry_live_[0-9a-f]{12}_[A-Za-z0-9_-]{43}/;
+/** Whether a text holds a Brydio developer API key. */
+export const holdsDeveloperKey = (text) => DEVELOPER_KEY.test(text);
+/**
+ * The first file holding a developer API key, by path, as Brydio's publish
+ * route finds it (`developerKeyIn`). Unlike the declaration scan, every file
+ * is read, scripts included: the key's shape is exact enough that a match is
+ * a key, not a guess, and no part of an app may hold one (ADR-A24).
+ */
+export function developerKeyIn(files) {
+    for (const [path, bytes] of files) {
+        if (holdsDeveloperKey(new TextDecoder('latin1').decode(bytes)))
+            return path;
+    }
+    return null;
+}

package/src/validate.d.ts

@@ -1,3 +1,4 @@
+import type { LookProblemCode } from './look.js';
 import { type AppManifestWithData, type DataProblemCode } from './schema.js';
 /**
  * Reading a manifest and saying what is wrong with it, the way Brydio would.
@@ -9,7 +10,9 @@ import { type AppManifestWithData, type DataProblemCode } from './schema.js';
  * `manifest_invalid` with the path to it, so an app's builder can find the
  * line.
  */
-export type ManifestProblemCode = DataProblemCode | 'manifest_not_json' | 'manifest_invalid';
+export type ManifestProblemCode = DataProblemCode | LookProblemCode
+/** A frame screen without an .html page, or an .html entry that isn't a frame screen (PB27). */
+ | 'screen_kind_entry' | 'manifest_not_json' | 'manifest_invalid';
 export interface ManifestProblem {
     code: ManifestProblemCode;
     message: string;
@@ -22,6 +25,12 @@ export interface ManifestValidation {
     manifest?: AppManifestWithData;
     problems: ManifestProblem[];
 }
-export declare function validateManifest(source: unknown): ManifestValidation;
+export declare function validateManifest(source: unknown, 
+/** `retired`: a manifest being written now, which may not use a retired kind such as `project-tab`. */
+options?: {
+    retired?: boolean;
+}): ManifestValidation;
 /** Parses the text of `.brydio/app.json` and validates it. */
-export declare function validateManifestText(text: string): ManifestValidation;
+export declare function validateManifestText(text: string, options?: {
+    retired?: boolean;
+}): ManifestValidation;

package/src/validate.js

@@ -1,6 +1,8 @@
-import { appManifestSchema } from "./schema.js";
-export function validateManifest(source) {
-    const parsed = appManifestSchema.safeParse(source);
+import { appManifestSchema, newAppManifestSchema } from "./schema.js";
+export function validateManifest(source, 
+/** `retired`: a manifest being written now, which may not use a retired kind such as `project-tab`. */
+options = {}) {
+    const parsed = (options.retired ? newAppManifestSchema : appManifestSchema).safeParse(source);
     if (parsed.success)
         return { ok: true, manifest: parsed.data, problems: [] };
     return {
@@ -14,7 +16,7 @@ export function validateManifest(source) {
     };
 }
 /** Parses the text of `.brydio/app.json` and validates it. */
-export function validateManifestText(text) {
+export function validateManifestText(text, options = {}) {
     let json;
     try {
         json = JSON.parse(text);
@@ -25,5 +27,5 @@ export function validateManifestText(text) {
             problems: [{ code: 'manifest_not_json', message: `The manifest is not valid JSON: ${error instanceof Error ? error.message : String(error)}` }],
         };
     }
-    return validateManifest(json);
+    return validateManifest(json, options);
 }