ticlawk 0.1.12-dev.0

package/src/core/media/inbound.mjs

@@ -0,0 +1,127 @@
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { extname } from 'node:path';
+import { randomUUID } from 'node:crypto';
+
+const EXT_TO_MIME = {
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.png': 'image/png',
+  '.gif': 'image/gif',
+  '.webp': 'image/webp',
+  '.bmp': 'image/bmp',
+  '.tiff': 'image/tiff',
+  '.tif': 'image/tiff',
+  '.heic': 'image/heic',
+  '.heif': 'image/heif',
+};
+
+function resolveMediaDir(subdir, options = {}) {
+  const baseDir = options.baseDir || '/tmp/ticlawk';
+  return `${baseDir}/${subdir}`;
+}
+
+async function downloadRemoteMedia(items, subdir, options = {}) {
+  const mediaDir = resolveMediaDir(subdir, options);
+  mkdirSync(mediaDir, { recursive: true });
+  const successful = [];
+
+  for (const item of items) {
+    if (item.kind === 'local_path' && item.value && existsSync(item.value)) {
+      const label = `Image #${successful.length + 1}`;
+      successful.push({
+        path: item.value,
+        mime: item.mime || EXT_TO_MIME[extname(item.value).toLowerCase()] || 'application/octet-stream',
+        source: item.value,
+        label,
+      });
+      continue;
+    }
+    if (item.kind !== 'remote_url' || !item.value) continue;
+    const guessedExt = extname(item.value.split('?')[0] || '').toLowerCase() || '.jpg';
+    const label = `Image #${successful.length + 1}`;
+    const localPath = `${mediaDir}/image-${successful.length + 1}-${randomUUID()}${guessedExt}`;
+    try {
+      const res = await fetch(item.value);
+      const buf = Buffer.from(await res.arrayBuffer());
+      writeFileSync(localPath, buf);
+      successful.push({
+        path: localPath,
+        mime: item.mime || EXT_TO_MIME[guessedExt] || 'application/octet-stream',
+        source: item.value,
+        label,
+      });
+    } catch {}
+  }
+
+  return successful;
+}
+
+export async function buildImageMessageFromInbound(inbound, subdir = 'inbound-media', options = {}) {
+  const successful = await downloadRemoteMedia(inbound.media || [], subdir, options);
+  const userText = (inbound.text || '').trim();
+  if (successful.length === 0) {
+    const fallbackList = (inbound.media || [])
+      .map((item) => `[media attached: ${item.value}]`)
+      .join('\n');
+    return [userText, fallbackList].filter(Boolean).join('\n\n').trim() || '(image attached)';
+  }
+
+  const lines = successful.map((entry, index) => {
+    const prefix = successful.length > 1
+      ? `[media attached ${index + 1}/${successful.length}: `
+      : '[media attached: ';
+    const mimePart = entry.mime ? ` (${entry.mime})` : '';
+    const sourcePart = entry.source ? ` | ${entry.source}` : '';
+    return `${prefix}${entry.path}${mimePart}${sourcePart}]`;
+  });
+
+  return [userText, ...lines].filter(Boolean).join('\n\n').trim();
+}
+
+function buildLocalImagePathSummary(entries) {
+  if (!entries.length) return '';
+  return [
+    'Attached images:',
+    ...entries.map((entry, index) => `${entry.label || `Image #${index + 1}`} local path: ${entry.path}`),
+  ].join('\n');
+}
+
+export async function buildOpenCodeInputFromInbound(inbound, subdir = 'opencode-media', options = {}) {
+  const successful = await downloadRemoteMedia(inbound.media || [], subdir, options);
+  const userText = (inbound.text || '').trim();
+  if (successful.length === 0) {
+    // No usable image bytes — caller decides whether to error or fall through to text-only
+    return {
+      text: userText,
+      files: [],
+      downloaded: 0,
+      attempted: (inbound.media || []).length,
+    };
+  }
+  return {
+    text: userText,
+    files: successful.map((entry) => entry.path),
+    downloaded: successful.length,
+    attempted: (inbound.media || []).length,
+  };
+}
+
+export async function buildCodexInputFromInbound(inbound, subdir = 'codex-media', options = {}) {
+  const successful = await downloadRemoteMedia(inbound.media || [], subdir, options);
+  if (successful.length === 0) {
+    const fallbackList = (inbound.media || []).map((item) => `[media attached: ${item.value}]`).join('\n');
+    const text = [(inbound.text || '').trim(), fallbackList].filter(Boolean).join('\n\n').trim() || '(image attached)';
+    return [{ type: 'text', text }];
+  }
+
+  const input = [];
+  const text = [
+    (inbound.text || '').trim(),
+    buildLocalImagePathSummary(successful),
+  ].filter(Boolean).join('\n\n');
+  input.push({ type: 'text', text });
+  for (const entry of successful) {
+    input.push({ type: 'localImage', path: entry.path });
+  }
+  return input;
+}

package/src/core/media/outbound.mjs

@@ -0,0 +1,163 @@
+import { extname } from 'node:path';
+import { homedir } from 'node:os';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+export const MIME_MAP = {
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.webp': 'image/webp',
+  '.svg': 'image/svg+xml',
+  '.mp4': 'video/mp4',
+  '.webm': 'video/webm',
+  '.pdf': 'application/pdf',
+};
+
+function mediaExtensionPattern() {
+  return Object.keys(MIME_MAP).map((entry) => entry.replace('.', '\\.')).join('|');
+}
+
+function stripUrlSuffix(value) {
+  return String(value || '').replace(/[?#].*$/, '');
+}
+
+function trimCandidate(value) {
+  return String(value || '')
+    .trim()
+    .replace(/^<|>$/g, '')
+    .replace(/^["']|["']$/g, '')
+    .replace(/\\\//g, '/');
+}
+
+function hasKnownMediaExtension(value) {
+  return Boolean(MIME_MAP[extname(stripUrlSuffix(value)).toLowerCase()]);
+}
+
+function normalizeMediaPath(value) {
+  let candidate = trimCandidate(value);
+  if (!candidate) return null;
+
+  candidate = candidate.replace(/^about:/i, '');
+
+  if (/^file:/i.test(candidate)) {
+    try {
+      candidate = fileURLToPath(candidate);
+    } catch {
+      candidate = candidate.replace(/^file:(?:\/\/)?/i, '');
+    }
+  }
+
+  candidate = stripUrlSuffix(candidate);
+
+  if (candidate.startsWith('~')) {
+    candidate = candidate.replace(/^~/, homedir());
+  }
+
+  if (candidate.startsWith('/')) {
+    candidate = candidate.replace(/^\/{2,}/, '/');
+  }
+
+  if (!candidate.startsWith('/')) return null;
+  if (!hasKnownMediaExtension(candidate)) return null;
+  return candidate;
+}
+
+function addMediaCandidate(paths, value) {
+  const normalized = normalizeMediaPath(value);
+  if (normalized) paths.add(normalized);
+}
+
+export function extractMediaPaths(text) {
+  const extPattern = mediaExtensionPattern();
+  const paths = new Set();
+  const candidates = [];
+
+  const body = String(text || '');
+  for (const match of body.matchAll(/<img[^>]+src=["']([^"']+)["'][^>]*>/gi)) {
+    candidates.push({ index: match.index || 0, value: match[1] });
+  }
+  for (const match of body.matchAll(/!?\[[^\]]*\]\(\s*<([^>\n]+)>/gi)) {
+    candidates.push({ index: match.index || 0, value: match[1] });
+  }
+  for (const match of body.matchAll(/!?\[[^\]]*\]\(\s*([^\s)>]+)>?/gi)) {
+    candidates.push({ index: match.index || 0, value: match[1] });
+  }
+
+  const re = new RegExp(`((?:file:(?://)?|about:(?://)?)?(?:~|/{1,3})[^\\s"'<>)]*?(?:${extPattern})(?:[?#][^\\s"'<>)]*)?)`, 'gi');
+  for (const match of body.matchAll(re)) {
+    candidates.push({ index: match.index || 0, value: match[1] });
+  }
+
+  candidates
+    .sort((a, b) => a.index - b.index)
+    .forEach((candidate) => addMediaCandidate(paths, candidate.value));
+
+  return [...paths];
+}
+
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function referencesPath(value, normalizedPaths) {
+  const normalized = normalizeMediaPath(value);
+  return Boolean(normalized && normalizedPaths.has(normalized));
+}
+
+function pathReferenceVariants(path) {
+  const normalized = normalizeMediaPath(path) || path;
+  const variants = new Set([normalized]);
+  if (normalized.startsWith('/')) {
+    variants.add(pathToFileURL(normalized).href);
+    variants.add(`about:${normalized}`);
+    variants.add(`about://${normalized}`);
+  }
+  return [...variants].sort((a, b) => b.length - a.length);
+}
+
+export function stripMediaPathReferences(text, explicitPaths = []) {
+  let next = String(text || '');
+  const paths = [...new Set([
+    ...explicitPaths,
+    ...extractMediaPaths(next),
+  ].map((path) => normalizeMediaPath(path)).filter(Boolean))];
+  const normalizedPaths = new Set(paths);
+
+  next = next
+    .replace(/<img[^>]+src=["']([^"']+)["'][^>]*>/gi, (match, src) => (
+      referencesPath(src, normalizedPaths) ? '' : match
+    ))
+    .replace(/!\[[^\]]*\]\(\s*<([^>\n]+)>(?:\s+["'][^"']*["'])?\s*\)/gi, (match, target) => (
+      referencesPath(target, normalizedPaths) ? '' : match
+    ))
+    .replace(/!\[[^\]]*\]\(\s*([^\s)>]+)>?(?:\s+["'][^"']*["'])?\s*\)/gi, (match, target) => (
+      referencesPath(target, normalizedPaths) ? '' : match
+    ));
+
+  for (const path of paths) {
+    for (const variant of pathReferenceVariants(path)) {
+      const escapedPath = escapeRegExp(variant);
+      next = next
+        .replace(new RegExp(`\\[media attached[^\\]]*${escapedPath}[^\\]]*\\]\\s*`, 'gi'), '')
+        .replace(new RegExp(`^\\s*${escapedPath}\\s*$`, 'gim'), '')
+        .replace(new RegExp(escapedPath, 'g'), '');
+    }
+  }
+
+  return next
+    .replace(/<img[^>]+src=["'](?:file:|about:)(?:\/){0,3}(?:tmp|private|var|Users|home)[^"']*["'][^>]*>/gi, '')
+    .replace(/!\[[^\]]*\]\(\s*<?(?:file:|about:)(?:\/){0,3}(?:tmp|private|var|Users|home)[^)]*\)/gi, '')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
+}
+
+export function normalizeOutboundMedia(result) {
+  const explicit = Array.isArray(result?.mediaUrls) ? result.mediaUrls : [];
+  const inferred = extractMediaPaths(result?.text || '');
+  return [...new Set([...explicit, ...inferred])].map((path) => ({
+    kind: 'local_path',
+    value: path,
+    mime: MIME_MAP[extname(path).toLowerCase()] || 'application/octet-stream',
+  }));
+}

