pacman-debian 7.2.0

package/src/core/control.ts

@@ -0,0 +1,22 @@
+export function parseControlFile(content: string): Record<string, string> {
+  const fields: Record<string, string> = {};
+  let key = '';
+  let val = '';
+
+  for (const line of content.split('\n')) {
+    if (line.startsWith(' ') || line.startsWith('\t')) {
+      val += '\n' + line.trimEnd();
+    } else if (line.trim() === '') {
+      continue;
+    } else {
+      if (key) fields[key.toLowerCase()] = val.trimEnd();
+      const ci = line.indexOf(':');
+      if (ci === -1) continue;
+      key = line.slice(0, ci).trim();
+      val = line.slice(ci + 1).trim();
+    }
+  }
+
+  if (key) fields[key.toLowerCase()] = val.trimEnd();
+  return fields;
+}

package/src/core/deb.ts

@@ -0,0 +1,47 @@
+import * as fs from 'node:fs';
+import { parseAr } from './ar';
+import { decompress } from './compress';
+import { readFileFromTar, listTarEntries } from './tar';
+import { parseControlFile } from './control';
+import type { DebPackage, DebControl } from './types';
+
+export function parseDeb(filePath: string): DebPackage {
+  const rawMembers = parseAr(fs.readFileSync(filePath));
+  let debianBinary: Buffer | null = null;
+  let controlTarRaw: Buffer | null = null;
+  let controlTarName = '';
+  let dataTarRaw: Buffer | null = null;
+  let dataTarName = '';
+
+  for (const m of rawMembers) {
+    if (m.name === 'debian-binary') debianBinary = m.data;
+    else if (m.name.startsWith('control.tar')) { controlTarRaw = m.data; controlTarName = m.name; }
+    else if (m.name.startsWith('data.tar')) { dataTarRaw = m.data; dataTarName = m.name; }
+  }
+
+  if (!debianBinary) throw new Error(`Missing debian-binary in ${filePath}`);
+  if (!controlTarRaw || !dataTarRaw) throw new Error(`Malformed .deb: missing tar members`);
+
+  const controlTar = decompress(controlTarRaw, controlTarName);
+  const dataTar = decompress(dataTarRaw, dataTarName);
+
+  const controlFileBuf = readFileFromTar(controlTar, './control')
+    ?? readFileFromTar(controlTar, 'control');
+  if (!controlFileBuf) throw new Error(`Missing control file in ${filePath}`);
+
+  const fields = parseControlFile(controlFileBuf.toString('utf8'));
+  if (!fields['package']) throw new Error(`control file missing Package field`);
+
+  const control: DebControl = { package: fields['package'], version: fields['version'] || '0.0', architecture: fields['architecture'] || 'amd64' };
+  for (const [k, v] of Object.entries(fields)) if (!(k in control)) (control as any)[k] = v;
+
+  return { path: filePath, control, controlTar, dataTar };
+}
+
+export function readScript(pkg: DebPackage, name: string): string | null {
+  for (const prefix of ['', './']) {
+    const buf = readFileFromTar(pkg.controlTar, prefix + name);
+    if (buf) return buf.toString('utf8');
+  }
+  return null;
+}

package/src/core/deps.ts

