akanjs 3.0.0-beta.20 → 3.0.0-beta.21

package/vendor/@akanjs/native/packages/cli/src/lib/compat.ts

@@ -0,0 +1,185 @@
+
+
+import { createHash } from "node:crypto";
+import { existsSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { join, relative } from "node:path";
+import type { Platform, PluginDecl, ResolvedAcl } from "../../../core/src/index.ts";
+import { BRIDGE_FEATURES } from "../../../core/src/protocol.ts";
+import { CliError } from "./log.ts";
+import type { Project } from "./project.ts";
+import { PACKAGE_ROOT } from "./root.ts";
+
+export const BUNDLE_FILE = "bundle.json";
+
+export interface NativeApi {
+  /** Bridge protocol version (architecture.md §4) and the v1.1 features the hosts speak. */
+  protocol: 1;
+  features: string[];
+  /** @akanjs/native/core major.minor, or major alone from 1.0 on (semver caret compatibility). */
+  runtime: string;
+  platform: Platform;
+  /** Every plugin the binary declares, with the package version of native implementations. */
+  plugins: Record<string, { decl: PluginDecl; version?: string }>;
+  /** The capabilities the binary enforces (PL-11). */
+  acl: ResolvedAcl | null;
+  /** App-level permissions (C8) and deep-link schemes the binary declares. */
+  permissions: string[];
+  deepLinks: string[];
+}
+
+export interface BundleInfo {
+  schema: 1;
+  app: { id: string; version: string; build: number };
+  platform: Platform;
+  runtimeVersion: string;
+  nativeApi: { hash: string; inputs: NativeApi };
+  /** sha256 of the web files (index.html as served and public/), for update integrity later. */
+  web: { hash: string; files: number };
+}
+
+/** "0.1.4" → "0.1", "1.2.0" → "1". */
+export function runtimeLine(version: string): string {
+  const [major = "0", minor = "0"] = version.split(".");
+  return major === "0" ? `0.${minor}` : major;
+}
+
+function packageVersion(dir: string): string | undefined {
+  const path = join(dir, "package.json");
+  if (!existsSync(path)) return undefined;
+  const version = (JSON.parse(readFileSync(path, "utf8")) as { version?: unknown }).version;
+  return typeof version === "string" ? version : undefined;
+}
+
+export function nativeApi(
+  project: Project,
+  platform: Platform,
+  decls: Record<string, PluginDecl>,
+  acl: ResolvedAcl | undefined,
+  runtimeVersion: string,
+): NativeApi {
+  const dirs = new Map(project.plugins.map((p) => [p.manifest.id, p.dir]));
+  const plugins: NativeApi["plugins"] = {};
+  for (const [id, decl] of Object.entries(decls)) {
+    
+    const dir = dirs.get(id) ?? "";
+    const version =
+      decl === "web" ? undefined : dir.startsWith(join(PACKAGE_ROOT, "plugins")) ? runtimeVersion : packageVersion(dir);
+    plugins[id] = { decl, ...(version ? { version } : {}) };
+  }
+  return {
+    protocol: 1,
+    features: [...BRIDGE_FEATURES],
+    runtime: runtimeLine(runtimeVersion),
+    platform,
+    plugins,
+    acl: acl ?? null,
+    permissions: Object.keys(project.config.permissions).sort(),
+    deepLinks: [...project.config.deepLinks.schemes].sort(),
+  };
+}
+
+/** JSON with sorted object keys (arrays keep their order), so the hash does not depend on it. */
+function canonical(value: unknown): string {
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+  if (value && typeof value === "object") {
+    const entries = Object.entries(value).filter(([, v]) => v !== undefined);
+    return `{${entries
+      .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+      .map(([k, v]) => `${JSON.stringify(k)}:${canonical(v)}`)
+      .join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+
+export function nativeApiHash(api: NativeApi): string {
+  return createHash("sha256").update(canonical(api)).digest("hex").slice(0, 16);
+}
+
+/** Why a bundle built against `bundle` cannot run in a binary that provides `installed` (empty: it can). */
+export function compatProblems(installed: NativeApi, bundle: NativeApi): string[] {
+  const problems: string[] = [];
+  if (installed.platform !== bundle.platform)
+    return [`the bundle is for ${bundle.platform}, the app is ${installed.platform}`];
+  if (installed.protocol !== bundle.protocol)
+    problems.push(`bridge protocol ${bundle.protocol} vs ${installed.protocol}`);
+  const features = (api: NativeApi) => [...(api.features ?? [])].sort().join(", ") || "none";
+  if (features(installed) !== features(bundle))
+    problems.push(`bridge features ${features(bundle)} vs ${features(installed)} in the app`);
+  if (installed.runtime !== bundle.runtime)
+    problems.push(`akan-native runtime ${bundle.runtime} vs ${installed.runtime} in the app`);
+  const ids = [...new Set([...Object.keys(installed.plugins), ...Object.keys(bundle.plugins)])].sort();
+  for (const id of ids) {
+    const a = installed.plugins[id];
+    const b = bundle.plugins[id];
+    if (!a) problems.push(`plugin ${id} is not in the app`);
+    else if (!b) problems.push(`plugin ${id} is in the app but not in the bundle`);
+    else {
+      if (a.version !== b.version) problems.push(`plugin ${id} ${b.version ?? "?"} vs ${a.version ?? "?"} in the app`);
+      const describe = (d: PluginDecl) =>
+        d === "web"
+          ? "web"
+          : `native: ${d.methods.join(", ")}${d.events.length ? `; events ${d.events.join(", ")}` : ""}${d.web ? " (+web)" : ""}`;
+      if (canonical(a.decl) !== canonical(b.decl))
+        problems.push(`plugin ${id} is ${describe(b.decl)} in the bundle, ${describe(a.decl)} in the app`);
+    }
+  }
+  if (canonical(installed.acl) !== canonical(bundle.acl)) problems.push("capabilities changed");
+  if (canonical(installed.permissions) !== canonical(bundle.permissions))
+    problems.push(`permissions [${bundle.permissions.join(", ")}] vs [${installed.permissions.join(", ")}] in the app`);
+  if (canonical(installed.deepLinks) !== canonical(bundle.deepLinks))
+    problems.push(
+      `deep link schemes [${bundle.deepLinks.join(", ")}] vs [${installed.deepLinks.join(", ")}] in the app`,
+    );
+  return problems;
+}
+
+function webHash(webDir: string, html: string): { hash: string; files: number } {
+  const hash = createHash("sha256");
+  const files: string[] = [];
+  const walk = (dir: string) => {
+    for (const name of readdirSync(dir).sort()) {
+      const path = join(dir, name);
+      if (statSync(path).isDirectory()) walk(path);
+      else files.push(path);
+    }
+  };
+  walk(webDir);
+  for (const file of files) {
+    const rel = relative(webDir, file);
+    hash.update(`${rel}\0`);
+    hash.update(rel === "index.html" ? html : readFileSync(file));
+    hash.update("\0");
+  }
+  return { hash: hash.digest("hex"), files: files.length };
+}
+
+/** Writes <outDir>/bundle.json for a native build. */
+export function writeBundleInfo(
+  outDir: string,
+  project: Project,
+  platform: Platform,
+  runtimeVersion: string,
+  api: NativeApi,
+  webDir: string,
+  html: string,
+): BundleInfo {
+  const { app } = project.config;
+  const info: BundleInfo = {
+    schema: 1,
+    app: { id: app.id, version: app.version, build: app.build },
+    platform,
+    runtimeVersion,
+    nativeApi: { hash: nativeApiHash(api), inputs: api },
+    web: webHash(webDir, html),
+  };
+  writeFileSync(join(outDir, BUNDLE_FILE), `${JSON.stringify(info, null, 2)}\n`);
+  return info;
+}
+
+export function readBundleInfo(path: string): BundleInfo {
+  if (!existsSync(path)) throw new CliError(`${path} not found`);
+  const info = JSON.parse(readFileSync(path, "utf8")) as BundleInfo;
+  if (info?.schema !== 1 || !info.nativeApi?.inputs)
+    throw new CliError(`${path} is not an akan-native bundle.json (schema 1)`);
+  return info;
+}

package/vendor/@akanjs/native/packages/cli/src/lib/configkeys.ts

@@ -0,0 +1,91 @@
+
+
+type Shape = true | { readonly [key: string]: Shape };
+
+const KNOWN: Shape = {
+  app: { id: true, name: true, fileName: true, version: true, build: true },
+  web: { dir: true, build: true, base: true, devEntry: true },
+  plugins: true,
+  capabilities: {
+    "[]": {
+      identifier: true,
+      description: true,
+      windows: true,
+      platforms: true,
+      permissions: { "[]": { identifier: true, allow: true, deny: true } },
+    },
+  },
+  env: { defaults: true, platforms: { web: true, macos: true, windows: true, linux: true, ios: true, android: true } },
+  shell: { backgroundColor: true, backgroundColorDark: true },
+  usageDescriptions: true,
+  privacy: { tracking: true, trackingDomains: true, collectedDataTypes: true, accessedApis: true },
+  permissions: { camera: true, microphone: true, location: true },
+  updates: { url: true, publicKey: true, channel: true, readyTimeout: true },
+  deepLinks: { schemes: true, domains: { "[]": { host: true, pathPrefixes: true } } },
+  native: {
+    ios: { infoPlist: true, entitlements: true },
+    android: { manifest: true, application: true, activity: true },
+    resources: { "[]": { from: true, to: true } },
+  },
+  security: { csp: true, shell: { externalSchemes: true } },
+  android: { minWebViewVersion: true, debugAppIdSuffix: true, googleServices: true },
+  desktop: { quitOnLastWindowClosed: true },
+  keyboard: { resize: true },
+  push: {
+    android: { channel: { id: true, name: true, importance: true, description: true }, smallIcon: true, color: true },
+  },
+  ios: { hideFormAccessoryBar: true },
+  icon: { image: true, backgroundColor: true },
+  splash: { backgroundColor: { light: true, dark: true }, image: true, autoHide: true, timeout: true },
+};
+
+const isObject = (value: unknown): value is Record<string, unknown> =>
+  !!value && typeof value === "object" && !Array.isArray(value);
+
+function distance(a: string, b: string): number {
+  const row = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i++) {
+    let diagonal = row[0]!;
+    row[0] = i;
+    for (let j = 1; j <= b.length; j++) {
+      const above = row[j]!;
+      row[j] = Math.min(row[j]! + 1, row[j - 1]! + 1, diagonal + (a[i - 1] === b[j - 1] ? 0 : 1));
+      diagonal = above;
+    }
+  }
+  return row[b.length]!;
+}
+
+/** The known key a misspelled one probably meant: the same key in other case, else one at most two edits away. */
+function suggestion(key: string, known: string[]): string | undefined {
+  const lower = key.toLowerCase();
+  return (
+    known.find((k) => k.toLowerCase() === lower) ??
+    known.filter((k) => distance(k.toLowerCase(), lower) <= 2).sort((a, b) => distance(a, key) - distance(b, key))[0]
+  );
+}
+
+/** "unknown key deepLink (did you mean deepLinks?)" for every key the config should not have. */
+export function unknownConfigKeys(config: unknown): string[] {
+  const problems: string[] = [];
+  const walk = (value: unknown, shape: Shape, path: string) => {
+    if (shape === true) return;
+    if (Array.isArray(value)) {
+      const items = shape["[]"];
+      if (items) for (const [i, item] of value.entries()) walk(item, items, `${path}[${i}]`);
+      return;
+    }
+    if (!isObject(value)) return;
+    const known = Object.keys(shape).filter((k) => k !== "[]");
+    for (const [key, child] of Object.entries(value)) {
+      const where = path ? `${path}.${key}` : key;
+      const sub = shape[key];
+      if (sub === undefined || key === "[]") {
+        const hint = suggestion(key, known);
+        problems.push(`unknown key ${where}${hint ? ` (did you mean ${path ? `${path}.` : ""}${hint}?)` : ""}`);
+      } else walk(child, sub, where);
+    }
+  };
+  walk(config, KNOWN, "");
+  return problems;
+}

package/vendor/@akanjs/native/packages/cli/src/lib/csp.ts

@@ -0,0 +1,198 @@
+
+
+import { createHash } from "node:crypto";
+import { NEVER_EXTERNAL_SCHEMES } from "../../../core/src/contract.ts";
+import { CliError } from "./log.ts";
+
+export type CspDirectives = Record<string, string | string[]>;
+/** "strict" is akan-native's recommended policy; a string or a directive map is used as given. */
+export type CspConfig = "strict" | string | CspDirectives;
+
+/**
+ * Everything an akan-native app needs and nothing else: the page, init.js, the bridge (desktop fetch to
+ * /__akan_native/ipc, Android /__akan_native/hello + MessagePort; iOS messageHandlers are outside CSP), FileRefs
+ * (/__akan_native/file/*), blob:/data: images and media (camera, file-picker, filesystem on the web), dev
+ * live reload (same-origin EventSource), fetch() of blob:/data: URLs (web FileRefs). Remote APIs,
+ * CDNs and fonts must be added by the app.
+ */
+export const STRICT_CSP: Record<string, string[]> = {
+  "default-src": ["'self'"],
+  "script-src": ["'self'"],
+  "style-src": ["'self'"],
+  "img-src": ["'self'", "blob:", "data:"],
+  "media-src": ["'self'", "blob:", "data:"],
+  "font-src": ["'self'", "data:"],
+  
+  "connect-src": ["'self'", "blob:", "data:"],
+  "worker-src": ["'self'", "blob:"],
+  "frame-src": ["'self'"],
+  "object-src": ["'none'"],
+  "base-uri": ["'none'"],
+  "form-action": ["'self'"],
+};
+
+/** frame-ancestors, report-uri, report-to and sandbox are ignored in a <meta> policy. */
+const HEADER_ONLY = ["frame-ancestors", "report-uri", "report-to", "sandbox"];
+
+export function parseCsp(text: string): Map<string, string[]> {
+  const out = new Map<string, string[]>();
+  for (const part of text.split(";")) {
+    const [name, ...sources] = part.trim().split(/\s+/);
+    if (!name) continue;
+    const key = name.toLowerCase();
+    if (!out.has(key)) out.set(key, sources); 
+  }
+  return out;
+}
+
+function toMap(config: CspConfig): Map<string, string[]> {
+  if (config === "strict") return new Map(Object.entries(STRICT_CSP).map(([k, v]) => [k, [...v]]));
+  if (typeof config === "string") return parseCsp(config);
+  return new Map(
+    Object.entries(config).map(([k, v]) => [
+      k.toLowerCase(),
+      Array.isArray(v) ? [...v] : v.trim().split(/\s+/).filter(Boolean),
+    ]),
+  );
+}
+
+export function serializeCsp(map: Map<string, string[]>): string {
+  return [...map].map(([name, sources]) => (sources.length ? `${name} ${sources.join(" ")}` : name)).join("; ");
+}
+
+/** The HTML parser turns CRLF and lone CR into LF before a script's text is hashed. */
+export function normalizeForHash(text: string): string {
+  return text.replace(/\r\n?/g, "\n");
+}
+
+export function cspHash(text: string): string {
+  return `'sha256-${createHash("sha256").update(normalizeForHash(text), "utf8").digest("base64")}'`;
+}
+
+/**
+ * Inline <script> (without src) and <style> contents of a document. Like the HTML tokenizer, a
+ * script or style ends at the first `</script` / `</style`, so text in the bundle that merely
+ * mentions a tag does not start a new element (bundlers escape `</script` inside JS).
+ */
+export function inlineBlocks(html: string): { scripts: string[]; styles: string[] } {
+  const scripts: string[] = [];
+  const styles: string[] = [];
+  const open = /<(script|style)\b([^>]*)>/gi;
+  for (let m = open.exec(html); m; m = open.exec(html)) {
+    const tag = m[1]!.toLowerCase();
+    const close = new RegExp(`</${tag}`, "i");
+    const rest = html.slice(m.index + m[0].length);
+    const end = close.exec(rest);
+    const body = end ? rest.slice(0, end.index) : rest;
+    const external = tag === "script" && /\bsrc\s*=/i.test(m[2] ?? "");
+    if (!external && body.length > 0) (tag === "script" ? scripts : styles).push(body);
+    open.lastIndex = m.index + m[0].length + (end ? end.index : rest.length);
+  }
+  return { scripts, styles };
+}
+
+/**
+ * The policy for this index.html: the configured directives plus hashes of its inline scripts
+ * and styles. A directive the app left out is derived from default-src first, so adding hashes
+ * never drops sources the app allowed. A directive with 'unsafe-inline' stays as it is: hashes
+ * would switch 'unsafe-inline' off (CSP2) and break inline styles the app relies on.
+ */
+export function buildCsp(
+  config: CspConfig,
+  html: string,
+): { policy: string; scripts: number; styles: number; warnings: string[] } {
+  const map = toMap(config);
+  const warnings: string[] = [];
+  for (const name of HEADER_ONLY) {
+    if (map.delete(name))
+      warnings.push(`security.csp: ${name} has no effect in a <meta> policy; set it as a server header on the web`);
+  }
+  const { scripts, styles } = inlineBlocks(html);
+  const add = (directive: string, blocks: string[]) => {
+    if (blocks.length === 0) return;
+    let sources = map.get(directive);
+    if (!sources) {
+      sources = [...(map.get("default-src") ?? ["'self'"])];
+      map.set(directive, sources);
+    }
+    if (sources.includes("'unsafe-inline'")) {
+      warnings.push(
+        `security.csp: ${directive} has 'unsafe-inline'; inline ${directive === "script-src" ? "scripts" : "styles"} are not hashed`,
+      );
+      return;
+    }
+    if (sources.includes("'none'")) sources.splice(sources.indexOf("'none'"), 1);
+    for (const hash of new Set(blocks.map(cspHash))) if (!sources.includes(hash)) sources.push(hash);
+  };
+  add("script-src", scripts);
+  add("style-src", styles);
+  return { policy: serializeCsp(map), scripts: scripts.length, styles: styles.length, warnings };
+}
+
+export function validateCsp(raw: unknown): CspConfig | undefined {
+  if (raw === undefined) return undefined;
+  if (typeof raw === "string" && raw.trim()) return raw;
+  if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+    for (const [name, value] of Object.entries(raw)) {
+      const ok = typeof value === "string" || (Array.isArray(value) && value.every((v) => typeof v === "string"));
+      if (!ok || !/^[a-z-]+$/i.test(name))
+        throw new CliError(`security.csp.${name} must be a source list (string or string[])`);
+    }
+    return raw as CspDirectives;
+  }
+  throw new CliError(`security.csp must be "strict", a policy string, or a directive map`);
+}
+
+const CSP_META = /<meta\b[^>]*http-equiv\s*=\s*["']?content-security-policy/i;
+
+/**
+ * Inserts the policy near the top of <head>: right after `<meta charset>` when there is one (so
+ * the charset stays in the first 1024 bytes a browser scans), else first. Either way it comes
+ * before the inlined styles and the bundle; only init.js may precede it, which 'self' allows.
+ */
+export function injectCspMeta(html: string, policy: string): string {
+  if (CSP_META.test(html)) {
+    throw new CliError(
+      "index.html already has a Content-Security-Policy <meta>; remove it or drop security.csp from akan-native.config.ts",
+    );
+  }
+  const tag = `<meta http-equiv="Content-Security-Policy" content="${policy.replace(/&/g, "&amp;").replace(/"/g, "&quot;")}">`;
+  const head = /<head(\s[^>]*)?>/i.exec(html);
+  if (!head) throw new CliError("index.html has no <head> for the Content-Security-Policy <meta>");
+  const afterHead = head.index + head[0].length;
+  const rest = html.slice(afterHead);
+  const charset = /<meta\b[^>]*\bcharset\s*=[^>]*>/i.exec(rest);
+  
+  const governed = /<(?:style|link)\b|<script\b(?![^>]*__akan_native\/init\.js)/i.exec(rest);
+  const at =
+    charset && (!governed || charset.index < governed.index)
+      ? afterHead + charset.index + charset[0].length
+      : afterHead;
+  return html.slice(0, at) + tag + html.slice(at);
+}
+
+/** True when the source index.html brings its own policy (left alone when security.csp is unset). */
+export function hasCspMeta(html: string): boolean {
+  return CSP_META.test(html);
+}
+
+/**
+ * security.shell.externalSchemes (L0): lowercase URL schemes the shell may also hand to the OS.
+ * Schemes that reach local files, run script or name the app itself can never be added.
+ */
+export function validateExternalSchemes(raw: unknown): string[] {
+  if (raw === undefined) return [];
+  if (!Array.isArray(raw)) throw new CliError("security.shell.externalSchemes must be an array of URL schemes");
+  for (const scheme of raw) {
+    if (typeof scheme !== "string" || !/^[a-z][a-z0-9+.-]*$/.test(scheme)) {
+      throw new CliError(
+        `security.shell.externalSchemes: ${JSON.stringify(scheme)} is not a lowercase URL scheme (write "sms", not "sms:")`,
+      );
+    }
+    if (NEVER_EXTERNAL_SCHEMES.includes(scheme))
+      throw new CliError(
+        `security.shell.externalSchemes: ${scheme}: links can never leave the app (${NEVER_EXTERNAL_SCHEMES.join(", ")})`,
+      );
+  }
+  return [...new Set(raw as string[])];
+}