codexmate 0.0.20 → 0.0.22

package/lib/cli-models-utils.js

@@ -1,6 +1,112 @@
 const crypto = require('crypto');
 const { joinApiUrl, normalizeBaseUrl } = require('./cli-utils');
 
+const BIGMODEL_CLAUDE_COMPAT_MODELS = Object.freeze([
+    'glm-3-turbo',
+    'glm-4',
+    'glm-4-0520',
+    'glm-4-plus',
+    'glm-4-air',
+    'glm-4-airx',
+    'glm-4-flash',
+    'glm-4-flashx',
+    'glm-4v',
+    'glm-4v-flash',
+    'glm-4v-plus',
+    'glm-4v-plus-0111',
+    'glm-4.5',
+    'glm-4.5-air',
+    'glm-4.5v',
+    'glm-4.6',
+    'glm-4.6v',
+    'glm-4.7',
+    'glm-4.7-flash',
+    'glm-4.7-flashx',
+    'glm-5',
+    'glm-5-turbo',
+    'glm-5.1',
+    'glm-5v',
+    'glm-5v-turbo',
+    'glm-z1',
+    'glm-z1-air',
+    'glm-coding'
+]);
+
+const ANTHROPIC_CLAUDE_MODELS = Object.freeze([
+    'claude-opus-4-6',
+    'claude-opus-4-1',
+    'claude-opus-4',
+    'claude-sonnet-4-6',
+    'claude-sonnet-4-5',
+    'claude-sonnet-4',
+    'claude-haiku-4-5',
+    'claude-3-7-sonnet',
+    'claude-3-5-sonnet',
+    'claude-3-5-haiku',
+    'claude-3-opus',
+    'claude-3-sonnet',
+    'claude-3-haiku'
+]);
+
+function normalizeModelCatalogId(value) {
+    return typeof value === 'string' ? value.trim().toLowerCase() : '';
+}
+
+function isBigModelClaudeCompatibleBaseUrl(baseUrl) {
+    const normalized = normalizeBaseUrl(baseUrl);
+    if (!normalized) return false;
+    try {
+        const parsed = new URL(normalized);
+        const host = String(parsed.hostname || '').toLowerCase();
+        const pathname = String(parsed.pathname || '').toLowerCase();
+        const isBigModelHost = host === 'bigmodel.cn' || host.endsWith('.bigmodel.cn');
+        const hasAnthropicSegment = /(^|\/)anthropic(\/|$)/.test(pathname);
+        return isBigModelHost && hasAnthropicSegment;
+    } catch (_) {
+        return false;
+    }
+}
+
+function isAnthropicBaseUrl(baseUrl) {
+    const normalized = normalizeBaseUrl(baseUrl);
+    if (!normalized) return false;
+    try {
+        const parsed = new URL(normalized);
+        const host = String(parsed.hostname || '').toLowerCase();
+        return host === 'api.anthropic.com' || host.endsWith('.anthropic.com');
+    } catch (_) {
+        return false;
+    }
+}
+
+function getSupplementalModelsForBaseUrl(baseUrl) {
+    if (isBigModelClaudeCompatibleBaseUrl(baseUrl)) {
+        return [...BIGMODEL_CLAUDE_COMPAT_MODELS];
+    }
+    if (isAnthropicBaseUrl(baseUrl)) {
+        return [...ANTHROPIC_CLAUDE_MODELS];
+    }
+    return [];
+}
+
+function mergeModelCatalog(remoteModels = [], supplementalModels = []) {
+    const merged = [];
+    const seen = new Set();
+    const push = (value) => {
+        if (typeof value !== 'string') return;
+        const trimmed = value.trim();
+        if (!trimmed) return;
+        const normalized = normalizeModelCatalogId(trimmed);
+        if (!normalized || seen.has(normalized)) return;
+        seen.add(normalized);
+        merged.push(trimmed);
+    };
+
+    for (const item of remoteModels) push(item);
+    for (const item of supplementalModels) push(item);
+    return merged;
+}
+
 function extractModelNames(payload) {
     if (!payload || typeof payload !== 'object') return [];
     const data = Array.isArray(payload.data)
@@ -307,5 +413,7 @@ module.exports = {
     buildModelConversationSpecs,
     extractModelResponseText,
     hashModelsCacheValue,
-    buildModelsCacheKey
+    buildModelsCacheKey,
+    getSupplementalModelsForBaseUrl,
+    mergeModelCatalog
 };

package/lib/cli-path-utils.js

@@ -0,0 +1,69 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+function normalizePathForCompare(targetPath, options = {}) {
+    const ignoreCase = !!options.ignoreCase;
+    let resolved = '';
+    try {
+        resolved = fs.realpathSync.native ? fs.realpathSync.native(targetPath) : fs.realpathSync(targetPath);
+    } catch (e) {
+        resolved = path.resolve(targetPath);
+    }
+    return ignoreCase ? resolved.toLowerCase() : resolved;
+}
+
+function isPathInside(targetPath, rootPath) {
+    if (!targetPath || !rootPath) {
+        return false;
+    }
+    const ignoreCase = process.platform === 'win32';
+    const resolvedTarget = normalizePathForCompare(targetPath, { ignoreCase });
+    const resolvedRoot = normalizePathForCompare(rootPath, { ignoreCase });
+    if (resolvedTarget === resolvedRoot) {
+        return true;
+    }
+    const separator = resolvedRoot.includes('/') && !resolvedRoot.includes('\\') ? '/' : path.sep;
+    const rootWithSlash = resolvedRoot.endsWith(separator) ? resolvedRoot : resolvedRoot + separator;
+    return resolvedTarget.startsWith(rootWithSlash);
+}
+
+function resolveCopyTargetRoot(targetDir) {
+    const base = typeof targetDir === 'string' ? targetDir.trim() : '';
+    const pathApi = base.includes('/') && !base.includes('\\') && path.posix ? path.posix : path;
+    const suffixSegments = [];
+    let current = pathApi.resolve(base || '');
+    while (current && !fs.existsSync(current)) {
+        const parent = pathApi.dirname(current);
+        if (!parent || parent === current) {
+            break;
+        }
+        suffixSegments.unshift(pathApi.basename(current));
+        current = parent;
+    }
+    let resolvedRoot = normalizePathForCompare(current || base);
+    if (!resolvedRoot) {
+        resolvedRoot = pathApi.resolve(base || '');
+    }
+    for (const segment of suffixSegments) {
+        resolvedRoot = pathApi.join(resolvedRoot, segment);
+    }
+    return resolvedRoot;
+}
+
+function commandExists(command, args = '') {
+    try {
+        execSync(`${command} ${args}`, { stdio: 'ignore', shell: process.platform === 'win32' });
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+
+module.exports = {
+    normalizePathForCompare,
+    isPathInside,
+    resolveCopyTargetRoot,
+    commandExists
+};
+

package/lib/cli-sessions.js

@@ -0,0 +1,386 @@
+const fs = require('fs');
+
+const {
+    toIsoTime,
+    truncateText,
+    extractMessageText,
+    normalizeRole
+} = require('./cli-session-utils');
+
+const DEFAULT_SESSION_DETAIL_MESSAGES = 300;
+const FAST_SESSION_DETAIL_PREVIEW_FILE_BYTES = 256 * 1024;
+const FAST_SESSION_DETAIL_PREVIEW_CHUNK_BYTES = 64 * 1024;
+const FAST_SESSION_DETAIL_PREVIEW_MAX_BYTES = 1024 * 1024;
+
+const BOOTSTRAP_TEXT_MARKERS = [
+    'agents.md instructions',
+    '<instructions>',
+    '<environment_context>',
+    'you are a coding agent',
+    'codex cli'
+];
+
+function getFileStatSafe(filePath) {
+    try {
+        return fs.statSync(filePath);
+    } catch (e) {
+        return null;
+    }
+}
+
+function isBootstrapLikeText(text) {
+    if (!text || typeof text !== 'string') {
+        return false;
+    }
+
+    const normalized = text.toLowerCase().replace(/\s+/g, ' ').trim();
+    if (!normalized) {
+        return false;
+    }
+
+    return BOOTSTRAP_TEXT_MARKERS.some(marker => normalized.includes(marker));
+}
+
+function removeLeadingSystemMessage(messages) {
+    if (!Array.isArray(messages) || messages.length === 0) {
+        return [];
+    }
+
+    let startIndex = 0;
+    while (startIndex < messages.length) {
+        const item = messages[startIndex];
+        const role = item ? normalizeRole(item.role) : '';
+        const text = item && typeof item.text === 'string' ? item.text : '';
+        const isSystemRole = role === 'system';
+        const isBootstrapText = isBootstrapLikeText(text);
+        if (!item || isSystemRole || isBootstrapText) {
+            startIndex += 1;
+            continue;
+        }
+        break;
+    }
+
+    if (startIndex <= 0) {
+        return messages;
+    }
+    return messages.slice(startIndex);
+}
+
+function normalizeQueryTokens(query) {
+    if (typeof query !== 'string') {
+        return [];
+    }
+    return query
+        .split(/\s+/)
+        .map(item => item.trim())
+        .map(item => item.toLowerCase())
+        .filter(Boolean);
+}
+
+function expandSessionQueryTokens(tokens) {
+    const base = Array.isArray(tokens) ? tokens.map(t => String(t || '').toLowerCase()).filter(Boolean) : [];
+    const result = [];
+    const seen = new Set();
+    let hasClaudeAlias = false;
+    let hasDaudeAlias = false;
+
+    // First pass: detect multi-token aliases (e.g., "claude code", "daude code")
+    for (let i = 0; i < base.length; i++) {
+        const token = base[i];
+        const nextToken = base[i + 1] || '';
+
+        // Check for "claude code" pattern (two separate tokens)
+        if (token === 'claude' && nextToken === 'code') {
+            hasClaudeAlias = true;
+            i++; // Skip next token
+            continue;
+        }
+        // Check for "daude code" pattern (two separate tokens)
+        if (token === 'daude' && nextToken === 'code') {
+            hasDaudeAlias = true;
+            i++; // Skip next token
+            continue;
+        }
+        // Check for combined patterns (e.g., "claude-code", "claude_code", "claudecode")
+        if (/^claude[-_ ]?code$/.test(token) || token === 'claudecode') {
+            hasClaudeAlias = true;
+            continue;
+        }
+        if (/^daude[-_ ]?code$/.test(token) || token === 'daudecode') {
+            hasDaudeAlias = true;
+            continue;
+        }
+        if (!seen.has(token)) {
+            seen.add(token);
+            result.push(token);
+        }
+    }
+
+    const push = (token) => {
+        const normalized = String(token || '').toLowerCase();
+        if (!normalized || seen.has(normalized)) return;
+        seen.add(normalized);
+        result.push(normalized);
+    };
+
+    if (hasClaudeAlias) {
+        push('claude');
+        push('code');
+    }
+    if (hasDaudeAlias) {
+        push('daude');
+        push('code');
+    }
+
+    return result;
+}
+
+function matchTokensInText(text, tokens, mode = 'and') {
+    if (!Array.isArray(tokens) || tokens.length === 0) {
+        return true;
+    }
+    const haystack = String(text || '').toLowerCase();
+    if (!haystack) {
+        return false;
+    }
+    if (mode === 'or') {
+        return tokens.some(token => haystack.includes(token));
+    }
+    return tokens.every(token => haystack.includes(token));
+}
+
+function extractMessageFromRecord(record, source) {
+    if (!record) {
+        return null;
+    }
+    if (source === 'codex') {
+        if (record.type === 'response_item' && record.payload && record.payload.type === 'message') {
+            const role = normalizeRole(record.payload.role);
+            const text = extractMessageText(record.payload.content);
+            if (!role || !text) {
+                return null;
+            }
+            return { role, text };
+        }
+        return null;
+    }
+
+    const role = normalizeRole(record.type);
+    if (!role) {
+        return null;
+    }
+    const content = record.message ? record.message.content : '';
+    const text = extractMessageText(content);
+    if (!text) {
+        return null;
+    }
+    return { role, text };
+}
+
+function appendSessionDetailTailMessage(state, record, source, lineIndex = -1) {
+    if (!state || typeof state !== 'object') {
+        return;
+    }
+
+    const message = extractMessageFromRecord(record, source);
+    if (!message) {
+        return;
+    }
+
+    const role = normalizeRole(message.role);
+    const text = typeof message.text === 'string' ? message.text : '';
+    if (!role || !text) {
+        return;
+    }
+
+    if (state.leadingSystem && (role === 'system' || isBootstrapLikeText(text))) {
+        return;
+    }
+
+    state.leadingSystem = false;
+    state.totalMessages += 1;
+    if (!Number.isFinite(state.tailLimit) || state.tailLimit <= 0) {
+        return;
+    }
+
+    if (state.messages.length >= state.tailLimit) {
+        state.messages.shift();
+    }
+    state.messages.push({
+        role,
+        text,
+        timestamp: toIsoTime(record && record.timestamp, ''),
+        recordLineIndex: Number.isInteger(lineIndex) ? lineIndex : -1
+    });
+}
+
+function applySessionDetailRecordMetadata(record, source, state) {
+    if (!state || typeof state !== 'object' || !record) {
+        return;
+    }
+
+    if (record.timestamp) {
+        state.updatedAt = toIsoTime(record.timestamp, state.updatedAt);
+    }
+
+    if (source === 'codex') {
+        if (record.type === 'session_meta' && record.payload) {
+            state.sessionId = record.payload.id || state.sessionId;
+            state.cwd = record.payload.cwd || state.cwd;
+        }
+        return;
+    }
+
+    if (!state.sessionId && record.sessionId) {
+        state.sessionId = record.sessionId;
+    }
+    if (!state.cwd && record.cwd) {
+        state.cwd = record.cwd;
+    }
+}
+
+function extractSessionDetailPreviewFromTailText(text, source, messageLimit) {
+    const safeMessageLimit = Number.isFinite(Number(messageLimit))
+        ? Math.max(1, Math.floor(Number(messageLimit)))
+        : DEFAULT_SESSION_DETAIL_MESSAGES;
+    const state = {
+        sessionId: '',
+        cwd: '',
+        updatedAt: '',
+        messages: [],
+        tailLimit: safeMessageLimit,
+        totalMessages: null,
+        clipped: false
+    };
+    const lines = typeof text === 'string' && text
+        ? text.split(/\r?\n/)
+        : [];
+
+    for (let lineIndex = lines.length - 1; lineIndex >= 0; lineIndex -= 1) {
+        const trimmed = lines[lineIndex].trim();
+        if (!trimmed) {
+            continue;
+        }
+
+        let record;
+        try {
+            record = JSON.parse(trimmed);
+        } catch (_) {
+            continue;
+        }
+
+        if (record && record.timestamp && !state.updatedAt) {
+            state.updatedAt = toIsoTime(record.timestamp, '');
+        }
+        if ((!state.sessionId || !state.cwd) && record) {
+            applySessionDetailRecordMetadata(record, source, state);
+        }
+
+        const message = extractMessageFromRecord(record, source);
+        if (!message) {
+            continue;
+        }
+
+        const role = normalizeRole(message.role);
+        const textValue = typeof message.text === 'string' ? message.text : '';
+        if (!role || !textValue) {
+            continue;
+        }
+
+        if (state.messages.length >= safeMessageLimit) {
+            state.clipped = true;
+            break;
+        }
+
+        state.messages.unshift({
+            role,
+            text: textValue,
+            timestamp: toIsoTime(record && record.timestamp, ''),
+            recordLineIndex: -1
+        });
+    }
+
+    return state;
+}
+
+function extractSessionDetailPreviewFromFileFast(filePath, source, messageLimit) {
+    const fileStat = getFileStatSafe(filePath);
+    if (!fileStat || !Number.isFinite(fileStat.size) || fileStat.size <= FAST_SESSION_DETAIL_PREVIEW_FILE_BYTES) {
+        return null;
+    }
+    const safeMessageLimit = Number.isFinite(Number(messageLimit))
+        ? Math.max(1, Math.floor(Number(messageLimit)))
+        : DEFAULT_SESSION_DETAIL_MESSAGES;
+
+    let fd = null;
+    let position = fileStat.size;
+    let totalBytesRead = 0;
+    let combined = Buffer.alloc(0);
+    let latest = {
+        sessionId: '',
+        cwd: '',
+        updatedAt: '',
+        messages: [],
+        totalMessages: null,
+        clipped: false
+    };
+
+    try {
+        fd = fs.openSync(filePath, 'r');
+        while (position > 0 && totalBytesRead < FAST_SESSION_DETAIL_PREVIEW_MAX_BYTES) {
+            const remainingBudget = FAST_SESSION_DETAIL_PREVIEW_MAX_BYTES - totalBytesRead;
+            const chunkSize = Math.min(FAST_SESSION_DETAIL_PREVIEW_CHUNK_BYTES, position, remainingBudget);
+            if (chunkSize <= 0) {
+                break;
+            }
+
+            position -= chunkSize;
+            const chunk = Buffer.allocUnsafe(chunkSize);
+            const bytesRead = fs.readSync(fd, chunk, 0, chunkSize, position);
+            if (bytesRead <= 0) {
+                break;
+            }
+
+            totalBytesRead += bytesRead;
+            combined = Buffer.concat([chunk.subarray(0, bytesRead), combined]);
+            latest = extractSessionDetailPreviewFromTailText(combined.toString('utf-8'), source, safeMessageLimit);
+            if (latest.messages.length >= safeMessageLimit) {
+                latest.clipped = latest.clipped || position > 0;
+                return latest;
+            }
+        }
+
+        if (position > 0) {
+            latest.clipped = latest.clipped || position > 0;
+            return latest;
+        }
+        const normalizedMessages = removeLeadingSystemMessage(latest.messages);
+        latest.messages = normalizedMessages.length > safeMessageLimit
+            ? normalizedMessages.slice(-safeMessageLimit)
+            : normalizedMessages;
+        latest.totalMessages = normalizedMessages.length;
+        latest.clipped = latest.totalMessages > latest.messages.length;
+        return latest;
+    } catch (_) {
+        return null;
+    } finally {
+        if (fd !== null) {
+            try { fs.closeSync(fd); } catch (e) {}
+        }
+    }
+}
+
+module.exports = {
+    BOOTSTRAP_TEXT_MARKERS,
+    getFileStatSafe,
+    isBootstrapLikeText,
+    removeLeadingSystemMessage,
+    normalizeQueryTokens,
+    expandSessionQueryTokens,
+    matchTokensInText,
+    extractMessageFromRecord,
+    appendSessionDetailTailMessage,
+    applySessionDetailRecordMetadata,
+    extractSessionDetailPreviewFromTailText,
+    extractSessionDetailPreviewFromFileFast
+};

package/lib/download-artifacts.js

@@ -0,0 +1,77 @@
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+const DEFAULT_DOWNLOAD_ARTIFACT_TTL_MS = 10 * 60 * 1000;
+const g_downloadArtifacts = new Map();
+
+function registerDownloadArtifact(filePath, options = {}) {
+    const token = crypto.randomBytes(16).toString('hex');
+    const fileName = typeof options.fileName === 'string' && options.fileName.trim()
+        ? options.fileName.trim()
+        : path.basename(filePath || '');
+    const ttlMs = Number.isFinite(options.ttlMs) && options.ttlMs > 0
+        ? Math.floor(options.ttlMs)
+        : DEFAULT_DOWNLOAD_ARTIFACT_TTL_MS;
+    const expiresAt = Date.now() + ttlMs;
+    const deleteAfterDownload = options.deleteAfterDownload !== false;
+
+    g_downloadArtifacts.set(token, {
+        filePath,
+        fileName,
+        deleteAfterDownload,
+        expiresAt
+    });
+
+    setTimeout(() => {
+        const artifact = g_downloadArtifacts.get(token);
+        if (!artifact) return;
+        if (Date.now() < artifact.expiresAt) return;
+        g_downloadArtifacts.delete(token);
+        if (artifact.deleteAfterDownload && artifact.filePath && fs.existsSync(artifact.filePath)) {
+            try {
+                fs.unlinkSync(artifact.filePath);
+            } catch (_) {}
+        }
+    }, ttlMs + 2000);
+
+    return {
+        token,
+        fileName,
+        downloadPath: `/download/${encodeURIComponent(token)}`
+    };
+}
+
+function resolveDownloadArtifact(tokenOrFileName, options = {}) {
+    if (!tokenOrFileName) return null;
+    const token = typeof tokenOrFileName === 'string' ? tokenOrFileName.trim() : '';
+    if (!token) return null;
+
+    const artifact = g_downloadArtifacts.get(token);
+    if (!artifact) {
+        return null;
+    }
+    if (Date.now() > artifact.expiresAt) {
+        g_downloadArtifacts.delete(token);
+        if (artifact.deleteAfterDownload && artifact.filePath && fs.existsSync(artifact.filePath)) {
+            try {
+                fs.unlinkSync(artifact.filePath);
+            } catch (_) {}
+        }
+        return null;
+    }
+    if (options && options.consume === true) {
+        g_downloadArtifacts.delete(token);
+    }
+    return {
+        token,
+        ...artifact
+    };
+}
+
+module.exports = {
+    DEFAULT_DOWNLOAD_ARTIFACT_TTL_MS,
+    registerDownloadArtifact,
+    resolveDownloadArtifact
+};
+