@mh-gg/cli 0.1.1-alpha.20260613T085325975Z

package/runtime/bin/matterhornApps.cjs

@@ -0,0 +1,223 @@
+const fs = require("node:fs");
+const path = require("node:path");
+const {
+  manifestHash,
+  validatePlayerPackManifest
+} = require("@mh-gg/base");
+const {
+  createMemoryRoomStore,
+  startRoomHost
+} = require("@mh-gg/host-runtime");
+const {
+  readmatterhornrc,
+  usermatterhornrcFile,
+  writematterhornrc
+} = require("../host/matterhornrc.cjs");
+
+function localWorkspaceRegistry() {
+  const events = require("@mh-gg/example-events");
+  const kanban = require("@mh-gg/example-kanban");
+  const wiki = require("@mh-gg/example-wiki");
+  const polls = require("@mh-gg/example-polls");
+  const budget = require("@mh-gg/example-budget");
+  const crm = require("@mh-gg/example-crm");
+  const plugins = require("@mh-gg/base-plugins");
+  const react = require("@mh-gg/example-react");
+  const svelte = require("@mh-gg/example-svelte");
+  const vue = require("@mh-gg/example-vue");
+  const lit = require("@mh-gg/example-lit");
+  const vanilla = require("@mh-gg/example-vanilla");
+  return {
+    "@app.matterhorn.events": events,
+    "@app.matterhorn.kanban": kanban,
+    "@app.matterhorn.wiki": wiki,
+    "@app.matterhorn.polls": polls,
+    "@app.matterhorn.budget": budget,
+    "@app.matterhorn.crm": crm,
+    "@mh-gg/example-events": events,
+    "@mh-gg/example-kanban": kanban,
+    "@mh-gg/example-wiki": wiki,
+    "@mh-gg/example-polls": polls,
+    "@mh-gg/example-budget": budget,
+    "@mh-gg/example-crm": crm,
+    "@app.matterhorn.react": react,
+    "@app.matterhorn.svelte": svelte,
+    "@app.matterhorn.vue": vue,
+    "@app.matterhorn.lit": lit,
+    "@app.matterhorn.vanilla": vanilla,
+    "@mh-gg/example-react": react,
+    "@mh-gg/example-svelte": svelte,
+    "@mh-gg/example-vue": vue,
+    "@mh-gg/example-lit": lit,
+    "@mh-gg/example-vanilla": vanilla,
+    "@mh-gg/base-plugins": plugins
+  };
+}
+
+function parseRefUrl(url) {
+  const text = String(url || "");
+  const hashIndex = text.indexOf("#");
+  return {
+    base: hashIndex === -1 ? text : text.slice(0, hashIndex),
+    exportName: hashIndex === -1 ? undefined : text.slice(hashIndex + 1)
+  };
+}
+
+function loadLocalPack(url, workspace = localWorkspaceRegistry()) {
+  const { base, exportName } = parseRefUrl(url);
+  let value;
+  if (base.startsWith("workspace:")) {
+    const packageName = base.slice("workspace:".length);
+    value = workspace[packageName];
+    if (value === undefined) throw new Error(`Workspace pack ${packageName} is not registered`);
+  } else if (base.startsWith("file:")) {
+    const filePath = path.resolve(base.slice("file:".length));
+    value = JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } else {
+    throw new Error(`Unsupported local pack ref ${url}`);
+  }
+
+  if (exportName) {
+    if (value[exportName] === undefined) throw new Error(`Pack ref ${url} does not export ${exportName}`);
+    value = value[exportName];
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`Pack ref ${url} did not resolve to a manifest`);
+  return value;
+}
+
+function packRefWithIntegrity(url, workspace) {
+  const manifest = loadLocalPack(url, workspace);
+  return {
+    manifest,
+    ref: {
+      url,
+      integrity: manifestHash(manifest)
+    }
+  };
+}
+
+function buildPluginRegistry(workspace) {
+  const registry = {};
+  for (const [packageName, exports] of Object.entries(workspace)) {
+    for (const [exportName, value] of Object.entries(exports)) {
+      if (!value || typeof value !== "object" || Array.isArray(value)) continue;
+      if (!value.id || !value.version || (!value.schemas && !value.createInitialState && !value.reduce)) continue;
+      registry[value.id] = value;
+      registry[`workspace:${packageName}#${exportName}`] = value;
+    }
+  }
+  return registry;
+}
+
+function parseOptionArgs(args) {
+  const parsed = {
+    positional: []
+  };
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index];
+    if (!token.startsWith("--")) {
+      parsed.positional.push(token);
+      continue;
+    }
+    const key = token.slice(2);
+    const value = args[index + 1];
+    if (value === undefined || value.startsWith("--")) {
+      parsed[key] = true;
+      continue;
+    }
+    parsed[key] = value;
+    index += 1;
+  }
+  return parsed;
+}
+
+function formatList(values) {
+  return values && values.length ? values.join(", ") : "none";
+}
+
+function createInviteUrl(packUrl) {
+  return ({ room }) => {
+    const params = new URLSearchParams({
+      roomId: room.id,
+      appPackId: room.appPack.id,
+      appPackHash: room.appPack.hash,
+      appPackUrl: packUrl
+    });
+    return `matterhorn://room/${encodeURIComponent(room.id)}?${params.toString()}`;
+  };
+}
+
+async function handleAppHostCommand(args, io = console, options = {}) {
+  const parsed = parseOptionArgs(args);
+  const roomName = parsed.positional[0];
+  if (!roomName || !parsed.pack) throw new Error("Usage: matterhorn host <roomName> --pack <app-pack-ref> [--player <player-pack-ref>]");
+
+  const workspace = options.workspace || localWorkspaceRegistry();
+  const app = packRefWithIntegrity(parsed.pack, workspace);
+  const player = parsed.player ? packRefWithIntegrity(parsed.player, workspace) : undefined;
+  const playerPacks = player ? [validatePlayerPackManifest(player.manifest)] : [];
+  const started = await startRoomHost({
+    roomName,
+    appPackRef: app.ref,
+    workspace,
+    pluginRegistry: buildPluginRegistry(workspace),
+    playerPacks,
+    store: options.store || createMemoryRoomStore(),
+    createInviteUrl: createInviteUrl(parsed.pack)
+  });
+
+  io.log("Matterhorn host ready");
+  io.log(`Room: ${started.room.id}`);
+  io.log(`App: ${app.manifest.name} (${app.manifest.id}@${app.manifest.version})`);
+  io.log(`App hash: ${started.room.appPack.hash}`);
+  io.log(`Publisher: ${app.manifest.publisher.name || app.manifest.publisher.id}`);
+  io.log(`Required capabilities: ${formatList(app.manifest.capabilities.required)}`);
+  io.log(`Optional capabilities: ${formatList(app.manifest.capabilities.optional || [])}`);
+  io.log(`Host sandbox: ${started.installed.hostPack.runtime.sandbox || "none"}`);
+  if (player) io.log(`Player override: ${player.manifest.name} (${player.manifest.id}@${player.manifest.version})`);
+  io.log(`Invite: ${started.inviteUrl}`);
+  return started;
+}
+
+function addPlayerToConfig(config, player, now = () => Date.now()) {
+  const players = Array.isArray(config.players) ? [...config.players] : [];
+  const next = {
+    url: player.ref.url,
+    integrity: player.ref.integrity,
+    id: player.manifest.id,
+    name: player.manifest.name,
+    version: player.manifest.version,
+    addedAt: new Date(now()).toISOString()
+  };
+  const index = players.findIndex((item) => item.url === next.url);
+  if (index === -1) players.push(next);
+  else players[index] = { ...players[index], ...next };
+  return { ...config, players };
+}
+
+function handleLauncherCommand(args, io = console, options = {}) {
+  if (args[0] !== "add-player") throw new Error("Usage: matterhorn launcher add-player --url <player-pack-ref>");
+  const parsed = parseOptionArgs(args.slice(1));
+  if (!parsed.url) throw new Error("Usage: matterhorn launcher add-player --url <player-pack-ref>");
+
+  const workspace = options.workspace || localWorkspaceRegistry();
+  const player = packRefWithIntegrity(parsed.url, workspace);
+  validatePlayerPackManifest(player.manifest);
+  const file = options.configFile || usermatterhornrcFile();
+  const next = addPlayerToConfig(readmatterhornrc(file), player, options.now);
+  writematterhornrc(next, file);
+  io.log(`Added player ${player.manifest.name} (${player.manifest.id})`);
+  io.log(`Config: ${file}`);
+  return next;
+}
+
+module.exports = {
+  addPlayerToConfig,
+  buildPluginRegistry,
+  handleAppHostCommand,
+  handleLauncherCommand,
+  loadLocalPack,
+  localWorkspaceRegistry,
+  packRefWithIntegrity,
+  parseOptionArgs
+};

