pacman-debian 7.3.36 → 7.5.0

package/dist/repo/repository.js

@@ -38,16 +38,21 @@ exports.syncRepos = syncRepos;
 exports.readPkgAt = readPkgAt;
 exports.batchFindInRepo = batchFindInRepo;
 exports.findProvides = findProvides;
+exports.findProvidesScoped = findProvidesScoped;
 exports.getRepoCache = getRepoCache;
 exports.invalidateCache = invalidateCache;
 exports.searchRepo = searchRepo;
 exports.findInRepo = findInRepo;
+exports.findInRepoScoped = findInRepoScoped;
+exports.findInRepoVersioned = findInRepoVersioned;
 exports.getPkgUrl = getPkgUrl;
 exports.downloadPkg = downloadPkg;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const https = __importStar(require("node:https"));
 const http = __importStar(require("node:http"));
+const crypto = __importStar(require("node:crypto"));
+const node_child_process_1 = require("node:child_process");
 const config_1 = require("./config");
 const control_1 = require("../core/control");
 const compress_1 = require("../core/compress");
@@ -56,15 +61,48 @@ const pkgfile_1 = require("../core/pkgfile");
 const colors_1 = require("../ui/colors");
 const i18n_1 = require("../i18n");
 const progress_1 = require("../ui/progress");
+const logger_1 = require("../core/logger");
 const CACHE_DIR = '/var/cache/pacman-debian';
 const PKG_CACHE = path.join(CACHE_DIR, 'packages');
 const DEB_CACHE = path.join(CACHE_DIR, 'pkg');
+const activePartials = new Set();
+let partialCleanupInstalled = false;
+function installPartialCleanup() {
+    if (partialCleanupInstalled)
+        return;
+    partialCleanupInstalled = true;
+    process.once('SIGINT', () => {
+        for (const file of activePartials) {
+            try {
+                fs.unlinkSync(file);
+            }
+            catch { }
+        }
+        process.exit(130);
+    });
+}
+async function atomicWrite(filePath, content) {
+    const tmp = `${filePath}.tmp-${process.pid}`;
+    try {
+        await fs.promises.writeFile(tmp, content, 'utf8');
+        await fs.promises.rename(tmp, filePath);
+    }
+    catch (error) {
+        try {
+            await fs.promises.unlink(tmp);
+        }
+        catch { }
+        throw error;
+    }
+}
 /* ---- Shared keep-alive HTTP agents ---- */
 const httpAgent = new http.Agent({ keepAlive: true, maxSockets: 8 });
 const httpsAgent = new https.Agent({ keepAlive: true, maxSockets: 8 });
 let _idxCache = new Map();
+let _pkgCache = new Map(); // LRU: key = chunkFile:offset
 function invalidateIdxCache() {
     _idxCache.clear();
+    _pkgCache.clear();
 }
 function parseIdxLine(line) {
     const lastTab = line.lastIndexOf('\t');
@@ -81,20 +119,24 @@ function parseIdxLine(line) {
     if (!chunkFile)
         return null;
     const rest = beforeOff.slice(0, secondLastTab);
-    const firstTab = rest.indexOf('\t');
-    const pkgName = rest.slice(0, rest.indexOf(' '));
-    const provides = firstTab >= 0 ? rest.slice(firstTab + 1) : '';
-    return { pkgName, provides, chunkFile, offset };
+    const thirdLastTab = rest.lastIndexOf('\t');
+    const provides = thirdLastTab >= 0 ? rest.slice(thirdLastTab + 1) : '';
+    const beforeProv = thirdLastTab >= 0 ? rest.slice(0, thirdLastTab) : rest;
+    const firstSpace = beforeProv.indexOf(' ');
+    const pkgName = beforeProv.slice(0, firstSpace);
+    const versionText = firstSpace >= 0 ? beforeProv.slice(firstSpace + 1) : '';
+    const firstTab = versionText.indexOf('\t');
+    const version = (firstTab >= 0 ? versionText.slice(0, firstTab) : versionText).trim();
+    return { pkgName, version, provides, chunkFile, offset };
 }
 function getIdx(repoName) {
+    const cached = _idxCache.get(repoName);
+    if (cached)
+        return cached;
     const pkgDir = path.join(PKG_CACHE, repoName);
     const idxPath = path.join(pkgDir, 'packages.idx');
     if (!fs.existsSync(idxPath))
         return null;
-    const st = fs.statSync(idxPath);
-    const cached = _idxCache.get(repoName);
-    if (cached && cached.mtime === st.mtimeMs)
-        return cached;
     const lines = fs.readFileSync(idxPath, 'utf8').split('\n').filter(l => l.length > 0);
     const providesIndex = new Map();
     for (const line of lines) {
@@ -110,11 +152,28 @@ function getIdx(repoName) {
             }
         }
     }
-    const entry = { lines, mtime: st.mtimeMs, providesIndex };
+    const entry = { lines, providesIndex };
     _idxCache.set(repoName, entry);
     return entry;
 }
