@condorinst/mobile-bridge 0.19.2 → 0.21.0

package/dist/cli.js

@@ -2,7 +2,7 @@
 
 // src/cli.ts
 import { mkdirSync, writeFileSync } from "fs";
-import { dirname as dirname2, resolve as resolve2 } from "path";
+import { dirname as dirname3, resolve as resolve3 } from "path";
 
 // src/cli-core.ts
 import { createHash } from "crypto";
@@ -167,8 +167,16 @@ var BLOCKED_API_RULES = [
     message: "connect-src 'self' on a null origin blocks every network call. Request data through the bridge instead (e.g. BridgeClient.fetchSensorLog)."
   }
 ];
+var DEV_HARNESS_MARKER = "__condorDevHarness__";
 function lintClientHtml(html) {
   const findings = [];
+  if (html.includes(DEV_HARNESS_MARKER)) {
+    findings.push({
+      severity: "error",
+      rule: "dev-harness-bundled",
+      message: "The bundle contains the development harness (@condorinst/mobile-bridge/dev). It belongs in the page that hosts the bundle during development, never in the bundle: remove the import."
+    });
+  }
   for (const { rule, pattern, message } of BLOCKED_API_RULES) {
     if (pattern.test(html)) findings.push({ severity: "warning", rule, message });
   }
@@ -276,6 +284,7 @@ function validateBundle(inputPath, maxBytes = DEFAULT_MAX_BYTES) {
   };
 }
 var DEFAULT_OUT = "dist/whitelabel-bundle.zip";
