@condorinst/mobile-bridge 0.21.0 → 0.22.0

package/dist/cli.cjs

@@ -2,8 +2,16 @@
 "use strict";
 
 // src/cli.ts
-var import_node_fs3 = require("fs");
-var import_node_path3 = require("path");
+var import_node_fs4 = require("fs");
+var import_node_path4 = require("path");
+
+// package.json
+var version = "0.22.0";
+
+// src/canvas-admin/command.ts
+var import_node_crypto2 = require("crypto");
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
 
 // src/cli-core.ts
 var import_node_crypto = require("crypto");
@@ -349,12 +357,15 @@ 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 canvas   publish|list|revoke ...   (see: canvas --help)
   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.
+  canvas     Publish, list and revoke the bundle of your company in the
+             Condor Canvas app (interactive login). See: canvas --help.
   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,
@@ -373,10 +384,477 @@ Options:
                        reach the native side.
   -h, --help           Show this help.`;
 
+// src/canvas-admin/client.ts
+var CANVAS_ADMIN_API = {
+  prod: "https://api.sleepdiary.condorapps.net",
+  dev: "https://dev.sleepdiary.condorapps.net"
+};
+var CanvasAdminError = class extends Error {
+  constructor(message, status, reason) {
+    super(message);
+    this.status = status;
+    this.reason = reason;
+    this.name = "CanvasAdminError";
+  }
+};
+function tokenFrom(headers) {
+  const values = typeof headers.getSetCookie === "function" ? headers.getSetCookie() : [headers.get("set-cookie") ?? ""];
+  for (const value of values) {
+    const match = /(?:^|[,;\s])token=([^;,\s]*)/.exec(value);
+    if (match?.[1]) return match[1];
+  }
+  return null;
+}
+async function reasonFrom(response) {
+  try {
+    const body = await response.json();
+    for (const key of ["error", "message", "description", "code"]) {
+      const value = body[key];
+      if (typeof value === "string" && value) return value;
+    }
+  } catch {
+  }
+  return null;
+}
+var CanvasAdminClient = class {
+  constructor(opts) {
+    this.token = null;
+    this.baseUrl = opts.baseUrl.replace(/\/+$/, "");
+    this.userAgent = opts.userAgent;
+    this.fetchImpl = opts.fetchImpl ?? fetch;
+    this.timeoutMs = opts.timeoutMs ?? 6e4;
+  }
+  async request(path, init = {}) {
+    const headers = new Headers(init.headers);
+    headers.set("user-agent", this.userAgent);
+    headers.set("accept", "application/json");
+    if (this.token) headers.set("cookie", `token=${this.token}`);
+    try {
+      return await this.fetchImpl(`${this.baseUrl}${path}`, {
+        ...init,
+        headers,
+        redirect: "manual",
+        signal: AbortSignal.timeout(this.timeoutMs)
+      });
+    } catch (err) {
+      throw new CanvasAdminError(
+        `Could not reach ${this.baseUrl}: ${err instanceof Error ? err.message : String(err)}`,
+        0,
+        null
+      );
+    }
+  }
+  async fail(response, what) {
+    const reason = await reasonFrom(response);
+    throw new CanvasAdminError(
+      `${what} failed (HTTP ${response.status})${reason ? `: ${reason}` : ""}`,
+      response.status,
+      reason
+    );
+  }
+  /**
+   * Logs in. Resolves `{ needsCode: true }` when the company requires a
+   * two-factor code (sent by e-mail): call {@link verifyCode} next.
+   */
+  async login(creds) {
+    const response = await this.request("/auth/login", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        company_id: creds.companyId,
+        user_id: creds.userId,
+        password: creds.password
+      })
+    });
+    if (!response.ok) await this.fail(response, "Login");
+    const token = tokenFrom(response.headers);
+    if (!token) throw new CanvasAdminError("Login answered without a session cookie", 200, null);
+    this.token = token;
+    const body = await response.json().catch(() => ({}));
+    return { needsCode: body.completed_auth_flow === false };
+  }
+  /** Sends the two-factor (or recovery) code; the server swaps the session cookie. */
+  async verifyCode(code) {
+    const response = await this.request("/auth/verify_2fa", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ otp_code: code })
+    });
+    if (!response.ok) await this.fail(response, "Two-factor verification");
+    const token = tokenFrom(response.headers);
+    if (token) this.token = token;
+  }
+  /**
+   * Publishes a bundle. **It goes live at once** for every user of the
+   * company: there is no draft. A version can be published only once per
+   * company (HTTP 409).
+   */
+  async publish(input) {
+    const form = new FormData();
+    form.set(
+      "bundle",
+      new Blob([input.zipBytes], { type: "application/zip" }),
+      "bundle.zip"
+    );
+    form.set("version", input.version);
+    if (input.companyId !== void 0) form.set("company_id", String(input.companyId));
+    if (input.minAppVersion) form.set("min_app_version", input.minAppVersion);
+    const response = await this.request("/v2/condor_canvas/bundles", {
+      method: "POST",
+      body: form
+    });
+    if (!response.ok) await this.fail(response, "Publish");
+    const body = await response.json();
+    return body.data;
+  }
+  /** Lists the bundles of a company (a manager always sees their own). */
+  async list(companyId) {
+    const query = companyId === void 0 ? "" : `?company_id=${companyId}`;
+    const response = await this.request(`/v2/condor_canvas/bundles${query}`);
+    if (!response.ok) await this.fail(response, "List");
+    const body = await response.json();
+    return body.data;
+  }
+  /**
+   * Revokes a bundle. Without `fallbackVersion`, revoking the current bundle
+   * leaves the company with none: the app shows its default screen.
+   */
+  async revoke(bundleId, fallbackVersion) {
+    const response = await this.request(`/v2/condor_canvas/bundles/${bundleId}/revoke`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(fallbackVersion ? { fallbackVersion } : {})
+    });
+    if (!response.ok) await this.fail(response, "Revoke");
+    const body = await response.json();
+    return body.data;
+  }
+};
+
+// src/canvas-admin/command.ts
+var CANVAS_USAGE = `condor-mobile-bridge canvas \u2014 publish a bundle to the Condor Canvas app.
+
+Usage:
+  npx condor-mobile-bridge canvas publish <dist/index.html|dir|bundle.zip> --version <v> [options]
+  npx condor-mobile-bridge canvas list    [options]
+  npx condor-mobile-bridge canvas revoke  <bundleId> [--fallback-version <v>] [options]
+
+Publishing goes LIVE AT ONCE for every user of the company \u2014 there is no draft.
+Use a test company, and see docs/device-testing.md.
+
+Options:
+  --company <id>          Company id, as in the Condor web login (or CONDOR_CANVAS_COMPANY).
+  --user <id>             Your user id, as in the Condor web login (or CONDOR_CANVAS_USER).
+                          Both are asked when not given.
+  --version <v>           publish: bundle version, unique per company.
+  --min-app-version <v>   publish: minimum app build that may load it.
+  --fallback-version <v>  revoke: VERSION to serve instead (the version column of
+                          canvas list, e.g. 0.0.8 \u2014 not the id).
+  --env prod|dev          API environment (default: prod). dev is for Condor staff.
+  --base-url <url>        Override the API URL.
+  --yes                   Do not ask for confirmation.
+  --json                  Print results as JSON.
+
+Your password (and the two-factor code, when your company uses one) is asked
+interactively, without echo, and never stored. There is no non-interactive login.`;
+var intOrUndefined = (value) => {
+  if (value === void 0) return void 0;
+  const n = Number(value);
+  return Number.isInteger(n) && n > 0 ? n : Number.NaN;
+};
+function parseCanvasArgs(argv, env = {}) {
+  const [action, ...rest] = argv;
+  if (action !== "publish" && action !== "list" && action !== "revoke") {
+    return { error: `Unknown canvas command "${action ?? ""}". Use publish, list or revoke.` };
+  }
+  const args = {
+    action,
+    env: "prod",
+    yes: false,
+    json: false,
+    companyId: intOrUndefined(env.CONDOR_CANVAS_COMPANY),
+    userId: intOrUndefined(env.CONDOR_CANVAS_USER)
+  };
+  const positional = [];
+  for (let i = 0; i < rest.length; i++) {
+    const token = rest[i] ?? "";
+    const next = () => rest[++i];
+    switch (token) {
+      case "--env": {
+        const env2 = next();
+        if (env2 !== "prod" && env2 !== "dev") return { error: "--env must be prod or dev." };
+        args.env = env2;
+        break;
+      }
+      case "--base-url":
+        args.baseUrl = next();
+        break;
+      case "--company":
+        args.companyId = intOrUndefined(next());
+        break;
+      case "--user":
+        args.userId = intOrUndefined(next());
+        break;
+      case "--version":
+        args.version = next();
+        break;
+      case "--min-app-version":
+        args.minAppVersion = next();
+        break;
+      case "--fallback-version":
+        args.fallbackVersion = next();
+        break;
+      case "--yes":
+        args.yes = true;
+        break;
+      case "--json":
+        args.json = true;
+        break;
+      case "--password":
+        return {
+          error: "There is no --password flag: the password is only read from the prompt."
+        };
+      default:
+        if (token.startsWith("-")) return { error: `Unknown option ${token}.` };
+        positional.push(token);
+    }
+  }
+  if (Number.isNaN(args.companyId) || Number.isNaN(args.userId)) {
+    return {
+      error: "--company and --user (or CONDOR_CANVAS_COMPANY / CONDOR_CANVAS_USER) take a positive integer id."
+    };
+  }
+  if (action === "publish") {
+    args.input = positional[0];
+    if (!args.input)
+      return { error: "canvas publish needs the bundle: dist/index.html, a dir or a .zip." };
+    if (!args.version) return { error: "canvas publish needs --version." };
+  }
+  if (action === "revoke") {
+    args.bundleId = intOrUndefined(positional[0]);
+    if (!args.bundleId || Number.isNaN(args.bundleId)) {
+      return { error: "canvas revoke needs the bundle id (see canvas list)." };
+    }
+  }
+  return args;
+}
+function loadZip(input) {
+  const path = (0, import_node_path2.resolve)(input);
+  if (!(0, import_node_fs2.existsSync)(path)) throw new Error(`${input}: not found.`);
+  let zipBytes;
+  if ((0, import_node_path2.extname)(path).toLowerCase() === ".zip") {
+    zipBytes = new Uint8Array((0, import_node_fs2.readFileSync)(path));
+  } else {
+    const html = (0, import_node_fs2.statSync)(path).isDirectory() ? (0, import_node_path2.join)(path, "index.html") : path;
+    zipBytes = buildBundle(html).zipBytes;
+  }
+  return { zipBytes, findings: validateZipBytes(zipBytes).findings };
+}
+async function askId(io, label, value) {
+  if (value !== void 0) return value;
+  const answer = (await io.ask(`${label}: `)).trim();
+  const n = Number(answer);
+  if (!Number.isInteger(n) || n <= 0) throw new Error(`${label} must be a positive integer.`);
+  return n;
+}
+async function confirm(io, args, question2) {
+  if (args.yes) return true;
+  const answer = (await io.ask(`${question2} [y/N] `)).trim().toLowerCase();
+  return answer === "y" || answer === "yes";
+}
+async function logIn(io, client, companyId, userId) {
+  io.print("");
+  io.print("Log in with your Condor web account (typing is hidden; press Enter when done).");
+  let password = "";
+  for (let attempt = 0; attempt < 3 && !password.trim(); attempt++) {
+    if (attempt > 0) io.printError("The password cannot be empty.");
+    password = await io.askSecret("Password: ");
+  }
+  if (!password.trim()) throw new Error("No password given. Nothing was sent.");
+  const { needsCode } = await client.login({ companyId, userId, password });
+  if (!needsCode) return;
+  io.print(
+    "Your company uses two-factor login: a code was sent to your e-mail. Type it below (hidden)."
+  );
+  for (let attempt = 1; attempt <= 2; attempt++) {
+    const code = (await io.askSecret("Code (or a recovery code): ")).trim();
+    try {
+      await client.verifyCode(code);
+      return;
+    } catch (err) {
+      if (attempt === 2 || !(err instanceof CanvasAdminError) || err.status !== 400) throw err;
+      io.printError("That code was not accepted. Try once more.");
+    }
+  }
+}
+function describeError(err) {
+  if (!(err instanceof CanvasAdminError)) return err instanceof Error ? err.message : String(err);
+  if (err.status === 400 && /fallback/i.test(err.reason ?? "")) {
+    return `${err.message}
+--fallback-version takes the VERSION column of \`canvas list\` (e.g. 0.0.8), not the id.`;
+  }
+  switch (err.status) {
+    case 401:
+      return `${err.message}
+Check the company id, user id and password.`;
+    case 403:
+      return `${err.message}
+Your user cannot do this for that company: publishing needs a manager of the company.`;
+    case 409:
+      return `${err.message}
+This version was already published for the company. Use a new --version.`;
+    case 413:
+      return `${err.message}
+The .zip is over 2 MB.`;
+    default:
+      return err.message;
+  }
+}
+function table(rows) {
+  if (rows.length === 0) return ["No bundle published for this company."];
+  return [
+    "id      version        current  revoked  published_at                min_app",
+    ...rows.map(
+      (r) => `${String(r.id).padEnd(8)}${r.version.padEnd(15)}${(r.is_current ? "yes" : "").padEnd(9)}${(r.revoked ? "yes" : "").padEnd(9)}${(r.published_at ?? "").padEnd(28)}${r.min_app_version ?? ""}`
+    )
+  ];
+}
+async function runCanvas(args, io, deps) {
+  const baseUrl = args.baseUrl ?? CANVAS_ADMIN_API[args.env];
+  const envLabel = args.baseUrl ? `custom (${baseUrl})` : `${args.env.toUpperCase()} (${baseUrl})`;
+  try {
+    let zip;
+    if (args.action === "publish") {
+      zip = loadZip(args.input ?? "");
+      const errors = zip.findings.filter((f) => f.severity === "error");
+      for (const f of zip.findings) {
+        (f.severity === "error" ? io.printError : io.print)(
+          `${f.severity.toUpperCase()} [${f.rule}] ${f.message}`
+        );
+      }
+      if (errors.length > 0) {
+        io.printError("The app would reject this bundle. Nothing was sent.");
+        return 1;
+      }
+    }
+    if (!io.interactive) {
+      io.printError(
+        "canvas needs an interactive terminal: the password is only read from a prompt."
+      );
+      return 1;
+    }
+    const companyId = await askId(io, "Company id", args.companyId);
+    const userId = await askId(io, "User id", args.userId);
+    if (args.action === "publish" && zip) {
+      const hash = `sha256-${(0, import_node_crypto2.createHash)("sha256").update(zip.zipBytes).digest("hex")}`;
+      io.print("");
+      io.print(`Environment:  ${envLabel}`);
+      io.print(`Company:      ${companyId}`);
+      io.print(
+        `Version:      ${args.version}${args.minAppVersion ? ` (min app ${args.minAppVersion})` : ""}`
+      );
+      io.print(`Bundle:       ${zip.zipBytes.length} bytes, ${hash}`);
+      io.print("It goes LIVE AT ONCE for every user of this company.");
+      if (!await confirm(io, args, "Publish?")) {
+        io.print("Cancelled. Nothing was sent.");
+        return 1;
+      }
+    }
+    if (args.action === "revoke") {
+      io.print("");
+      io.print(`Environment:  ${envLabel}`);
+      io.print(`Revoke bundle ${args.bundleId} of company ${companyId}.`);
+      io.print(
+        args.fallbackVersion ? `The app switches to version ${args.fallbackVersion} (a version, not an id).` : "Without --fallback-version, revoking the current bundle leaves the company with none: the app shows its default screen."
+      );
+      if (!await confirm(io, args, "Revoke?")) {
+        io.print("Cancelled. Nothing was sent.");
+        return 1;
+      }
+    }
+    const client = new CanvasAdminClient({
+      baseUrl,
+      userAgent: deps.userAgent,
+      fetchImpl: deps.fetchImpl
+    });
+    await logIn(io, client, companyId, userId);
+    if (args.action === "publish" && zip) {
+      const record = await client.publish({
+        zipBytes: zip.zipBytes,
+        version: args.version ?? "",
+        companyId,
+        minAppVersion: args.minAppVersion
+      });
+      if (args.json) io.print(JSON.stringify(record));
+      else {
+        io.print(
+          `Published version ${record.version} (id ${record.id}) \u2014 current: ${record.is_current}.`
+        );
+        io.print(`bundleHash: ${record.bundle_hash}`);
+        io.print("Apps of this company load it the next time they come to the foreground.");
+      }
+      return 0;
+    }
+    if (args.action === "list") {
+      const rows = await client.list(companyId);
+      if (args.json) io.print(JSON.stringify(rows));
+      else for (const line of table(rows)) io.print(line);
+      return 0;
+    }
+    const result = await client.revoke(args.bundleId ?? 0, args.fallbackVersion);
+    io.print(args.json ? JSON.stringify(result) : `Revoked. ${JSON.stringify(result)}`);
+    return 0;
+  } catch (err) {
+    io.printError(describeError(err));
+    return 1;
+  }
+}
+
+// src/canvas-admin/tty.ts
+var import_node_readline = require("readline");
+var rl = null;
+var mutedPrompt = null;
+function reader() {
+  if (rl) return rl;
+  rl = (0, import_node_readline.createInterface)({ input: process.stdin, output: process.stderr, terminal: true });
+  const out = rl;
+  const write = out._writeToOutput.bind(rl);
+  out._writeToOutput = (s) => {
+    if (mutedPrompt === null || s.includes(mutedPrompt)) write(s);
+  };
+  return rl;
+}
+function question(prompt, secret) {
+  const r = reader();
+  return new Promise((resolve5) => {
+    mutedPrompt = secret ? prompt : null;
+    r.question(prompt, (answer) => {
+      if (secret) {
+        mutedPrompt = null;
+        process.stderr.write("\n");
+      }
+      resolve5(answer);
+    });
+  });
+}
+function terminalIo() {
+  return {
+    interactive: Boolean(process.stdin.isTTY),
+    ask: (q) => question(q, false),
+    askSecret: (q) => question(q, true),
+    print: (line) => console.log(line),
+    printError: (line) => console.error(line)
+  };
+}
+function closeTerminalIo() {
+  rl?.close();
+  rl = null;
+}
+
 // src/cli-dev.ts
