codexmate 0.0.20 → 0.0.21

package/lib/cli-network-utils.js

@@ -1,164 +1,164 @@
-const http = require('http');
-const https = require('https');
-
-function shouldRetryWithIpv4(result) {
-    if (!result || result.ok || typeof result.error !== 'string') {
-        return false;
-    }
-    return /timeout|timed out|ETIMEDOUT|ENETUNREACH|EHOSTUNREACH|EAI_AGAIN/i.test(result.error);
-}
-
-function performProbeRequest(transport, parsed, requestOptions, options = {}) {
-    return new Promise((resolve) => {
-        const start = Date.now();
-        const req = transport.request(parsed, requestOptions, (res) => {
-            const chunks = [];
-            let size = 0;
-            res.on('data', (chunk) => {
-                if (!chunk) return;
-                size += chunk.length;
-                if (size <= options.maxBytes) {
-                    chunks.push(chunk);
-                }
-            });
-            res.on('end', () => {
-                resolve({
-                    ok: true,
-                    status: res.statusCode || 0,
-                    durationMs: Date.now() - start,
-                    body: chunks.length > 0 ? Buffer.concat(chunks).toString('utf-8') : ''
-                });
-            });
-        });
-
-        if (options.timeoutMs > 0) {
-            req.setTimeout(options.timeoutMs, () => {
-                req.destroy(new Error('timeout'));
-            });
-        }
-
-        req.on('error', (err) => {
-            resolve({
-                ok: false,
-                error: err.message || 'request failed',
-                durationMs: Date.now() - start
-            });
-        });
-
-        if (options.payload) {
-            req.write(options.payload);
-        }
-        req.end();
-    });
-}
-
-async function probeUrl(targetUrl, options = {}) {
-    let parsed;
-    try {
-        parsed = new URL(targetUrl);
-    } catch (e) {
-        return { ok: false, error: 'Invalid URL' };
-    }
-
-    const protocol = parsed.protocol;
-    if (protocol !== 'http:' && protocol !== 'https:') {
-        return {
-            ok: false,
-            error: `ERR_INVALID_PROTOCOL: Protocol "${protocol}" not supported. Expected "http:" or "https:"`
-        };
-    }
-
-    const transport = protocol === 'https:' ? https : http;
-    const headers = {
-        'User-Agent': 'codexmate-health-check',
-        'Accept': 'application/json'
-    };
-    if (options.apiKey) {
-        headers['Authorization'] = `Bearer ${options.apiKey}`;
-    }
-
-    const timeoutMs = Number.isFinite(options.timeoutMs) ? options.timeoutMs : 0;
-    const maxBytes = Number.isFinite(options.maxBytes) ? options.maxBytes : 256 * 1024;
-    const requestOptions = {
-        method: 'GET',
-        headers
-    };
-
-    const firstResult = await performProbeRequest(transport, parsed, requestOptions, {
-        timeoutMs,
-        maxBytes
-    });
-    if (!shouldRetryWithIpv4(firstResult)) {
-        return firstResult;
-    }
-
-    const secondResult = await performProbeRequest(transport, parsed, {
-        ...requestOptions,
-        family: 4
-    }, {
-        timeoutMs,
-        maxBytes
-    });
-    return secondResult.ok ? secondResult : firstResult;
-}
-
-async function probeJsonPost(targetUrl, body, options = {}) {
-    let parsed;
-    try {
-        parsed = new URL(targetUrl);
-    } catch (e) {
-        return { ok: false, error: 'Invalid URL' };
-    }
-
-    const protocol = parsed.protocol;
-    if (protocol !== 'http:' && protocol !== 'https:') {
-        return {
-            ok: false,
-            error: `ERR_INVALID_PROTOCOL: Protocol "${protocol}" not supported. Expected "http:" or "https:"`
-        };
-    }
-
-    const transport = protocol === 'https:' ? https : http;
-    const headers = {
-        'User-Agent': 'codexmate-health-check',
-        'Accept': 'application/json',
-        'Content-Type': 'application/json'
-    };
-    if (options.apiKey) {
-        headers['Authorization'] = `Bearer ${options.apiKey}`;
-    }
-
-    const payload = JSON.stringify(body || {});
-    headers['Content-Length'] = Buffer.byteLength(payload);
-
-    const timeoutMs = Number.isFinite(options.timeoutMs) ? options.timeoutMs : 0;
-    const maxBytes = Number.isFinite(options.maxBytes) ? options.maxBytes : 256 * 1024;
-    const requestOptions = {
-        method: 'POST',
-        headers
-    };
-
-    const firstResult = await performProbeRequest(transport, parsed, requestOptions, {
-        timeoutMs,
-        maxBytes,
-        payload
-    });
-    if (!shouldRetryWithIpv4(firstResult)) {
-        return firstResult;
-    }
-
-    const secondResult = await performProbeRequest(transport, parsed, {
-        ...requestOptions,
-        family: 4
-    }, {
-        timeoutMs,
-        maxBytes,
-        payload
-    });
-    return secondResult.ok ? secondResult : firstResult;
-}
-
-module.exports = {
-    probeUrl,
-    probeJsonPost
-};
+const http = require('http');
+const https = require('https');
+
+function shouldRetryWithIpv4(result) {
+    if (!result || result.ok || typeof result.error !== 'string') {
+        return false;
+    }
+    return /timeout|timed out|ETIMEDOUT|ENETUNREACH|EHOSTUNREACH|EAI_AGAIN/i.test(result.error);
+}
+
+function performProbeRequest(transport, parsed, requestOptions, options = {}) {
+    return new Promise((resolve) => {
+        const start = Date.now();
+        const req = transport.request(parsed, requestOptions, (res) => {
+            const chunks = [];
+            let size = 0;
+            res.on('data', (chunk) => {
+                if (!chunk) return;
+                size += chunk.length;
+                if (size <= options.maxBytes) {
+                    chunks.push(chunk);
+                }
+            });
+            res.on('end', () => {
+                resolve({
+                    ok: true,
+                    status: res.statusCode || 0,
+                    durationMs: Date.now() - start,
+                    body: chunks.length > 0 ? Buffer.concat(chunks).toString('utf-8') : ''
+                });
+            });
+        });
+
+        if (options.timeoutMs > 0) {
+            req.setTimeout(options.timeoutMs, () => {
+                req.destroy(new Error('timeout'));
+            });
+        }
+
+        req.on('error', (err) => {
+            resolve({
+                ok: false,
+                error: err.message || 'request failed',
+                durationMs: Date.now() - start
+            });
+        });
+
+        if (options.payload) {
+            req.write(options.payload);
+        }
+        req.end();
+    });
+}
+
+async function probeUrl(targetUrl, options = {}) {
+    let parsed;
+    try {
+        parsed = new URL(targetUrl);
+    } catch (e) {
+        return { ok: false, error: 'Invalid URL' };
+    }
+
+    const protocol = parsed.protocol;
+    if (protocol !== 'http:' && protocol !== 'https:') {
+        return {
+            ok: false,
+            error: `ERR_INVALID_PROTOCOL: Protocol "${protocol}" not supported. Expected "http:" or "https:"`
+        };
+    }
+
+    const transport = protocol === 'https:' ? https : http;
+    const headers = {
+        'User-Agent': 'codexmate-health-check',
+        'Accept': 'application/json'
+    };
+    if (options.apiKey) {
+        headers['Authorization'] = `Bearer ${options.apiKey}`;
+    }
+
+    const timeoutMs = Number.isFinite(options.timeoutMs) ? options.timeoutMs : 0;
+    const maxBytes = Number.isFinite(options.maxBytes) ? options.maxBytes : 256 * 1024;
+    const requestOptions = {
+        method: 'GET',
+        headers
+    };
+
+    const firstResult = await performProbeRequest(transport, parsed, requestOptions, {
+        timeoutMs,
+        maxBytes
+    });
+    if (!shouldRetryWithIpv4(firstResult)) {
+        return firstResult;
+    }
+
+    const secondResult = await performProbeRequest(transport, parsed, {
+        ...requestOptions,
+        family: 4
+    }, {
+        timeoutMs,
+        maxBytes
+    });
+    return secondResult.ok ? secondResult : firstResult;
+}
+
+async function probeJsonPost(targetUrl, body, options = {}) {
+    let parsed;
+    try {
+        parsed = new URL(targetUrl);
+    } catch (e) {
+        return { ok: false, error: 'Invalid URL' };
+    }
+
+    const protocol = parsed.protocol;
+    if (protocol !== 'http:' && protocol !== 'https:') {
+        return {
+            ok: false,
+            error: `ERR_INVALID_PROTOCOL: Protocol "${protocol}" not supported. Expected "http:" or "https:"`
+        };
+    }
+
+    const transport = protocol === 'https:' ? https : http;
+    const headers = {
+        'User-Agent': 'codexmate-health-check',
+        'Accept': 'application/json',
+        'Content-Type': 'application/json'
+    };
+    if (options.apiKey) {
+        headers['Authorization'] = `Bearer ${options.apiKey}`;
+    }
+
+    const payload = JSON.stringify(body || {});
+    headers['Content-Length'] = Buffer.byteLength(payload);
+
+    const timeoutMs = Number.isFinite(options.timeoutMs) ? options.timeoutMs : 0;
+    const maxBytes = Number.isFinite(options.maxBytes) ? options.maxBytes : 256 * 1024;
+    const requestOptions = {
+        method: 'POST',
+        headers
+    };
+
+    const firstResult = await performProbeRequest(transport, parsed, requestOptions, {
+        timeoutMs,
+        maxBytes,
+        payload
+    });
+    if (!shouldRetryWithIpv4(firstResult)) {
+        return firstResult;
+    }
+
+    const secondResult = await performProbeRequest(transport, parsed, {
+        ...requestOptions,
+        family: 4
+    }, {
+        timeoutMs,
+        maxBytes,
+        payload
+    });
+    return secondResult.ok ? secondResult : firstResult;
+}
+
+module.exports = {
+    probeUrl,
+    probeJsonPost
+};

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-session-utils.js