+var DEFAULT_DEV_PORT = 5173;
 function parseArgs(argv) {
   const args = {
     command: "build",
@@ -283,6 +292,9 @@ function parseArgs(argv) {
     outPath: DEFAULT_OUT,
     maxBytes: DEFAULT_MAX_BYTES,
     strict: false,
+    scenario: "default",
+    port: DEFAULT_DEV_PORT,
+    nativeVersion: void 0,
     help: false
   };
   for (let i = 0; i < argv.length; i++) {
@@ -313,6 +325,18 @@ function parseArgs(argv) {
       case "validate":
         args.command = "validate";
         break;
+      case "dev":
+        args.command = "dev";
+        break;
+      case "--scenario":
+        args.scenario = argv[++i] ?? "default";
+        break;
+      case "--native-version":
+        args.nativeVersion = argv[++i] ?? "null";
+        break;
+      case "--port":
+        args.port = Number.parseInt(argv[++i] ?? "", 10) || DEFAULT_DEV_PORT;
+        break;
       default:
         if (token && !token.startsWith("-") && !args.htmlPath) args.htmlPath = token;
     }
@@ -324,24 +348,421 @@ var USAGE = `condor-mobile-bridge \u2014 tooling for Condor Canvas client bundle
 Usage:
   npx condor-mobile-bridge build    -i <html> [-o <zip>]
   npx condor-mobile-bridge validate -i <zip|html> [--strict]
+  npx condor-mobile-bridge dev      -i <html|zip|dir> [--scenario <name>] [--native-version <v|null>] [--port <n>]
 
 Commands:
   build      Inline a dist/index.html into a self-contained .zip.
   validate   Check a bundle against every rule the Canvas app enforces, plus
              the APIs the sandbox and the CSP block at runtime.
+  dev        Serve the bundle in a browser harness that behaves like the app:
+             same sandbox, shell and policy, and a simulated native side.
+             Re-reads the input on every reload. Scenarios: default,
+             cold-start, no-devices, shared-serial, offline.
 
 Options:
   -i, --html <path>    Input. build: dist/index.html. validate: .zip or .html. Required.
   -o, --out <path>     build only: output .zip (default: ${DEFAULT_OUT}).
       --max-bytes <n>  Size limit in bytes (default: ${DEFAULT_MAX_BYTES} = 2 MB).
       --strict         validate only: exit 1 on warnings too, not just errors.
+      --scenario <n>   dev only: device behaviour to simulate (default: default).
+      --port <n>       dev only: HTTP port (default: ${DEFAULT_DEV_PORT}).
+      --native-version <v|null>
+                       dev only: nativeVersion the harness reports (default
+                       0.17.0). 'null' reproduces a shell that could not
+                       reach the native side.
   -h, --help           Show this help.`;
 
+// src/cli-dev.ts
+import { existsSync, readFileSync as readFileSync2, statSync } from "fs";
+import { createServer } from "http";
+import { dirname as dirname2, extname as extname2, join, resolve as resolve2 } from "path";
+import { fileURLToPath } from "url";
+import { strFromU8, unzipSync as unzipSync2 } from "fflate";
+
+// src/keys.ts
+var BRIDGE_KEYS = {
+  pingPong: "pingPong",
+  userDevice: "userDevice",
+  deviceLightSensors: "deviceLightSensors",
+  syncTime: "syncTime",
+  realTime: "realTime",
+  deleteMemory: "deleteMemory",
+  deviceNotification: "deviceNotification",
+  deviceConnection: "deviceConnection",
+  sensorLog: "sensorLog",
+  dfu: "dfu",
+  systemStatus: "systemStatus",
+  /**
+   * Native → client: the OS back button was pressed and the client had
+   * reported internal history via `reportNavigation(true)`. Go back exactly
+   * ONE internal page. Emitted only when the native side decided to delegate
+   * the back gesture. See `BridgeClient.onBack`.
+   */
+  navigationBack: "navigationBack",
+  /**
+   * Native → client: the app's language state. Carries the raw device locale
+   * AND the language explicitly chosen in the app Settings, so the client can
+   * apply its own precedence rule — including rendering a language the native
+   * chrome does not support. Emitted on attach, after `handshake-ack`, and on
+   * every change in Settings. See `LanguagePayload`.
+   */
+  language: "language"
+};
+
+// src/dev/policy.ts
+var CANVAS_POLICY = {
+  readOnlyKeys: [
+    BRIDGE_KEYS.userDevice,
+    BRIDGE_KEYS.deviceConnection,
+    BRIDGE_KEYS.deviceLightSensors,
+    BRIDGE_KEYS.deviceNotification,
+    BRIDGE_KEYS.pingPong,
+    BRIDGE_KEYS.realTime,
+    BRIDGE_KEYS.syncTime,
+    BRIDGE_KEYS.deleteMemory,
+    BRIDGE_KEYS.sensorLog,
+    BRIDGE_KEYS.systemStatus,
+    BRIDGE_KEYS.navigationBack,
+    BRIDGE_KEYS.language
+  ],
+  allowedCommands: [
+    "userDevice",
+    "realTime",
+    "openSettings",
+    "deviceConnection",
+    "ping",
+    "jsError",
+    "sensorLog",
+    "setStatusBarColor",
+    "requestPermission",
+    "navigationState",
+    "language"
+  ],
+  requiresConfirmation: ["syncTime", "deleteMemory", "logout"],
+  deniedCommands: ["dfu"]
+};
+var CANVAS_CSP = "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; font-src 'self' data:; connect-src 'self'; frame-src 'self'; object-src 'none'; base-uri 'none'; form-action 'none';";
+
+// src/dev/fixtures.ts
+function config(spec) {
+  const item = {
+    deviceId: spec.deviceId,
+    serialNo: spec.serialNo,
+    deviceBodyPart: spec.bodyPart,
+    bleConnectionPeriod: 5,
+    autosync: true,
+    eraseDeviceMemory: false,
+    autoEraseDeviceMemory: false,
+    autoEraseDeviceMemoryThreshold: 80,
+    readSensorsMemory: false,
+    startDevice: false,
+    readFullMemory: false,
+    allowFirmwareUpdate: true
+  };
+  if (spec.modelId) item.modelId = spec.modelId;
+  return item;
+}
+function telemetry(spec, now) {
+  return {
+    serialNo: spec.serialNo,
+    deviceId: spec.deviceId,
+    updataDateTime: now - spec.syncedMinutesAgo * 6e4,
+    deviceName: spec.name,
+    deviceVersion: spec.modelId === "actlumus_plus" ? "3.0.2" : "2.1.0",
+    hardwareVersion: spec.modelId === "actlumus_plus" ? "B" : "A",
+    deviceDateTime: now - spec.syncedMinutesAgo * 6e4,
+    memoryDataUsage: 37.5,
+    memorySystemUsage: 4.2,
+    batteryLevel: spec.battery,
+    batteryVoltage: 3.7 + spec.battery / 1e3,
+    isCharging: spec.charging,
+    isOnDock: spec.charging,
+    syncErrors: spec.syncError ? [
+      {
+        serialNo: spec.serialNo,
+        attemptDate: now - 10 * 6e4,
+        message: spec.syncError,
+        messageCode: "SYNC_FAILED"
+      }
+    ] : []
+  };
+}
+function userConfig(spec) {
+  return {
+    serialNo: spec.serialNo,
+    deviceId: spec.deviceId,
+    syncTime: false,
+    realTime: false,
+    deleteMemory: false,
+    readAllMemory: false,
+    readAllSystemLog: false
+  };
+}
+function payloadOf(specs, now = Date.now()) {
+  return {
+    lastUpdate: now,
+    devicesConfig: specs.map(config),
+    devicesTelemetry: specs.map((s) => telemetry(s, now)),
+    devicesUserConfig: specs.map(userConfig)
+  };
+}
+function twoDevices(now = Date.now()) {
+  return payloadOf(
+    [
+      {
+        deviceId: 9001,
+        serialNo: 4534,
+        modelId: "actlumus",
+        bodyPart: "wrist",
+        name: "ActLumus 4534",
+        battery: 82,
+        charging: false,
+        syncedMinutesAgo: 12
+      },
+      {
+        deviceId: 9002,
+        serialNo: 5120,
+        modelId: "actlumus_plus",
+        bodyPart: "necklace",
+        name: "ActLumus Plus 5120",
+        battery: 41,
+        charging: true,
+        syncedMinutesAgo: 190,
+        syncError: "Could not read the device memory."
+      }
+    ],
+    now
+  );
+}
+function sharedSerial(now = Date.now()) {
+  return payloadOf(
+    [
+      {
+        deviceId: 9101,
+        serialNo: 7047,
+        bodyPart: "wrist",
+        name: "ActLumus 7047",
+        battery: 67,
+        charging: false,
+        syncedMinutesAgo: 30
+      },
+      {
+        deviceId: 9102,
+        serialNo: 7047,
+        modelId: "actlumus_plus",
+        bodyPart: "necklace",
+        name: "ActLumus Plus 7047",
+        battery: 93,
+        charging: false,
+        syncedMinutesAgo: 8
+      }
+    ],
+    now
+  );
+}
+function systemStatus(overrides = {}) {
+  return {
+    bluetooth: true,
+    internet: true,
+    permission: true,
+    hasDevices: true,
+    missingOptionalPermissions: [],
+    missingEssentialPermissions: [],
+    deviceSyncError: {},
+    deviceSyncErrorById: {},
+    ...overrides
+  };
+}
+
+// src/dev/scenarios.ts
+var HARNESS_NATIVE_VERSION = "0.17.0";
+var base = {
+  description: "Two devices, background service already running, realistic latency.",
+  nativeVersion: HARNESS_NATIVE_VERSION,
+  latencyMs: [80, 250],
+  serviceStartMs: 0,
+  userDeviceSilent: false,
+  logPeriodS: 60,
+  systemStatus: systemStatus(),
+  devices: () => twoDevices()
+};
+var SCENARIOS = {
+  default: base,
+  "cold-start": {
+    ...base,
+    description: "App launched from cold: the background service takes 4 s to start, and every ping/userDevice sent before that is lost. A bundle that asks once stays on its loading screen forever.",
+    serviceStartMs: 4e3
+  },
+  "no-devices": {
+    ...base,
+    description: "Account with no linked device: userDevice never answers and systemStatus.hasDevices is false. Your bundle must show an empty state.",
+    userDeviceSilent: true,
+    systemStatus: systemStatus({ hasDevices: false })
+  },
+  "shared-serial": {
+    ...base,
+    description: "An ActLumus and an ActLumus Plus share serial number 7047. Only deviceId tells them apart; sensorLog cannot address one of them.",
+    devices: () => sharedSerial()
+  },
+  offline: {
+    ...base,
+    description: "No internet. systemStatus.internet is false and sensorLog fails; userDevice answers from the cache.",
+    sensorLogError: "Connection failed",
+    systemStatus: systemStatus({ internet: false })
+  }
+};
+
+// src/cli-dev.ts
+function readClientHtml(input) {
+  const path = resolve2(input);
+  if (existsSync(path) && statSync(path).isDirectory()) {
+    return inlineHtml(join(path, "index.html"));
+  }
+  if (extname2(path).toLowerCase() === ".zip") {
+    const files = unzipSync2(new Uint8Array(readFileSync2(path)));
+    const entry = files["index.html"];
+    if (!entry) throw new Error(`${input}: no index.html at the root of the zip.`);
+    return strFromU8(entry);
+  }
+  return inlineHtml(path);
+}
+var escapeHtml = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+function harnessPage(scenario, nativeVersion) {
+  const options = Object.entries(SCENARIOS).map(
+    ([name, s]) => `<option value="${name}" title="${escapeHtml(s.description)}"${name === scenario ? " selected" : ""}>${name}</option>`
+  ).join("");
+  const description = escapeHtml(SCENARIOS[scenario]?.description ?? "");
+  const scenarioJson = JSON.stringify(scenario).replace(/</g, "\\u003c");
+  const nativeJson = JSON.stringify(
+    nativeVersion === void 0 ? void 0 : nativeVersion === "null" ? null : nativeVersion
+  )?.replace(/</g, "\\u003c") ?? "undefined";
+  const nativeLabel = escapeHtml(
+    nativeVersion === void 0 ? "" : `nativeVersion ${nativeVersion}`
+  );
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta http-equiv="Content-Security-Policy" content="${CANVAS_CSP}">
+<title>Condor Canvas \u2014 dev harness</title>
+<style>
+  body { margin: 0; font: 13px system-ui, sans-serif; background: #e9ebef; color: #1b1f24; }
+  header { display: flex; gap: 12px; align-items: center; padding: 8px 16px; background: #1b1f24; color: #fff; flex-wrap: wrap; }
+  header p { margin: 0; opacity: .8; flex: 1 1 320px; }
+  main { display: flex; justify-content: center; padding: 16px; }
+  #device { width: 390px; height: 780px; max-width: 100%; border-radius: 28px; overflow: hidden; box-shadow: 0 10px 40px rgba(0,0,0,.25); background: #fff; }
+</style>
+</head>
+<body>
+<header>
+  <strong>Condor Canvas \xB7 dev harness</strong>
+  <label>Scenario <select id="scenario">${options}</select></label>
+  <button id="back" type="button" title="The OS back button: reaches the bundle only after it reported canGoBack true">\u25C0 OS back</button>
+  <span>${nativeLabel}</span>
+  <p>${description}</p>
+</header>
+<main><div id="device"></div></main>
+<script src="/__condor/harness.js"></script>
+<script>
+  var scenario = ${scenarioJson};
+  var nativeVersion = ${nativeJson};
+  var harness = null;
+  document.getElementById('scenario').addEventListener('change', function (e) {
+    var params = new URLSearchParams(location.search);
+    params.set('scenario', e.target.value);
+    location.search = params.toString();
+  });
+  document.getElementById('back').addEventListener('click', function () {
+    if (harness) harness.pressBack();
+  });
+  var chosen = CondorDevHarness.SCENARIOS[scenario];
+  if (nativeVersion !== undefined) chosen = Object.assign({}, chosen, { nativeVersion: nativeVersion });
+  fetch('/__condor/client.html')
+    .then(function (r) { if (!r.ok) throw new Error('could not read the bundle: HTTP ' + r.status); return r.text(); })
+    .then(function (html) {
+      return CondorDevHarness.createDevHarness({ html: html, scenario: chosen, mount: document.getElementById('device') });
+    })
+    .then(function (h) { harness = h; })
+    .catch(function (err) { document.getElementById('device').textContent = String(err); console.error(err); });
+</script>
+</body>
+</html>`;
+}
+function harnessScriptPath() {
+  const here = typeof __dirname !== "undefined" ? __dirname : dirname2(fileURLToPath(import.meta.url));
+  return join(here, "dev-harness.global.js");
+}
+function startDevServer(opts) {
+  if (!(opts.scenario in SCENARIOS)) {
+    throw new Error(
+      `Unknown scenario "${opts.scenario}". Known: ${Object.keys(SCENARIOS).join(", ")}.`
+    );
+  }
+  readClientHtml(opts.input);
+  const server = createServer((req, res) => {
+    const url = new URL(req.url ?? "/", "http://localhost");
+    try {
+      if (url.pathname === "/__condor/client.html") {
+        res.writeHead(200, {
+          "content-type": "text/html; charset=utf-8",
+          "cache-control": "no-store"
+        });
+        res.end(readClientHtml(opts.input));
+        return;
+      }
+      if (url.pathname === "/__condor/harness.js") {
+        res.writeHead(200, {
+          "content-type": "text/javascript; charset=utf-8",
+          "cache-control": "no-store"
+        });
+        res.end(readFileSync2(harnessScriptPath()));
+        return;
+      }
+      if (url.pathname === "/") {
+        const scenario = url.searchParams.get("scenario") ?? opts.scenario;
+        res.writeHead(200, {
+          "content-type": "text/html; charset=utf-8",
+          "content-security-policy": CANVAS_CSP,
+          "cache-control": "no-store"
+        });
+        const nativeVersion = url.searchParams.get("nativeVersion") ?? opts.nativeVersion;
+        res.end(harnessPage(scenario in SCENARIOS ? scenario : opts.scenario, nativeVersion));
+        return;
+      }
+      res.writeHead(404).end();
+    } catch (err) {
+      res.writeHead(500, { "content-type": "text/plain; charset=utf-8" });
+      res.end(String(err instanceof Error ? err.message : err));
+    }
+  });
+  server.listen(opts.port, "127.0.0.1");
+  return server;
+}
+
 // src/cli.ts
+function runDev(input, scenario, port, nativeVersion) {
+  const server = startDevServer({ input, scenario, port, nativeVersion });
+  server.on("listening", () => {
+    const native = nativeVersion === void 0 ? "" : `&nativeVersion=${nativeVersion}`;
+    console.log(
+      `Condor Canvas dev harness: http://localhost:${port}/?scenario=${scenario}${native}`
+    );
+    console.log(`  bundle:   ${input} (re-read on every reload)`);
+    console.log("  sandbox, shell policy and CSP: same as the app");
+    console.log("  scenarios: default, cold-start, no-devices, shared-serial, offline");
+    console.log('  OS back button: the "\u25C0 OS back" button at the top');
+    console.log("\nA bundle is ready for a device only when it handles every scenario.");
+  });
+  server.on("error", (err) => {
+    console.error(`dev: ${err.message}`);
+    process.exit(1);
+  });
+}
 function runBuild(htmlPath, outPath, maxBytes) {
   const result = buildBundle(htmlPath, maxBytes);
-  const resolvedOut = resolve2(outPath);
-  mkdirSync(dirname2(resolvedOut), { recursive: true });
+  const resolvedOut = resolve3(outPath);
+  mkdirSync(dirname3(resolvedOut), { recursive: true });
   writeFileSync(resolvedOut, result.zipBytes);
   const kb = (Buffer.byteLength(result.html) / 1024).toFixed(1);
   console.log(`Built ${outPath}`);
@@ -396,6 +817,15 @@ function main() {
     console.log(USAGE);
     process.exit(args.help ? 0 : 1);
   }
+  if (args.command === "dev") {
+    try {
+      runDev(args.htmlPath, args.scenario, args.port, args.nativeVersion);
+    } catch (err) {
+      console.error(`dev: ${err instanceof Error ? err.message : String(err)}`);
+      process.exit(1);
+    }
+    return;
+  }
   if (args.command === "validate") {
     const result = validateBundle(args.htmlPath, args.maxBytes);
     process.exit(reportValidation(args.htmlPath, result, args.strict));