@getmonoceros/workbench 1.37.14 → 1.38.0

package/bundled-components/services/keycloak/component.yml

@@ -9,7 +9,14 @@ service:
   # Dev mode + realm import. The Keycloak image has no auto-start default,
   # so a command is mandatory. `--import-realm` reads every *.json from
   # /opt/keycloak/data/import at startup (a no-op if the dir is empty).
-  command: start-dev --import-realm
+  # `--proxy-headers=xforwarded` makes Keycloak derive the issuer host and
+  # scheme from X-Forwarded-Host / X-Forwarded-Proto, so the realm stamps a
+  # matching issuer whether it is reached over http via the Traefik proxy
+  # (`plantlove.localhost`) or over https via `monoceros share` on a phone.
+  # Without it Keycloak uses the raw connection scheme (always http behind a
+  # TLS-terminating proxy) and the OIDC token exchange fails on the https
+  # client. See ADR 0033.
+  command: start-dev --import-realm --proxy-headers=xforwarded
   # Starts in a host-side second wave AFTER the repo clone (ADR 0025), so a
   # mounted realm.json / theme from the project is present at boot. No
   # dataMount: the dev H2 database is ephemeral and re-seeds from the

package/dist/bin.js

@@ -4107,12 +4107,12 @@ async function writeScaffold(opts, targetDir, scaffoldOpts = {}) {
   const devcontainerDir = path11.join(targetDir, ".devcontainer");
   const monocerosDir = path11.join(targetDir, ".monoceros");
   const projectsDir = path11.join(targetDir, "projects");
-  const homeDir = path11.join(targetDir, "home");
+  const homeDir2 = path11.join(targetDir, "home");
   const dataDir = path11.join(targetDir, "data");
   await fs9.mkdir(devcontainerDir, { recursive: true });
   await fs9.mkdir(monocerosDir, { recursive: true });
   await fs9.mkdir(projectsDir, { recursive: true });
-  await fs9.mkdir(homeDir, { recursive: true });
+  await fs9.mkdir(homeDir2, { recursive: true });
   if (needsCompose(opts)) {
     await fs9.mkdir(dataDir, { recursive: true });
     for (const svc of opts.services) {
@@ -4176,10 +4176,10 @@ async function writeScaffold(opts, targetDir, scaffoldOpts = {}) {
   }
   for (const f of resolvedFeatures) {
     for (const sub of f.persistentHomePaths) {
-      await fs9.mkdir(path11.join(homeDir, sub), { recursive: true });
+      await fs9.mkdir(path11.join(homeDir2, sub), { recursive: true });
     }
     for (const entry2 of f.persistentHomeFiles) {
-      const filePath = path11.join(homeDir, entry2.path);
+      const filePath = path11.join(homeDir2, entry2.path);
       await fs9.mkdir(path11.dirname(filePath), { recursive: true });
       if (!existsSync8(filePath)) {
         await fs9.writeFile(filePath, entry2.initialContent);
@@ -5481,8 +5481,8 @@ function removeRepoFromDoc(doc, urlOrPath) {
     if (!isMap2(item)) return false;
     const url = item.get("url");
     if (url === urlOrPath) return true;
-    const path33 = item.get("path");
-    const effectivePath = typeof path33 === "string" ? path33 : typeof url === "string" ? deriveRepoName(url) : void 0;
+    const path35 = item.get("path");
+    const effectivePath = typeof path35 === "string" ? path35 : typeof url === "string" ? deriveRepoName(url) : void 0;
     return effectivePath === urlOrPath;
   });
   if (idx < 0) return false;
@@ -5625,7 +5625,7 @@ async function runAddRepo(input) {
       "Missing repo URL. Usage: monoceros add-repo <containername> <url>."
     );
   }
-  const path33 = (input.path ?? deriveRepoName(url)).trim();
+  const path35 = (input.path ?? deriveRepoName(url)).trim();
   const hasName = typeof input.gitName === "string" && input.gitName.trim().length > 0;
   const hasEmail = typeof input.gitEmail === "string" && input.gitEmail.trim().length > 0;
   if (hasName !== hasEmail) {
@@ -5662,7 +5662,7 @@ async function runAddRepo(input) {
   const providerToWrite = !canonical && explicitProvider ? explicitProvider : void 0;
   const entry2 = {
     url,
-    path: path33,
+    path: path35,
     ...hasName && hasEmail ? {
       gitUser: {
         name: input.gitName.trim(),
@@ -8974,7 +8974,7 @@ var CLI_VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    CLI_VERSION = true ? "1.37.14" : "dev";
+    CLI_VERSION = true ? "1.38.0" : "dev";
   }
 });
 
@@ -12370,9 +12370,212 @@ var init_run3 = __esm({
   }
 });
 
+// src/tls/ca.ts
+import { promises as fs21 } from "fs";
+import path33 from "path";
+import forge from "node-forge";
+function homeDir(monocerosHome2) {
+  return monocerosHome2 ?? monocerosHome();
+}
+function randomSerial() {
+  return "00" + forge.util.bytesToHex(forge.random.getBytesSync(16));
+}
+async function fileExists(p) {
+  try {
+    await fs21.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function loadOrCreateCa(monocerosHome2) {
+  const dir = path33.join(homeDir(monocerosHome2), CA_DIR);
+  const certPath = path33.join(dir, CA_CERT_FILE);
+  const keyPath = path33.join(dir, CA_KEY_FILE);
+  if (await fileExists(certPath) && await fileExists(keyPath)) {
+    const cert2 = forge.pki.certificateFromPem(
+      await fs21.readFile(certPath, "utf8")
+    );
+    const key = forge.pki.privateKeyFromPem(
+      await fs21.readFile(keyPath, "utf8")
+    );
+    return { cert: cert2, key, certPath, keyPath };
+  }
+  const keys = forge.pki.rsa.generateKeyPair(2048);
+  const cert = forge.pki.createCertificate();
+  cert.publicKey = keys.publicKey;
+  cert.serialNumber = randomSerial();
+  cert.validity.notBefore = /* @__PURE__ */ new Date();
+  cert.validity.notAfter = new Date(
+    cert.validity.notBefore.getTime() + CA_DAYS * 24 * 60 * 60 * 1e3
+  );
+  const attrs = [{ name: "commonName", value: "Monoceros Local CA" }];
+  cert.setSubject(attrs);
+  cert.setIssuer(attrs);
+  cert.setExtensions([
+    { name: "basicConstraints", cA: true, critical: true },
+    { name: "keyUsage", keyCertSign: true, cRLSign: true, critical: true },
+    { name: "subjectKeyIdentifier" }
+  ]);
+  cert.sign(keys.privateKey, forge.md.sha256.create());
+  await fs21.mkdir(dir, { recursive: true });
+  await fs21.writeFile(certPath, forge.pki.certificateToPem(cert), {
+    mode: 420
+  });
+  await fs21.writeFile(keyPath, forge.pki.privateKeyToPem(keys.privateKey), {
+    mode: 384
+  });
+  return { cert, key: keys.privateKey, certPath, keyPath };
+}
+function normalizeSans(sans) {
+  return [...new Set(sans.filter((s) => s.length > 0))].sort();
+}
+async function readLeafMeta(metaPath) {
+  try {
+    return JSON.parse(await fs21.readFile(metaPath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function leafStillGood(meta, sans) {
+  if (!meta) return false;
+  if (meta.sans.join(",") !== sans.join(",")) return false;
+  const notAfter = new Date(meta.notAfter).getTime();
+  if (Number.isNaN(notAfter)) return false;
+  return notAfter - Date.now() > LEAF_RENEW_BEFORE_MS;
+}
+async function ensureLeafCert(opts) {
+  const sans = normalizeSans(opts.sans);
+  const dir = path33.join(homeDir(opts.monocerosHome), CERTS_DIR);
+  const certPath = path33.join(dir, LEAF_CERT_FILE);
+  const keyPath = path33.join(dir, LEAF_KEY_FILE);
+  const metaPath = path33.join(dir, LEAF_META_FILE);
+  const ca = await loadOrCreateCa(opts.monocerosHome);
+  const haveFiles = await fileExists(certPath) && await fileExists(keyPath);
+  if (haveFiles && leafStillGood(await readLeafMeta(metaPath), sans)) {
+    return {
+      caCertPath: ca.certPath,
+      certDir: dir,
+      certFile: LEAF_CERT_FILE,
+      keyFile: LEAF_KEY_FILE
+    };
+  }
+  const keys = forge.pki.rsa.generateKeyPair(2048);
+  const cert = forge.pki.createCertificate();
+  cert.publicKey = keys.publicKey;
+  cert.serialNumber = randomSerial();
+  cert.validity.notBefore = /* @__PURE__ */ new Date();
+  cert.validity.notAfter = new Date(
+    cert.validity.notBefore.getTime() + LEAF_DAYS * 24 * 60 * 60 * 1e3
+  );
+  cert.setSubject([{ name: "commonName", value: "monoceros share" }]);
+  cert.setIssuer(ca.cert.subject.attributes);
+  cert.setExtensions([
+    { name: "basicConstraints", cA: false },
+    {
+      name: "keyUsage",
+      digitalSignature: true,
+      keyEncipherment: true,
+      critical: true
+    },
+    { name: "extKeyUsage", serverAuth: true },
+    {
+      name: "subjectAltName",
+      altNames: sans.map(
+        (s) => IPV4_RE2.test(s) ? { type: 7, ip: s } : { type: 2, value: s }
+      )
+    }
+  ]);
+  cert.sign(ca.key, forge.md.sha256.create());
+  await fs21.mkdir(dir, { recursive: true });
+  await fs21.writeFile(certPath, forge.pki.certificateToPem(cert), {
+    mode: 420
+  });
+  await fs21.writeFile(keyPath, forge.pki.privateKeyToPem(keys.privateKey), {
+    mode: 384
+  });
+  const meta = {
+    sans,
+    notAfter: cert.validity.notAfter.toISOString()
+  };
+  await fs21.writeFile(metaPath, JSON.stringify(meta), { mode: 420 });
+  return {
+    caCertPath: ca.certPath,
+    certDir: dir,
+    certFile: LEAF_CERT_FILE,
+    keyFile: LEAF_KEY_FILE
+  };
+}
+async function provisionShareTls(opts) {
+  return ensureLeafCert(opts);
+}
+var CA_DIR, CA_CERT_FILE, CA_KEY_FILE, CERTS_DIR, LEAF_CERT_FILE, LEAF_KEY_FILE, LEAF_META_FILE, CA_DAYS, LEAF_DAYS, LEAF_RENEW_BEFORE_MS, IPV4_RE2;
+var init_ca = __esm({
+  "src/tls/ca.ts"() {
+    "use strict";
+    init_paths();
+    CA_DIR = "ca";
+    CA_CERT_FILE = "rootCA.pem";
+    CA_KEY_FILE = "rootCA-key.pem";
+    CERTS_DIR = "certs";
+    LEAF_CERT_FILE = "leaf.pem";
+    LEAF_KEY_FILE = "leaf-key.pem";
+    LEAF_META_FILE = "leaf.json";
+    CA_DAYS = 3650;
+    LEAF_DAYS = 397;
+    LEAF_RENEW_BEFORE_MS = 7 * 24 * 60 * 60 * 1e3;
+    IPV4_RE2 = /^(\d{1,3}\.){3}\d{1,3}$/;
+  }
+});
+
+// src/share/caddy.ts
+function renderCaddyfile(sites, certFile, keyFile) {
+  const blocks = sites.map(
+    (s) => `:${s.port} {
+	tls /certs/${certFile} /certs/${keyFile}
+	reverse_proxy http://${s.targetHost}:${s.port}
+}`
+  );
+  return [
+    "{",
+    "	auto_https off",
+    "	admin off",
+    "	servers {",
+    "		protocols h1 h2",
+    "	}",
+    "}",
+    ...blocks,
+    ""
+  ].join("\n");
+}
+function buildCaddyDockerArgs(input) {
+  const args = ["run", "--rm", "-i", `--network=${input.network}`];
+  for (const port of input.ports) {
+    args.push("-p", `${input.localAddress}:${port}:${port}`);
+  }
+  args.push(
+    "-v",
+    `${input.certDir}:/certs:ro`,
+    "-v",
+    `${input.caddyfilePath}:/etc/caddy/Caddyfile:ro`,
+    CADDY_IMAGE
+  );
+  return args;
+}
+var CADDY_IMAGE;
+var init_caddy = __esm({
+  "src/share/caddy.ts"() {
+    "use strict";
+    CADDY_IMAGE = "caddy:2.11.4";
+  }
+});
+
 // src/share/run.ts
 import os3 from "os";
+import { spawnSync as spawnSync2 } from "child_process";
 import { consola as consola35 } from "consola";
+import { promises as fs22 } from "fs";
+import path34 from "path";
 function realHostAddresses() {
   let ip;
   for (const list of Object.values(os3.networkInterfaces())) {
@@ -12384,9 +12587,18 @@ function realHostAddresses() {
     }
     if (ip) break;
   }
+  return { ...ip ? { ip } : {}, mdnsName: mdnsHostName() };
+}
+function mdnsHostName() {
+  if (process.platform === "darwin") {
+    const res = spawnSync2("scutil", ["--get", "LocalHostName"], {
+      encoding: "utf8"
+    });
+    const name = res.status === 0 ? res.stdout.trim() : "";
+    if (name) return `${name}.local`;
+  }
   const hn = os3.hostname();
-  const mdnsName = hn.endsWith(".local") ? hn : `${hn}.local`;
-  return { ...ip ? { ip } : {}, mdnsName };
+  return hn.endsWith(".local") ? hn : `${hn}.local`;
 }
 async function runShare(opts) {
   const log = opts.logger ?? {
@@ -12418,31 +12630,62 @@ async function runShare(opts) {
   for (const port of ports) {
     await preflight({ port, address: SHARE_ADDRESS });
   }
+  const { ip, mdnsName } = (opts.hostAddresses ?? realHostAddresses)();
+  const sans = [mdnsName, ip, "localhost", "127.0.0.1"].filter(
+    (s) => typeof s === "string" && s.length > 0
+  );
+  const provisionTls = opts.provisionTls ?? provisionShareTls;
+  const tls = await provisionTls({
+    sans,
+    ...opts.monocerosHome !== void 0 ? { monocerosHome: opts.monocerosHome } : {}
+  });
+  const sites = ports.map((port) => ({
+    port,
+    targetHost: base.targetHost
+  }));
+  const home = opts.monocerosHome ?? monocerosHome();
+  const shareDir = path34.join(home, "share");
+  await fs22.mkdir(shareDir, { recursive: true });
+  const caddyfilePath = path34.join(
+    shareDir,
+    `${opts.name}__${opts.app}.Caddyfile`
+  );
+  await fs22.rm(caddyfilePath, { force: true });
+  await fs22.writeFile(
+    caddyfilePath,
+    renderCaddyfile(sites, tls.certFile, tls.keyFile)
+  );
   const dockerSpawn = opts.dockerSpawn ?? defaultDockerSpawn;
-  const handles = ports.map(
-    (port) => dockerSpawn(
-      buildDockerArgs({
+  const handles = [
+    dockerSpawn(
+      buildCaddyDockerArgs({
         localAddress: SHARE_ADDRESS,
-        localPort: port,
-        internalPort: port,
+        ports,
         network: base.network,
-        targetHost: base.targetHost
+        certDir: tls.certDir,
+        caddyfilePath
       })
     )
-  );
-  const { ip, mdnsName } = (opts.hostAddresses ?? realHostAddresses)();
-  const host = ip ?? mdnsName ?? "<host-ip>";
+  ];
+  const host = mdnsName ?? ip ?? "<host-ip>";
   log.info(
     `Sharing ${opts.name}/${opts.app} on the local network (Ctrl+C to stop):`
   );
   for (const t of ported) {
-    log.info(`  ${cyan2(t.name)}  http://${host}:${t.port}`);
+    log.info(`  ${cyan2(t.name)}  https://${host}:${t.port}`);
   }
   if (mdnsName && ip) {
     log.info(
-      dim(`  also reachable as http://${mdnsName}:<port> where mDNS resolves`)
+      dim(
+        `  also reachable as https://${ip}:<port> if .local does not resolve`
+      )
     );
   }
+  log.info(
+    dim(
+      `  First device? Trust the local CA once so HTTPS is warning-free: ${tls.caCertPath}`
+    )
+  );
   const installSignalHandler = opts.installSignalHandler ?? installSigintDefault;
   let stopping = false;
   const uninstall = installSignalHandler(() => {
@@ -12466,6 +12709,9 @@ var init_run4 = __esm({
     init_resolve2();
     init_port_check2();
     init_run3();
+    init_ca();
+    init_caddy();
+    init_paths();
     init_format();
     SHARE_ADDRESS = "0.0.0.0";
   }
@@ -12483,7 +12729,7 @@ var init_share = __esm({
       meta: {
         name: "share",
         group: "discovery",
-        description: "Expose an app's ports to the local network (phone, tablet, other devices) so any device can open it - reached via the host's LAN IP (or `.local` name). Every target in the app's launch.json that declares a port is shared. Foreground: Ctrl+C stops sharing. See ADR 0030."
+        description: "Expose an app's ports to the local network (phone, tablet, other devices) over HTTPS so any device can open it - reached via the host's LAN IP (or `.local` name). TLS is served with a machine-local CA; trust the printed rootCA.pem once per device for warning-free HTTPS (and a working PWA secure context). Every target in the app's launch.json that declares a port is shared. Foreground: Ctrl+C stops sharing. See ADR 0030 and 0033."
       },
       args: {
         name: {
@@ -13267,7 +13513,7 @@ var init_prune = __esm({
 });
 
 // src/upgrade/index.ts
-import { existsSync as existsSync21, promises as fs21 } from "fs";
+import { existsSync as existsSync21, promises as fs23 } from "fs";
 import { consola as consola41 } from "consola";
 async function fetchRuntimeVersions() {
   const tokenUrl = `https://ghcr.io/token?service=ghcr.io&scope=repository:${RUNTIME_REPO}:pull`;
@@ -13384,10 +13630,10 @@ async function runUpgrade(opts) {
   for (const name of targets) {
     const ymlPath = containerConfigPath(name, home);
     if (!existsSync21(ymlPath)) continue;
-    const raw = await fs21.readFile(ymlPath, "utf8");
+    const raw = await fs23.readFile(ymlPath, "utf8");
     const updated = setRuntimeVersion(raw, pinVersion);
     if (updated !== raw) {
-      await fs21.writeFile(ymlPath, updated);
+      await fs23.writeFile(ymlPath, updated);
       bumped += 1;
       logger.info(`Pinned '${name}' to runtime ${pinVersion}.`);
     }
@@ -13429,7 +13675,7 @@ function formatPruneLine(prune) {
 }
 async function listContainerNames2(home) {
   try {
-    const entries = await fs21.readdir(containerConfigsDir(home));
+    const entries = await fs23.readdir(containerConfigsDir(home));
     return entries.filter((e) => e.endsWith(".yml")).map((e) => e.slice(0, -".yml".length));
   } catch {
     return [];
@@ -13844,25 +14090,25 @@ function detectHelpRequest(argv, main2) {
   const separatorIdx = argv.indexOf("--");
   if (helpIdx === -1) return null;
   if (separatorIdx !== -1 && separatorIdx < helpIdx) return null;
-  const path33 = [];
+  const path35 = [];
   const tokens = argv.slice(
     0,
     separatorIdx === -1 ? argv.length : separatorIdx
   );
   let cursor = main2;
   const mainName = (main2.meta ?? {}).name ?? "monoceros";
-  path33.push(mainName);
+  path35.push(mainName);
   for (const tok of tokens) {
     if (tok.startsWith("-")) continue;
     const subs = cursor.subCommands ?? {};
     if (tok in subs) {
       cursor = subs[tok];
-      path33.push(tok);
+      path35.push(tok);
       continue;
     }
     break;
   }
-  return { path: path33, cmd: cursor };
+  return { path: path35, cmd: cursor };
 }
 async function maybeRenderHelp(argv, main2) {
   const hit = detectHelpRequest(argv, main2);