@@ -1,121 +1,121 @@
-function toIsoTime(value, fallback = '') {
-    if (value === undefined || value === null || value === '') {
-        return fallback;
-    }
-    const date = new Date(value);
-    if (Number.isNaN(date.getTime())) {
-        return fallback;
-    }
-    return date.toISOString();
-}
-
-function updateLatestIso(currentIso, candidate) {
-    const currentTime = Date.parse(currentIso || '') || 0;
-    const candidateIso = toIsoTime(candidate, '');
-    const candidateTime = Date.parse(candidateIso || '') || 0;
-    if (!candidateTime) {
-        return currentIso;
-    }
-    return candidateTime > currentTime ? candidateIso : currentIso;
-}
-
-function truncateText(text, maxLength = 90) {
-    if (!text) return '';
-    const normalized = String(text).replace(/\s+/g, ' ').trim();
-    if (normalized.length <= maxLength) return normalized;
-    return normalized.slice(0, maxLength - 1) + '…';
-}
-
-function extractMessageText(content) {
-    if (typeof content === 'string') {
-        return content.trim();
-    }
-
-    if (Array.isArray(content)) {
-        const parts = content
-            .map(item => extractMessageText(item))
-            .filter(Boolean);
-        return parts.join('\n').trim();
-    }
-
-    if (!content || typeof content !== 'object') {
-        return '';
-    }
-
-    if (typeof content.text === 'string') {
-        return content.text.trim();
-    }
-
-    if (typeof content.value === 'string') {
-        return content.value.trim();
-    }
-
-    if (content.content !== undefined) {
-        return extractMessageText(content.content);
-    }
-
-    if (typeof content.output === 'string') {
-        return content.output.trim();
-    }
-
-    return '';
-}
-
-function normalizeRole(value) {
-    if (typeof value !== 'string') {
-        return '';
-    }
-    const role = value.trim().toLowerCase();
-    if (role === 'assistant' || role === 'user' || role === 'system') {
-        return role;
-    }
-    return '';
-}
-
-function parseMaxMessagesValue(value) {
-    if (value === Infinity) {
-        return Infinity;
-    }
-
-    if (typeof value === 'string') {
-        const trimmed = value.trim();
-        if (!trimmed) {
-            return null;
-        }
-        const lower = trimmed.toLowerCase();
-        if (lower === 'all' || lower === 'infinity' || lower === 'inf') {
-            return Infinity;
-        }
-        const parsed = Number(trimmed);
-        if (Number.isFinite(parsed)) {
-            return parsed;
-        }
-        return null;
-    }
-
-    if (Number.isFinite(value)) {
-        return value;
-    }
-    return null;
-}
-
-function resolveMaxMessagesValue(value, fallback) {
-    const parsed = parseMaxMessagesValue(value);
-    if (parsed === null) {
-        return fallback;
-    }
-    if (parsed === Infinity) {
-        return Infinity;
-    }
-    return Math.max(1, Math.floor(parsed));
-}
-
-module.exports = {
-    toIsoTime,
-    updateLatestIso,
-    truncateText,
-    extractMessageText,
-    normalizeRole,
-    parseMaxMessagesValue,
-    resolveMaxMessagesValue
-};
+function toIsoTime(value, fallback = '') {
+    if (value === undefined || value === null || value === '') {
+        return fallback;
+    }
+    const date = new Date(value);
+    if (Number.isNaN(date.getTime())) {
+        return fallback;
+    }
+    return date.toISOString();
+}
+
+function updateLatestIso(currentIso, candidate) {
+    const currentTime = Date.parse(currentIso || '') || 0;
+    const candidateIso = toIsoTime(candidate, '');
+    const candidateTime = Date.parse(candidateIso || '') || 0;
+    if (!candidateTime) {
+        return currentIso;
+    }
+    return candidateTime > currentTime ? candidateIso : currentIso;
+}
+
+function truncateText(text, maxLength = 90) {
+    if (!text) return '';
+    const normalized = String(text).replace(/\s+/g, ' ').trim();
+    if (normalized.length <= maxLength) return normalized;
+    return normalized.slice(0, maxLength - 1) + '…';
+}
+
+function extractMessageText(content) {
+    if (typeof content === 'string') {
+        return content.trim();
+    }
+
+    if (Array.isArray(content)) {
+        const parts = content
+            .map(item => extractMessageText(item))
+            .filter(Boolean);
+        return parts.join('\n').trim();
+    }
+
+    if (!content || typeof content !== 'object') {
+        return '';
+    }
+
+    if (typeof content.text === 'string') {
+        return content.text.trim();
+    }
+
+    if (typeof content.value === 'string') {
+        return content.value.trim();
+    }
+
+    if (content.content !== undefined) {
+        return extractMessageText(content.content);
+    }
+
+    if (typeof content.output === 'string') {
+        return content.output.trim();
+    }
+
+    return '';
+}
+
+function normalizeRole(value) {
+    if (typeof value !== 'string') {
+        return '';
+    }
+    const role = value.trim().toLowerCase();
+    if (role === 'assistant' || role === 'user' || role === 'system') {
+        return role;
+    }
+    return '';
+}
+
+function parseMaxMessagesValue(value) {
+    if (value === Infinity) {
+        return Infinity;
+    }
+
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (!trimmed) {
+            return null;
+        }
+        const lower = trimmed.toLowerCase();
+        if (lower === 'all' || lower === 'infinity' || lower === 'inf') {
+            return Infinity;
+        }
+        const parsed = Number(trimmed);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+        return null;
+    }
+
+    if (Number.isFinite(value)) {
+        return value;
+    }
+    return null;
+}
+
+function resolveMaxMessagesValue(value, fallback) {
+    const parsed = parseMaxMessagesValue(value);
+    if (parsed === null) {
+        return fallback;
+    }
+    if (parsed === Infinity) {
+        return Infinity;
+    }
+    return Math.max(1, Math.floor(parsed));
+}
+
+module.exports = {
+    toIsoTime,
+    updateLatestIso,
+    truncateText,
+    extractMessageText,
+    normalizeRole,
+    parseMaxMessagesValue,
+    resolveMaxMessagesValue
+};