@mindexec/cli 0.2.371 → 0.2.372

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindexec/cli",
-  "version": "0.2.371",
+  "version": "0.2.372",
   "description": "MindExec local runtime and bridge CLI",
   "main": "server.js",
   "type": "module",

package/server.js

@@ -2198,10 +2198,11 @@ const PROTECTED_BRIDGE_ROUTES = [
     { method: 'GET', exact: '/api/concept/embed/readiness' },
     { method: 'POST', exact: '/api/concept/embed' },
     { method: 'POST', prefix: '/api/browser/act' },
-    { method: 'GET', prefix: '/api/company-core/' },
+    { method: 'GET', prefix: '/api/company-core/' },
     { method: 'POST', prefix: '/api/company-core/' },
     { method: 'PUT', prefix: '/api/company-core/' },
     { method: 'DELETE', prefix: '/api/company-core/' },
+    { method: 'GET', prefix: '/api/model-catalog' },
     { method: 'GET', prefix: '/api/codex/' },
     { method: 'POST', prefix: '/api/codex/' },
     { method: 'GET', prefix: '/api/shell/' },
@@ -3231,14 +3232,78 @@ function extractCodexOutputPath(command) {
     return match[2] || match[3] || match[4] || null;
 }
 
-const CODEX_CONFIG_PATH = path.join(os.homedir(), '.codex', 'config.toml');
-const CODEX_MODEL_CATALOG_TTL_MS = 15 * 60 * 1000;
-let cachedCodexConfig = null;
-let cachedCodexConfigMtimeMs = -1;
+const CODEX_CONFIG_PATH = path.join(os.homedir(), '.codex', 'config.toml');
+const CODEX_MODEL_CATALOG_TTL_MS = 15 * 60 * 1000;
+const EXTERNAL_MODEL_CATALOG_TTL_MS = 60 * 1000;
+let cachedCodexConfig = null;
+let cachedCodexConfigMtimeMs = -1;
 let cachedCodexModelCatalog = null;
 let cachedCodexModelCatalogExpiresAt = 0;
+let cachedBridgeModelCatalog = null;
+let cachedBridgeModelCatalogExpiresAt = 0;
 let lastCodexExecRuntime = null;
 let codexRuntime = null;
+
+const FALLBACK_CODEX_TEXT_MODELS = [
+    { id: 'gpt-5.5', displayName: 'GPT-5.5' },
+    { id: 'gpt-5.4', displayName: 'GPT-5.4' },
+    { id: 'gpt-5.4-mini', displayName: 'GPT-5.4 mini' },
+    { id: 'gpt-5.3-codex-spark', displayName: 'GPT-5.3 Codex Spark' }
+];
+
+const FALLBACK_OPENROUTER_TEXT_MODELS = [
+    { id: 'openrouter/auto', displayName: 'Auto Router', isFallback: true },
+    { id: 'openai/gpt-chat-latest', displayName: 'GPT Chat Latest', isFallback: true },
+    { id: 'anthropic/claude-sonnet-4.5', displayName: 'Claude Sonnet 4.5', supportsReasoning: true, isFallback: true },
+    { id: 'google/gemini-2.5-pro', displayName: 'Gemini 2.5 Pro', supportsReasoning: true, isFallback: true },
+    { id: 'google/gemini-2.5-flash', displayName: 'Gemini 2.5 Flash', isFallback: true }
+];
+
+const FALLBACK_IMAGE_MODELS = [
+    {
+        id: 'gpt-image-2',
+        label: 'GPT Image 2',
+        displayName: 'GPT Image 2',
+        provider: 'openai',
+        mode: 'image',
+        supportedSizes: ['custom'],
+        vendorPricing: { averageUsd: 0.02, source: 'fallback' },
+        isFallback: true
+    },
+    {
+        id: 'Tongyi-MAI/Z-Image-Turbo:free',
+        label: 'Z-Image Turbo',
+        displayName: 'Z-Image Turbo',
+        provider: 'imagerouter',
+        mode: 'image',
+        supportedSizes: ['custom'],
+        vendorPricing: { averageUsd: 0.02, source: 'fallback' },
+        isFallback: true
+    }
+];
+
+const FALLBACK_VIDEO_MODELS = [
+    {
+        id: 'google/veo-2',
+        label: 'Google Veo 2',
+        displayName: 'Google Veo 2',
+        provider: 'imagerouter',
+        mode: 'video',
+        supportedSizes: ['1280x720', '720x1280'],
+        vendorPricing: { averageUsd: 0.25, maxUsd: 0.25, source: 'fallback' },
+        isFallback: true
+    },
+    {
+        id: 'runway/gen-3',
+        label: 'Runway Gen-3',
+        displayName: 'Runway Gen-3',
+        provider: 'imagerouter',
+        mode: 'video',
+        supportedSizes: ['1280x720', '720x1280'],
+        vendorPricing: { averageUsd: 0.20, maxUsd: 0.20, source: 'fallback' },
+        isFallback: true
+    }
+];
 
 function readCodexConfig(options = {}) {
     const forceRefresh = Boolean(options.forceRefresh);
@@ -3409,6 +3474,371 @@ async function getCodexModelCatalog(options = {}) {
     }
 }
 
+function getPlainString(value) {
+    return String(value ?? '').trim();
+}
+
+function getCatalogString(item, propertyName) {
+    if (!item || typeof item !== 'object') {
+        return '';
+    }
+
+    return getPlainString(item[propertyName]);
+}
+
+function getCatalogNumber(item, propertyName) {
+    if (!item || typeof item !== 'object') {
+        return null;
+    }
+
+    const value = Number(item[propertyName]);
+    return Number.isFinite(value) ? value : null;
+}
+
+function getCatalogStringArray(item, propertyName) {
+    if (!item || typeof item !== 'object' || !Array.isArray(item[propertyName])) {
+        return [];
+    }
+
+    return [...new Set(item[propertyName]
+        .map(entry => getPlainString(entry))
+        .filter(Boolean))];
+}
+
+function getNestedCatalogStringArray(item, objectPropertyName, arrayPropertyName) {
+    if (!item || typeof item !== 'object') {
+        return [];
+    }
+
+    return getCatalogStringArray(item[objectPropertyName], arrayPropertyName);
+}
+
+function getNestedCatalogBoolean(item, objectPropertyName, propertyName) {
+    if (!item || typeof item !== 'object') {
+        return false;
+    }
+
+    const parent = item[objectPropertyName];
+    if (!parent || typeof parent !== 'object') {
+        return false;
+    }
+
+    const value = parent[propertyName];
+    return value === true || /^(1|true|yes|on)$/i.test(String(value ?? ''));
+}
+
+function getCatalogDecimal(item, propertyName) {
+    const value = getCatalogNumber(item, propertyName);
+    return value === null ? undefined : value;
+}
+
+function getOpenRouterPricing(item) {
+    const pricing = item?.pricing;
+    if (!pricing || typeof pricing !== 'object') {
+        return null;
+    }
+
+    const promptUsdPerToken = getCatalogDecimal(pricing, 'prompt');
+    const completionUsdPerToken = getCatalogDecimal(pricing, 'completion');
+    const requestUsd = getCatalogDecimal(pricing, 'request');
+    if (promptUsdPerToken === undefined && completionUsdPerToken === undefined && requestUsd === undefined) {
+        return null;
+    }
+
+    return {
+        promptUsdPerToken,
+        completionUsdPerToken,
+        requestUsd,
+        source: 'openrouter',
+        fetchedAt: new Date().toISOString()
+    };
+}
+
+function getImageRouterPricing(item) {
+    const price = item?.price;
+    if (!price || typeof price !== 'object') {
+        return null;
+    }
+
+    const minUsd = getCatalogDecimal(price, 'min');
+    const averageUsd = getCatalogDecimal(price, 'average');
+    const maxUsd = getCatalogDecimal(price, 'max');
+    if (minUsd === undefined && averageUsd === undefined && maxUsd === undefined) {
+        return null;
+    }
+
+    return {
+        minUsd,
+        averageUsd,
+        maxUsd,
+        source: 'imagerouter',
+        fetchedAt: new Date().toISOString()
+    };
+}
+
+function buildCatalogDisplayLabel(name, id) {
+    const label = getPlainString(name);
+    const modelId = getPlainString(id);
+    if (!label || label.toLowerCase() === modelId.toLowerCase()) {
+        return modelId;
+    }
+
+    return `${label} (${modelId})`;
+}
+
+function containsCatalogString(item, propertyName, expected) {
+    return getCatalogStringArray(item, propertyName)
+        .some(value => value.toLowerCase() === String(expected).toLowerCase());
+}
+
+function containsAnyCatalogString(item, propertyName, expectedValues) {
+    const expected = new Set(expectedValues.map(value => String(value).toLowerCase()));
+    return getCatalogStringArray(item, propertyName)
+        .some(value => expected.has(value.toLowerCase()));
+}
+
+function hasCatalogMediaModalityInElement(item) {
+    const modality = getCatalogString(item, 'modality').toLowerCase();
+    return containsAnyCatalogString(item, 'input_modalities', ['image', 'video', 'audio'])
+        || containsAnyCatalogString(item, 'output_modalities', ['image', 'video', 'audio'])
+        || /image|video|audio/i.test(modality);
+}
+
+function supportsOpenRouterTextOnlyOutput(item) {
+    const architecture = item?.architecture && typeof item.architecture === 'object'
+        ? item.architecture
+        : null;
+    const supportsText = containsCatalogString(item, 'output_modalities', 'text')
+        || (architecture && containsCatalogString(architecture, 'output_modalities', 'text'));
+    const hasMedia = hasCatalogMediaModalityInElement(item)
+        || (architecture && hasCatalogMediaModalityInElement(architecture));
+    return supportsText && !hasMedia;
+}
+
+function normalizeOpenRouterModel(item) {
+    const id = getCatalogString(item, 'id');
+    if (!id || !supportsOpenRouterTextOnlyOutput(item)) {
+        return null;
+    }
+
+    const name = getCatalogString(item, 'name');
+    const supportedParameters = getCatalogStringArray(item, 'supported_parameters');
+    return {
+        id,
+        label: buildCatalogDisplayLabel(name, id),
+        displayName: name || id,
+        provider: 'openrouter',
+        mode: 'text',
+        supportsReasoning: supportedParameters.some(value => value.toLowerCase() === 'reasoning'),
+        vendorPricing: getOpenRouterPricing(item),
+        source: 'openrouter'
+    };
+}
+
+async function fetchJsonWithTimeout(url, timeoutMs = 10000) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const response = await fetch(url, {
+            headers: {
+                Accept: 'application/json',
+                'Cache-Control': 'no-store',
+                Pragma: 'no-cache'
+            },
+            signal: controller.signal
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}`);
+        }
+        return await response.json();
+    } finally {
+        clearTimeout(timeout);
+    }
+}
+
+async function getOpenRouterTextModelCatalog() {
+    const payload = await fetchJsonWithTimeout('https://openrouter.ai/api/v1/models', 10000);
+    const items = Array.isArray(payload?.data) ? payload.data : [];
+    const options = items
+        .map(normalizeOpenRouterModel)
+        .filter(Boolean)
+        .sort((a, b) => String(a.label).localeCompare(String(b.label)));
+    return options.length > 0
+        ? options
+        : FALLBACK_OPENROUTER_TEXT_MODELS.map(option => ({
+            id: option.id,
+            label: option.displayName,
+            displayName: option.displayName,
+            provider: 'openrouter',
+            mode: 'text',
+            supportsReasoning: option.supportsReasoning === true,
+            isFallback: true,
+            source: 'fallback'
+        }));
+}
+
+function normalizeImageRouterModel(item, outputType) {
+    const id = getCatalogString(item, 'id');
+    if (!id) {
+        return null;
+    }
+
+    const displayName = getCatalogString(item, 'name') || id;
+    const supportedSizes = getNestedCatalogStringArray(item, 'inputs', 'size');
+    const supportedSeconds = getNestedCatalogStringArray(item, 'inputs', 'seconds');
+    return {
+        id,
+        label: displayName,
+        displayName,
+        provider: 'imagerouter',
+        mode: outputType,
+        supportedSizes: supportedSizes.length > 0 ? supportedSizes : (outputType === 'image' ? ['custom'] : []),
+        supportedSeconds,
+        capabilities: {
+            supportsTextToImage: outputType === 'image',
+            supportsImageToImage: getNestedCatalogBoolean(item, 'inputs', 'image'),
+            supportsInpaint: getNestedCatalogBoolean(item, 'inputs', 'mask'),
+            supportsSizeSelection: supportedSizes.length > 0,
+            supportedSizes,
+            supportedSeconds
+        },
+        vendorPricing: getImageRouterPricing(item),
+        source: 'imagerouter'
+    };
+}
+
+async function getImageRouterModelCatalog(outputType) {
+    const endpoint = new URL('https://api.imagerouter.io/v2/models');
+    endpoint.searchParams.set('outputType', outputType);
+    endpoint.searchParams.set('limit', '200');
+    endpoint.searchParams.set('fields', 'name,price,inputs');
+
+    const payload = await fetchJsonWithTimeout(endpoint.toString(), 10000);
+    const items = Array.isArray(payload)
+        ? payload
+        : Array.isArray(payload?.data)
+            ? payload.data
+            : [];
+    const options = items
+        .map(item => normalizeImageRouterModel(item, outputType))
+        .filter(Boolean)
+        .sort((a, b) => String(a.label).localeCompare(String(b.label)));
+
+    if (options.length > 0) {
+        return options;
+    }
+
+    return (outputType === 'image' ? FALLBACK_IMAGE_MODELS : FALLBACK_VIDEO_MODELS)
+        .map(option => ({ ...option, source: 'fallback' }));
+}
+
+function normalizeCodexCatalogOption(model) {
+    if (!model || typeof model !== 'object') {
+        return null;
+    }
+
+    const id = getCatalogString(model, 'id');
+    if (!id) {
+        return null;
+    }
+
+    const displayName = getCatalogString(model, 'displayName') || id;
+    return {
+        id,
+        label: `OpenAI Codex - ${displayName}`,
+        displayName,
+        description: getCatalogString(model, 'description'),
+        provider: 'codex',
+        mode: 'text',
+        supportsReasoning: true,
+        source: 'codex debug models',
+        priority: getCatalogNumber(model, 'priority') ?? 999,
+        defaultReasoningLevel: getCatalogString(model, 'defaultReasoningLevel'),
+        supportedReasoningLevels: getCatalogStringArray(model, 'supportedReasoningLevels'),
+        supportedInApi: model.supportedInApi === true
+    };
+}
+
+async function getBridgeModelCatalog(options = {}) {
+    const now = Date.now();
+    if (!options.forceRefresh && cachedBridgeModelCatalog && cachedBridgeModelCatalogExpiresAt > now) {
+        return cachedBridgeModelCatalog;
+    }
+
+    const errors = [];
+    const codexCatalog = await getCodexModelCatalog({ forceRefresh: options.forceRefresh });
+    if (codexCatalog?.error) {
+        errors.push(`codex: ${codexCatalog.error}`);
+    }
+
+    let codexTextModels = (codexCatalog?.models || [])
+        .map(normalizeCodexCatalogOption)
+        .filter(Boolean)
+        .sort((a, b) => (a.priority ?? 999) - (b.priority ?? 999) || a.id.localeCompare(b.id));
+    if (codexTextModels.length === 0) {
+        codexTextModels = FALLBACK_CODEX_TEXT_MODELS.map((model, index) => ({
+            id: model.id,
+            label: `OpenAI Codex - ${model.displayName}`,
+            displayName: model.displayName,
+            provider: 'codex',
+            mode: 'text',
+            supportsReasoning: true,
+            priority: index,
+            isFallback: true,
+            source: 'fallback'
+        }));
+    }
+
+    const [openRouterResult, imageResult, videoResult] = await Promise.allSettled([
+        getOpenRouterTextModelCatalog(),
+        getImageRouterModelCatalog('image'),
+        getImageRouterModelCatalog('video')
+    ]);
+
+    const openRouterTextModels = openRouterResult.status === 'fulfilled'
+        ? openRouterResult.value
+        : FALLBACK_OPENROUTER_TEXT_MODELS.map(option => ({
+            id: option.id,
+            label: option.displayName,
+            displayName: option.displayName,
+            provider: 'openrouter',
+            mode: 'text',
+            supportsReasoning: option.supportsReasoning === true,
+            isFallback: true,
+            source: 'fallback'
+        }));
+    if (openRouterResult.status === 'rejected') {
+        errors.push(`openrouter: ${openRouterResult.reason?.message || String(openRouterResult.reason)}`);
+    }
+
+    const imageModels = imageResult.status === 'fulfilled'
+        ? imageResult.value
+        : FALLBACK_IMAGE_MODELS.map(option => ({ ...option, source: 'fallback' }));
+    if (imageResult.status === 'rejected') {
+        errors.push(`imagerouter:image: ${imageResult.reason?.message || String(imageResult.reason)}`);
+    }
+
+    const videoModels = videoResult.status === 'fulfilled'
+        ? videoResult.value
+        : FALLBACK_VIDEO_MODELS.map(option => ({ ...option, source: 'fallback' }));
+    if (videoResult.status === 'rejected') {
+        errors.push(`imagerouter:video: ${videoResult.reason?.message || String(videoResult.reason)}`);
+    }
+
+    const updatedAt = new Date().toISOString();
+    cachedBridgeModelCatalog = {
+        success: true,
+        textModels: [...codexTextModels, ...openRouterTextModels],
+        imageModels,
+        videoModels,
+        source: 'localbridge-model-catalog',
+        updatedAt,
+        errors
+    };
+    cachedBridgeModelCatalogExpiresAt = now + EXTERNAL_MODEL_CATALOG_TTL_MS;
+    return cachedBridgeModelCatalog;
+}
+
 function getCodexRuntime() {
     if (!codexRuntime) {
         codexRuntime = createCodexRuntime({
@@ -13601,6 +14031,19 @@ app.get('/api/codex/capabilities', async (req, res) => {
     }
 });
 
+app.get('/api/model-catalog', async (req, res) => {
+    try {
+        const forceRefresh = /^(1|true|yes|on)$/i.test(String(req.query?.refresh || ''));
+        res.json(await getBridgeModelCatalog({ forceRefresh }));
+    } catch (err) {
+        console.error('[ModelCatalog] Error:', err);
+        res.status(500).json({
+            success: false,
+            error: err?.message || String(err)
+        });
+    }
+});
+
 app.post('/api/codex/thread/start', async (req, res) => {
     try {
         res.json(await getCodexRuntime().startThread(req.body || {}));