package/runtime/bin/matterhornDeploy.cjs

@@ -0,0 +1,108 @@
+const { slugifyRoom } = require("@mh-gg/room-link");
+const { parseServeMode } = require("./appFrontend.cjs");
+const { runAppHostCommand } = require("./appHostCommand.cjs");
+const { loadMatterhornDeployment } = require("./matterhornAppLoader.cjs");
+
+const DEPLOY_OPTIONS = new Set(["--serve", "--frontend-port"]);
+
+function splitAtSeparator(args) {
+  const index = args.indexOf("--");
+  if (index === -1) return { deployArgs: args, hostArgs: [] };
+  return {
+    deployArgs: args.slice(0, index),
+    hostArgs: args.slice(index + 1)
+  };
+}
+
+function optionHasValue(args, index) {
+  return args[index + 1] !== undefined && !args[index + 1].startsWith("--");
+}
+
+function appendHostOption(hostArgs, args, index) {
+  hostArgs.push(args[index]);
+  if (optionHasValue(args, index)) {
+    hostArgs.push(args[index + 1]);
+    return index + 1;
+  }
+  return index;
+}
+
+function parseAppDeployArgs(args) {
+  const { deployArgs, hostArgs: separatedHostArgs } = splitAtSeparator(args);
+  const [appRef, roomName, ...rest] = deployArgs;
+  if (!appRef || !roomName) {
+    throw new Error("Usage: matterhorn deploy <app-ref> <room-slug> [--serve [dev|built]] [--frontend-port PORT] [host options]");
+  }
+
+  const parsed = {
+    appRef,
+    roomName: slugifyRoom(roomName),
+    serveMode: undefined,
+    frontendPort: undefined,
+    hostArgs: [...separatedHostArgs]
+  };
+
+  for (let index = 0; index < rest.length; index += 1) {
+    const token = rest[index];
+    if (token === "--serve") {
+      if (optionHasValue(rest, index)) {
+        parsed.serveMode = parseServeMode(rest[index + 1]);
+        index += 1;
+      } else {
+        parsed.serveMode = "dev";
+      }
+      continue;
+    }
+    if (token === "--frontend-port") {
+      if (!optionHasValue(rest, index)) throw new Error("--frontend-port requires a port");
+      parsed.frontendPort = Number(rest[index + 1]);
+      if (!Number.isInteger(parsed.frontendPort) || parsed.frontendPort <= 0) throw new Error("--frontend-port must be a positive integer");
+      index += 1;
+      continue;
+    }
+    if (token.startsWith("--") && !DEPLOY_OPTIONS.has(token)) {
+      index = appendHostOption(parsed.hostArgs, rest, index);
+      continue;
+    }
+    throw new Error(`Unexpected Matterhorn deploy argument ${token}`);
+  }
+
+  return parsed;
+}
+
+function appHostArgsForDeployment(plan) {
+  const args = [plan.appRef, plan.roomName];
+  if (plan.serveMode) args.push("--serve", plan.serveMode);
+  if (plan.frontendPort) args.push("--frontend-port", String(plan.frontendPort));
+  if (plan.hostArgs.length > 0) args.push("--", ...plan.hostArgs);
+  return args;
+}
+
+function assertDeployable(deployment) {
+  if (deployment.kind !== "matterhorn.self-contained-app") throw new Error("Matterhorn deployment kind must be matterhorn.self-contained-app");
+  if (deployment.relay?.mode !== "embedded" || deployment.relay?.autoStart !== true) {
+    throw new Error("Matterhorn deploy requires an embedded auto-start relay");
+  }
+  if (deployment.host?.runner !== "matterhorn-example-host") {
+    throw new Error(`Unsupported Matterhorn deploy host runner ${deployment.host?.runner || "unknown"}`);
+  }
+}
+
+async function runAppDeployCommand(args, io = console, options = {}) {
+  const plan = parseAppDeployArgs(args);
+  const deployment = (options.loadMatterhornDeployment || loadMatterhornDeployment)(plan.appRef, {
+    cwd: options.cwd || process.cwd()
+  });
+  assertDeployable(deployment);
+  io.log(`Matterhorn deployment: ${deployment.name} (${deployment.id}@${deployment.version || "unknown"})`);
+  io.log("Relay: embedded p2p relay with host runtime registration");
+  if (deployment.relay.acceptsPeerRelays) io.log("Relay peers: enabled with --relay-peer <relay-address>");
+  return await (options.runAppHostCommand || runAppHostCommand)(appHostArgsForDeployment(plan), io, options);
+}
+
+module.exports = {
+  appHostArgsForDeployment,
+  assertDeployable,
+  parseAppDeployArgs,
+  runAppDeployCommand
+};

package/runtime/bin/matterhornEmitAppBundle.cjs

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+const { emitMatterhornBundleForRef } = require("./matterhornAppLoader.cjs");
+
+function main(argv = process.argv.slice(2)) {
+  const [appRef, cwd] = argv;
+  if (!appRef) throw new Error("Usage: matterhornEmitAppBundle <app-ref> [cwd]");
+  const result = emitMatterhornBundleForRef(appRef, { cwd: cwd || process.cwd() });
+  console.log(result.bundlePath);
+}
+
+if (require.main === module) {
+  try {
+    main();
+  } catch (error) {
+    console.error(error?.message || error);
+    process.exit(1);
+  }
+}
+
+module.exports = { main };