-var import_node_fs2 = require("fs");
+var import_node_fs3 = require("fs");
 var import_node_http = require("http");
-var import_node_path2 = require("path");
+var import_node_path3 = require("path");
 var import_node_url = require("url");
 var import_fflate2 = require("fflate");
 
@@ -616,12 +1094,12 @@ var SCENARIOS = {
 // src/cli-dev.ts
 var import_meta = {};
 function readClientHtml(input) {
-  const path = (0, import_node_path2.resolve)(input);
-  if ((0, import_node_fs2.existsSync)(path) && (0, import_node_fs2.statSync)(path).isDirectory()) {
-    return inlineHtml((0, import_node_path2.join)(path, "index.html"));
+  const path = (0, import_node_path3.resolve)(input);
+  if ((0, import_node_fs3.existsSync)(path) && (0, import_node_fs3.statSync)(path).isDirectory()) {
+    return inlineHtml((0, import_node_path3.join)(path, "index.html"));
   }
-  if ((0, import_node_path2.extname)(path).toLowerCase() === ".zip") {
-    const files = (0, import_fflate2.unzipSync)(new Uint8Array((0, import_node_fs2.readFileSync)(path)));
+  if ((0, import_node_path3.extname)(path).toLowerCase() === ".zip") {
+    const files = (0, import_fflate2.unzipSync)(new Uint8Array((0, import_node_fs3.readFileSync)(path)));
     const entry = files["index.html"];
     if (!entry) throw new Error(`${input}: no index.html at the root of the zip.`);
     return (0, import_fflate2.strFromU8)(entry);
@@ -692,8 +1170,8 @@ function harnessPage(scenario, nativeVersion) {
 </html>`;
 }
 function harnessScriptPath() {
-  const here = typeof __dirname !== "undefined" ? __dirname : (0, import_node_path2.dirname)((0, import_node_url.fileURLToPath)(import_meta.url));
-  return (0, import_node_path2.join)(here, "dev-harness.global.js");
+  const here = typeof __dirname !== "undefined" ? __dirname : (0, import_node_path3.dirname)((0, import_node_url.fileURLToPath)(import_meta.url));
+  return (0, import_node_path3.join)(here, "dev-harness.global.js");
 }
 function startDevServer(opts) {
   if (!(opts.scenario in SCENARIOS)) {
@@ -718,7 +1196,7 @@ function startDevServer(opts) {
           "content-type": "text/javascript; charset=utf-8",
           "cache-control": "no-store"
         });
-        res.end((0, import_node_fs2.readFileSync)(harnessScriptPath()));
+        res.end((0, import_node_fs3.readFileSync)(harnessScriptPath()));
         return;
       }
       if (url.pathname === "/") {
@@ -763,9 +1241,9 @@ function runDev(input, scenario, port, nativeVersion) {
 }
 function runBuild(htmlPath, outPath, maxBytes) {
   const result = buildBundle(htmlPath, maxBytes);
-  const resolvedOut = (0, import_node_path3.resolve)(outPath);
-  (0, import_node_fs3.mkdirSync)((0, import_node_path3.dirname)(resolvedOut), { recursive: true });
-  (0, import_node_fs3.writeFileSync)(resolvedOut, result.zipBytes);
+  const resolvedOut = (0, import_node_path4.resolve)(outPath);
+  (0, import_node_fs4.mkdirSync)((0, import_node_path4.dirname)(resolvedOut), { recursive: true });
+  (0, import_node_fs4.writeFileSync)(resolvedOut, result.zipBytes);
   const kb = (Buffer.byteLength(result.html) / 1024).toFixed(1);
   console.log(`Built ${outPath}`);
   console.log(`  entry: index.html (${kb} KB self-contained)`);
@@ -813,7 +1291,28 @@ ${errors.length} error(s), ${warnings.length} warning(s).` + (result.size === nu
   );
   return 0;
 }
+async function runCanvasCommand(argv) {
+  if (argv.length === 0 || argv.includes("--help") || argv.includes("-h")) {
+    console.log(CANVAS_USAGE);
+    process.exit(argv.length === 0 ? 1 : 0);
+  }
+  const parsed = parseCanvasArgs(argv, process.env);
+  if ("error" in parsed) {
+    console.error(parsed.error);
+    console.error("Run `condor-mobile-bridge canvas --help`.");
+    process.exit(1);
+  }
+  const code = await runCanvas(parsed, terminalIo(), {
+    userAgent: `condor-mobile-bridge-cli/${version}`
+  });
+  closeTerminalIo();
+  process.exit(code);
+}
 function main() {
+  if (process.argv[2] === "canvas") {
+    void runCanvasCommand(process.argv.slice(3));
+    return;
+  }
   const args = parseArgs(process.argv.slice(2));
   if (args.help || !args.htmlPath) {
     console.log(USAGE);