package/src/core/profiles.mjs

@@ -0,0 +1,173 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import dotenv from 'dotenv';
+import { AF_HOME, AF_CONFIG_PATH, loadPersistentConfig } from './config.mjs';
+
+export const AF_ACTIVE_PROFILE_PATH = join(AF_HOME, 'active-profile');
+export const AF_PROFILE_ROOT = join(AF_HOME, 'profiles');
+
+function parseProfileRef(value) {
+  const normalized = String(value || '').trim();
+  const [adapter, ...rest] = normalized.split(':');
+  const userId = rest.join(':');
+  if (!adapter || !userId) return null;
+  return { adapter, userId, ref: `${adapter}:${userId}` };
+}
+
+function writeTextAtomic(filePath, text, mode = 0o600) {
+  mkdirSync(dirname(filePath), { recursive: true });
+  const tempPath = `${filePath}.tmp`;
+  writeFileSync(tempPath, text, { mode });
+  renameSync(tempPath, filePath);
+}
+
+function writeJsonAtomic(filePath, value) {
+  writeTextAtomic(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+function writeDotenvAtomic(filePath, value) {
+  const lines = [
+    '# Persistent ticlawk profile config',
+    ...Object.entries(value || {})
+      .filter(([, item]) => item !== undefined && item !== null && item !== '')
+      .map(([key, item]) => `${key}=${String(item)}`),
+  ];
+  writeTextAtomic(filePath, `${lines.join('\n')}\n`);
+}
+
+export function profileRef(adapter, userId) {
+  return `${adapter}:${userId}`;
+}
+
+export function getProfileDir(adapter, userId) {
+  return join(AF_PROFILE_ROOT, adapter, userId);
+}
+
+export function getProfileConfigPath(adapter, userId) {
+  return join(getProfileDir(adapter, userId), '.config');
+}
+
+export function getProfileBindingsPath(adapter, userId) {
+  return join(getProfileDir(adapter, userId), 'bindings.json');
+}
+
+export function getActiveProfile() {
+  if (!existsSync(AF_ACTIVE_PROFILE_PATH)) return null;
+  try {
+    return parseProfileRef(readFileSync(AF_ACTIVE_PROFILE_PATH, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+export function getActiveBindingsPath(fallbackPath) {
+  const active = getActiveProfile();
+  if (!active) return fallbackPath;
+  return getProfileBindingsPath(active.adapter, active.userId);
+}
+
+export function readProfileConfig(adapter, userId) {
+  const filePath = getProfileConfigPath(adapter, userId);
+  if (!existsSync(filePath)) return {};
+  try {
+    return dotenv.parse(readFileSync(filePath, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+export function readProfileMeta(adapter, userId) {
+  const filePath = join(getProfileDir(adapter, userId), 'profile.json');
+  if (!existsSync(filePath)) return null;
+  try {
+    return JSON.parse(readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+export function saveProfile({ adapter, userId, config = {}, meta = {} }) {
+  if (!adapter || !userId) throw new Error('profile adapter and userId are required');
+  const dir = getProfileDir(adapter, userId);
+  mkdirSync(dir, { recursive: true });
+  const currentConfig = readProfileConfig(adapter, userId);
+  const nextConfig = { ...currentConfig, ...config };
+  delete nextConfig.TICLAWK_SETUP_CODE;
+  writeDotenvAtomic(getProfileConfigPath(adapter, userId), nextConfig);
+
+  const currentMeta = readProfileMeta(adapter, userId) || {};
+  writeJsonAtomic(join(dir, 'profile.json'), {
+    ...currentMeta,
+    ...meta,
+    adapter,
+    userId,
+    updatedAt: new Date().toISOString(),
+    createdAt: currentMeta.createdAt || meta.createdAt || new Date().toISOString(),
+  });
+}
+
+export function activateProfile(adapter, userId) {
+  const config = readProfileConfig(adapter, userId);
+  if (!Object.keys(config).length) {
+    throw new Error(`profile does not exist: ${profileRef(adapter, userId)}`);
+  }
+  writeTextAtomic(AF_ACTIVE_PROFILE_PATH, `${profileRef(adapter, userId)}\n`);
+  writeDotenvAtomic(AF_CONFIG_PATH, config);
+  for (const [key, value] of Object.entries(config)) {
+    process.env[key] = String(value);
+  }
+  return { adapter, userId, ref: profileRef(adapter, userId) };
+}
+
+export function saveAndActivateProfile({ adapter, userId, config = {}, meta = {} }) {
+  saveProfile({ adapter, userId, config, meta });
+  return activateProfile(adapter, userId);
+}
+
+export function listProfiles() {
+  const result = [];
+  for (const adapter of fsSafeReaddir(AF_PROFILE_ROOT)) {
+    for (const userId of fsSafeReaddir(join(AF_PROFILE_ROOT, adapter))) {
+      const meta = readProfileMeta(adapter, userId) || {};
+      result.push({
+        adapter,
+        userId,
+        ref: profileRef(adapter, userId),
+        emailMasked: meta.emailMasked || meta.email_masked || '',
+        phoneMasked: meta.phoneMasked || meta.phone_masked || '',
+        meta,
+        config: readProfileConfig(adapter, userId),
+      });
+    }
+  }
+  return result;
+}
+
+function fsSafeReaddir(path) {
+  try {
+    return existsSync(path)
+      ? readdirSync(path, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name)
+      : [];
+  } catch {
+    return [];
+  }
+}
+
+export function ensureLegacyProfile({ adapter, userId, meta = {} }) {
+  if (!adapter || !userId) return null;
+  const profileConfigPath = getProfileConfigPath(adapter, userId);
+  if (!existsSync(profileConfigPath)) {
+    saveProfile({
+      adapter,
+      userId,
+      config: loadPersistentConfig(),
+      meta,
+    });
+  }
+  if (!getActiveProfile()) {
+    writeTextAtomic(AF_ACTIVE_PROFILE_PATH, `${profileRef(adapter, userId)}\n`);
+  }
+  return readProfileMeta(adapter, userId);
+}

package/src/core/runtime-contract.mjs

@@ -0,0 +1,68 @@
+/**
+ * Runtime contract shared by the daemon and CLI.
+ *
+ * Runtimes expose a small common surface:
+ * - `resolveBinding(payload)` validates a runtime locator such as sessionId,
+ *   workdir, or agentId and returns the metadata persisted in the binding store
+ * - `deliverTurn(inbound, ctx)` handles a routed inbound turn
+ * - optional lifecycle hooks let the daemon replay bindings and recover
+ *   after restart without adapter-specific branching in startTiclawk()
+ */
+
+import { normalizeServiceType } from './runtime-registry.mjs';
+
+/**
+ * @typedef {string} RuntimeServiceType
+ */
+
+/**
+ * @typedef {Object} RuntimeBindingPayload
+ * @property {string} [adapter]
+ * @property {RuntimeServiceType} serviceType
+ * @property {string} [sessionId]
+ * @property {string} [workdir]
+ * @property {string} [projectDir]
+ * @property {string} [cwd]
+ * @property {string} [agentId]
+ * @property {string} [code]
+ * @property {string} [name]
+ */
+
+/**
+ * @typedef {Object} ResolvedRuntimeBinding
+ * @property {string} runtime
+ * @property {string} displayName
+ * @property {Record<string, any>} runtimeMeta
+ */
+
+/**
+ * @typedef {Object} RuntimeDeliveryContext
+ * @property {any} adapter
+ * @property {Record<string, AgentRuntime>} runtimes
+ * @property {(bindingId: string) => any} getBinding
+ * @property {(filters?: Record<string, any>) => any[]} listBindings
+ * @property {(bindingId: string) => Promise<void>} [deleteBinding]
+ * @property {(binding: any) => Promise<any>} [cacheBinding]
+ * @property {(binding: any) => Promise<any>} upsertBinding
+ * @property {(inbound: any, runtimeName: string) => Promise<string>} buildImageMessageFromInbound
+ * @property {any} logger
+ */
+
+/**
+ * @typedef {Object} AgentRuntime
+ * @property {string} name
+ * @property {(payload: RuntimeBindingPayload) => Promise<ResolvedRuntimeBinding>} resolveBinding
+ * @property {(inbound: any, ctx: RuntimeDeliveryContext) => Promise<boolean>} deliverTurn
+ * @property {(binding: any, ctx: { adapter: any, logger: any }) => (Promise<void>|void)} [onBindingUpdated]
+ * @property {(ctx: { adapter: any, getBinding: (bindingId: string) => any }) => (Promise<number>|number)} [recoverInFlight]
+ * @property {(binding: any, ctx: { adapter: any, logger: any }) => (Promise<number>|number)} [reconcileAfterRestart]
+ */
+
+/**
+ * Normalize user-facing runtime selectors into the canonical serviceType
+ * stored in bindings and passed over the local control API.
+ *
+ * Supported inputs are defined by `RUNTIME_DEFINITIONS` in
+ * `runtime-registry.mjs`.
+ */
+export { normalizeServiceType };

package/src/core/runtime-env.mjs

@@ -0,0 +1,9 @@
+export function buildRuntimeEnv(extra = {}) {
+  const env = { ...process.env, ...extra };
+  for (const key of Object.keys(env)) {
+    if (key.startsWith('TICLAWK_')) {
+      delete env[key];
+    }
+  }
+  return env;
+}

package/src/core/runtime-registry.mjs

@@ -0,0 +1,93 @@
+/**
+ * Runtime registry.
+ *
+ * New runtime integrations should be added here plus their own
+ * `src/runtimes/<name>/` implementation. Core code consumes this registry for
+ * aliases, config keys, CLI labels, and lazy runtime loading.
+ */
+
+function normalizeRuntimeToken(value) {
+  return String(value || '').trim().toLowerCase().replace(/[-\s]+/g, '_');
+}
+
+export const RUNTIME_DEFINITIONS = Object.freeze([
+  {
+    name: 'claude_code',
+    displayName: 'Claude Code',
+    aliases: ['', 'claude', 'claude_code', 'claude-code'],
+    streamingEnvKey: 'AF_STREAMING_CLAUDE_CODE',
+    executableConfigKey: 'CLAUDE_CODE_BIN',
+    executableCliKey: 'runtimes.claude_code.path',
+    connect: { locator: 'workdir', session: true },
+    loadRuntime: async () => (await import('../runtimes/claude-code/index.mjs')).claudeCodeRuntime,
+  },
+  {
+    name: 'codex',
+    displayName: 'Codex',
+    aliases: ['codex'],
+    streamingEnvKey: 'AF_STREAMING_CODEX',
+    executableConfigKey: 'CODEX_BIN',
+    executableCliKey: 'runtimes.codex.path',
+    connect: { locator: 'workdir', session: true },
+    loadRuntime: async () => (await import('../runtimes/codex/index.mjs')).codexRuntime,
+  },
+  {
+    name: 'openclaw',
+    displayName: 'OpenClaw',
+    aliases: ['openclaw', 'open_claw', 'open-claw'],
+    streamingEnvKey: 'AF_STREAMING_OPENCLAW',
+    connect: { locator: 'agentId', session: false },
+    loadRuntime: async () => (await import('../runtimes/openclaw/index.mjs')).openClawRuntime,
+  },
+  {
+    name: 'opencode',
+    displayName: 'opencode',
+    aliases: ['opencode', 'open_code', 'open-code'],
+    streamingEnvKey: 'AF_STREAMING_OPENCODE',
+    executableConfigKey: 'OPENCODE_BIN',
+    executableCliKey: 'runtimes.opencode.path',
+    connect: { locator: 'workdir', session: true },
+    loadRuntime: async () => (await import('../runtimes/opencode/index.mjs')).openCodeRuntime,
+  },
+  {
+    name: 'pi',
+    displayName: 'pi',
+    aliases: ['pi', 'pi_agent', 'pi-agent'],
+    streamingEnvKey: 'AF_STREAMING_PI',
+    executableConfigKey: 'PI_BIN',
+    executableCliKey: 'runtimes.pi.path',
+    connect: { locator: 'workdir', session: true },
+    loadRuntime: async () => (await import('../runtimes/pi/index.mjs')).piRuntime,
+  },
+]);
+
+export function normalizeServiceType(value) {
+  const normalized = normalizeRuntimeToken(value);
+  const match = RUNTIME_DEFINITIONS.find((runtime) => {
+    return runtime.name === normalized || runtime.aliases.map(normalizeRuntimeToken).includes(normalized);
+  });
+  return match?.name || null;
+}
+
+export function getRuntimeDefinition(value) {
+  const name = normalizeServiceType(value);
+  return RUNTIME_DEFINITIONS.find((runtime) => runtime.name === name) || null;
+}
+
+export function getRuntimeDisplayName(value) {
+  return getRuntimeDefinition(value)?.displayName || String(value || '').trim() || 'runtime';
+}
+
+export function getRuntimeExecutableDefinitions() {
+  return RUNTIME_DEFINITIONS.filter((runtime) => runtime.executableConfigKey && runtime.executableCliKey);
+}
+
+export async function buildRuntimeContext() {
+  const loaded = await Promise.all(RUNTIME_DEFINITIONS.map(async (definition) => {
+    const runtime = await definition.loadRuntime();
+    return { definition, runtime };
+  }));
+  const runtimeList = loaded.map(({ runtime }) => runtime);
+  const runtimes = Object.fromEntries(loaded.map(({ runtime }) => [runtime.name, runtime]));
+  return { runtimeList, runtimes };
+}