@condorinst/mobile-bridge 0.8.0

package/README.md

@@ -0,0 +1,396 @@
+# @condorinst/mobile-bridge
+
+Canonical TypeScript SDK for the JS↔Native bridge of the Condor white-label
+mobile app.
+
+> **Purpose:** give the JavaScript code that runs inside the white-label app's
+> WebView a typed, runtime-validated, testable API to talk to the native
+> Flutter side — versioned handshake, observation of keys emitted by the
+> background, commands to the foreground service, and hooks into native
+> screens (Settings).
+
+> **New here?** Start with the [Client Guide](./docs/client-guide.md) —
+> _"Build your White Label Home"_ — and the runnable
+> [`examples/minimal-home`](./examples/minimal-home).
+
+## Installation
+
+```bash
+npm install @condorinst/mobile-bridge
+```
+
+The published package ships a prebuilt `dist/` (ESM + CJS + type
+declarations) — **no build toolchain is required on your side**.
+
+> **Versioning during the pilot.** The package is on `0.x` (beta). Pin
+> `"@condorinst/mobile-bridge": "^0.8.0"`. Under semver, while on `0.x` a
+> caret range auto-updates **patches only** (`0.8.x`); moving to `0.9.0` is
+> an intentional opt-in. `1.0.0` is reserved for production.
+
+## Quickstart
+
+```typescript
+import { Bridge, BRIDGE_KEYS } from '@condorinst/mobile-bridge';
+
+// Versioned handshake with the native side (can be called at any time;
+// recommended on the client's DOMContentLoaded)
+const ack = await Bridge.handshake({ clientVersion: '1.0.0' });
+console.log('Native bridge:', ack.nativeVersion, 'accepted:', ack.accepted);
+
+// Subscribe to an observable key coming from the background
+const unsubscribe = Bridge.on(BRIDGE_KEYS.deviceConnection, (payload) => {
+  console.log('Device:', payload);
+});
+
+// Command: enable real-time
+Bridge.send('realTime', { enabled: true });
+
+// Native hook: open the app's native Settings screen
+Bridge.openSettings();
+
+// Cleanup
+unsubscribe();
+```
+
+> The recommended model for white-label clients is **`BridgeClient`** (sandbox
+> iframe), not the legacy `Bridge`. See below.
+
+## Sandbox iframe — `BridgeClient` + `BridgeShell`
+
+The recommended model isolates the external client code inside an
+`<iframe sandbox="allow-scripts">`, communicating over `window.postMessage`
+with schema-validated messages and a default-deny policy.
+
+### For the external client — `BridgeClient`
+
+API **identical** to the legacy `Bridge`, but over a postMessage transport.
+The client imports it and never notices it is sandboxed:
+
+```typescript
+import { BridgeClient, BRIDGE_KEYS } from '@condorinst/mobile-bridge';
+
+const ack = await BridgeClient.handshake({ clientVersion: '1.0.0' });
+console.log('Shell:', ack.shellVersion, 'accepted:', ack.accepted);
+
+const unsubscribe = BridgeClient.on(BRIDGE_KEYS.userDevice, (payload) => {
+  console.log('Devices:', payload);
+});
+
+BridgeClient.send('realTime', { serialNo: 1234, value: true });
+BridgeClient.openSettings();
+```
+
+**Differences vs `Bridge`:**
+- Does not expose `mockEmit`, `installDevPanel`, `isMock`, `getMockState` —
+  dev/mock APIs live only on the shell.
+- `handshake` resolves with `{ shellVersion, accepted }` (not `nativeVersion`).
+- Commands not allowed by the `ShellPolicy` are silently dropped (with a
+  `console.warn`). The external client has no visibility into which commands
+  do or do not exist.
+
+### For the Condor-controlled shell — `BridgeShell`
+
+```typescript
+import { BridgeShell, BRIDGE_KEYS, type ShellPolicy } from '@condorinst/mobile-bridge';
+
+const iframe = document.getElementById('client-frame') as HTMLIFrameElement;
+
+const policy: ShellPolicy = {
+  readOnlyKeys: [
+    BRIDGE_KEYS.userDevice,
+    BRIDGE_KEYS.deviceConnection,
+    BRIDGE_KEYS.deviceLightSensors,
+    BRIDGE_KEYS.realTime,
+  ],
+  allowedCommands: ['userDevice', 'realTime', 'openSettings'],
+  requiresConfirmation: ['syncTime', 'deleteMemory'],
+  deniedCommands: ['dfu'],
+};
+
+const shell = new BridgeShell({
+  iframe,
+  policy,
+  onConfirmationRequest: async ({ command, args }) => {
+    return await showConfirmationModal(command, args); // shell UI
+  },
+});
+
+// Layer 1 — bootstrap with an override prefix.
+//
+// Use bootstrapClientIframe(clientPath) when HTML comes over HTTP:
+await shell.bootstrapClientIframe('https://api.condor.example/whitelabel/bundle.html');
+//
+// Use bootstrapClientIframeWithHtml(htmlString) when the HTML is already in
+// memory — required for an asset bundled at file:// (Android WebView cannot
+// fetch over file://), a build-time inlined bundle, etc:
+declare const __CLIENT_HTML__: string; // e.g. via esbuild.define
+await shell.bootstrapClientIframeWithHtml(__CLIENT_HTML__);
+
+// Layer 2 — iframe attestation.
+const verify = await shell.verifySandbox();
+if (!verify.ok) {
+  // Abort the boot — Layer 1 failed.
+  throw new Error('Sandbox compromised: bridges still reachable from iframe.');
+}
+
+// From here on, BridgeShell routes postMessage ↔ native Bridge
+// automatically. Nothing else to do at boot.
+```
+
+### Layered defense (propagation of `window.flutter_inappwebview`)
+
+| Layer | Where | What it does |
+|---|---|---|
+| **1** | `BridgeShell.bootstrapClientIframe` | `srcdoc` with a prefix that deletes `window.flutter_inappwebview` + `window.CondorBridge` before any client script runs. |
+| **2** | `BridgeShell.verifySandbox` + `BridgeClient` handler | Round-trip `postMessage` to attest the iframe state. |
+| **3** | (Native side) | Shell nonce validated natively in the Flutter bridge. |
+| **4** | (Fallback if 1+2 fail) | Dual `InAppWebView` — shell and client in separate WebViews. |
+
+## Build CLI — `condor-mobile-bridge build`
+
+Generates the **self-contained `.zip` bundle** that the white-label app
+consumes. The app injects the client HTML via `iframe.srcdoc` (origin `null`,
+no base URL) → **relative references do not resolve** and the CSP blocks
+external fetches; therefore the `.zip` must contain **a single `index.html`**
+with inline JS/CSS and media as `data:` URIs.
+
+The CLI does this from your build's `dist/`: it reads `index.html`, **inlines**
+`<script src>` (escaping `</script>`) and `<link rel=stylesheet>`, resolves CSS
+`url()` and local `<img>`/icons to `data:` URIs, and packs a `.zip` with
+`index.html` at the root. External refs (`https://…`) are **preserved** (and
+blocked by the app's CSP at runtime).
+
+```bash
+npx condor-mobile-bridge build -i dist/index.html -o dist/bundle.zip
+```
+
+| Option | Description |
+|---|---|
+| `-i, --html <path>` | Input HTML (e.g. `dist/index.html`). Required. |
+| `-o, --out <path>` | Output `.zip` (default: `dist/whitelabel-bundle.zip`). |
+| `--max-bytes <n>` | **Warning** threshold in bytes (default: `2097152` = 2 MB). |
+
+Output (for registering the bundle with the backend — `bundleSize`/`bundleHash`):
+
+```
+Built dist/bundle.zip
+  entry: index.html (123.4 KB self-contained)
+  bundleSize (zip): 45678 bytes
+  bundleHash (zip): sha256-<hex>
+```
+
+The hash is **deterministic** (fixed mtime on the zip entry) — the same input
+produces the same `bundleHash`. Above the threshold, the CLI **warns** (does
+not block): remember that **the app rejects** a `.zip` larger than 2 MB and
+falls back to the mock.
+
+> ⚠️ **Constraint: single-chunk build.** The inliner is post-build and assumes
+> a `dist` with **one JS + one CSS + assets**. Builds with **code-splitting /
+> ES modules** that `import` across chunks **break** in `srcdoc` (the imports
+> do not resolve). Configure your build to emit a single file:
+> - **Vite:** `vite-plugin-singlefile` (or `build.rollupOptions.output.inlineDynamicImports: true` + `manualChunks: undefined`).
+> - **CRA:** build without code-splitting (no `React.lazy`/dynamic `import()` in routes), single bundle.
+>
+> Inlining inflates `data:` media by ~33% (base64) — size against the 2 MB limit.
+
+## Key catalog (strictly typed)
+
+Mirrors the JS-facing side of the native foreground com keys. The strings here
+are what the JS receives via `window.CondorBridge.emit(key, payload)`.
+
+| `BRIDGE_KEYS.*` | Wire (JS) | Typed payload | Typical direction |
+|---|---|---|---|
+| `pingPong` | `'pingPong'` | `PingPongPayload = { data: 'ping' \| 'pong' }` | bidirectional |
+| `userDevice` | `'userDevice'` | `UserDevicePayload = { lastUpdate, devicesConfig[], devicesTelemetry[], devicesUserConfig[] }` | BG → JS |
+| `deviceLightSensors` | `'deviceLightSensors'` | `DeviceLightSensorsPayload = { serialNo, type, data }` | BG → JS |
+| `syncTime` | `'syncTime'` | `SyncTimeAckPayload = { serialNo, success }` | JS → BG (cmd) / BG → JS (ack) |
+| `realTime` | `'realTime'` | `RealTimeAckPayload = { serialNo, success, value }` | JS → BG (cmd) / BG → JS (state) |
+| `deleteMemory` | `'deleteMemory'` | `DeleteMemoryAckPayload = { serialNo, success }` | JS → BG (cmd) / BG → JS (ack) |
+| `deviceNotification` | `'deviceNotification'` | `DeviceNotificationPayload = { serialNo, isConnect, message, messageCode, isError }` | BG → JS |
+| `deviceConnection` | `'deviceConnection'` | `DeviceConnectionPayload = { serialNo, isConnect }` | BG → JS (status); JS → BG (`{type, serialNo}`, permissive) |
+| `sensorLog` | `'sensorLog'` | `SensorLogPayload` | BG → JS |
+| `dfu` | `'dfu'` | `Record<string, unknown>` (fallback) | BG → JS |
+
+**Automatic inference on `Bridge.on`:**
+
+```typescript
+Bridge.on(BRIDGE_KEYS.realTime, (payload) => {
+  // payload: RealTimeAckPayload — type-safe!
+  console.log(payload.serialNo, payload.success, payload.value);
+});
+```
+
+**`Bridge.send` commands** remain permissive (heterogeneous shapes per type).
+The client passes `Record<string, unknown>`.
+
+## Versioning policy (semver)
+
+- **PATCH** (`0.8.x`): bugfix with no API change.
+- **MINOR** (`0.x.0`): new observable key, new command, backward-compatible API.
+  > While on `0.x`, a minor bump may carry breaking changes (semver treats
+  > pre-1.0 minors as breaking). Pin `^0.8.0` to stay on safe patches.
+- **MAJOR** (`x.0.0`): incompatible schema change (key rename, payload shape
+  change, public API change). `1.0.0` marks the production-stable contract.
+
+The native side declares `nativeVersion` in the `handshake`; the client
+declares `clientVersion`. This release does **not** enforce hard semver
+validation — the native side accepts any `clientVersion`. Real validation will
+land once there are 2+ versions in the field.
+
+## Host detection
+
+The package detects automatically:
+
+- **Android / iOS** — `window.flutter_inappwebview` (via the `flutter_inappwebview` package on the Flutter side).
+- **Browser outside the app** (dev/test): **mock mode** activates automatically.
+
+## Mock mode
+
+When the package runs outside the Flutter WebView (regular browser, Vite dev
+server, Storybook), the adapter activates mock mode automatically. You can
+develop in the browser without building the APK.
+
+```typescript
+import { Bridge, BRIDGE_KEYS } from '@condorinst/mobile-bridge';
+
+if (Bridge.isMock) {
+  // Subscribe to a listener as usual
+  Bridge.on(BRIDGE_KEYS.deviceConnection, (payload) => {
+    console.log('Device:', payload);
+  });
+
+  // Simulate the native side sending an event
+  Bridge.mockEmit(BRIDGE_KEYS.deviceConnection, {
+    serialNo: 1234,
+    connected: true,
+  });
+}
+```
+
+### Handshake in mock is EXPLICIT
+
+```typescript
+// In mock, handshake does NOT resolve by itself — the client/test responds.
+const ackPromise = Bridge.handshake({ clientVersion: '1.0.0' });
+
+if (Bridge.isMock) {
+  Bridge.mockEmit('handshake-ack', {
+    nativeVersion: '0.1.0',
+    accepted: true,
+  });
+}
+
+const ack = await ackPromise;
+```
+
+Design decision: it forces tests to be intentional about the native state. In
+real mode (inside the Flutter WebView), the ack arrives naturally from native.
+
+### `Bridge.send` in mock
+
+Messages sent via `Bridge.send` (or helpers like `openSettings`) are recorded
+in an internal FIFO buffer (cap 100) + `console.debug`. Inspect via
+`Bridge.getMockState()`:
+
+```typescript
+Bridge.send('realTime', { enabled: true });
+
+const state = Bridge.getMockState();
+console.log(state.messages);
+// → [{ handlerName: 'CondorBridge', payload: {...}, timestamp: ... }]
+console.log(state.subscriberKeys);
+// → ['deviceConnection']
+```
+
+## Dev panel
+
+An opt-in HTML panel to inspect the bridge in the browser during development.
+
+```typescript
+import { Bridge } from '@condorinst/mobile-bridge';
+
+if (Bridge.isMock) {
+  Bridge.installDevPanel({
+    position: 'bottom-right',   // 'bottom-right' | 'bottom-left' | 'top-*'
+    maxMessages: 20,            // last N shown
+    theme: 'dark',              // 'dark' | 'light'
+    startCollapsed: false,
+  });
+}
+```
+
+Contents:
+
+- Header with a "MOCK" badge, sent counter, minimize button.
+- Sent log — last N messages (timestamp, type, truncated payload).
+- Trigger emit — dropdown of `BRIDGE_KEYS` + JSON textarea + "Emit" button
+  (fires `Bridge.mockEmit`) + "Clear sent" button.
+
+Idempotent — calling `installDevPanel` again replaces the previous panel.
+Throws if called in real mode (`!Bridge.isMock`).
+
+### Auto-respond toggle
+
+To close the full loop in the browser (client clicks a button → native
+responds → subscriber fires), pass a **policy** that maps `send` to `emit`.
+The package provides the **mechanism** (checkbox UI + hook); you provide the
+**policy** (app-specific mappings).
+
+```typescript
+import { Bridge, BRIDGE_KEYS } from '@condorinst/mobile-bridge';
+
+if (Bridge.isMock) {
+  Bridge.installDevPanel({
+    startAutoRespondEnabled: true, // default false
+    autoRespondDelayMs: 50,        // default 50 (simulates IPC)
+    onSendForAutoRespond(msg) {
+      const payload = msg.payload as { type?: string };
+      switch (payload?.type) {
+        case 'handshake':
+          return {
+            key: 'handshake-ack',
+            payload: { nativeVersion: '0.1.0 (mock)', accepted: true },
+          };
+        case 'ping':
+          return {
+            key: BRIDGE_KEYS.pingPong,
+            payload: { data: 'pong' },
+          };
+        default:
+          return null; // do not auto-respond to this send
+      }
+    },
+  });
+}
+```
+
+Behavior:
+
+- The toggle appears in the panel **only when** `onSendForAutoRespond` is
+  passed — without a policy, the panel keeps the manual-emit UX.
+- The toggle state persists in memory for the panel's lifetime. Re-install
+  resets to `startAutoRespondEnabled`.
+- Errors thrown by the policy or the internal `triggerEmit` are caught and
+  logged (`console.error`) — they do not destabilize the bridge.
+- Use `BRIDGE_KEYS` to avoid string-magic in the mappings.
+
+## Local development (SDK contributors)
+
+```bash
+npm install          # installs deps + runs prepare (build)
+npm run typecheck    # tsc --noEmit
+npm run lint         # biome check
+npm run format       # biome format --write
+npm run test         # vitest run
+npm run build        # tsup (ESM + CJS + types in dist/)
+```
+
+## Further reading
+
+- [Client Guide — Build your White Label Home](./docs/client-guide.md)
+- [`examples/minimal-home`](./examples/minimal-home) — runnable minimal client
+- [CHANGELOG](./CHANGELOG.md)
+
+## License
+
+Proprietary — Condor Instruments. See [LICENSE](./LICENSE).

package/dist/cli.cjs

@@ -0,0 +1,194 @@
+#!/usr/bin/env node
+"use strict";
+
+// src/cli.ts
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
+
+// src/cli-core.ts
+var import_node_crypto = require("crypto");
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_fflate = require("fflate");
+var import_node_html_parser = require("node-html-parser");
+var DEFAULT_MAX_BYTES = 2 * 1024 * 1024;
+var FIXED_MTIME = /* @__PURE__ */ new Date("2000-01-01T00:00:00Z");
+var MIME_TYPES = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".avif": "image/avif",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".bmp": "image/bmp",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".otf": "font/otf",
+  ".eot": "application/vnd.ms-fontobject",
+  ".mp3": "audio/mpeg",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".json": "application/json"
+};
+function isExternalOrInline(url) {
+  return /^(https?:)?\/\//i.test(url) || /^data:/i.test(url) || /^(mailto:|tel:|#)/i.test(url);
+}
+function stripQueryHash(url) {
+  return url.split(/[?#]/)[0] ?? url;
+}
+function resolveLocal(htmlRoot, resourceDir, url) {
+  const clean = stripQueryHash(url);
+  return clean.startsWith("/") ? (0, import_node_path.resolve)(htmlRoot, `.${clean}`) : (0, import_node_path.resolve)(resourceDir, clean);
+}
+function toDataUri(filePath) {
+  const bytes = (0, import_node_fs.readFileSync)(filePath);
+  const mime = MIME_TYPES[(0, import_node_path.extname)(filePath).toLowerCase()] ?? "application/octet-stream";
+  return `data:${mime};base64,${bytes.toString("base64")}`;
+}
+function inlineCssUrls(css, htmlRoot, cssDir) {
+  return css.replace(/url\(\s*(['"]?)([^'")]+)\1\s*\)/gi, (match, _quote, rawUrl) => {
+    if (isExternalOrInline(rawUrl)) return match;
+    const filePath = resolveLocal(htmlRoot, cssDir, rawUrl);
+    return `url(${toDataUri(filePath)})`;
+  });
+}
+function inlineScripts(root, htmlRoot) {
+  for (const el of root.querySelectorAll("script[src]")) {
+    const src = el.getAttribute("src");
+    if (!src || isExternalOrInline(src)) continue;
+    const js = (0, import_node_fs.readFileSync)(resolveLocal(htmlRoot, htmlRoot, src), "utf-8").replace(
+      /<\/script>/gi,
+      "<\\/script>"
+    );
+    el.removeAttribute("src");
+    el.set_content(js);
+  }
+}
+function inlineStylesheets(root, htmlRoot) {
+  for (const el of root.querySelectorAll('link[rel="stylesheet"]')) {
+    const href = el.getAttribute("href");
+    if (!href || isExternalOrInline(href)) continue;
+    const cssPath = resolveLocal(htmlRoot, htmlRoot, href);
+    const css = inlineCssUrls((0, import_node_fs.readFileSync)(cssPath, "utf-8"), htmlRoot, (0, import_node_path.dirname)(cssPath));
+    el.replaceWith(...(0, import_node_html_parser.parse)(`<style>${css}</style>`).childNodes);
+  }
+}
+function inlineExistingStyleBlocks(root, htmlRoot) {
+  for (const el of root.querySelectorAll("style")) {
+    const css = el.innerHTML;
+    if (!css.includes("url(")) continue;
+    el.set_content(inlineCssUrls(css, htmlRoot, htmlRoot));
+  }
+}
+function inlineMediaAttributes(root, htmlRoot) {
+  const targets = [
+    ["img[src]", "src"],
+    ["source[src]", "src"],
+    ["audio[src]", "src"],
+    ["video[src]", "src"],
+    ['link[rel="icon"]', "href"],
+    ['link[rel="shortcut icon"]', "href"],
+    ['link[rel="apple-touch-icon"]', "href"],
+    ['link[rel="preload"]', "href"]
+  ];
+  for (const [selector, attr] of targets) {
+    for (const el of root.querySelectorAll(selector)) {
+      const ref = el.getAttribute(attr);
+      if (!ref || isExternalOrInline(ref)) continue;
+      el.setAttribute(attr, toDataUri(resolveLocal(htmlRoot, htmlRoot, ref)));
+    }
+  }
+}
+function inlineHtml(htmlPath) {
+  const htmlRoot = (0, import_node_path.dirname)((0, import_node_path.resolve)(htmlPath));
+  const root = (0, import_node_html_parser.parse)((0, import_node_fs.readFileSync)(htmlPath, "utf-8"), {
+    comment: true,
+    voidTag: { closingSlash: true }
+  });
+  inlineScripts(root, htmlRoot);
+  inlineStylesheets(root, htmlRoot);
+  inlineExistingStyleBlocks(root, htmlRoot);
+  inlineMediaAttributes(root, htmlRoot);
+  return root.toString();
+}
+function buildBundle(htmlPath, maxBytes = DEFAULT_MAX_BYTES) {
+  const html = inlineHtml(htmlPath);
+  const zipBytes = (0, import_fflate.zipSync)({ "index.html": [(0, import_fflate.strToU8)(html), { mtime: FIXED_MTIME }] }, { level: 6 });
+  const size = zipBytes.length;
+  const hash = `sha256-${(0, import_node_crypto.createHash)("sha256").update(zipBytes).digest("hex")}`;
+  return { html, zipBytes, size, hash, overLimit: size > maxBytes };
+}
+var DEFAULT_OUT = "dist/whitelabel-bundle.zip";
+function parseArgs(argv) {
+  const args = {
+    htmlPath: "",
+    outPath: DEFAULT_OUT,
+    maxBytes: DEFAULT_MAX_BYTES,
+    help: false
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const token = argv[i];
+    switch (token) {
+      case "--help":
+      case "-h":
+        args.help = true;
+        break;
+      case "--html":
+      case "-i":
+        args.htmlPath = argv[++i] ?? "";
+        break;
+      case "--out":
+      case "-o":
+        args.outPath = argv[++i] ?? DEFAULT_OUT;
+        break;
+      case "--max-bytes":
+        args.maxBytes = Number.parseInt(argv[++i] ?? "", 10) || DEFAULT_MAX_BYTES;
+        break;
+      case "build":
+        break;
+      default:
+        if (token && !token.startsWith("-") && !args.htmlPath) args.htmlPath = token;
+    }
+  }
+  return args;
+}
+var USAGE = `condor-mobile-bridge build \u2014 gera o .zip white-label self-contained.
+
+Uso:
+  npx condor-mobile-bridge build -i <html> [-o <zip>]
+
+Op\xE7\xF5es:
+  -i, --html <path>    HTML de entrada (ex.: dist/index.html). Obrigat\xF3rio.
+  -o, --out <path>     .zip de sa\xEDda (default: ${DEFAULT_OUT}).
+      --max-bytes <n>  Limite de aviso em bytes (default: ${DEFAULT_MAX_BYTES} = 2 MB).
+  -h, --help           Mostra esta ajuda.`;
+
+// src/cli.ts
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help || !args.htmlPath) {
+    console.log(USAGE);
+    process.exit(args.help ? 0 : 1);
+  }
+  const result = buildBundle(args.htmlPath, args.maxBytes);
+  const outPath = (0, import_node_path2.resolve)(args.outPath);
+  (0, import_node_fs2.mkdirSync)((0, import_node_path2.dirname)(outPath), { recursive: true });
+  (0, import_node_fs2.writeFileSync)(outPath, result.zipBytes);
+  const kb = (Buffer.byteLength(result.html) / 1024).toFixed(1);
+  console.log(`Built ${args.outPath}`);
+  console.log(`  entry: index.html (${kb} KB self-contained)`);
+  console.log(`  bundleSize (zip): ${result.size} bytes`);
+  console.log(`  bundleHash (zip): ${result.hash}`);
+  if (result.overLimit) {
+    const limitMb = (args.maxBytes / (1024 * 1024)).toFixed(1);
+    console.warn(
+      `
+\u26A0\uFE0F  AVISO: o .zip (${result.size} bytes) excede o limite de ${limitMb} MB \u2014 o app vai REJEITAR este bundle (cai no mock). Reduza assets/m\xEDdias inline.`
+    );
+  }
+}
+main();
+//# sourceMappingURL=cli.cjs.map

package/dist/cli.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/cli.ts","../src/cli-core.ts"],"sourcesContent":["/**\n * cli.ts — Entry `bin` do `condor-mobile-bridge build`.\n *\n * Fino: parse de argv → `buildBundle` → escreve o `.zip` (mkdir recursivo) →\n * imprime tamanho + SHA-256 (formato que espelha `web-mock-src/build-demo.mjs`)\n * e avisa se passar do limite. Toda a lógica testável vive em `cli-core.ts`.\n */\nimport { mkdirSync, writeFileSync } from 'node:fs';\nimport { dirname, resolve } from 'node:path';\nimport { buildBundle, parseArgs, USAGE } from './cli-core';\n\nfunction main(): void {\n  const args = parseArgs(process.argv.slice(2));\n\n  if (args.help || !args.htmlPath) {\n    console.log(USAGE);\n    process.exit(args.help ? 0 : 1);\n  }\n\n  const result = buildBundle(args.htmlPath, args.maxBytes);\n\n  const outPath = resolve(args.outPath);\n  mkdirSync(dirname(outPath), { recursive: true });\n  writeFileSync(outPath, result.zipBytes);\n\n  const kb = (Buffer.byteLength(result.html) / 1024).toFixed(1);\n  console.log(`Built ${args.outPath}`);\n  console.log(`  entry: index.html (${kb} KB self-contained)`);\n  console.log(`  bundleSize (zip): ${result.size} bytes`);\n  console.log(`  bundleHash (zip): ${result.hash}`);\n\n  if (result.overLimit) {\n    const limitMb = (args.maxBytes / (1024 * 1024)).toFixed(1);\n    console.warn(\n      `\\n⚠️  AVISO: o .zip (${result.size} bytes) excede o limite de ${limitMb} MB — ` +\n        'o app vai REJEITAR este bundle (cai no mock). Reduza assets/mídias inline.',\n    );\n  }\n}\n\nmain();\n","/**\n * cli-core.ts — Núcleo (puro/testável) do CLI `condor-mobile-bridge build`.\n *\n * Materializa a Frente 1 da Opção A do bundle white-label: pega um\n * `dist/index.html` (build React/Vite do cliente), inlina JS em `<script>`,\n * CSS em `<style>` (resolvendo `url()` em `data:` URI), converte mídias\n * locais em `data:` URI e empacota num `.zip` com um único `index.html` na\n * raiz. Não toca o filesystem de saída — quem escreve o `.zip` é `cli.ts`.\n *\n * Modelo de render do app: `iframe.srcdoc` (origem `null`, sem base URL) só\n * resolve conteúdo inline + `data:` URI — por isso o bundle precisa ser\n * self-contained. Ver `condor_wiki/decisions/2026-06-22_whitelabel-bundle-format.md`.\n *\n * LIMITAÇÃO conhecida: o inliner pós-build assume `dist` single-chunk\n * (um JS + um CSS + assets). Builds com code-split / ES modules que fazem\n * `import` entre chunks quebram em `srcdoc` — o cliente deve buildar\n * single-file (Vite: `vite-plugin-singlefile`; CRA: sem split). Ver README.\n */\nimport { createHash } from 'node:crypto';\nimport { readFileSync } from 'node:fs';\nimport { dirname, extname, resolve } from 'node:path';\nimport { strToU8, zipSync } from 'fflate';\nimport { type HTMLElement, parse } from 'node-html-parser';\n\n/** Default do tamanho máximo do `.zip` (espelha `WhitelabelBundleLimits.maxZipBytes` no app). */\nexport const DEFAULT_MAX_BYTES = 2 * 1024 * 1024;\n\n/** Mtime fixo (>=1980, limite do formato ZIP) → SHA-256 reprodutível entre builds. */\nconst FIXED_MTIME = new Date('2000-01-01T00:00:00Z');\n\n/** Mapa de extensão → MIME para montar `data:` URIs de mídias embutidas. */\nexport const MIME_TYPES: Record<string, string> = {\n  '.png': 'image/png',\n  '.jpg': 'image/jpeg',\n  '.jpeg': 'image/jpeg',\n  '.gif': 'image/gif',\n  '.webp': 'image/webp',\n  '.avif': 'image/avif',\n  '.svg': 'image/svg+xml',\n  '.ico': 'image/x-icon',\n  '.bmp': 'image/bmp',\n  '.woff': 'font/woff',\n  '.woff2': 'font/woff2',\n  '.ttf': 'font/ttf',\n  '.otf': 'font/otf',\n  '.eot': 'application/vnd.ms-fontobject',\n  '.mp3': 'audio/mpeg',\n  '.mp4': 'video/mp4',\n  '.webm': 'video/webm',\n  '.json': 'application/json',\n};\n\n/** Refs que NÃO devem ser inlinadas: absolutas externas, protocol-relative, data: já-inline. */\nfunction isExternalOrInline(url: string): boolean {\n  return /^(https?:)?\\/\\//i.test(url) || /^data:/i.test(url) || /^(mailto:|tel:|#)/i.test(url);\n}\n\n/** Remove query/hash de uma ref local (`main.js?v=abc#x` → `main.js`). */\nfunction stripQueryHash(url: string): string {\n  return url.split(/[?#]/)[0] ?? url;\n}\n\n/**\n * Resolve uma ref local para caminho absoluto no filesystem.\n * `htmlRoot` é a raiz do site (dir do `index.html`); `resourceDir` é o dir do\n * recurso que contém a ref (p/ `url()` no CSS, é o dir do `.css`). Refs que\n * começam com `/` são relativas à raiz do site.\n */\nfunction resolveLocal(htmlRoot: string, resourceDir: string, url: string): string {\n  const clean = stripQueryHash(url);\n  return clean.startsWith('/') ? resolve(htmlRoot, `.${clean}`) : resolve(resourceDir, clean);\n}\n\n/** Lê um arquivo local e devolve uma `data:` URI base64. */\nexport function toDataUri(filePath: string): string {\n  const bytes = readFileSync(filePath);\n  const mime = MIME_TYPES[extname(filePath).toLowerCase()] ?? 'application/octet-stream';\n  return `data:${mime};base64,${bytes.toString('base64')}`;\n}\n\n/**\n * Resolve `url(...)` dentro de um bloco CSS, trocando refs locais por `data:`\n * URIs. `cssDir` é o dir do arquivo CSS (ou do HTML, p/ `<style>` inline).\n */\nexport function inlineCssUrls(css: string, htmlRoot: string, cssDir: string): string {\n  return css.replace(/url\\(\\s*(['\"]?)([^'\")]+)\\1\\s*\\)/gi, (match, _quote, rawUrl: string) => {\n    if (isExternalOrInline(rawUrl)) return match;\n    const filePath = resolveLocal(htmlRoot, cssDir, rawUrl);\n    return `url(${toDataUri(filePath)})`;\n  });\n}\n\n/** Inlina `<script src=\"local\">` → `<script>…</script>` (escapando `</script>`). */\nfunction inlineScripts(root: HTMLElement, htmlRoot: string): void {\n  for (const el of root.querySelectorAll('script[src]')) {\n    const src = el.getAttribute('src');\n    if (!src || isExternalOrInline(src)) continue;\n    const js = readFileSync(resolveLocal(htmlRoot, htmlRoot, src), 'utf-8').replace(\n      /<\\/script>/gi,\n      '<\\\\/script>',\n    );\n    el.removeAttribute('src');\n    el.set_content(js);\n  }\n}\n\n/** Inlina `<link rel=\"stylesheet\" href=\"local\">` → `<style>…</style>` (com `url()` resolvido). */\nfunction inlineStylesheets(root: HTMLElement, htmlRoot: string): void {\n  for (const el of root.querySelectorAll('link[rel=\"stylesheet\"]')) {\n    const href = el.getAttribute('href');\n    if (!href || isExternalOrInline(href)) continue;\n    const cssPath = resolveLocal(htmlRoot, htmlRoot, href);\n    const css = inlineCssUrls(readFileSync(cssPath, 'utf-8'), htmlRoot, dirname(cssPath));\n    el.replaceWith(...parse(`<style>${css}</style>`).childNodes);\n  }\n}\n\n/** Resolve `url()` em blocos `<style>` já existentes no HTML. */\nfunction inlineExistingStyleBlocks(root: HTMLElement, htmlRoot: string): void {\n  for (const el of root.querySelectorAll('style')) {\n    const css = el.innerHTML;\n    if (!css.includes('url(')) continue;\n    el.set_content(inlineCssUrls(css, htmlRoot, htmlRoot));\n  }\n}\n\n/** Converte mídias locais referenciadas por atributo (`src`/`href`) em `data:` URIs. */\nfunction inlineMediaAttributes(root: HTMLElement, htmlRoot: string): void {\n  const targets: Array<[selector: string, attr: string]> = [\n    ['img[src]', 'src'],\n    ['source[src]', 'src'],\n    ['audio[src]', 'src'],\n    ['video[src]', 'src'],\n    ['link[rel=\"icon\"]', 'href'],\n    ['link[rel=\"shortcut icon\"]', 'href'],\n    ['link[rel=\"apple-touch-icon\"]', 'href'],\n    ['link[rel=\"preload\"]', 'href'],\n  ];\n  for (const [selector, attr] of targets) {\n    for (const el of root.querySelectorAll(selector)) {\n      const ref = el.getAttribute(attr);\n      if (!ref || isExternalOrInline(ref)) continue;\n      el.setAttribute(attr, toDataUri(resolveLocal(htmlRoot, htmlRoot, ref)));\n    }\n  }\n}\n\n/**\n * Lê o HTML de entrada e devolve o HTML consolidado self-contained\n * (JS/CSS inline, mídias em `data:` URI). Não escreve nada em disco.\n */\nexport function inlineHtml(htmlPath: string): string {\n  const htmlRoot = dirname(resolve(htmlPath));\n  const root = parse(readFileSync(htmlPath, 'utf-8'), {\n    comment: true,\n    voidTag: { closingSlash: true },\n  });\n  inlineScripts(root, htmlRoot);\n  inlineStylesheets(root, htmlRoot);\n  inlineExistingStyleBlocks(root, htmlRoot);\n  inlineMediaAttributes(root, htmlRoot);\n  return root.toString();\n}\n\nexport interface BundleResult {\n  /** HTML consolidado self-contained. */\n  html: string;\n  /** Bytes do `.zip` (entry único `index.html` na raiz). */\n  zipBytes: Uint8Array;\n  /** Tamanho do `.zip` em bytes. */\n  size: number;\n  /** SHA-256 dos bytes do `.zip`, no formato `sha256-<hex>`. */\n  hash: string;\n  /** `true` se `size` excede `maxBytes`. */\n  overLimit: boolean;\n}\n\n/**\n * Constrói o bundle a partir do `index.html` de entrada: inlina, zipa\n * (entry `index.html` na raiz, mtime fixo p/ hash determinístico) e calcula\n * tamanho + SHA-256. Puro — não escreve o `.zip` (responsabilidade do caller).\n */\nexport function buildBundle(htmlPath: string, maxBytes: number = DEFAULT_MAX_BYTES): BundleResult {\n  const html = inlineHtml(htmlPath);\n  const zipBytes = zipSync({ 'index.html': [strToU8(html), { mtime: FIXED_MTIME }] }, { level: 6 });\n  const size = zipBytes.length;\n  const hash = `sha256-${createHash('sha256').update(zipBytes).digest('hex')}`;\n  return { html, zipBytes, size, hash, overLimit: size > maxBytes };\n}\n\nexport interface CliArgs {\n  htmlPath: string;\n  outPath: string;\n  maxBytes: number;\n  help: boolean;\n}\n\nconst DEFAULT_OUT = 'dist/whitelabel-bundle.zip';\n\n/** Parse mínimo de argv (sem deps): `--html/-i`, `--out/-o`, `--max-bytes`, `--help/-h`. */\nexport function parseArgs(argv: string[]): CliArgs {\n  const args: CliArgs = {\n    htmlPath: '',\n    outPath: DEFAULT_OUT,\n    maxBytes: DEFAULT_MAX_BYTES,\n    help: false,\n  };\n  for (let i = 0; i < argv.length; i++) {\n    const token = argv[i];\n    switch (token) {\n      case '--help':\n      case '-h':\n        args.help = true;\n        break;\n      case '--html':\n      case '-i':\n        args.htmlPath = argv[++i] ?? '';\n        break;\n      case '--out':\n      case '-o':\n        args.outPath = argv[++i] ?? DEFAULT_OUT;\n        break;\n      case '--max-bytes':\n        args.maxBytes = Number.parseInt(argv[++i] ?? '', 10) || DEFAULT_MAX_BYTES;\n        break;\n      case 'build':\n        // Subcomando (`condor-mobile-bridge build …`) — ignorado aqui.\n        break;\n      default:\n        // Primeiro posicional vira o html de entrada (ergonomia: `build dist/index.html`).\n        if (token && !token.startsWith('-') && !args.htmlPath) args.htmlPath = token;\n    }\n  }\n  return args;\n}\n\nexport const USAGE = `condor-mobile-bridge build — gera o .zip white-label self-contained.\n\nUso:\n  npx condor-mobile-bridge build -i <html> [-o <zip>]\n\nOpções:\n  -i, --html <path>    HTML de entrada (ex.: dist/index.html). Obrigatório.\n  -o, --out <path>     .zip de saída (default: ${DEFAULT_OUT}).\n      --max-bytes <n>  Limite de aviso em bytes (default: ${DEFAULT_MAX_BYTES} = 2 MB).\n  -h, --help           Mostra esta ajuda.`;\n"],"mappings":"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","names":["import_node_fs","import_node_path"]}