-async function downloadFile(url, onProgress, ifModifiedSince) {
+async function downloadFile(url, onProgress, ifModifiedSince, dest) {
+    const cfg = (0, config_1.loadConfig)();
+    // XferCommand support
+    if (cfg.xferCommand) {
+        const tmpDest = dest || path.join('/tmp', `download-${Date.now()}`);
+        const cmd = cfg.xferCommand.replace(/%u/g, url).replace(/%o/g, tmpDest);
+        const result = (0, node_child_process_1.spawnSync)('/bin/sh', ['-c', cmd], { stdio: 'pipe', timeout: 300000 });
+        if (result.status !== 0) {
+            const out = result.stdout?.toString() || '';
+            const err = result.stderr?.toString() || '';
+            (0, logger_1.logError)(`XferCommand exit ${result.status} for ${url}: ${err || out}`);
+            throw new Error(`XferCommand failed (exit ${result.status}): ${err || out}`);
+        }
+        if (dest)
+            return null;
+        (0, logger_1.log)(`download: ${url} -> ${tmpDest}`);
+        return fs.readFileSync(tmpDest);
+    }
     const maxRedirects = 5;
     const doRequest = (u, redirects) => {
         return new Promise((resolve, reject) => {
@@ -129,7 +188,6 @@ async function downloadFile(url, onProgress, ifModifiedSince) {
                     resolve(null);
                     return;
                 }
-                // Handle redirects (301, 302, 303, 307, 308)
                 if (res.statusCode && (res.statusCode >= 300 && res.statusCode < 400)) {
                     const loc = res.headers['location'];
                     res.destroy();
@@ -148,14 +206,29 @@ async function downloadFile(url, onProgress, ifModifiedSince) {
                 }
                 const total = parseInt(res.headers['content-length'] || '0', 10);
                 let received = 0;
-                const chunks = [];
-                res.on('data', (c) => {
-                    chunks.push(c);
-                    received += c.length;
-                    if (onProgress)
-                        onProgress(received, total);
-                });
-                res.on('end', () => resolve(Buffer.concat(chunks)));
+                if (dest) {
+                    // Stream directly to file (for package downloads)
+                    const ws = fs.createWriteStream(dest);
+                    res.on('data', (c) => {
+                        received += c.length;
+                        if (onProgress)
+                            onProgress(received, total);
+                    });
+                    res.pipe(ws);
+                    ws.on('finish', () => resolve(null));
+                    ws.on('error', reject);
+                }
+                else {
+                    // Buffer in memory (for metadata)
+                    const chunks = [];
+                    res.on('data', (c) => {
+                        chunks.push(c);
+                        received += c.length;
+                        if (onProgress)
+                            onProgress(received, total);
+                    });
+                    res.on('end', () => resolve(Buffer.concat(chunks)));
+                }
             });
             req.on('error', reject);
             req.on('timeout', () => { req.destroy(); reject(new Error('timeout')); });
@@ -182,36 +255,124 @@ function parseDebianPackages(content, repo) {
     }
     return pkgs;
 }
+function parseReleaseSha256(text) {
+    const map = new Map();
+    let inSha256 = false;
+    for (const line of text.split('\n')) {
+        const t = line.trim();
+        if (t === 'SHA256:') {
+            inSha256 = true;
+            continue;
+        }
+        if (inSha256) {
+            if (!t || t === '') {
+                inSha256 = false;
+                continue;
+            }
+            const m = t.match(/^([a-f0-9]{64})\s+\d+\s+(.+)$/);
+            if (m)
+                map.set(m[2], m[1]);
+        }
+    }
+    return map;
+}
+function debArch(arch) {
+    const map = { aarch64: 'arm64', x86_64: 'amd64', x64: 'amd64', i686: 'i386' };
+    return map[arch] || arch;
+}
 async function syncDebian(repo, arch, ifModifiedSince, onProgress) {
+    arch = debArch(arch);
     const comps = repo.components || ['main'];
+    const pkgDir = path.join(PKG_CACHE, repo.name);
+    let info = {};
+    const infoFile = path.join(pkgDir, '.info');
+    if (fs.existsSync(infoFile)) {
+        try {
+            info = JSON.parse(fs.readFileSync(infoFile, 'utf8'));
+        }
+        catch {
+            info = {};
+        }
+    }
+    const oldSha256 = info.sha256 || {};
+    // Download Release file first (like apt does)
+    const releaseBase = `${repo.server}/dists/${repo.dist}`;
+    let releaseText = null;
+    let releaseSize = 0;
+    for (const rfile of ['InRelease', 'Release']) {
+        try {
+            const releaseBuf = await downloadFile(`${releaseBase}/${rfile}`, (rec, tot) => {
+                if (onProgress)
+                    onProgress(rec, tot);
+            }, ifModifiedSince);
+            if (releaseBuf === null)
+                return { pkgs: [], size: 0, notModified: true };
+            releaseText = releaseBuf.toString('utf8');
+            releaseSize = releaseBuf.length;
+            break;
+        }
+        catch { }
+    }
+    if (!releaseText)
+        return { pkgs: [], size: 0, notModified: true };
+    const sha256Map = parseReleaseSha256(releaseText);
     const all = [];
-    let totalSize = 0;
+    let totalSize = releaseSize;
+    let anyData = false;
+    const newSha256 = {};
     for (const comp of comps) {
-        const base = `${repo.server}/dists/${repo.dist}/${comp}/binary-${arch}/Packages`;
-        for (const ext of ['gz', 'xz']) {
-            let gotData = false;
+        const prefix = `${comp}/binary-${arch}/Packages`;
+        let downloaded = false;
+        for (const ext of ['xz', 'gz']) {
+            const key = `${prefix}.${ext}`;
+            const expectedHash = sha256Map.get(key);
+            if (!expectedHash)
+                continue;
+            newSha256[key] = expectedHash;
+            if (oldSha256[key] === expectedHash)
+                continue; // SHA256 matches, skip download
             try {
-                const url = `${base}.${ext}`;
+                const url = `${releaseBase}/${key}`;
                 const buf = await downloadFile(url, (rec, tot) => {
                     if (onProgress)
                         onProgress(totalSize + rec, totalSize + (tot || 0));
-                }, ifModifiedSince);
-                if (buf === null)
-                    return { pkgs: [], size: 0, notModified: true }; // 304
-                gotData = true;
+                }, undefined);
+                if (!buf)
+                    continue;
+                downloaded = true;
+                anyData = true;
                 totalSize += buf.length;
-                const text = (await (0, compress_1.decompressAsync)(buf, `packages.${ext}`)).toString('utf8');
+                const text = (await (0, compress_1.decompressAsync)(buf, key)).toString('utf8');
                 all.push(...parseDebianPackages(text, repo.name));
                 break;
             }
-            catch (e) {
-                if (gotData)
-                    throw e;
-            }
+            catch { }
         }
         ifModifiedSince = undefined;
     }
-    return { pkgs: all, size: totalSize, notModified: false };
+    // Save SHA256 info only if anything was downloaded
+    if (anyData) {
+        info.sha256 = newSha256;
+        info.total = all.length;
+        try {
+            fs.mkdirSync(pkgDir, { recursive: true });
+            fs.writeFileSync(infoFile, JSON.stringify(info));
+        }
+        catch { }
+    }
+    // If idx is empty but Release was fresh → force re-download next time
+    if (!anyData && all.length === 0) {
+        const idxPath = path.join(pkgDir, 'packages.idx');
+        if (!fs.existsSync(idxPath) || fs.statSync(idxPath).size < 10) {
+            // Clear cached SHA256 so next sync forces Packages download
+            delete info.sha256;
+            try {
+                fs.writeFileSync(infoFile, JSON.stringify(info));
+            }
+            catch { }
+        }
+    }
+    return { pkgs: all, size: totalSize, notModified: !anyData };
 }
 function parseArchDb(dbTar, repo) {
     const pkgs = [];
@@ -449,6 +610,11 @@ async function syncRepos(force = false) {
                 progress.setRow(idx, `\x1b[K ${pname}${' '.repeat(fixedNameWidth - repo.name.length)}${colors_1.color.ok((0, i18n_1.t)('repo_already_uptodate'))}`);
                 return;
             }
+            // Show "up to date" when 0 bytes downloaded (304 or empty sync)
+            if (totalDownloaded === 0 && totalExpected === 0 && ifModifiedSince) {
+                progress.setRow(idx, `\x1b[K ${pname}${' '.repeat(fixedNameWidth - repo.name.length)}${colors_1.color.ok((0, i18n_1.t)('repo_already_uptodate'))}`);
+                return;
+            }
             // Write JSON Lines chunks (parallel per chunk)
             const pkgDir = path.join(PKG_CACHE, repo.name);
             if (!fs.existsSync(pkgDir))
@@ -461,7 +627,7 @@ async function syncRepos(force = false) {
                 const chunk = pkgs.slice(c * CHUNK, (c + 1) * CHUNK);
                 const lines = chunk.map(p => JSON.stringify(p)).join('\n');
                 const fname = `${String(c).padStart(5, '0')}.jsonl`;
-                writeTasks.push(fs.promises.writeFile(path.join(pkgDir, fname), lines + '\n'));
+                writeTasks.push(atomicWrite(path.join(pkgDir, fname), lines + '\n'));
                 // Build index with byte offsets (computed from previous chunk lengths)
                 let offset = 0;
                 for (let pi = 0; pi < chunk.length; pi++) {
@@ -469,19 +635,20 @@ async function syncRepos(force = false) {
                     const json = JSON.stringify(p);
                     const desc = (p.description || '').replace(/\\/g, '\\\\').replace(/\t/g, '\\t').replace(/\n/g, '\\n');
                     const provides = (p.provides || '').replace(/\\/g, '\\\\').replace(/\t/g, '\\t').replace(/\n/g, '\\n');
-                    idxLines.push(`${p.package} ${desc}\t${provides}\t${fname}\t${offset}`);
+                    const version = (p.version || '').replace(/\\/g, '\\\\').replace(/\t/g, '\\t').replace(/\n/g, '\\n');
+                    idxLines.push(`${p.package} ${version}\t${desc}\t${provides}\t${fname}\t${offset}`);
                     offset += Buffer.byteLength(json, 'utf8') + 1;
                 }
             }
             await Promise.all(writeTasks);
-            await fs.promises.writeFile(path.join(pkgDir, '.info'), JSON.stringify({ total: pkgs.length, chunks, chunkSize: CHUNK }));
+            await atomicWrite(path.join(pkgDir, '.info'), JSON.stringify({ total: pkgs.length, chunks, chunkSize: CHUNK }));
             // Remove legacy all.json
             try {
                 fs.unlinkSync(path.join(pkgDir, 'all.json'));
             }
             catch { }
             idxLines.sort(); // global sort so binary search works
-            await fs.promises.writeFile(path.join(pkgDir, 'packages.idx'), idxLines.join('\n') + '\n');
+            await atomicWrite(path.join(pkgDir, 'packages.idx'), idxLines.join('\n') + '\n');
             // Final line
             const elapsed = (Date.now() - startTime) / 1000;
             const totalSec = Math.round(elapsed);
@@ -636,6 +803,26 @@ function findProvides(name) {
     }
     return undefined;
 }
+/** Look up a virtual provider in one repository only. */
+function findProvidesScoped(repoName, name) {
+    const cfg = (0, config_1.loadConfig)();
+    const repo = cfg.repos.find(r => r.name === repoName);
+    if (!repo)
+        return undefined;
+    const idxEntry = getIdx(repo.name);
+    if (!idxEntry)
+        return undefined;
+    const entries = idxEntry.providesIndex.get(name);
+    if (!entries)
+        return undefined;
+    const pkgDir = path.join(PKG_CACHE, repo.name);
+    for (const e of entries) {
+        const p = readPkgAt(pkgDir, e.chunkFile, e.offset);
+        if (p)
+            return p;
+    }
+    return undefined;
+}
 // ---- Cache ----
 let _cache = null;
 function getRepoCache() {
@@ -676,7 +863,8 @@ function invalidateCache() {
     invalidateIdxCache();
 }
 function searchRepo(query) {
-    const lq = query.toLowerCase();
+    const sl = query.indexOf('/');
+    const lq = (sl > 0 ? query.slice(sl + 1) : query).toLowerCase();
     const results = [];
     const cfg = (0, config_1.loadConfig)();
     const seen = new Set();
@@ -693,14 +881,24 @@ function searchRepo(query) {
             if (!info || seen.has(info.pkgName))
                 continue;
             seen.add(info.pkgName);
-            const p = readPkgAt(pkgDir, info.chunkFile, info.offset);
-            if (p)
+            // Read from cache first, fallback to JSONL
+            const cacheKey = `${info.chunkFile}:${info.offset}`;
+            let p = _pkgCache.get(cacheKey);
+            if (!p) {
+                p = readPkgAt(pkgDir, info.chunkFile, info.offset);
+                if (p)
+                    _pkgCache.set(cacheKey, p);
+            }
+            if (p && results.length < 50)
                 results.push(p);
         }
     }
     return results;
 }
 function findInRepo(pkgName) {
+    const sl = pkgName.indexOf('/');
+    if (sl > 0)
+        return findInRepoScoped(pkgName.slice(0, sl), pkgName.slice(sl + 1));
     const cfg = (0, config_1.loadConfig)();
     for (const repo of cfg.repos) {
         const idxEntry = getIdx(repo.name);
@@ -719,10 +917,79 @@ function findInRepo(pkgName) {
                 lo = mid + 1;
             else {
                 const info = parseIdxLine(line);
-                if (info)
-                    return readPkgAt(pkgDir, info.chunkFile, info.offset);
+                if (!info)
+                    return undefined;
+                const cacheKey = `${info.chunkFile}:${info.offset}`;
+                let p = _pkgCache.get(cacheKey);
+                if (!p) {
+                    p = readPkgAt(pkgDir, info.chunkFile, info.offset);
+                    if (p)
+                        _pkgCache.set(cacheKey, p);
+                }
+                return p;
+            }
+        }
+    }
+    return undefined;
+}
+/** Search only in a specific repo by name (e.g. "extra", "trixie"). */
+function findInRepoScoped(repoName, pkgName) {
+    const cfg = (0, config_1.loadConfig)();
+    const repo = cfg.repos.find(r => r.name === repoName);
+    if (!repo)
+        return undefined;
+    const idxEntry = getIdx(repo.name);
+    if (!idxEntry)
+        return undefined;
+    const { lines } = idxEntry;
+    const pkgDir = path.join(PKG_CACHE, repo.name);
+    let lo = 0, hi = lines.length - 1;
+    while (lo <= hi) {
+        const mid = (lo + hi) >>> 1;
+        const line = lines[mid];
+        const pname = line.slice(0, line.indexOf(' '));
+        if (pkgName < pname)
+            hi = mid - 1;
+        else if (pkgName > pname)
+            lo = mid + 1;
+        else {
+            const info = parseIdxLine(line);
+            if (!info)
                 return undefined;
+            const cacheKey = `${info.chunkFile}:${info.offset}`;
+            let p = _pkgCache.get(cacheKey);
+            if (!p) {
+                p = readPkgAt(pkgDir, info.chunkFile, info.offset);
+                if (p)
+                    _pkgCache.set(cacheKey, p);
             }
+            return p;
+        }
+    }
+    return undefined;
+}
+/** Find an exact package version, respecting repository order or a scope. */
+function findInRepoVersioned(pkgName, version, repoName) {
+    const cfg = (0, config_1.loadConfig)();
+    const repos = repoName ? cfg.repos.filter(r => r.name === repoName) : cfg.repos;
+    for (const repo of repos) {
+        const idxEntry = getIdx(repo.name);
+        if (!idxEntry)
+            continue;
+        const pkgDir = path.join(PKG_CACHE, repo.name);
+        for (const line of idxEntry.lines) {
+            const info = parseIdxLine(line);
+            if (!info || info.pkgName !== pkgName)
+                continue;
+            const cacheKey = `${info.chunkFile}:${info.offset}`;
+            let p = _pkgCache.get(cacheKey);
+            if (!p) {
+                p = readPkgAt(pkgDir, info.chunkFile, info.offset);
+                if (p)
+                    _pkgCache.set(cacheKey, p);
+            }
+            if (p && p.package === pkgName && p.version === version)
+                return p;
         }
     }
     return undefined;
@@ -747,13 +1014,45 @@ async function downloadPkg(rp, dest, onProgress) {
         fs.mkdirSync(DEB_CACHE, { recursive: true });
     const fn = path.basename(rp.filename);
     const local = path.join(dest || DEB_CACHE, fn);
-    if (fs.existsSync(local))
-        return local;
+    if (fs.existsSync(local)) {
+        if (!rp.sha256)
+            return local;
+        try {
+            const hash = crypto.createHash('sha256').update(fs.readFileSync(local)).digest('hex');
+            if (hash === rp.sha256)
+                return local;
+            fs.unlinkSync(local);
+        }
+        catch { }
+    }
     const url = getPkgUrl(rp);
-    const data = await downloadFile(url, onProgress);
-    if (!data)
-        throw new Error('failed to download package');
-    fs.writeFileSync(local, data);
+    const partial = `${local}.part`;
+    try {
+        fs.unlinkSync(partial);
+    }
+    catch { }
+    installPartialCleanup();
+    activePartials.add(partial);
+    // Stream directly to file instead of buffering in memory
+    try {
+        const data = await downloadFile(url, onProgress, undefined, partial);
+        if (data === null)
+            fs.renameSync(partial, local);
+        else if (data)
+            fs.writeFileSync(partial, data);
+        if (data)
+            fs.renameSync(partial, local);
+    }
+    catch (error) {
+        try {
+            fs.unlinkSync(partial);
+        }
+        catch { }
+        throw error;
+    }
+    finally {
+        activePartials.delete(partial);
+    }
     return local;
 }
 //# sourceMappingURL=repository.js.map