@agent-flow-board/bridge 0.2.0 → 0.3.0

package/dist/checks/profiles.js

@@ -0,0 +1,110 @@
+// SAVED SIGN-INS: ONE SEALED FILE PER REGISTRATION AND SITE
+// A saved sign-in is the browser state (cookies and local storage) of a person signed in to one site. It is sealed with the bridge's key, bound
+// to the registration and the site address (the AAD), and lives under that registration's own state folder. It is used only for the site it
+// was saved for, and it never reaches a check except through the child's stdin.
+// -- DEP-MODULES -- //
+import { createHash } from 'node:crypto';
+import { existsSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+// -- MODULES -- //
+import { ensureDir, ORG_SLUG, stateDirFor } from './paths.js';
+import { renameRetry } from './fsretry.js';
+import { seal, unseal } from './store.js';
+// -- CONSTANTS -- //
+const NAME = /^[A-Za-z0-9_-]{1,32}$/;
+const FILE = /^[0-9a-f]{16}\.enc$/;
+const enc = new TextEncoder();
+const dec = new TextDecoder();
+// -- FUNCTIONS -- //
+function check(org, name) {
+    if (!ORG_SLUG.test(org))
+        throw new Error('The organisation is not a slug.');
+    if (!NAME.test(name))
+        throw new Error('The registration name is not a plain name.');
+}
+const profilesDir = (org, name) => {
+    check(org, name);
+    return join(stateDirFor(org, name), 'profiles');
+};
+/** The file name for a site address: 16 hex characters of its hash. */
+export const fileNameFor = (bindKey) => `${createHash('sha256').update(bindKey).digest('hex').slice(0, 16)}.enc`;
+const aadFor = (org, name, bindKey) => `profile:${org}/${name}:${bindKey}`;
+/** Saves (replaces) the sign-in of one registration and site. Returns the file name, not the path. */
+export function saveProfile(org, name, bindKey, state) {
+    if (!bindKey)
+        throw new Error('A saved sign-in needs the address of the site.');
+    const dir = ensureDir(profilesDir(org, name));
+    const file = fileNameFor(bindKey);
+    const profile = { bindKey, savedAt: new Date().toISOString(), state };
+    const blob = seal(aadFor(org, name, bindKey), enc.encode(JSON.stringify(profile)));
+    const tmp = join(dir, `${file}.${process.pid}.tmp`);
+    writeFileSync(tmp, blob, { mode: 0o600 });
+    renameRetry(tmp, join(dir, file));
+    // The address is not a secret: a plain index lets a listing name the site without opening the sealed file
+    writeFileSync(indexPath(org, name, file), JSON.stringify({ bindKey }), { mode: 0o600 });
+    return file;
+}
+/** The saved sign-in for exactly this registration and site, or null (none, damaged, or saved for another address). */
+export function loadProfile(org, name, bindKey) {
+    return loadProfileChecked(org, name, bindKey).profile;
+}
+/** The same, and says when a file is there but cannot be opened (damaged, or sealed for another address), so a run does not go signed out without saying so. */
+export function loadProfileChecked(org, name, bindKey) {
+    const path = join(profilesDir(org, name), fileNameFor(bindKey));
+    if (!existsSync(path))
+        return { profile: null, damaged: false };
+    try {
+        const raw = unseal(aadFor(org, name, bindKey), readFileSync(path));
+        const p = JSON.parse(dec.decode(raw));
+        return p && p.bindKey === bindKey
+            ? { profile: p, damaged: false }
+            : { profile: null, damaged: true };
+    }
+    catch {
+        return { profile: null, damaged: true };
+    }
+}
+/** A plain sentence when every timed cookie has run out, so a run can say so before it fails on a sign-in page. */
+export function expiryNote(profile) {
+    const cookies = profile?.state?.cookies ?? [];
+    const now = Date.now() / 1000;
+    const timed = cookies.filter((c) => typeof c.expires === 'number' && c.expires > 0);
+    return timed.length && timed.every((c) => c.expires < now)
+        ? 'The saved sign-in has expired.'
+        : null;
+}
+/** Which sites have a saved sign-in: file, address and date, never a cookie or a value. The address is read from the plain index beside each file. */
+export function listProfiles(org, name) {
+    const dir = profilesDir(org, name);
+    if (!existsSync(dir))
+        return [];
+    const out = [];
+    for (const file of readdirSync(dir).filter((f) => FILE.test(f))) {
+        let bindKey = '(unknown)';
+        try {
+            bindKey = String(JSON.parse(readFileSync(indexPath(org, name, file), 'utf8'))
+                .bindKey ?? bindKey);
+        }
+        catch {
+            /* No index: the file is still listed */
+        }
+        out.push({ file, bindKey, savedAt: statSync(join(dir, file)).mtime.toISOString() });
+    }
+    return out;
+}
+const indexPath = (org, name, file) => join(profilesDir(org, name), file + '.site');
+/** Removes one saved sign-in by its exact file name. True when a file went. */
+export function removeProfile(org, name, file) {
+    if (!FILE.test(file))
+        throw new Error('That is not a saved sign-in file name.');
+    const dir = profilesDir(org, name);
+    let removed = false;
+    for (const f of [file, `${file}.site`]) {
+        const p = join(dir, f);
+        if (existsSync(p)) {
+            rmSync(p, { force: true });
+            removed ||= f === file;
+        }
+    }
+    return removed;
+}

package/dist/checks/provision.js

@@ -18,7 +18,7 @@ const IMAGE = 'postgres:16-alpine';
 const DOCKER_COMMANDS = new Set(['version', 'run', 'rm', 'exec', 'inspect', 'logs']);
 // -- FUNCTIONS -- //
 /** Runs the real docker program. Never throws: a program that cannot start is a status of -1. */
-const realDocker = (args) => new Promise((resolve) => {
+export const realDocker = (args) => new Promise((resolve) => {
     execFile('docker', args, { windowsHide: true, timeout: 120_000, maxBuffer: 8 * 1024 * 1024 }, (err, stdout, stderr) => {
         const code = err
             ? typeof err.code === 'number'

package/dist/checks/recipe.js

@@ -2,13 +2,15 @@
 // The repo is the one thing an agent edits, so the recipe is never trusted as it stands: it is pinned (bind.ts) and it is checked here
 // against constants of this package. A recipe cannot name another program, a port a check never uses, an env key outside the list, or a value
 // that is anything but a placeholder or a short plain word. It can only ask for less than the guardrails allow.
-// Sealed secrets ({secret:NAME}) are not supported in this version: a recipe that uses one is refused.
+// Sealed secrets ({secret:NAME}) are allowed only on Supabase-style and mail settings (sealedNames.ts), a mail setting takes only the sealed value of its own name, and a
+// service key never goes to a PUBLIC_, VITE_ or NEXT_PUBLIC_ name. The values are filled in by secrets.ts when the preview starts; this file only checks the shape.
 // -- DEP-MODULES -- //
 import { createHash } from 'node:crypto';
 import { existsSync, readFileSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
 // -- MODULES -- //
 import { FORBIDDEN_PORTS, checkRepoFolder, commandProblem } from './guardrails.js';
+import { MAIL_ENV_KEY, SECRET_ENV_KEY, placeholderProblems } from './sealedNames.js';
 // -- CONSTANTS -- //
 export const RECIPE_FILE = '.afb-checks.json';
 /** The only keys of a recipe. */
@@ -22,7 +24,8 @@ export const RECIPE_KEYS = [
     'runtimeRole',
     'testUser',
     'env',
-    'appPaths'
+    'appPaths',
+    'warm'
 ];
 /** Env keys a recipe may name: the app's own settings and the database urls, never PATH, NODE_OPTIONS or anything that loads code. */
 const ENV_KEY = /^(AFB_[A-Z0-9_]{1,50}|BETTER_AUTH_SECRET|DATABASE_URL|DATABASE_OWNER_URL|EMAIL_PROVIDER|EMAIL_FROM|ORIGIN)$/;
@@ -130,6 +133,13 @@ export function validateRecipe(recipe, scripts) {
         if (!ok)
             out.push('"testUser" must be { "email": ..., "password": ... } with a plain email and a password of 8 or more plain characters. It is a preview-only account, public by design.');
     }
+    // Warm previews are not wired in this version (the benchmark rule waived them), so the key is refused instead of being accepted and ignored
+    if (recipe.warm !== undefined) {
+        if (typeof recipe.warm !== 'boolean')
+            out.push('"warm" must be true or false.');
+        else if (recipe.warm)
+            out.push('"warm": warm previews are not enabled in this version.');
+    }
     if (recipe.appPaths !== undefined &&
         !(Array.isArray(recipe.appPaths) &&
             recipe.appPaths.every((p) => typeof p === 'string' && APP_PATH.test(p) && !p.includes('..'))))
@@ -139,10 +149,14 @@ export function validateRecipe(recipe, scripts) {
             out.push('"env" must be an object of setting names and values.');
         else
             for (const [k, v] of Object.entries(recipe.env)) {
-                if (typeof v === 'string' && v.includes('{secret:'))
-                    out.push(`The recipe gives ${k} a sealed secret. Sealed secrets are not supported in this version of the check commands.`);
-                else if (!ENV_KEY.test(k) && !PUBLIC_ENV_KEY.test(k))
+                if (!ENV_KEY.test(k) && !PUBLIC_ENV_KEY.test(k) && !SECRET_ENV_KEY.test(k))
                     out.push(`The recipe sets ${k}, which is not an env key a recipe may set.`);
+                // A sealed value only on a Supabase-style or mail setting, and only a key of that kind: never a database, NODE_OPTIONS or a path
+                else if (typeof v === 'string' && v.startsWith('{secret:'))
+                    out.push(...placeholderProblems(k, v));
+                // A mail setting is never written in the recipe: its value comes from the sealed store, behind the mail guard
+                else if (MAIL_ENV_KEY.test(k))
+                    out.push(`The recipe gives ${k}, a mail setting, a value that is not its own sealed value ({secret:${k}}).`);
                 else if (typeof v !== 'string' || !(PLACEHOLDER.test(v) || PLAIN.test(v)))
                     out.push(`The recipe gives ${k} a value that is not a placeholder ({baseUrl}, {port}, {random}, {databaseUrl}, {databaseOwnerUrl}) or a short plain word.`);
                 else if (/^\d+$/.test(v) && FORBIDDEN_PORTS.has(Number(v)))