@@ -0,0 +1,260 @@
+import { execSync } from 'node:child_process';
+import { findInRepo, getRepoCache } from '../repo/repository';
+import { loadDatabase } from '../db/database';
+import { readDpkgStatus, dpkgHasPackage } from '../db/dpkg-compat';
+import type { RepoPkg } from './types';
+
+export interface Dep {
+  name: string;
+  version?: string;
+  operator?: string;
+  arch?: string;
+}
+
+export interface DepResult {
+  pkg: RepoPkg;
+  needed: boolean;
+  reason: string;
+}
+
+/* ---- Dependency string parser ---- */
+export function parseDep(s: string): Dep[] {
+  const alternatives = s.split('|').map(a => a.trim());
+  return alternatives.map(a => {
+    let name = a;
+    let operator: string | undefined;
+    let version: string | undefined;
+
+    // Debian: "pkg (>= 1.0)" or Arch: "pkg>=1.0"
+    const parenMatch = a.match(/\(?\s*([<>=!]+)\s*([^)]+)\s*\)?\s*$/);
+    if (parenMatch) {
+      operator = parenMatch[1].trim();
+      version = parenMatch[2].trim().replace(/\)$/, '').trim();
+      name = a.slice(0, a.indexOf(parenMatch[1])).trim();
+      // Clean trailing paren/space from name
+      name = name.replace(/\(\s*$/, '').trim();
+    }
+
+    // Architecture qualifier: "libc6:arm64"
+    const archSep = name.lastIndexOf(':');
+    let arch: string | undefined;
+    if (archSep > 0 && name.length - archSep <= 8 && !name.includes('/')) {
+      arch = name.slice(archSep + 1);
+      name = name.slice(0, archSep);
+    }
+
+    return { name, version, operator, arch };
+  });
+}
+
+/* ---- Version comparison ---- */
+function verCmp(a: string, b: string): number {
+  // Try dpkg compare first
+  try {
+    const out = execSync(`dpkg --compare-versions "${a}" gt "${b}" 2>/dev/null && echo gt || (dpkg --compare-versions "${a}" eq "${b}" 2>/dev/null && echo eq) || echo lt`, { encoding: 'utf8', timeout: 5000 }).trim();
+    if (out === 'gt') return 1;
+    if (out === 'eq') return 0;
+    if (out === 'lt') return -1;
+  } catch {}
+
+  // Fallback: simple numeric/string comparison
+  const aParts = a.replace(/[^\d.]/g, '').split('.').map(Number);
+  const bParts = b.replace(/[^\d.]/g, '').split('.').map(Number);
+  for (let i = 0; i < Math.max(aParts.length, bParts.length); i++) {
+    const an = aParts[i] || 0, bn = bParts[i] || 0;
+    if (an !== bn) return an - bn;
+  }
+  return a.localeCompare(b);
+}
+
+function checkVersion(installed: string, operator: string, required: string): boolean {
+  const cmp = verCmp(installed, required);
+  switch (operator) {
+    case '>=': return cmp >= 0;
+    case '<=': return cmp <= 0;
+    case '>': return cmp > 0;
+    case '<': return cmp < 0;
+    case '=': case '==': return cmp === 0;
+    default: return true; // no constraint
+  }
+}
+
+/* ---- Fast path: pre-load DBs once ---- */
+interface DepState {
+  localPkgs: Map<string, string>;
+  dpkgPkgs: Map<string, string>;
+  repoCache: RepoPkg[] | null;
+}
+
+// Packages that MUST come from dpkg - never install from Arch repos
+const SYSTEM_PKGS = new Set([
+  'glibc', 'libc6', 'linux-api-headers', 'filesystem', 'iana-etc',
+  'bash', 'coreutils', 'systemd', 'dbus', 'util-linux', 'shadow',
+  'pam', 'libcap', 'libseccomp', 'zlib', 'libzstd', 'libarchive',
+]);
+
+let _state: DepState | null = null;
+
+function getState(): DepState {
+  if (_state) return _state;
+  const local = loadDatabase();
+  const localMap = new Map<string, string>();
+  for (const [n, p] of local.packages) localMap.set(n, p.version);
+
+  const dpkg = readDpkgStatus();
+  const dpkgMap = new Map<string, string>();
+  for (const [n, p] of dpkg) dpkgMap.set(n, p.version);
+
+  _state = { localPkgs: localMap, dpkgPkgs: dpkgMap, repoCache: null };
+  return _state;
+}
+
+/* ---- Check if dep is satisfied ---- */
+function isDepSatisfied(dep: Dep, state: DepState): boolean {
+  const installedVer = state.localPkgs.get(dep.name) || state.dpkgPkgs.get(dep.name);
+  if (!installedVer) return false;
+  if (dep.operator && dep.version) {
+    return checkVersion(installedVer, dep.operator, dep.version);
+  }
+  return true;
+}
+
+/* ---- Find provider in repo ---- */
+function findProvider(name: string, state: DepState): RepoPkg | undefined {
+  const direct = findInRepo(name);
+  if (direct) return direct;
+
+  // Search provides via packages.idx (index has provides field)
+  const { loadConfig } = require('../repo/config');
+  const { readPkgAt } = require('../repo/repository');
+  const fs = require('node:fs');
+  const path = require('node:path');
+
+  const cfg = loadConfig();
+  const PKG_CACHE = '/var/cache/pacman-debian/packages';
+  for (const repo of cfg.repos) {
+    const pkgDir = path.join(PKG_CACHE, repo.name);
+    const idxPath = path.join(pkgDir, 'packages.idx');
+    if (!fs.existsSync(idxPath)) continue;
+    const idx = fs.readFileSync(idxPath, 'utf8').split('\n');
+    for (const line of idx) {
+      if (!line) continue;
+      // idx: pkgname desc\tprovides\tchunkFile\toffset
+      const firstTab = line.indexOf('\t');
+      if (firstTab < 0) continue;
+      const rest = line.slice(firstTab + 1);
+      const secondTab = rest.indexOf('\t');
+      if (secondTab < 0) continue;
+      const provides = rest.slice(0, secondTab);
+      if (!provides) continue;
+      if (provides.split(',').some((pr: string) => {
+        const pn = pr.trim().split(/[<>=]/)[0].trim();
+        return pn === name;
+      })) {
+        const lastTab = line.lastIndexOf('\t');
+        const byteOff = parseInt(line.slice(lastTab + 1), 10);
+        const beforeOff = line.slice(0, lastTab);
+        const thirdLastTab = beforeOff.lastIndexOf('\t');
+        const chunkFile = beforeOff.slice(thirdLastTab + 1);
+        if (chunkFile && !isNaN(byteOff)) {
+          return readPkgAt(pkgDir, chunkFile, byteOff);
+        }
+      }
+    }
+  }
+  return undefined;
+}
+
+/* ---- Full dependency resolution ---- */
+export function resolveDeps(targets: string[]): { install: DepResult[]; errors: string[] } {
+  const state = getState();
+  const install: DepResult[] = [];
+  const errors: string[] = [];
+  const seen = new Set<string>();
+  const toProcess: string[] = [...targets];
+
+  while (toProcess.length > 0) {
+    const name = toProcess.shift()!;
+    if (seen.has(name)) continue;
+    seen.add(name);
+
+    if (isDepSatisfied({ name }, state)) continue;
+
+    // System packages must come from dpkg - skip Arch versions
+    if (SYSTEM_PKGS.has(name)) {
+      if (!state.dpkgPkgs.has(name)) {
+        errors.push(`'${name}' is a system package not available via dpkg`);
+      }
+      continue;
+    }
+
+    const rp = findProvider(name, state);
+    if (!rp) {
+      errors.push(`'${name}' not found`);
+      continue;
+    }
+
+    const alreadyResolved = install.some(i => i.pkg.package === rp.package);
+    if (!alreadyResolved) {
+      install.push({ pkg: rp, needed: true, reason: 'target' });
+    }
+
+    const deps = parseDepList(rp.depends);
+    for (const d of deps) {
+      if (!seen.has(d.name) && !isDepSatisfied(d, state)) {
+        toProcess.push(d.name);
+      }
+    }
+  }
+
+  return { install, errors };
+}
+
+export function invalidateDepCache(): void { _state = null; }
+
+function parseDepList(s?: string): Dep[] {
+  if (!s) return [];
+  const result: Dep[] = [];
+  // Arch format: space-separated (glibc>=2.35  yyjson)
+  // Debian format: comma-separated (libc6 (>= 2.34), libyyjson)
+  const parts = s.includes(',') ? s.split(',') : s.split(/\s+/);
+  for (const part of parts) {
+    const trimmed = part.trim();
+    if (!trimmed) continue;
+    const parsed = parseDep(trimmed);
+    if (parsed.length > 0) result.push(parsed[0]);
+  }
+  return result;
+}
+
+/* ---- Conflict detection ---- */
+export interface Conflict {
+  a: string;
+  b: string;
+  reason: string;
+}
+
+export function detectConflicts(packages: RepoPkg[]): Conflict[] {
+  const conflicts: Conflict[] = [];
+  const names = new Set(packages.map(p => p.package));
+
+  for (const pkg of packages) {
+    const pkgConflicts = pkg.conflicts || '';
+    const conflictNames = pkgConflicts.split(',').map(s => s.trim().split(/[<>=]/)[0].trim()).filter(Boolean);
+
+    for (const c of conflictNames) {
+      // Check against other to-be-installed packages
+      for (const other of packages) {
+        if (other.package !== pkg.package && other.package === c) {
+          conflicts.push({ a: pkg.package, b: c, reason: `${pkg.package} conflicts with ${c}` });
+        }
+      }
+      // Check against installed packages
+      if (dpkgHasPackage(c) || loadDatabase().packages.has(c)) {
+        conflicts.push({ a: pkg.package, b: c, reason: `${pkg.package} conflicts with installed ${c}` });
+      }
+    }
+  }
+
+  return conflicts;
+}

