enigma-memory 0.1.1 → 0.1.2

package/apps/browser-extension/src/native-bridge.js

@@ -0,0 +1,289 @@
+const NATIVE_HOST = 'com.enigma.native_host';
+const PROTOCOL = 'enigma.native.browser.v1';
+const REQUEST_TIMEOUT_MS = 30000;
+const MAX_CONTEXT_CHARS = 32000;
+const SAFE_NATIVE_ERROR_CODE = /^[A-Z][A-Z0-9_]{0,31}$/;
+
+export const SUPPORTED_PROVIDERS = Object.freeze({
+  chatgpt: Object.freeze({ id: 'chatgpt', label: 'ChatGPT', hosts: Object.freeze(['chatgpt.com', 'chat.openai.com']) }),
+  claude: Object.freeze({ id: 'claude', label: 'Claude', hosts: Object.freeze(['claude.ai']) }),
+  kimi: Object.freeze({ id: 'kimi', label: 'Kimi', hosts: Object.freeze(['kimi.com', 'www.kimi.com', 'kimi.moonshot.cn']) }),
+  perplexity: Object.freeze({ id: 'perplexity', label: 'Perplexity', hosts: Object.freeze(['perplexity.ai', 'www.perplexity.ai']) })
+});
+
+const RECEIPT_RAW_FIELD_NAMES = new Set([
+  'memory',
+  'memories',
+  'plaintext',
+  'plainText',
+  'raw',
+  'rawMemory',
+  'rawMemories',
+  'context',
+  'contextText',
+  'text',
+  'content',
+  'prompt'
+]);
+
+export function detectProviderFromUrl(url) {
+  let parsed;
+  try {
+    parsed = new URL(String(url));
+  } catch {
+    return undefined;
+  }
+
+  if (parsed.protocol !== 'https:') return undefined;
+  const hostname = parsed.hostname.toLowerCase();
+  for (const provider of Object.values(SUPPORTED_PROVIDERS)) {
+    if (provider.hosts.includes(hostname)) return provider;
+  }
+  return undefined;
+}
+
+export async function requestContextPack(input) {
+  const provider = requireSupportedProvider(input?.url, input?.providerId);
+  const response = await sendNativeMessage({
+    protocol: PROTOCOL,
+    id: requestId(),
+    type: 'enigma.browser.context.request',
+    provider: provider.id,
+    page: sanitizePage(input, provider),
+    selection: sanitizeSelection(input?.selection),
+    requirements: {
+      custody: 'local-only',
+      approval: 'user-click',
+      receipt: 'required',
+      receiptPlaintext: 'forbidden',
+      providerNativeMemory: 'cache-only',
+      storage: 'transient-extension-memory'
+    }
+  });
+
+  return validateContextResponse(response);
+}
+
+export async function recordInsertionReceipt(input) {
+  const provider = requireSupportedProvider(input?.url, input?.providerId);
+  const receipt = sanitizeReceipt(input?.receipt);
+  const response = await sendNativeMessage({
+    protocol: PROTOCOL,
+    id: requestId(),
+    type: 'enigma.browser.insertion.record',
+    provider: provider.id,
+    page: sanitizePage(input, provider),
+    insertion: {
+      mode: input?.mode === 'replace-selection' ? 'replace-selection' : 'insert-at-cursor',
+      target: typeof input?.target === 'string' ? input.target.slice(0, 80) : 'prompt',
+      insertedCharCount: nonNegativeInteger(input?.insertedCharCount),
+      insertedAt: requireString(input?.insertedAt, 'insertion.insertedAt', 80),
+      receipt
+    },
+    requirements: {
+      plaintextInRecord: 'forbidden',
+      receiptPlaintext: 'forbidden'
+    }
+  });
+
+  if (!response || response.protocol !== PROTOCOL || response.type !== 'enigma.browser.insertion.recorded') {
+    throw new Error('Native host returned an invalid insertion receipt acknowledgement.');
+  }
+  if (response.ok !== true) {
+    throw new Error(nativeHostErrorMessage('Native host rejected insertion receipt.', response));
+  }
+  return Object.freeze({ ok: true, receipt });
+}
+
+export function serializeError(error) {
+  if (error instanceof Error) return { message: sanitizeSerializableErrorMessage(error.message) };
+  return { message: 'Unexpected Enigma bridge error.' };
+}
+
+function requireSupportedProvider(url, expectedProviderId) {
+  const provider = detectProviderFromUrl(url);
+  if (!provider) throw new Error('Unsupported or unknown AI provider page.');
+  if (expectedProviderId !== undefined && expectedProviderId !== provider.id) {
+    throw new Error('Provider mismatch for active tab URL.');
+  }
+  return provider;
+}
+
+function sanitizePage(input, provider) {
+  const parsed = new URL(String(input?.url ?? ''));
+  return Object.freeze({
+    providerId: provider.id,
+    origin: parsed.origin,
+    hostname: parsed.hostname.toLowerCase(),
+    display: Object.freeze({
+      providerLabel: provider.label,
+      hostLabel: parsed.hostname.toLowerCase(),
+      titlePresent: typeof input?.title === 'string' && input.title.length > 0,
+      titleCharCount: typeof input?.title === 'string' ? input.title.length : 0
+    }),
+    topLevel: input?.topLevel !== false
+  });
+}
+
+function sanitizeSelection(selection) {
+  if (!selection || typeof selection !== 'object') return undefined;
+  const text = typeof selection.text === 'string' ? selection.text : '';
+  if (text.length === 0) return undefined;
+  if (text.length > 4000) throw new Error('Selected page text exceeds 4000 characters.');
+  const source = typeof selection.source === 'string' && selection.source.length > 0 ? selection.source : 'user-selection';
+  if (source.length > 80) throw new Error('selection.source exceeds 80 characters.');
+  return Object.freeze({
+    text,
+    source
+  });
+}
+
+function validateContextResponse(response) {
+  if (!response || response.protocol !== PROTOCOL || response.type !== 'enigma.browser.context.response') {
+    throw new Error('Native host returned an invalid Enigma context response.');
+  }
+  if (response.ok !== true) {
+    throw new Error(nativeHostErrorMessage('Native host rejected context request.', response));
+  }
+
+  const text = response.context?.text;
+  if (typeof text !== 'string' || text.length === 0) {
+    throw new Error('Native host did not return insertable context.');
+  }
+  if (text.length > MAX_CONTEXT_CHARS) {
+    throw new Error(`Native host context exceeds ${MAX_CONTEXT_CHARS} characters.`);
+  }
+
+  const receipt = sanitizeReceipt(response.receipt);
+  return Object.freeze({
+    ok: true,
+    context: Object.freeze({
+      text,
+      mime: response.context?.mime === 'text/markdown' ? 'text/markdown' : 'text/plain',
+      charCount: text.length
+    }),
+    receipt
+  });
+}
+
+function sanitizeReceipt(receipt) {
+  if (!receipt || typeof receipt !== 'object' || Array.isArray(receipt)) {
+    throw new Error('Enigma native host must return a receipt object.');
+  }
+  if (containsRawReceiptField(receipt)) {
+    throw new Error('Receipt contains a forbidden plaintext-like field.');
+  }
+
+  const id = requireString(receipt.id, 'receipt.id', 160);
+  const commitment = requireString(receipt.commitment ?? receipt.digest, 'receipt.commitment', 256);
+  const digestAlgorithm = requireString(receipt.digestAlgorithm, 'receipt.digestAlgorithm', 80);
+  const createdAt = requireString(receipt.createdAt, 'receipt.createdAt', 80);
+
+  return Object.freeze({ id, commitment, digestAlgorithm, createdAt });
+}
+
+function containsRawReceiptField(value, depth = 0) {
+  if (depth > 12 || value === null || typeof value !== 'object') return false;
+  if (Array.isArray(value)) return value.some((item) => containsRawReceiptField(item, depth + 1));
+  for (const [key, child] of Object.entries(value)) {
+    if (RECEIPT_RAW_FIELD_NAMES.has(key)) return true;
+    if (containsRawReceiptField(child, depth + 1)) return true;
+  }
+  return false;
+}
+
+function requireString(value, name, maxLength) {
+  if (typeof value !== 'string' || value.length === 0) throw new Error(`Missing ${name}.`);
+  if (value.length > maxLength) throw new Error(`${name} exceeds ${maxLength} characters.`);
+  return value;
+}
+
+function nonNegativeInteger(value) {
+  return Number.isSafeInteger(value) && value >= 0 ? value : 0;
+}
+
+function requestId() {
+  const random = new Uint8Array(16);
+  crypto.getRandomValues(random);
+  return Array.from(random, (byte) => byte.toString(16).padStart(2, '0')).join('');
+}
+
+function sendNativeMessage(message) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const timeout = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      reject(new Error('Timed out waiting for Enigma native host.'));
+    }, REQUEST_TIMEOUT_MS);
+
+    chrome.runtime.sendNativeMessage(NATIVE_HOST, message, (response) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+
+      const lastError = chrome.runtime.lastError;
+      if (lastError) {
+        reject(new Error(nativeHostErrorMessage('Unable to reach Enigma native host.', lastError)));
+        return;
+      }
+      if (response && response.id !== message.id) {
+        reject(new Error('Native host response id did not match the request id.'));
+        return;
+      }
+      resolve(response);
+    });
+  });
+}
+
+function nativeHostErrorMessage(fallback, detail) {
+  const code = safeNativeErrorCode(detail);
+  return code ? `${fallback} (${code})` : fallback;
+}
+
+function safeNativeErrorCode(detail) {
+  if (!detail || typeof detail !== 'object') return undefined;
+  const code = detail.code ?? detail.errorCode;
+  if (typeof code !== 'string') return undefined;
+  const trimmed = code.trim();
+  return SAFE_NATIVE_ERROR_CODE.test(trimmed) ? trimmed : undefined;
+}
+
+function sanitizeSerializableErrorMessage(message) {
+  if (typeof message !== 'string') return 'Unexpected Enigma bridge error.';
+  const trimmed = message.trim();
+  if (!trimmed) return 'Unexpected Enigma bridge error.';
+  if (trimmed.length > 240 || looksLikeSensitiveErrorText(trimmed) || !isKnownSafeErrorMessage(trimmed)) {
+    return 'Enigma action failed without exposing local memory.';
+  }
+  return trimmed;
+}
+
+function isKnownSafeErrorMessage(message) {
+  switch (message) {
+    case 'Unsupported or unknown AI provider page.':
+    case 'Provider mismatch for active tab URL.':
+    case 'Message provider does not match the active page.':
+    case 'Unsupported Enigma extension message.':
+    case 'Native host rejected context request.':
+    case 'Native host rejected insertion receipt.':
+    case 'Unable to reach Enigma native host.':
+    case 'Timed out waiting for Enigma native host.':
+    case 'Native host returned an invalid Enigma context response.':
+    case 'Native host returned an invalid insertion receipt acknowledgement.':
+    case 'Native host response id did not match the request id.':
+    case 'Native host did not return insertable context.':
+    case 'Enigma native host must return a receipt object.':
+    case 'Receipt contains a forbidden plaintext-like field.':
+    case 'Selected page text exceeds 4000 characters.':
+    case 'selection.source exceeds 80 characters.':
+      return true;
+    default:
+      return /^(?:Native host context exceeds|Missing [A-Za-z0-9_.]+|[A-Za-z0-9_.]+ exceeds) \d+ characters\.$/.test(message) ||
+        /^Missing [A-Za-z0-9_.]+\.$/.test(message);
+  }
+}
+
+function looksLikeSensitiveErrorText(text) {
+  return /https?:\/\/|[?&#](?:token|key|prompt|q)=|\b(selectedText|selected_text|plaintext|rawMemory|raw_memory|contextText|context_text)\b|["'](?:text|content|memory|raw|prompt|receipt)["']\s*:/i.test(text);
+}

package/apps/cli/bin/enigma.mjs

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { createHash } from 'node:crypto';
 import { createServer as createHttpServer } from 'node:http';
 import { realpathSync } from 'node:fs';
 import { access, mkdir, readFile, readdir, writeFile } from 'node:fs/promises';
@@ -30,6 +31,24 @@ const DEFAULT_BUNDLE = '.enigma/bundle.json';
 export const DEFAULT_RELAY_PORT = 8787;
 export const DEFAULT_GATEWAY_PORT = 8797;
 const DEFAULT_QUICKSTART_MEMORY = 'Enigma quickstart demo memory: local proof bundles can be created and verified without provider or cloud credentials.';
+const DEFAULT_CROSS_MODEL_DEMO_BUNDLE = '.enigma/cross-model-demo-bundle.json';
+const DEFAULT_CROSS_MODEL_MEMORY = 'Enigma cross-model demo memory: a local encrypted memory can be packaged for ChatGPT, Claude, Kimi, Cursor, and a local LLM without provider credentials.';
+const CROSS_MODEL_PROFILES = Object.freeze([
+  { id: 'chatgpt', provider: 'chatgpt', model: 'chatgpt-mcp-profile', label: 'ChatGPT' },
+  { id: 'claude', provider: 'claude', model: 'claude-mcp-profile', label: 'Claude' },
+  { id: 'kimi', provider: 'kimi', model: 'kimi-mcp-profile', label: 'Kimi' },
+  { id: 'cursor', provider: 'cursor', model: 'cursor-mcp-profile', label: 'Cursor' },
+  { id: 'local-llm', provider: 'local', model: 'local-llm-profile', label: 'Local LLM' },
+]);
+const CROSS_MODEL_CLAIM_BOUNDARIES = Object.freeze({
+  local_only: true,
+  provider_credentials_required: false,
+  provider_native_memory_canonical: false,
+  provider_deletion_proof: false,
+  model_forgetting_proof: false,
+  roi_or_savings_guarantee: false,
+  compliance_certification: false,
+});
 const PACKAGE_JSON_URL = new URL('../../../package.json', import.meta.url);
 const SPECS_URL = new URL('../../../specs/', import.meta.url);
 const IMPORTERS = Object.freeze({
@@ -191,6 +210,73 @@ async function quickstartMemoryTextFromFlags(flags) {
   return DEFAULT_QUICKSTART_MEMORY;
 }
 
+async function crossModelMemoryTextFromFlags(flags) {
+  const textFile = getFlag(flags, ['memory-file', 'memoryFile', 'text-file', 'textFile']);
+  if (textFile === undefined) return DEFAULT_CROSS_MODEL_MEMORY;
+  if (textFile === true || textFile === '') throw new Error('Missing required --memory-file.');
+  return readFile(resolve(String(textFile)), 'utf8');
+}
+
+function activeMemoryCount(vault) {
+  return vault.activeAddresses instanceof Set ? vault.activeAddresses.size : 0;
+}
+
+function sha256Json(value) {
+  return `sha256:${createHash('sha256').update(JSON.stringify(value)).digest('hex')}`;
+}
+
+function contextPackPublicDigest(pack) {
+  return sha256Json({
+    schema: pack.schema,
+    context_pack_id: pack.context_pack_id,
+    provider: pack.provider,
+    model: pack.model,
+    purpose: pack.purpose,
+    memory_addresses: pack.memory_addresses,
+    receipt_hashes: pack.receipt_hashes,
+    active_set_root: pack.active_set_root,
+    receipt_log_root: pack.receipt_log_root,
+  });
+}
+
+function publicReceiptRefs(receipts) {
+  return (Array.isArray(receipts) ? receipts : []).map((receipt) => ({
+    receipt_id: receipt.receipt_id,
+    operation: receipt.operation,
+    memory_addr: receipt.memory_addr,
+    provider: receipt.provider,
+    model: receipt.model,
+    event_hash: receipt.event_hash,
+    receipt_log_root: receipt.receipt_log_root,
+    timestamp: receipt.timestamp,
+  }));
+}
+
+function publicContextPackSummary(pack) {
+  const receipts = publicReceiptRefs(pack.receipts);
+  return {
+    schema: pack.schema,
+    context_pack_ref: `enigma://context-pack/${pack.context_pack_id}`,
+    context_pack_id: pack.context_pack_id,
+    context_pack_digest: contextPackPublicDigest(pack),
+    provider: pack.provider,
+    model: pack.model,
+    purpose: pack.purpose,
+    memory_addresses: Array.isArray(pack.memory_addresses) ? [...pack.memory_addresses] : [],
+    memory_count: Array.isArray(pack.memory_addresses) ? pack.memory_addresses.length : 0,
+    receipt_count: receipts.length,
+    receipt_hashes: Array.isArray(pack.receipt_hashes) ? [...pack.receipt_hashes] : [],
+    receipts,
+    active_set_root: pack.active_set_root,
+    receipt_log_root: pack.receipt_log_root,
+    content_redacted: true,
+  };
+}
+
+function demoBundleRef(bundleWasSupplied) {
+  return bundleWasSupplied ? 'supplied_bundle' : DEFAULT_CROSS_MODEL_DEMO_BUNDLE;
+}
+
 async function readPackageJson() {
   return readJson(PACKAGE_JSON_URL);
 }
@@ -488,6 +574,119 @@ export async function quickstartCommand(flags, io) {
   return verifyReport.ok === true ? 0 : 1;
 }
 
+export async function crossModelDemoCommand(flags, io) {
+  const bundleFlag = getFlag(flags, ['bundle', 'file']);
+  if (bundleFlag === true || bundleFlag === '') throw new Error('Missing required --bundle.');
+  const bundleWasSupplied = bundleFlag !== undefined;
+  const bundleInput = bundleWasSupplied ? String(bundleFlag) : DEFAULT_CROSS_MODEL_DEMO_BUNDLE;
+  const bundlePath = resolve(bundleInput);
+  const out = getFlag(flags, ['out']);
+  if (out === true || out === '') throw new Error('Missing required --out.');
+  const outPath = out === undefined ? undefined : resolve(String(out));
+  if (outPath !== undefined) ensureDistinctOutputPaths([bundlePath, outPath]);
+
+  const memoryFileWasSupplied = getFlag(flags, ['memory-file', 'memoryFile', 'text-file', 'textFile']) !== undefined;
+  let bundleCreated = false;
+  let vault;
+  let passport;
+  let demoMemoryAddr;
+
+  if (!bundleWasSupplied) {
+    vault = createVault({
+      subjectId: 'cross-model-demo-user',
+      displayName: 'Cross-model demo user',
+      passphrase: 'local-cross-model-demo-passphrase',
+    });
+    passport = createPassport({ vault, subjectId: vault.subject_id, displayName: 'Cross-model demo user' });
+    const remembered = remember({
+      vault,
+      passport,
+      text: await crossModelMemoryTextFromFlags(flags),
+      purpose: 'cross_model_demo_memory',
+      purpose_tags: ['cross-model-demo'],
+      metadata: { source: memoryFileWasSupplied ? 'local file supplied to demo' : 'generic cross-model demo memory' },
+    });
+    demoMemoryAddr = remembered.memory_addr;
+    bundleCreated = true;
+  } else {
+    const existed = await fileExists(bundlePath);
+    if (!existed) {
+      await ensureBundle(bundlePath, flags);
+      bundleCreated = true;
+    }
+    ({ vault, passport } = await loadState(bundlePath));
+    const remembered = remember({
+      vault,
+      passport,
+      text: await crossModelMemoryTextFromFlags(flags),
+      purpose: 'cross_model_demo_memory',
+      purpose_tags: ['cross-model-demo'],
+      metadata: { source: memoryFileWasSupplied ? 'local file supplied to demo' : 'generic cross-model demo memory' },
+    });
+    demoMemoryAddr = remembered.memory_addr;
+  }
+  const memorySource = memoryFileWasSupplied ? 'memory_file' : 'generic_demo';
+
+  const limit = integerFlag(flags, ['limit'], 'limit', 1);
+  if (limit < 1) throw new Error('--limit must be at least 1.');
+  const receiptCountBeforeProfiles = Array.isArray(vault.receipts) ? vault.receipts.length : 0;
+  const profiles = [];
+  for (const profile of CROSS_MODEL_PROFILES) {
+    const pack = compileContextPack({
+      vault,
+      passport,
+      provider: profile.provider,
+      model: profile.model,
+      query: 'memory follows me across models',
+      purpose: `cross_model_demo:${profile.id}`,
+      memory_addresses: [demoMemoryAddr],
+      limit,
+    });
+    const contextPack = publicContextPackSummary(pack);
+    profiles.push({
+      profile: profile.id,
+      label: profile.label,
+      provider: profile.provider,
+      model: profile.model,
+      context_pack_ref: contextPack.context_pack_ref,
+      context_pack_id: contextPack.context_pack_id,
+      context_pack_digest: contextPack.context_pack_digest,
+      context_pack: contextPack,
+      receipt_count: contextPack.receipt_count,
+      memory_count: contextPack.memory_count,
+      provider_native_memory_canonical: false,
+      receipts: contextPack.receipts,
+      claim_boundaries: { ...CROSS_MODEL_CLAIM_BOUNDARIES },
+    });
+  }
+
+  const bundle = await persistState(bundlePath, vault);
+  const report = {
+    ok: true,
+    schema: 'enigma.cross_model_demo.v1',
+    command: 'enigma demo cross-model',
+    story: 'One local Enigma memory is packaged as public-safe context pack references and receipts for ChatGPT, Claude, Kimi, Cursor, and a local LLM. No provider is called.',
+    bundle_ref: demoBundleRef(bundleWasSupplied),
+    bundle_supplied: bundleWasSupplied,
+    bundle_created: bundleCreated,
+    demo_only_vault: !bundleWasSupplied,
+    memory_source: memorySource,
+    demo_memory_addr: demoMemoryAddr,
+    profile_count: profiles.length,
+    profiles,
+    memory_count: activeMemoryCount(vault),
+    receipt_count: Array.isArray(bundle.receipts) ? bundle.receipts.length : 0,
+    generated_receipt_count: (Array.isArray(bundle.receipts) ? bundle.receipts.length : 0) - receiptCountBeforeProfiles,
+    provider_credentials_required: false,
+    provider_native_memory_canonical: false,
+    out_written: outPath !== undefined,
+    claim_boundaries: { ...CROSS_MODEL_CLAIM_BOUNDARIES },
+  };
+  if (outPath !== undefined) await writeJson(outPath, report);
+  print(report, io);
+  return 0;
+}
+
 async function rememberCommand(flags, io) {
   const bundlePath = resolve(String(getFlag(flags, ['bundle', 'file'], DEFAULT_BUNDLE)));
   const { vault, passport } = await loadState(bundlePath);
@@ -1074,6 +1273,7 @@ function usage() {
     commands: [
       'init',
       'quickstart',
+      'demo cross-model',
       'doctor',
       'install',
       'connect <client>',
@@ -1127,6 +1327,12 @@ function usage() {
       '--memory-text <text>': 'Inline demo memory text for non-private demos only.',
       '--overwrite': 'Replace existing quickstart output files.',
     },
+    cross_model_demo_options: {
+      '--bundle <path>': `Reuse a local Enigma bundle. If omitted, ${DEFAULT_CROSS_MODEL_DEMO_BUNDLE} is recreated as a demo-only local vault.`,
+      '--memory-file <path>': 'Seed the demo from a local file without echoing plaintext. Alias: --text-file.',
+      '--out <path>': 'Write the same public-safe JSON report to a local file.',
+      '--limit <n>': 'Maximum active memories per generated profile context pack. Defaults to 1 for the same-memory demo story.',
+    },
     native_host: {
       bin: 'enigma-native-host',
       host_name: 'com.enigma.native_host',
@@ -1192,16 +1398,17 @@ export async function main(argv = process.argv.slice(2), io = { stdout: process.
     print(usage(), io);
     return 0;
   }
-  const twoPartCommands = ['boundary', 'mcp', 'mesh', 'enterprise', 'capsule', 'relay', 'gateway', 'connect', 'disconnect', 'import', 'native-host', 'meter', 'settlement'];
+  const twoPartCommands = ['boundary', 'mcp', 'mesh', 'enterprise', 'capsule', 'relay', 'gateway', 'connect', 'disconnect', 'import', 'native-host', 'meter', 'settlement', 'demo'];
   const flags = parseArgs(twoPartCommands.includes(command) ? argv.slice(2) : argv.slice(1));
   const positionalFile = optionalPositional(argv[2]);
-  if ((flags.has('help') || argv.includes('-h')) && (((command === 'relay' || command === 'gateway') && (subcommand === 'serve' || subcommand === 'demo')) || (command === 'native-host' && (subcommand === 'manifest' || subcommand === 'install-plan')))) {
+  if ((flags.has('help') || argv.includes('-h')) && (((command === 'relay' || command === 'gateway') && (subcommand === 'serve' || subcommand === 'demo')) || (command === 'native-host' && (subcommand === 'manifest' || subcommand === 'install-plan')) || (command === 'demo' && subcommand === 'cross-model'))) {
     print(usage(), io);
     return 0;
   }
   try {
     if (command === 'init') return await initCommand(flags, io);
     if (command === 'quickstart') return await quickstartCommand(flags, io);
+    if (command === 'demo' && subcommand === 'cross-model') return await crossModelDemoCommand(flags, io);
     if (command === 'doctor') return await doctorCommand(flags, io);
     if (command === 'install') return await installCommand(flags, io);
     if (command === 'connect') return await connectCommand(subcommand, flags, io);