package/src/core/options.ts

@@ -0,0 +1,20 @@
+export interface InstallOptions {
+  needed?: boolean;
+  noscriptlet?: boolean;
+  asdeps?: boolean;
+  print?: boolean;
+}
+
+export interface RemoveOptions {
+  recursive?: boolean;
+  noscriptlet?: boolean;
+  cascade?: boolean;
+  nodeps?: boolean;
+  nosave?: boolean;
+  print?: boolean;
+}
+
+export interface DbOptions {
+  asdeps?: boolean;
+  asexplicit?: boolean;
+}

package/src/core/pkgfile.ts

@@ -0,0 +1,146 @@
+import * as zlib from 'node:zlib';
+import { iterateTar } from './tar';
+
+export interface PkgInfo {
+  name: string;
+  version: string;
+  description?: string;
+  depends?: string[];
+  conflicts?: string[];
+  provides?: string[];
+  url?: string;
+  license?: string[];
+  arch?: string;
+  installedSize?: number;
+  size?: number;
+  packager?: string;
+}
+
+export interface InstallScript {
+  pre_install?: string;
+  post_install?: string;
+  pre_remove?: string;
+  post_remove?: string;
+}
+
+function parsePKGINFO(content: string): PkgInfo {
+  const info: PkgInfo = { name: '', version: '' };
+  const deps: string[] = [];
+  const conflicts: string[] = [];
+  const provides: string[] = [];
+  const licenses: string[] = [];
+
+  for (const line of content.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const eq = trimmed.indexOf(' = ');
+    if (eq === -1) continue;
+    const key = trimmed.slice(0, eq).trim();
+    const val = trimmed.slice(eq + 3).trim();
+
+    switch (key) {
+      case 'pkgname': info.name = val; break;
+      case 'pkgver': info.version = val; break;
+      case 'pkgdesc': info.description = val; break;
+      case 'url': info.url = val; break;
+      case 'arch': info.arch = val; break;
+      case 'packager': info.packager = val; break;
+      case 'size': info.size = parseInt(val, 10) || undefined; break;
+      case 'installed_size': info.installedSize = parseInt(val, 10) || undefined; break;
+      case 'depend': deps.push(val.split(/[<>=]/)[0].trim()); break;
+      case 'conflict': conflicts.push(val.split(/[<>=]/)[0].trim()); break;
+      case 'provides': provides.push(val.split(/[<>=]/)[0].trim()); break;
+      case 'license': licenses.push(val); break;
+    }
+  }
+
+  if (deps.length > 0) info.depends = deps;
+  if (conflicts.length > 0) info.conflicts = conflicts;
+  if (provides.length > 0) info.provides = provides;
+  if (licenses.length > 0) info.license = licenses;
+  return info;
+}
+
+function parseInstallScript(content: string): InstallScript {
+  const script: InstallScript = {};
+  const funcs = ['pre_install', 'post_install', 'pre_remove', 'post_remove'];
+  for (const fn of funcs) {
+    const re = new RegExp(`${fn}\\s*\\(\\)\\s*\\{([\\s\\S]*?)\\n\\}`, 'm');
+    const m = content.match(re);
+    if (m) (script as any)[fn] = m[1].trim();
+  }
+  return script;
+}
+
+export function parsePkgTarZst(data: Buffer): { info: PkgInfo; install?: InstallScript; files: string[]; dataBlocks: { name: string; data: Buffer | null }[] } {
+  // decompress zstd
+  const { execSync } = require('node:child_process');
+  const fs = require('node:fs');
+  const path = require('node:path');
+  const os = require('node:os');
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'archpkg-'));
+  const inFile = path.join(tmp, 'input.zst');
+  const outFile = path.join(tmp, 'output.tar');
+  try {
+    fs.writeFileSync(inFile, data);
+    execSync(`zstd -d -f "${inFile}" --stdout > "${outFile}"`, { stdio: 'pipe' });
+    const tarData = fs.readFileSync(outFile);
+    return parseArchTar(tarData);
+  } finally {
+    try { fs.unlinkSync(inFile); } catch {}
+    try { fs.unlinkSync(outFile); } catch {}
+    try { fs.rmdirSync(tmp); } catch {}
+  }
+}
+
+function parseArchTar(tarData: Buffer): { info: PkgInfo; install?: InstallScript; files: string[]; dataBlocks: { name: string; data: Buffer | null }[] } {
+  let info: PkgInfo = { name: '', version: '' };
+  let install: InstallScript | undefined;
+  const files: string[] = [];
+  const dataBlocks: { name: string; data: Buffer | null }[] = [];
+
+  for (const entry of iterateTar(tarData)) {
+    const name = entry.name.replace(/^\.\//, '');
+    if (name === '.PKGINFO' && entry.data) {
+      info = parsePKGINFO(entry.data.toString('utf8'));
+      continue;
+    }
+    if (name === '.INSTALL' && entry.data) {
+      install = parseInstallScript(entry.data.toString('utf8'));
+      continue;
+    }
+    if (name === '.MTREE' || name === '' || name.startsWith('.')) continue;
+    files.push('/' + name);
+    dataBlocks.push({ name, data: entry.data });
+  }
+
+  return { info, install, files, dataBlocks };
+}
+
+export function extractArchTarEntry(name: string, dest: string, entries: { name: string; data: Buffer | null }[]): void {
+  const entry = entries.find(e => e.name === name);
+  if (!entry || !entry.data) return;
+  const targetPath = require('node:path').resolve(dest, name);
+  require('node:fs').mkdirSync(require('node:path').dirname(targetPath), { recursive: true });
+  require('node:fs').writeFileSync(targetPath, entry.data, { mode: 0o755 });
+}
+
+export function parseDescFile(content: string): Record<string, string[]> {
+  const result: Record<string, string[]> = {};
+  let currentKey = '';
+  const values: string[] = [];
+
+  for (const line of content.split('\n')) {
+    const keyMatch = line.match(/^%([A-Z_]+)%$/);
+    if (keyMatch) {
+      if (currentKey && values.length > 0) result[currentKey] = [...values];
+      currentKey = keyMatch[1].toLowerCase();
+      values.length = 0;
+    } else if (line.trim()) {
+      values.push(line.trim());
+    }
+  }
+  if (currentKey && values.length > 0) result[currentKey] = [...values];
+
+  return result;
+}

package/src/core/tar.ts

@@ -0,0 +1,101 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+interface TarHeader {
+  name: string;
+  mode: number;
+  size: number;
+  type: 'file' | 'directory' | 'symlink' | 'unknown';
+  linkname: string;
+}
+
+function parseOctal(buf: Buffer, start: number, len: number): number {
+  const str = buf.subarray(start, start + len).toString('utf8').replace(/\0/g, '').trim();
+  return parseInt(str, 8) || 0;
+}
+
+function trim(s: string): string {
+  return s.replace(/\0/g, '').trim();
+}
+
+function readHeader(buf: Buffer): TarHeader | null {
+  if (buf.length < 512) return null;
+  if (buf.subarray(0, 512).every(b => b === 0)) return null;
+
+  const name = trim(buf.subarray(0, 100).toString('utf8'));
+  const prefix = trim(buf.subarray(345, 500).toString('utf8'));
+  const mode = parseOctal(buf, 100, 8);
+  const size = parseOctal(buf, 124, 12);
+  const typeflag = String.fromCharCode(buf[156]);
+  const linkname = trim(buf.subarray(157, 257).toString('utf8'));
+  const fullName = prefix ? `${prefix}/${name}` : name;
+
+  let type: 'file' | 'directory' | 'symlink' | 'unknown' = 'unknown';
+  if (typeflag === '0' || typeflag === '\0') type = 'file';
+  else if (typeflag === '5') type = 'directory';
+  else if (typeflag === '2') type = 'symlink';
+
+  return { name: fullName, mode, size, type, linkname };
+}
+
+export interface TarEntry {
+  name: string;
+  type: string;
+  size: number;
+  data: Buffer | null;
+  linkname: string;
+  mode: number;
+}
+
+export function* iterateTar(buf: Buffer): Generator<TarEntry> {
+  let offset = 0;
+  while (offset < buf.length) {
+    if (offset + 512 > buf.length) break;
+    const hdr = readHeader(buf.subarray(offset));
+    if (!hdr) break;
+    offset += 512;
+    const paddedSize = Math.ceil(hdr.size / 512) * 512;
+    const data = hdr.type === 'file' && hdr.size > 0
+      ? buf.subarray(offset, offset + hdr.size) : null;
+    yield { name: hdr.name, type: hdr.type, size: hdr.size, data, linkname: hdr.linkname, mode: hdr.mode };
+    offset += paddedSize;
+  }
+}
+
+export function readFileFromTar(buf: Buffer, filePath: string): Buffer | null {
+  for (const entry of iterateTar(buf)) {
+    if (entry.name === filePath && entry.data) return entry.data;
+  }
+  return null;
+}
+
+export function extractTar(buf: Buffer, dest: string): string[] {
+  const extracted: string[] = [];
+  for (const entry of iterateTar(buf)) {
+    let targetPath = entry.name;
+    if (targetPath.startsWith('./')) targetPath = targetPath.slice(2);
+    if (targetPath.startsWith('/')) targetPath = targetPath.slice(1);
+    if (!targetPath) continue;
+    const fullPath = path.resolve(dest, targetPath);
+    if (!fullPath.startsWith(path.resolve(dest))) continue;
+    extracted.push(`/${targetPath}`);
+
+    if (entry.type === 'directory') {
+      fs.mkdirSync(fullPath, { recursive: true, mode: entry.mode || 0o755 });
+    } else if (entry.type === 'file') {
+      fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+      if (entry.data) fs.writeFileSync(fullPath, entry.data, { mode: entry.mode || 0o644 });
+    } else if (entry.type === 'symlink') {
+      fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+      try { fs.unlinkSync(fullPath); } catch {}
+      fs.symlinkSync(entry.linkname, fullPath);
+    }
+  }
+  return extracted;
+}
+
+export function listTarEntries(buf: Buffer): string[] {
+  const names: string[] = [];
+  for (const entry of iterateTar(buf)) names.push(entry.name);
+  return names;
+}

package/src/core/types.ts

@@ -0,0 +1,89 @@
+export interface DebControl {
+  package: string;
+  version: string;
+  architecture: string;
+  maintainer?: string;
+  description?: string;
+  depends?: string;
+  'pre-depends'?: string;
+  conflicts?: string;
+  provides?: string;
+  'installed-size'?: string;
+  section?: string;
+  priority?: string;
+  homepage?: string;
+  [key: string]: string | undefined;
+}
+
+export interface DebPackage {
+  path: string;
+  control: DebControl;
+  controlTar: Buffer;
+  dataTar: Buffer;
+}
+
+export interface InstalledPackage {
+  name: string;
+  version: string;
+  architecture: string;
+  description: string;
+  depends?: string;
+  'pre-depends'?: string;
+  conflicts?: string;
+  provides?: string;
+  maintainer?: string;
+  homepage?: string;
+  controlSection?: string;
+  controlPriority?: string;
+  installedSize?: number;
+  installTime: number;
+  reason: 'explicit' | 'dependency';
+  files: string[];
+  repoType?: 'debian' | 'arch';
+}
+
+export interface RepoPkg {
+  package: string;
+  version: string;
+  architecture: string;
+  description?: string;
+  depends?: string;
+  conflicts?: string;
+  provides?: string;
+  filename: string;
+  size?: number;
+  installedSize?: number;
+  sha256?: string;
+  repo: string;
+  repoType: 'debian' | 'arch';
+}
+
+export interface RepoConfig {
+  name: string;
+  type?: 'debian' | 'arch';
+  server: string;
+  dist?: string;
+  components?: string[];
+  dbFile?: string;
+  architecture?: string;
+}
+
+export interface Config {
+  architecture: string;
+  color: boolean;
+  repos: RepoConfig[];
+}
+
+export interface Database {
+  packages: Map<string, InstalledPackage>;
+  fileIndex: Map<string, string>;
+}
+
+export interface Transaction {
+  id: string;
+  timestamp: number;
+  action: 'install' | 'remove';
+  package: string;
+  version: string;
+  completed: boolean;
+}