Something went wrong. Try again.
MIRROR: javascript for 🐜's, a tiny runtime with big ambitions ant.themackabu.dev
Something went wrong. Try again.
Zig
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216const std = @import("std");const builtin = @import("builtin");
pub const cli = @import("cli.zig");pub const lockfile = @import("lockfile.zig");pub const cache = @import("cache.zig");pub const fetcher = @import("fetcher.zig");pub const extractor = @import("extractor.zig");pub const linker = @import("linker.zig");pub const resolver = @import("resolver.zig");pub const intern = @import("intern.zig");pub const json = @import("json.zig");pub const debug = @import("debug.zig");
const global_allocator: std.mem.Allocator = std.heap.c_allocator;
fn getHomeDir(allocator: std.mem.Allocator) ![]const u8 { if (builtin.os.tag == .windows) { const home_w = std.process.getenvW( std.unicode.utf8ToUtf16LeStringLiteral("USERPROFILE") ) orelse return error.NoHomeDir; return std.unicode.utf16LeToUtf8Alloc(allocator, home_w) catch error.NoHomeDir; } const home = std.posix.getenv("HOME") orelse return error.NoHomeDir; return allocator.dupe(u8, home);}
fn getAbsoluteEnv(name: [:0]const u8) ?[]const u8 { if (builtin.os.tag == .windows) return null; const value = std.posix.getenv(name) orelse return null; if (value.len == 0 or !std.fs.path.isAbsolute(value)) return null; return value;}
fn getLegacyAntDirIfExists(allocator: std.mem.Allocator) !?[]const u8 { const home = try getHomeDir(allocator); defer allocator.free(home);
const dir = try std.fmt.allocPrint(allocator, "{s}/.ant", .{home}); std.fs.cwd().access(dir, .{}) catch { allocator.free(dir); return null; }; return dir;}
pub const PkgError = enum(c_int) { ok = 0, out_of_memory = -1, invalid_lockfile = -2, io_error = -3, network_error = -4, cache_error = -5, extract_error = -6, resolve_error = -7, invalid_argument = -8, not_found = -9, integrity_mismatch = -10,};
pub const ProgressCallback = ?*const fn ( user_data: ?*anyopaque, phase: Phase, current: u32, total: u32, message: [*:0]const u8,) callconv(.c) void;
pub const Phase = enum(c_int) { resolving = 0, fetching = 1, extracting = 2, linking = 3, caching = 4, postinstall = 5,};
pub const PkgOptions = extern struct { cache_dir: ?[*:0]const u8 = null, registry_url: ?[*:0]const u8 = null, max_connections: u32 = 6, progress_callback: ProgressCallback = null, user_data: ?*anyopaque = null, verbose: bool = false,};
pub const CacheStats = extern struct { total_size: u64, db_size: u64, package_count: u32,};
pub const AddedPackage = extern struct { name: [*:0]const u8, version: [*:0]const u8, direct: bool,};
pub const InstallResult = extern struct { package_count: u32, cache_hits: u32, cache_misses: u32, files_linked: u32, files_copied: u32, packages_installed: u32, packages_skipped: u32, elapsed_ms: u64,};
pub const LifecycleScript = extern struct { name: [*:0]const u8, script: [*:0]const u8,};
const PkgInfo = extern struct { name: [*:0]const u8, version: [*:0]const u8, description: [*:0]const u8, license: [*:0]const u8, homepage: [*:0]const u8, tarball: [*:0]const u8, shasum: [*:0]const u8, integrity: [*:0]const u8, keywords: [*:0]const u8, published: [*:0]const u8, dep_count: u32, version_count: u32, unpacked_size: u64,};
const DistTag = extern struct { tag: [*:0]const u8, version: [*:0]const u8,};
const Maintainer = extern struct { name: [*:0]const u8, email: [*:0]const u8,};
const Dependency = extern struct { name: [*:0]const u8, version: [*:0]const u8,};
pub const PkgContext = struct { allocator: std.mem.Allocator, arena_state: std.heap.ArenaAllocator, string_pool: intern.StringPool, cache_db: ?*cache.CacheDB, http: ?*fetcher.Fetcher, options: PkgOptions, last_error: ?[:0]u8, cache_dir: []const u8, metadata_cache: std.StringHashMap(resolver.PackageMetadata), last_install_result: InstallResult, added_packages: std.ArrayListUnmanaged(AddedPackage), added_packages_storage: std.ArrayListUnmanaged([:0]u8), lifecycle_scripts: std.ArrayListUnmanaged(LifecycleScript), lifecycle_scripts_storage: std.ArrayListUnmanaged([:0]u8), info_dist_tags: std.ArrayListUnmanaged(DistTag), info_maintainers: std.ArrayListUnmanaged(Maintainer), info_dependencies: std.ArrayListUnmanaged(Dependency), info_storage: std.ArrayListUnmanaged([:0]u8),
pub fn init(allocator: std.mem.Allocator, options: PkgOptions) !*PkgContext { const ctx = try allocator.create(PkgContext); errdefer allocator.destroy(ctx); const default_cache_path = if (options.cache_dir == null) try getDefaultCacheDir(allocator) else null; defer { if (default_cache_path) |path| allocator.free(path); } const cache_path = if (options.cache_dir) |dir| std.mem.span(dir) else default_cache_path.?; ctx.* = .{ .allocator = allocator, .arena_state = std.heap.ArenaAllocator.init(allocator), .string_pool = intern.StringPool.init(allocator), .cache_db = null, .http = null, .options = options, .last_error = null, .cache_dir = try allocator.dupe(u8, cache_path), .metadata_cache = std.StringHashMap(resolver.PackageMetadata).init(allocator), .last_install_result = .{ .package_count = 0, .cache_hits = 0, .cache_misses = 0, .files_linked = 0, .files_copied = 0, .packages_installed = 0, .packages_skipped = 0, .elapsed_ms = 0 }, .added_packages = .{}, .added_packages_storage = .{}, .lifecycle_scripts = .{}, .lifecycle_scripts_storage = .{}, .info_dist_tags = .{}, .info_maintainers = .{}, .info_dependencies = .{}, .info_storage = .{}, };
debug.enabled = options.verbose; debug.log("init: cache_dir={s}", .{ctx.cache_dir}); ctx.cache_db = cache.CacheDB.open(ctx.cache_dir) catch |err| { ctx.setErrorFmt("Failed to open cache database: {}", .{err}); return error.CacheError; }; debug.log("init: cache database opened", .{}); const registry = if (options.registry_url) |url| std.mem.span(url) else "registry.npmjs.org";
ctx.http = fetcher.Fetcher.init(allocator, registry) catch |err| { ctx.setErrorFmt("Failed to initialize fetcher: {}", .{err}); return error.NetworkError; }; debug.log("init: http fetcher ready, registry={s}", .{registry});
return ctx; }
pub fn deinit(self: *PkgContext) void { if (self.http) |h| h.deinit(); if (self.cache_db) |db| db.close(); var meta_iter = self.metadata_cache.valueIterator(); while (meta_iter.next()) |meta| meta.deinit(); self.metadata_cache.deinit(); self.string_pool.deinit(); self.arena_state.deinit(); if (self.last_error) |e| self.allocator.free(e); for (self.added_packages_storage.items) |s| self.allocator.free(s); self.added_packages_storage.deinit(self.allocator); self.added_packages.deinit(self.allocator); for (self.lifecycle_scripts_storage.items) |s| self.allocator.free(s); self.lifecycle_scripts_storage.deinit(self.allocator); self.lifecycle_scripts.deinit(self.allocator); for (self.info_storage.items) |s| self.allocator.free(s); self.info_storage.deinit(self.allocator); self.info_dist_tags.deinit(self.allocator); self.info_maintainers.deinit(self.allocator); self.info_dependencies.deinit(self.allocator); self.allocator.free(self.cache_dir); self.allocator.destroy(self); }
pub fn setErrorFmt(self: *PkgContext, comptime fmt: []const u8, args: anytype) void { if (self.last_error) |e| self.allocator.free(e); self.last_error = std.fmt.allocPrintSentinel(self.allocator, fmt, args, 0) catch null; }
pub fn setError(self: *PkgContext, msg: []const u8) void { if (self.last_error) |e| self.allocator.free(e); self.last_error = self.allocator.dupeZ(u8, msg) catch null; }
fn getDefaultCacheDir(allocator: std.mem.Allocator) ![]const u8 { if (builtin.os.tag != .windows) { if (try getLegacyAntDirIfExists(allocator)) |dir| { defer allocator.free(dir); return std.fmt.allocPrint(allocator, "{s}/pkg", .{dir}); } if (getAbsoluteEnv("XDG_CACHE_HOME")) |base| { return std.fmt.allocPrint(allocator, "{s}/ant/pkg", .{base}); } const home = try getHomeDir(allocator); defer allocator.free(home); return std.fmt.allocPrint(allocator, "{s}/.cache/ant/pkg", .{home}); }
const home = try getHomeDir(allocator); defer allocator.free(home); return std.fmt.allocPrint(allocator, "{s}/.ant/pkg", .{home}); }
fn reportProgress(self: *PkgContext, phase: Phase, current: u32, total: u32, message: [:0]const u8) void { if (self.options.progress_callback) |cb| { cb(self.options.user_data, phase, current, total, message.ptr); } }
fn clearAddedPackages(self: *PkgContext) void { for (self.added_packages_storage.items) |s| self.allocator.free(s); self.added_packages_storage.clearRetainingCapacity(); self.added_packages.clearRetainingCapacity(); }
fn clearLifecycleScripts(self: *PkgContext) void { for (self.lifecycle_scripts_storage.items) |s| self.allocator.free(s); self.lifecycle_scripts_storage.clearRetainingCapacity(); self.lifecycle_scripts.clearRetainingCapacity(); }
fn clearInfo(self: *PkgContext) void { for (self.info_storage.items) |s| self.allocator.free(s); self.info_storage.clearRetainingCapacity(); self.info_dist_tags.clearRetainingCapacity(); self.info_maintainers.clearRetainingCapacity(); self.info_dependencies.clearRetainingCapacity(); }
fn storeInfoString(self: *PkgContext, str: []const u8) ![*:0]const u8 { const z = try self.allocator.dupeZ(u8, str); try self.info_storage.append(self.allocator, z); return z.ptr; }
fn addLifecycleScript(self: *PkgContext, name: []const u8, script: []const u8) !void { const name_z = try self.allocator.dupeZ(u8, name); errdefer self.allocator.free(name_z); const script_z = try self.allocator.dupeZ(u8, script); errdefer self.allocator.free(script_z);
try self.lifecycle_scripts_storage.append(self.allocator, name_z); try self.lifecycle_scripts_storage.append(self.allocator, script_z); try self.lifecycle_scripts.append(self.allocator, .{ .name = name_z.ptr, .script = script_z.ptr, }); }
fn addPackageToResults(self: *PkgContext, name: []const u8, version: []const u8, direct: bool) !void { for (self.added_packages.items) |pkg| { if (std.mem.eql(u8, std.mem.span(pkg.name), name)) return; }
const name_z = try self.allocator.dupeZ(u8, name); errdefer self.allocator.free(name_z); const version_z = try self.allocator.dupeZ(u8, version); errdefer self.allocator.free(version_z);
try self.added_packages_storage.append(self.allocator, name_z); try self.added_packages_storage.append(self.allocator, version_z); try self.added_packages.append(self.allocator, .{ .name = name_z.ptr, .version = version_z.ptr, .direct = direct, }); }
pub fn install(self: *PkgContext, lockfile_path: []const u8, node_modules_path: []const u8) !void { _ = self.arena_state.reset(.retain_capacity); const arena_alloc = self.arena_state.allocator();
self.clearAddedPackages();
var timer = std.time.Timer.start() catch return error.OutOfMemory; var stage_start: u64 = @intCast(std.time.nanoTimestamp());
debug.log("install start: lockfile={s} node_modules={s}", .{ lockfile_path, node_modules_path });
var lf = lockfile.Lockfile.open(lockfile_path) catch { self.setError("Failed to open lockfile"); return error.InvalidLockfile; }; defer lf.close();
const pkg_count = lf.header.package_count; stage_start = debug.timer("lockfile open", stage_start); debug.log(" packages in lockfile: {d}", .{pkg_count});
var integrities = try arena_alloc.alloc([64]u8, pkg_count); for (lf.packages, 0..) |pkg, i| { integrities[i] = pkg.integrity; }
const db = self.cache_db orelse return error.CacheError; var cache_hits = try db.batchLookup(integrities, arena_alloc); defer cache_hits.deinit(); stage_start = debug.timer("cache lookup", stage_start);
var hit_set = std.AutoHashMap(u32, u32).init(arena_alloc); for (cache_hits.items) |hit| { try hit_set.put(hit.index, hit.file_count); }
var misses = std.ArrayListUnmanaged(u32){}; for (0..pkg_count) |i| { if (!hit_set.contains(@intCast(i))) { try misses.append(arena_alloc, @intCast(i)); } } debug.log(" cache hits: {d}, misses: {d}", .{ cache_hits.items.len, misses.items.len });
std.sort.heap(cache.CacheDB.BatchHit, cache_hits.items, &lf, batchHitLessThanParentFirst);
var pkg_linker = linker.Linker.init(self.allocator); defer pkg_linker.deinit(); try pkg_linker.setNodeModulesPath(node_modules_path);
for (cache_hits.items, 0..) |hit, i| { const pkg = &lf.packages[hit.index]; const pkg_name = pkg.name.slice(lf.string_table); const cache_path = try db.getPackagePath(&pkg.integrity, arena_alloc); const parent_path = pkg.parent_path.slice(lf.string_table);
const msg = std.fmt.allocPrintSentinel(arena_alloc, "{s}", .{pkg_name}, 0) catch continue; self.reportProgress(.linking, @intCast(i), @intCast(cache_hits.items.len), msg);
try pkg_linker.linkPackage(.{ .cache_path = cache_path, .node_modules_path = node_modules_path, .name = pkg_name, .parent_path = if (parent_path.len > 0) parent_path else null, .file_count = hit.file_count, .has_bin = pkg.flags.has_bin, });
if (pkg.flags.direct) { const version_str = pkg.versionString(arena_alloc, lf.string_table) catch continue; self.addPackageToResults(pkg_name, version_str, true) catch {}; } } stage_start = debug.timer("link cache hits", stage_start);
if (misses.items.len > 0) { const http = self.http orelse return error.NetworkError; const PkgExtractCtx = struct { ext: *extractor.Extractor, pkg_idx: u32, integrity: [64]u8, cache_path: []const u8, pkg_name: []const u8, version_str: []const u8, direct: bool, parent_path: ?[]const u8, has_bin: bool, completed: bool, has_error: bool, };
var extract_contexts = try arena_alloc.alloc(PkgExtractCtx, misses.items.len); var valid_count: usize = 0;
debug.log("queuing {d} tarball fetches...", .{misses.items.len});
for (misses.items, 0..) |pkg_idx, i| { const pkg = &lf.packages[pkg_idx]; const pkg_name = pkg.name.slice(lf.string_table); const tarball_url = pkg.tarball_url.slice(lf.string_table); const version_str = pkg.versionString(arena_alloc, lf.string_table) catch continue; const cache_path = db.getPackagePath(&pkg.integrity, arena_alloc) catch continue;
const msg = std.fmt.allocPrintSentinel(arena_alloc, "{s}", .{pkg_name}, 0) catch continue; self.reportProgress(.fetching, @intCast(i), @intCast(misses.items.len), msg);
if (self.options.verbose) { debug.log(" queue: {s}@{s}", .{ pkg_name, version_str }); }
const ext = extractor.Extractor.init(self.allocator, cache_path) catch continue; const parent_path_str = pkg.parent_path.slice(lf.string_table); extract_contexts[valid_count] = .{ .ext = ext, .pkg_idx = pkg_idx, .integrity = pkg.integrity, .cache_path = cache_path, .pkg_name = pkg_name, .version_str = version_str, .direct = pkg.flags.direct, .parent_path = if (parent_path_str.len > 0) parent_path_str else null, .has_bin = pkg.flags.has_bin, .completed = false, .has_error = false, };
http.fetchTarball(tarball_url, fetcher.StreamHandler.init( struct { fn onData(data: []const u8, user_data: ?*anyopaque) void { const ctx: *PkgExtractCtx = @ptrCast(@alignCast(user_data)); ctx.ext.feedCompressed(data) catch { ctx.has_error = true; }; } }.onData, struct { fn onComplete(_: u16, user_data: ?*anyopaque) void { const ctx: *PkgExtractCtx = @ptrCast(@alignCast(user_data)); ctx.completed = true; } }.onComplete, struct { fn onError(_: fetcher.FetchError, user_data: ?*anyopaque) void { const ctx: *PkgExtractCtx = @ptrCast(@alignCast(user_data)); ctx.has_error = true; ctx.completed = true; } }.onError, &extract_contexts[valid_count], )) catch continue;
valid_count += 1; } stage_start = debug.timer("queue fetches", stage_start); debug.log("running event loop for {d} fetches...", .{valid_count}); http.run() catch {}; stage_start = debug.timer("fetch + extract", stage_start);
var success_count: usize = 0; var error_count: usize = 0; std.sort.heap(PkgExtractCtx, extract_contexts[0..valid_count], {}, struct { fn lessThan(_: void, a: PkgExtractCtx, b: PkgExtractCtx) bool { const depth_a = linkPathDepth(a.parent_path); const depth_b = linkPathDepth(b.parent_path); if (depth_a != depth_b) return depth_a < depth_b;
const parent_a = a.parent_path orelse ""; const parent_b = b.parent_path orelse ""; const parent_order = std.mem.order(u8, parent_a, parent_b); if (parent_order != .eq) return parent_order == .lt; return std.mem.order(u8, a.pkg_name, b.pkg_name) == .lt; } }.lessThan);
for (extract_contexts[0..valid_count], 0..) |*ctx, i| { defer ctx.ext.deinit();
if (ctx.has_error) { error_count += 1; debug.log(" error: {s}", .{ctx.pkg_name}); continue; } success_count += 1;
const msg = std.fmt.allocPrintSentinel(arena_alloc, "{s}", .{ctx.pkg_name}, 0) catch continue; self.reportProgress(.linking, @intCast(i), @intCast(valid_count), msg);
const stats = ctx.ext.stats(); if (stats.files >= 100) { debug.log(" extracted {s}: {d} files, {d} bytes", .{ ctx.pkg_name, stats.files, stats.bytes }); } db.insert(&.{ .integrity = ctx.integrity, .path = ctx.cache_path, .unpacked_size = stats.bytes, .file_count = stats.files, .cached_at = std.time.timestamp(), }, ctx.pkg_name, ctx.version_str) catch continue;
self.addPackageToResults(ctx.pkg_name, ctx.version_str, ctx.direct) catch {};
pkg_linker.linkPackage(.{ .cache_path = ctx.cache_path, .node_modules_path = node_modules_path, .name = ctx.pkg_name, .parent_path = ctx.parent_path, .file_count = stats.files, .has_bin = ctx.has_bin, }) catch {}; } stage_start = debug.timer("cache insert + link misses", stage_start); debug.log(" fetched: {d} success, {d} errors", .{ success_count, error_count }); }
db.sync(); stage_start = debug.timer("cache sync", stage_start);
const link_stats = pkg_linker.getStats(); self.last_install_result = .{ .package_count = pkg_count, .cache_hits = @intCast(cache_hits.items.len), .cache_misses = @intCast(misses.items.len), .files_linked = link_stats.files_linked, .files_copied = link_stats.files_copied, .packages_installed = link_stats.packages_installed, .packages_skipped = link_stats.packages_skipped, .elapsed_ms = timer.read() / 1_000_000, }; }};
fn trySetHttpResolveError(c: *PkgContext, err: anyerror) bool { if (err != error.ResponseError) return false;
const http = c.http orelse return false; const info = http.getLastHttpError() orelse return false;
c.setErrorFmt("error: GET {s} - {d}", .{ info.url, info.status }); return true;}
fn setResolveError(c: *PkgContext, target: ?[]const u8, err: anyerror) void { if (trySetHttpResolveError(c, err)) return;
if (target) |name| c.setErrorFmt("Failed to resolve {s}: {}", .{ name, err }) else c.setErrorFmt("Failed to resolve dependencies: {}", .{ err });}
fn linkPathDepth(parent_path: ?[]const u8) u32 { const parent = parent_path orelse return 0; if (parent.len == 0) return 0;
var depth: u32 = 1; var it: usize = 0; while (std.mem.indexOfPos(u8, parent, it, "/node_modules/")) |idx| { depth += 1; it = idx + "/node_modules/".len; } return depth;}
fn packageLinkLessThanParentFirst(_: void, a: linker.PackageLink, b: linker.PackageLink) bool { const a_depth = linkPathDepth(a.parent_path); const b_depth = linkPathDepth(b.parent_path); if (a_depth != b_depth) return a_depth < b_depth;
const a_parent = a.parent_path orelse ""; const b_parent = b.parent_path orelse ""; const parent_order = std.mem.order(u8, a_parent, b_parent); if (parent_order != .eq) return parent_order == .lt;
return std.mem.order(u8, a.name, b.name) == .lt;}
fn batchHitLessThanParentFirst(lf: *const lockfile.Lockfile, a: cache.CacheDB.BatchHit, b: cache.CacheDB.BatchHit) bool { const pkg_a = &lf.packages[a.index]; const pkg_b = &lf.packages[b.index];
const parent_a = pkg_a.parent_path.slice(lf.string_table); const parent_b = pkg_b.parent_path.slice(lf.string_table); const depth_a = linkPathDepth(if (parent_a.len > 0) parent_a else null); const depth_b = linkPathDepth(if (parent_b.len > 0) parent_b else null); if (depth_a != depth_b) return depth_a < depth_b;
const name_a = pkg_a.name.slice(lf.string_table); const name_b = pkg_b.name.slice(lf.string_table); const parent_order = std.mem.order(u8, parent_a, parent_b); if (parent_order != .eq) return parent_order == .lt; return std.mem.order(u8, name_a, name_b) == .lt;}
export fn pkg_init(options: *const PkgOptions) ?*PkgContext { return PkgContext.init(global_allocator, options.*) catch null;}
export fn pkg_free(ctx: ?*PkgContext) void { if (ctx) |c| c.deinit();}
export fn pkg_install( ctx: ?*PkgContext, package_json_path: [*:0]const u8, lockfile_path: [*:0]const u8, node_modules_path: [*:0]const u8,) PkgError { const c = ctx orelse return .invalid_argument;
_ = c.arena_state.reset(.retain_capacity); const arena_alloc = c.arena_state.allocator();
c.install( std.mem.span(lockfile_path), std.mem.span(node_modules_path), ) catch |err| { return switch (err) { error.InvalidLockfile => .invalid_lockfile, error.CacheError => .cache_error, error.NetworkError => .network_error, error.OutOfMemory => .out_of_memory, else => .io_error, }; };
var pkg_json = json.PackageJson.parse(arena_alloc, std.mem.span(package_json_path)) catch return .ok; defer pkg_json.deinit(arena_alloc); if (pkg_json.trusted_dependencies.count() > 0) { runTrustedPostinstall(c, &pkg_json.trusted_dependencies, std.mem.span(node_modules_path), arena_alloc); }
return .ok;}
export fn pkg_get_install_result(ctx: ?*PkgContext, out: *InstallResult) PkgError { const c = ctx orelse return .invalid_argument; out.* = c.last_install_result; return .ok;}
export fn pkg_get_added_count(ctx: ?*const PkgContext) u32 { const c = ctx orelse return 0; return @intCast(c.added_packages.items.len);}
export fn pkg_get_added_package(ctx: ?*const PkgContext, index: u32, out: *AddedPackage) PkgError { const c = ctx orelse return .invalid_argument; if (index >= c.added_packages.items.len) return .invalid_argument; out.* = c.added_packages.items[index]; return .ok;}
export fn pkg_get_latest_available_version( ctx: ?*PkgContext, package_name: [*:0]const u8, installed_version: [*:0]const u8, out_version: [*]u8, out_version_len: usize,) c_int { const c = ctx orelse return 0; if (out_version_len == 0) return 0; out_version[0] = 0;
const name = std.mem.span(package_name); const installed_str = std.mem.span(installed_version); const installed = resolver.Version.parse(installed_str) catch return 0; const meta = c.metadata_cache.get(name) orelse return 0;
var best: ?*const resolver.VersionInfo = null; for (meta.versions.items) |*v| { if (v.version.prerelease != null) continue; if (!v.matchesPlatform()) continue; if (best == null or v.version.order(best.?.version) == .gt) best = v; } if (best == null) { for (meta.versions.items) |*v| { if (!v.matchesPlatform()) continue; if (best == null or v.version.order(best.?.version) == .gt) best = v; } }
const latest = best orelse return 0; if (latest.version.order(installed) != .gt) return 0;
if (latest.version_str.len + 1 > out_version_len) return 0; @memcpy(out_version[0..latest.version_str.len], latest.version_str); out_version[latest.version_str.len] = 0; return 1;}
export fn pkg_count_installed(node_modules_path: [*:0]const u8) u32 { const nm_path = std.mem.span(node_modules_path); if (!std.mem.endsWith(u8, nm_path, "node_modules")) return 0; const base = nm_path[0 .. nm_path.len - "node_modules".len]; var buf: [std.fs.max_path_bytes]u8 = undefined; const lp = std.fmt.bufPrint(&buf, "{s}ant.lockb", .{base}) catch return 0; var lf = lockfile.Lockfile.open(lp) catch return 0; defer lf.close(); return lf.header.package_count;}
export fn pkg_discover_lifecycle_scripts( ctx: ?*PkgContext, node_modules_path: [*:0]const u8,) PkgError { const c = ctx orelse return .invalid_argument; c.clearLifecycleScripts();
const nm_path = std.mem.span(node_modules_path); var nm_dir = std.fs.cwd().openDir(nm_path, .{ .iterate = true }) catch return .io_error; defer nm_dir.close();
var iter = nm_dir.iterate(); while (iter.next() catch null) |entry| { if (entry.kind != .directory) continue; if (entry.name[0] == '@') { var scope_dir = nm_dir.openDir(entry.name, .{ .iterate = true }) catch continue; defer scope_dir.close(); var scope_iter = scope_dir.iterate(); while (scope_iter.next() catch null) |scoped_entry| { if (scoped_entry.kind != .directory) continue; const full_name = std.fmt.allocPrint(c.allocator, "@{s}/{s}", .{ entry.name[1..], scoped_entry.name }) catch continue; defer c.allocator.free(full_name); discoverPackageScript(c, nm_path, full_name, scope_dir, scoped_entry.name); } } else { discoverPackageScript(c, nm_path, entry.name, nm_dir, entry.name); } }
return .ok;}
fn discoverPackageScript(ctx: *PkgContext, nm_path: []const u8, pkg_name: []const u8, parent_dir: std.fs.Dir, dir_name: []const u8) void { var pkg_dir = parent_dir.openDir(dir_name, .{}) catch return; defer pkg_dir.close();
pkg_dir.access(".postinstall", .{}) catch |err| { if (err != error.FileNotFound) return; const pkg_json = pkg_dir.openFile("package.json", .{}) catch return; defer pkg_json.close();
const content = pkg_json.readToEndAlloc(ctx.allocator, 1024 * 1024) catch return; defer ctx.allocator.free(content);
var doc = json.JsonDoc.parse(content) catch return; defer doc.deinit();
const root = doc.root(); if (root.getObject("scripts")) |scripts| { const script = scripts.getString("postinstall") orelse scripts.getString("install") orelse return;
if (std.mem.eql(u8, pkg_name, "esbuild")) return; ctx.addLifecycleScript(pkg_name, script) catch return; } return; }; _ = nm_path;}
export fn pkg_get_lifecycle_script_count(ctx: ?*const PkgContext) u32 { const c = ctx orelse return 0; return @intCast(c.lifecycle_scripts.items.len);}
export fn pkg_get_lifecycle_script(ctx: ?*const PkgContext, index: u32, out: *LifecycleScript) PkgError { const c = ctx orelse return .invalid_argument; if (index >= c.lifecycle_scripts.items.len) return .invalid_argument; out.* = c.lifecycle_scripts.items[index]; return .ok;}
export fn pkg_run_postinstall( ctx: ?*PkgContext, node_modules_path: [*:0]const u8, package_names: [*]const [*:0]const u8, count: u32,) PkgError { const c = ctx orelse return .invalid_argument; _ = c.arena_state.reset(.retain_capacity); const arena_alloc = c.arena_state.allocator();
var trusted = std.StringHashMap(void).init(arena_alloc); for (0..count) |i| { trusted.put(std.mem.span(package_names[i]), {}) catch continue; }
runTrustedPostinstall(c, &trusted, std.mem.span(node_modules_path), arena_alloc); return .ok;}
export fn pkg_add_trusted_dependencies( package_json_path: [*:0]const u8, package_names: [*]const [*:0]const u8, count: u32,) PkgError { const allocator = std.heap.c_allocator; const path = std.mem.span(package_json_path); const path_z = package_json_path;
debug.log("[trust] pkg_add_trusted_dependencies: path={s} count={d}", .{ path, count });
const file = std.fs.cwd().openFile(path, .{ .mode = .read_write }) catch |err| { debug.log("[trust] failed to open file: {}", .{err}); return .io_error; }; defer file.close();
const content = file.readToEndAlloc(allocator, 10 * 1024 * 1024) catch |err| { debug.log("[trust] failed to read file: {}", .{err}); return .io_error; }; defer allocator.free(content);
debug.log("[trust] read {d} bytes from package.json", .{content.len});
const doc = json.yyjson.yyjson_read(content.ptr, content.len, 0); if (doc == null) { debug.log("[trust] failed to parse JSON", .{}); return .io_error; } defer json.yyjson.yyjson_doc_free(doc);
const mdoc = json.yyjson.yyjson_doc_mut_copy(doc, null); if (mdoc == null) { debug.log("[trust] failed to create mutable doc", .{}); return .out_of_memory; } defer json.yyjson.yyjson_mut_doc_free(mdoc);
const root = json.yyjson.yyjson_mut_doc_get_root(mdoc); if (root == null) { debug.log("[trust] failed to get root", .{}); return .io_error; }
var trusted_arr = json.yyjson.yyjson_mut_obj_get(root, "trustedDependencies"); if (trusted_arr == null) { debug.log("[trust] creating new trustedDependencies array", .{}); trusted_arr = json.yyjson.yyjson_mut_arr(mdoc); if (trusted_arr == null) { debug.log("[trust] failed to create array", .{}); return .out_of_memory; } _ = json.yyjson.yyjson_mut_obj_add_val(mdoc, root, "trustedDependencies", trusted_arr); } else { debug.log("[trust] trustedDependencies array already exists", .{}); }
var string_copies = std.ArrayListUnmanaged([:0]u8){}; defer { for (string_copies.items) |s| allocator.free(s); string_copies.deinit(allocator); }
var added: u32 = 0; for (0..count) |i| { const pkg_name = std.mem.span(package_names[i]); var exists = false;
var iter = json.yyjson.yyjson_mut_arr_iter{}; _ = json.yyjson.yyjson_mut_arr_iter_init(trusted_arr, &iter); while (json.yyjson.yyjson_mut_arr_iter_next(&iter)) |val| { if (json.yyjson.yyjson_mut_is_str(val)) { const existing = json.yyjson.yyjson_mut_get_str(val); if (existing != null and std.mem.eql(u8, std.mem.span(existing.?), pkg_name)) { exists = true; break; } } }
if (!exists) { const name_copy = allocator.dupeZ(u8, pkg_name) catch continue; string_copies.append(allocator, name_copy) catch { allocator.free(name_copy); continue; }; const val = json.yyjson.yyjson_mut_str(mdoc, name_copy.ptr); if (val != null) { _ = json.yyjson.yyjson_mut_arr_append(trusted_arr, val); added += 1; debug.log("[trust] added {s}", .{pkg_name}); } } else { debug.log("[trust] {s} already in trustedDependencies", .{pkg_name}); } } debug.log("[trust] added {d} packages, writing file", .{added});
var write_err: json.yyjson.yyjson_write_err = undefined; const flags = json.yyjson.YYJSON_WRITE_PRETTY_TWO_SPACES | json.yyjson.YYJSON_WRITE_ESCAPE_UNICODE; const written = json.yyjson.yyjson_mut_write_file(path_z, mdoc, flags, null, &write_err); if (!written) { const msg = if (write_err.msg) |m| std.mem.span(m) else "unknown"; debug.log("[trust] failed to write file: code={d} msg={s}", .{ write_err.code, msg }); return .io_error; }
debug.log("[trust] successfully wrote package.json", .{}); return .ok;}
const InterleavedExtractCtx = struct { ext: *extractor.Extractor, integrity: [64]u8, cache_path: []const u8, pkg_name: []const u8, version_str: []const u8, direct: bool, parent_path: ?[]const u8, has_bin: bool, completed: bool, has_error: bool, queued: bool, parent: *InterleavedContext,};
const InterleavedContext = struct { allocator: std.mem.Allocator, arena_alloc: std.mem.Allocator, db: *cache.CacheDB, http: *fetcher.Fetcher, pkg_ctx: *PkgContext, extract_contexts: std.ArrayListUnmanaged(*InterleavedExtractCtx), queued_integrities: std.AutoHashMap([64]u8, void), callbacks_received: usize, integrity_duplicates: usize, cache_hits: usize, tarballs_queued: usize, tarballs_completed: std.atomic.Value(u32),
fn init(allocator: std.mem.Allocator, arena_alloc: std.mem.Allocator, db: *cache.CacheDB, http: *fetcher.Fetcher, pkg_ctx: *PkgContext) InterleavedContext { return .{ .allocator = allocator, .arena_alloc = arena_alloc, .db = db, .http = http, .pkg_ctx = pkg_ctx, .extract_contexts = .{}, .queued_integrities = std.AutoHashMap([64]u8, void).init(arena_alloc), .callbacks_received = 0, .integrity_duplicates = 0, .cache_hits = 0, .tarballs_queued = 0, .tarballs_completed = std.atomic.Value(u32).init(0), }; }
fn deinit(self: *InterleavedContext) void { self.extract_contexts.deinit(self.arena_alloc); self.queued_integrities.deinit(); }
fn onPackageResolved(pkg: *const resolver.ResolvedPackage, user_data: ?*anyopaque) void { const self: *InterleavedContext = @ptrCast(@alignCast(user_data)); self.callbacks_received += 1;
const pkg_name = pkg.name.slice(); const current: u32 = @intCast(self.callbacks_received); const msg = std.fmt.allocPrintSentinel(self.arena_alloc, "{s}", .{pkg_name}, 0) catch return; self.pkg_ctx.reportProgress(.resolving, current, current, msg);
if (self.queued_integrities.contains(pkg.integrity)) { self.integrity_duplicates += 1; return; } self.queued_integrities.put(pkg.integrity, {}) catch return;
if (self.db.hasIntegrity(&pkg.integrity)) { self.cache_hits += 1; return; } self.tarballs_queued += 1;
const cache_path = self.db.getPackagePath(&pkg.integrity, self.arena_alloc) catch return; const version_str = pkg.version.format(self.arena_alloc) catch return;
const ext = extractor.Extractor.init(self.allocator, cache_path) catch return; const ctx = self.arena_alloc.create(InterleavedExtractCtx) catch { ext.deinit(); return; }; ctx.* = .{ .ext = ext, .integrity = pkg.integrity, .cache_path = cache_path, .pkg_name = pkg.name.slice(), .version_str = version_str, .direct = pkg.direct, .parent_path = pkg.parent_path, .has_bin = pkg.has_bin, .completed = false, .has_error = false, .queued = false, .parent = self, };
self.http.fetchTarball(pkg.tarball_url, fetcher.StreamHandler.init( struct { fn onData(data: []const u8, ud: ?*anyopaque) void { const c: *InterleavedExtractCtx = @ptrCast(@alignCast(ud)); if (c.has_error) return; c.ext.feedCompressed(data) catch { c.has_error = true; }; } }.onData, struct { fn onComplete(_: u16, ud: ?*anyopaque) void { const c: *InterleavedExtractCtx = @ptrCast(@alignCast(ud)); c.completed = true;
const completed = c.parent.tarballs_completed.fetchAdd(1, .monotonic) + 1; const total: u32 = @intCast(c.parent.tarballs_queued); var msg_buf: [256]u8 = undefined; const msg_len = std.fmt.bufPrint(&msg_buf, "{s}", .{c.pkg_name}) catch return; msg_buf[msg_len.len] = 0; c.parent.pkg_ctx.reportProgress(.fetching, completed, total, msg_buf[0..msg_len.len :0]); } }.onComplete, struct { fn onError(_: fetcher.FetchError, ud: ?*anyopaque) void { const c: *InterleavedExtractCtx = @ptrCast(@alignCast(ud)); c.has_error = true; c.completed = true; } }.onError, ctx, )) catch { ext.deinit(); self.arena_alloc.destroy(ctx); return; };
ctx.queued = true; self.extract_contexts.append(self.arena_alloc, ctx) catch return;
debug.log(" queued tarball: {s}@{s}", .{ pkg.name.slice(), version_str }); }};
export fn pkg_resolve_and_install( ctx: ?*PkgContext, package_json_path: [*:0]const u8, lockfile_path: [*:0]const u8, node_modules_path: [*:0]const u8,) PkgError { const c = ctx orelse return .invalid_argument; _ = c.arena_state.reset(.retain_capacity); const arena_alloc = c.arena_state.allocator();
var timer = std.time.Timer.start() catch return .out_of_memory; var stage_start: u64 = @intCast(std.time.nanoTimestamp());
debug.log("resolve+install (interleaved): package_json={s} lockfile={s} node_modules={s}", .{ std.mem.span(package_json_path), std.mem.span(lockfile_path), std.mem.span(node_modules_path), });
const http = c.http orelse return .network_error; http.resetMetaClients(); const db = c.cache_db orelse return .cache_error;
const pkg_json_path_z = arena_alloc.dupeZ(u8, std.mem.span(package_json_path)) catch return .out_of_memory; var pkg_json = json.PackageJson.parse(arena_alloc, pkg_json_path_z) catch { c.setError("Failed to parse package.json"); return .io_error; }; defer pkg_json.deinit(arena_alloc);
if (pkg_json.trusted_dependencies.count() > 0) { debug.log(" trusted dependencies: {d}", .{pkg_json.trusted_dependencies.count()}); }
var interleaved = InterleavedContext.init(c.allocator, arena_alloc, db, http, c); defer interleaved.deinit();
var res = resolver.Resolver.init( arena_alloc, c.allocator, &c.string_pool, http, db, if (c.options.registry_url) |url| std.mem.span(url) else "https://registry.npmjs.org", &c.metadata_cache, ); defer res.deinit();
res.setOnPackageResolved(InterleavedContext.onPackageResolved, &interleaved); res.resolveFromPackageJson(std.mem.span(package_json_path)) catch |err| { setResolveError(c, null, err); return .resolve_error; }; stage_start = debug.timer("resolve + queue tarballs", stage_start); debug.log(" resolved {d} packages, callbacks={d} (dupes={d}), cache hits={d}, queued={d}", .{ res.resolved.count(), interleaved.callbacks_received, interleaved.integrity_duplicates, interleaved.cache_hits, interleaved.tarballs_queued, });
var direct_iter = res.resolved.valueIterator(); while (direct_iter.next()) |pkg_ptr| { const pkg = pkg_ptr.*; if (pkg.direct) { const version_str = pkg.version.format(arena_alloc) catch continue; c.addPackageToResults(pkg.name.slice(), version_str, true) catch {}; } }
var pkg_linker = linker.Linker.init(c.allocator); defer pkg_linker.deinit(); pkg_linker.setNodeModulesPath(std.mem.span(node_modules_path)) catch return .io_error;
var cache_hit_jobs = std.ArrayListUnmanaged(linker.PackageLink){}; var pkg_iter = res.resolved.valueIterator(); while (pkg_iter.next()) |pkg_ptr| { const pkg = pkg_ptr.*; if (interleaved.queued_integrities.contains(pkg.integrity)) { var is_download = false; for (interleaved.extract_contexts.items) |ext_ctx| { if (std.mem.eql(u8, &ext_ctx.integrity, &pkg.integrity)) { is_download = true; break; } } if (is_download) continue; }
var cache_entry = db.lookup(&pkg.integrity) orelse continue; defer cache_entry.deinit(); const cache_path = arena_alloc.dupe(u8, cache_entry.path) catch continue; cache_hit_jobs.append(arena_alloc, .{ .cache_path = cache_path, .node_modules_path = std.mem.span(node_modules_path), .name = pkg.name.slice(), .parent_path = pkg.parent_path, .file_count = cache_entry.file_count, .has_bin = pkg.has_bin, }) catch continue; }
var tarball_thread: ?std.Thread = null; if (interleaved.tarballs_queued > 0) { debug.log("finishing {d} tarball downloads (pending={d})...", .{ interleaved.tarballs_queued, http.pending.items.len, }); tarball_thread = std.Thread.spawn(.{}, struct { fn work(h: *fetcher.Fetcher) void { h.run() catch {}; } }.work, .{http}) catch |err| blk: { debug.log("warning: failed to spawn tarball thread: {}, running synchronously", .{err}); http.run() catch {}; break :blk null; }; }
std.sort.heap(linker.PackageLink, cache_hit_jobs.items, {}, packageLinkLessThanParentFirst);
var linked_count: usize = 0; for (cache_hit_jobs.items, 0..) |job, i| { const msg = std.fmt.allocPrintSentinel(arena_alloc, "{s}", .{job.name}, 0) catch continue; c.reportProgress(.linking, @intCast(i), @intCast(cache_hit_jobs.items.len), msg); pkg_linker.linkPackage(job) catch continue; linked_count += 1; }
if (tarball_thread) |t| { t.join(); stage_start = debug.timer("finish tarballs + link cache hits", stage_start); } else stage_start = debug.timer("link cache hits", stage_start); debug.log(" linked {d} from cache", .{linked_count});
res.writeLockfile(std.mem.span(lockfile_path)) catch |err| { c.setErrorFmt("Failed to write lockfile: {}", .{err}); return .io_error; }; stage_start = debug.timer("write lockfile", stage_start);
var success_count: usize = 0; var error_count: usize = 0;
const LinkJobWithSize = struct { job: linker.PackageLink, size: u64, };
var cache_entries = std.ArrayListUnmanaged(cache.CacheDB.NamedCacheEntry){}; var link_jobs = std.ArrayListUnmanaged(LinkJobWithSize){}; const current_time = std.time.timestamp(); const nm_path = std.mem.span(node_modules_path);
for (interleaved.extract_contexts.items) |ext_ctx| { if (ext_ctx.has_error or !ext_ctx.completed) { error_count += 1; debug.log(" error: {s}", .{ext_ctx.pkg_name}); continue; } success_count += 1;
const stats = ext_ctx.ext.stats(); cache_entries.append(arena_alloc, .{ .entry = .{ .integrity = ext_ctx.integrity, .path = ext_ctx.cache_path, .unpacked_size = stats.bytes, .file_count = stats.files, .cached_at = current_time, }, .name = ext_ctx.pkg_name, .version = ext_ctx.version_str, }) catch continue;
link_jobs.append(arena_alloc, .{ .job = .{ .cache_path = ext_ctx.cache_path, .node_modules_path = nm_path, .name = ext_ctx.pkg_name, .parent_path = ext_ctx.parent_path, .file_count = stats.files, .has_bin = ext_ctx.has_bin, }, .size = stats.bytes, }) catch continue;
c.addPackageToResults(ext_ctx.pkg_name, ext_ctx.version_str, ext_ctx.direct) catch {}; }
for (cache_entries.items, 0..) |entry, i| { const msg = std.fmt.allocPrintSentinel(arena_alloc, "{s}", .{entry.name}, 0) catch continue; c.reportProgress(.caching, @intCast(i), @intCast(cache_entries.items.len), msg); } db.batchInsertNamed(cache_entries.items) catch {}; stage_start = debug.timer("cache insert (batch)", stage_start);
const total_jobs: u32 = @intCast(link_jobs.items.len); var link_counter = std.atomic.Value(u32).init(0); std.sort.heap(LinkJobWithSize, link_jobs.items, {}, struct { fn lessThan(_: void, a: LinkJobWithSize, b: LinkJobWithSize) bool { const depth_a = linkPathDepth(a.job.parent_path); const depth_b = linkPathDepth(b.job.parent_path); if (depth_a != depth_b) return depth_a < depth_b; if (a.size != b.size) return a.size > b.size;
const parent_a = a.job.parent_path orelse ""; const parent_b = b.job.parent_path orelse ""; const parent_order = std.mem.order(u8, parent_a, parent_b); if (parent_order != .eq) return parent_order == .lt; return std.mem.order(u8, a.job.name, b.job.name) == .lt; } }.lessThan);
var slow_link_count = std.atomic.Value(u32).init(0); var max_link_ms = std.atomic.Value(u64).init(0); var slow_link_names = std.ArrayListUnmanaged([]const u8){}; defer slow_link_names.deinit(c.allocator); var slow_link_lock = std.Thread.Mutex{};
var depth_start: usize = 0; while (depth_start < link_jobs.items.len) { const depth = linkPathDepth(link_jobs.items[depth_start].job.parent_path); var depth_end = depth_start + 1; while (depth_end < link_jobs.items.len and linkPathDepth(link_jobs.items[depth_end].job.parent_path) == depth) : (depth_end += 1) {}
const depth_jobs = link_jobs.items[depth_start..depth_end]; const num_threads = @min(8, depth_jobs.len); if (c.options.verbose and depth_jobs.len > 1) { debug.log(" linking depth {d} ({d} items)", .{ depth, depth_jobs.len }); }
if (num_threads > 1 and depth_jobs.len > 4) { var threads: [8]?std.Thread = .{null} ** 8; const jobs_per_thread = (depth_jobs.len + num_threads - 1) / num_threads;
for (0..num_threads) |t| { const start_idx = t * jobs_per_thread; const end_idx = @min(start_idx + jobs_per_thread, depth_jobs.len); if (start_idx >= end_idx) break;
threads[t] = std.Thread.spawn(.{}, struct { fn work(lnk: *linker.Linker, jobs: []const LinkJobWithSize, pkg_ctx: *PkgContext, total: u32, counter: *std.atomic.Value(u32), slow_count: *std.atomic.Value(u32), max_ms: *std.atomic.Value(u64), names: *std.ArrayListUnmanaged([]const u8), lock: *std.Thread.Mutex, alloc: std.mem.Allocator) void { for (jobs) |job_with_size| { const job = job_with_size.job; const current = counter.fetchAdd(1, .monotonic) + 1; var msg_buf: [256]u8 = undefined; const msg_len = std.fmt.bufPrint(&msg_buf, "{s}", .{job.name}) catch continue; msg_buf[msg_len.len] = 0; pkg_ctx.reportProgress(.linking, current, total, msg_buf[0..msg_len.len :0]); const start = std.time.nanoTimestamp(); lnk.linkPackage(job) catch {}; const delta = std.time.nanoTimestamp() - start; const elapsed_ms: u64 = if (delta < 0) 0 else @intCast(@as(u128, @intCast(delta)) / 1_000_000); if (elapsed_ms > 100) { _ = slow_count.fetchAdd(1, .monotonic); lock.lock(); const entry = std.fmt.allocPrint(alloc, "{s} {d}ms", .{ job.name, elapsed_ms }) catch null; if (entry) |val| { names.append(alloc, val) catch {}; } lock.unlock(); var current_max = max_ms.load(.monotonic); while (elapsed_ms > current_max) : (current_max = max_ms.load(.monotonic)) { if (max_ms.cmpxchgWeak(current_max, elapsed_ms, .monotonic, .monotonic) == null) break; } } } } }.work, .{ &pkg_linker, depth_jobs[start_idx..end_idx], c, total_jobs, &link_counter, &slow_link_count, &max_link_ms, &slow_link_names, &slow_link_lock, c.allocator }) catch null; }
for (&threads) |*t| { if (t.*) |thread| thread.join(); } } else { for (depth_jobs) |job_with_size| { const job = job_with_size.job; const current = link_counter.fetchAdd(1, .monotonic) + 1; const msg = std.fmt.allocPrintSentinel(arena_alloc, "{s}", .{job.name}, 0) catch continue; c.reportProgress(.linking, current, total_jobs, msg); const start = std.time.nanoTimestamp(); pkg_linker.linkPackage(job) catch {}; const elapsed_ms: u64 = @intCast((@as(u64, @intCast(std.time.nanoTimestamp())) - @as(u64, @intCast(start))) / 1_000_000); if (elapsed_ms > 100 and c.options.verbose) { debug.log(" link slow: {s} {d}ms", .{ job.name, elapsed_ms }); } } }
depth_start = depth_end; }
if (c.options.verbose) { debug.log(" link slow (>100ms): {d} max={d}ms", .{ slow_link_count.load(.monotonic), max_link_ms.load(.monotonic) }); for (slow_link_names.items) |entry| { debug.log(" link slow: {s}", .{entry}); } } for (slow_link_names.items) |entry| c.allocator.free(entry); stage_start = debug.timer("link downloads (parallel)", stage_start); debug.log(" downloaded: {d} success, {d} errors", .{ success_count, error_count }); for (interleaved.extract_contexts.items) |ext_ctx| ext_ctx.ext.deinit();
db.sync(); _ = debug.timer("cache sync", stage_start);
const link_stats = pkg_linker.getStats(); c.last_install_result = .{ .package_count = @intCast(res.resolved.count()), .cache_hits = @intCast(interleaved.cache_hits), .cache_misses = @intCast(interleaved.tarballs_queued), .files_linked = link_stats.files_linked, .files_copied = link_stats.files_copied, .packages_installed = link_stats.packages_installed, .packages_skipped = link_stats.packages_skipped, .elapsed_ms = timer.read() / 1_000_000, };
debug.log("total: {d} packages in {d}ms", .{ res.resolved.count(), c.last_install_result.elapsed_ms });
if (pkg_json.trusted_dependencies.count() > 0) { runTrustedPostinstall(c, &pkg_json.trusted_dependencies, std.mem.span(node_modules_path), arena_alloc); }
return .ok;}
const PostinstallJob = struct { pkg_name: []const u8, pkg_dir: []const u8, script: []const u8, child: ?std.process.Child = null, exit_code: ?u8 = null, stderr: ?[]const u8 = null, failed: bool = false,};
fn runTrustedPostinstall( ctx: *PkgContext, trusted: *std.StringHashMap(void), node_modules_path: []const u8, allocator: std.mem.Allocator,) void { var env_map = std.process.getEnvMap(allocator) catch return; defer env_map.deinit();
const cwd = std.fs.cwd(); const abs_nm_path = cwd.realpathAlloc(allocator, node_modules_path) catch return; defer allocator.free(abs_nm_path);
const bin_path = std.fmt.allocPrint(allocator, "{s}/.bin", .{abs_nm_path}) catch return; defer allocator.free(bin_path);
const current_path = env_map.get("PATH") orelse ""; const new_path = if (builtin.os.tag == .windows) std.fmt.allocPrint(allocator, "{s};{s}", .{ bin_path, current_path }) catch return else std.fmt.allocPrint(allocator, "{s}:{s}", .{ bin_path, current_path }) catch return; defer allocator.free(new_path);
env_map.put("PATH", new_path) catch return;
var jobs = std.ArrayListUnmanaged(PostinstallJob){}; defer { for (jobs.items) |*job| if (job.stderr) |s| allocator.free(s); jobs.deinit(allocator); }
var key_iter = trusted.keyIterator(); while (key_iter.next()) |pkg_name_ptr| { const pkg_name = pkg_name_ptr.*;
const pkg_json_path = std.fmt.allocPrint(allocator, "{s}/{s}/package.json", .{ node_modules_path, pkg_name, }) catch continue; defer allocator.free(pkg_json_path);
const file = std.fs.cwd().openFile(pkg_json_path, .{}) catch continue; defer file.close();
const content = file.readToEndAlloc(allocator, 1024 * 1024) catch continue; defer allocator.free(content);
var doc = json.JsonDoc.parse(content) catch continue; defer doc.deinit();
const root = doc.root();
if (root.getObject("scripts")) |scripts| { const script = scripts.getString("postinstall") orelse scripts.getString("install") orelse continue;
if (std.mem.eql(u8, pkg_name, "esbuild")) { debug.log("ignoring esbuild lifecycle scripts", .{}); continue; }
const pkg_dir = std.fmt.allocPrint(allocator, "{s}/{s}", .{ node_modules_path, pkg_name, }) catch continue;
const marker_path = std.fmt.allocPrint(allocator, "{s}/.postinstall", .{pkg_dir}) catch continue; defer allocator.free(marker_path); if (std.fs.cwd().access(marker_path, .{})) |_| { debug.log("postinstall already done: {s}", .{pkg_name}); allocator.free(pkg_dir); continue; } else |_| {}
jobs.append(allocator, .{ .pkg_name = pkg_name, .pkg_dir = pkg_dir, .script = allocator.dupe(u8, script) catch continue, }) catch continue; } }
if (jobs.items.len == 0) return; for (jobs.items) |job| debug.log("starting postinstall: {s}", .{job.pkg_name});
for (jobs.items, 0..) |*job, i| { const msg = std.fmt.allocPrintSentinel(allocator, "{s}", .{job.pkg_name}, 0) catch continue; ctx.reportProgress(.postinstall, @intCast(i), @intCast(jobs.items.len), msg); debug.log("running postinstall: {s}", .{job.pkg_name});
const shell_argv: []const []const u8 = if (builtin.os.tag == .windows) &[_][]const u8{ "cmd", "/c", job.script } else &[_][]const u8{ "sh", "-c", job.script };
var child = std.process.Child.init(shell_argv, allocator); child.cwd = job.pkg_dir; child.env_map = &env_map; child.stderr_behavior = .Pipe; child.stdout_behavior = .Pipe;
child.spawn() catch { job.failed = true; continue; }; job.child = child; }
var scripts_run: u32 = 0; for (jobs.items) |*job| { if (job.child) |*child| { var stdout_buf: std.ArrayList(u8) = .empty; var stderr_buf: std.ArrayList(u8) = .empty;
child.collectOutput(allocator, &stdout_buf, &stderr_buf, 1024 * 1024) catch {};
const term = child.wait() catch { stdout_buf.deinit(allocator); stderr_buf.deinit(allocator); job.failed = true; continue; };
if (stdout_buf.items.len > 0) { var line_iter = std.mem.splitScalar(u8, stdout_buf.items, '\n'); while (line_iter.next()) |line| { if (line.len > 0) debug.log(" {s}: {s}", .{ job.pkg_name, line }); } } stdout_buf.deinit(allocator);
switch (term) { .Exited => |code| { if (code != 0) { job.exit_code = code; job.stderr = if (stderr_buf.items.len > 0) stderr_buf.toOwnedSlice(allocator) catch null else null; debug.log(" postinstall failed for {s}: exit code {d}", .{ job.pkg_name, code }); if (job.stderr) |s| { if (s.len > 0) debug.log(" stderr: {s}", .{s}); } } else { stderr_buf.deinit(allocator); scripts_run += 1; const marker_path = std.fmt.allocPrint(allocator, "{s}/.postinstall", .{job.pkg_dir}) catch continue; defer allocator.free(marker_path); if (std.fs.cwd().createFile(marker_path, .{})) |f| f.close() else |_| {} } }, .Signal => |sig| { job.failed = true; debug.log(" postinstall killed by signal {d}: {s}", .{ sig, job.pkg_name }); stderr_buf.deinit(allocator); }, else => { job.failed = true; stderr_buf.deinit(allocator); }, } } }
for (jobs.items) |job| { allocator.free(job.pkg_dir); allocator.free(job.script); }
if (scripts_run > 0) debug.log("ran {d} postinstall scripts", .{scripts_run});}
export fn pkg_add( ctx: ?*PkgContext, package_json_path: [*:0]const u8, package_spec: [*:0]const u8, dev: bool,) PkgError { const c = ctx orelse return .invalid_argument; _ = c.arena_state.reset(.retain_capacity); const arena_alloc = c.arena_state.allocator();
const pkg_json_str = std.mem.span(package_json_path); const spec_str = std.mem.span(package_spec);
var pkg_name: []const u8 = spec_str; var version_constraint: []const u8 = "latest";
if (std.mem.indexOf(u8, spec_str, "@")) |at_idx| { if (at_idx == 0) { if (std.mem.indexOfPos(u8, spec_str, 1, "@")) |second_at| { pkg_name = spec_str[0..second_at]; version_constraint = spec_str[second_at + 1 ..]; } } else { pkg_name = spec_str[0..at_idx]; version_constraint = spec_str[at_idx + 1 ..]; } }
const http = c.http orelse return .network_error; var res = resolver.Resolver.init( arena_alloc, c.allocator, &c.string_pool, http, c.cache_db, if (c.options.registry_url) |url| std.mem.span(url) else "https://registry.npmjs.org", &c.metadata_cache, ); defer res.deinit();
const resolved_pkg = res.resolve(pkg_name, version_constraint, 0) catch |err| { setResolveError(c, pkg_name, err); return .resolve_error; };
const content = blk: { const file = std.fs.cwd().openFile(pkg_json_str, .{ .mode = .read_only }) catch |err| { if (err == error.FileNotFound) break :blk "{}"; c.setError("Failed to open package.json"); return .io_error; }; defer file.close(); break :blk file.readToEndAlloc(arena_alloc, 10 * 1024 * 1024) catch { c.setError("Failed to read package.json"); return .io_error; }; };
const parsed = std.json.parseFromSlice(std.json.Value, arena_alloc, content, .{}) catch { c.setError("Failed to parse package.json"); return .invalid_argument; }; defer parsed.deinit();
if (parsed.value != .object) { c.setError("Invalid package.json format"); return .invalid_argument; }
const version_str = resolved_pkg.version.format(arena_alloc) catch { return .out_of_memory; }; const version_with_caret = std.fmt.allocPrint(arena_alloc, "^{s}", .{version_str}) catch { return .out_of_memory; };
const target_key = if (dev) "devDependencies" else "dependencies"; var deps = if (parsed.value.object.get(target_key)) |d| if (d == .object) d.object else std.json.ObjectMap.init(arena_alloc) else std.json.ObjectMap.init(arena_alloc);
deps.put(pkg_name, .{ .string = version_with_caret }) catch { return .out_of_memory; };
var writer = json.JsonWriter.init() catch { return .out_of_memory; }; defer writer.deinit();
const root_obj = writer.createObject(); writer.setRoot(root_obj);
var found_target = false; for (parsed.value.object.keys(), parsed.value.object.values()) |key, value| { if (std.mem.eql(u8, key, target_key)) { found_target = true; const deps_obj = writer.createObject(); var dep_iter = deps.iterator(); while (dep_iter.next()) |entry| { if (entry.value_ptr.* == .string) { writer.objectAdd(deps_obj, entry.key_ptr.*, writer.createString(entry.value_ptr.string)); } } writer.objectAdd(root_obj, key, deps_obj); } else { const json_val = jsonValueToMut(&writer, value) catch continue; writer.objectAdd(root_obj, key, json_val); } }
if (!found_target) { const deps_obj = writer.createObject(); writer.objectAdd(deps_obj, pkg_name, writer.createString(version_with_caret)); writer.objectAdd(root_obj, target_key, deps_obj); }
const pkg_json_z = arena_alloc.dupeZ(u8, pkg_json_str) catch { return .out_of_memory; }; writer.writeToFile(pkg_json_z) catch { c.setError("Failed to write package.json"); return .io_error; };
return .ok;}
export fn pkg_add_many( ctx: ?*PkgContext, package_json_path: [*:0]const u8, package_specs: [*]const [*:0]const u8, count: u32, dev: bool,) PkgError { const c = ctx orelse return .invalid_argument; _ = c.arena_state.reset(.retain_capacity); const arena_alloc = c.arena_state.allocator();
const pkg_json_str = std.mem.span(package_json_path);
const http = c.http orelse return .network_error; var res = resolver.Resolver.init( arena_alloc, c.allocator, &c.string_pool, http, c.cache_db, if (c.options.registry_url) |url| std.mem.span(url) else "https://registry.npmjs.org", &c.metadata_cache, ); defer res.deinit();
const ResolvedEntry = struct { name: []const u8, version_str: []const u8, };
const resolved = arena_alloc.alloc(ResolvedEntry, count) catch return .out_of_memory;
for (0..count) |i| { const spec_str = std.mem.span(package_specs[i]); var pkg_name: []const u8 = spec_str; var version_constraint: []const u8 = "latest";
if (std.mem.indexOf(u8, spec_str, "@")) |at_idx| { if (at_idx == 0) { if (std.mem.indexOfPos(u8, spec_str, 1, "@")) |second_at| { pkg_name = spec_str[0..second_at]; version_constraint = spec_str[second_at + 1 ..]; } } else { pkg_name = spec_str[0..at_idx]; version_constraint = spec_str[at_idx + 1 ..]; } }
const resolved_pkg = res.resolve(pkg_name, version_constraint, 0) catch |err| { setResolveError(c, pkg_name, err); return .resolve_error; };
const version_str = resolved_pkg.version.format(arena_alloc) catch return .out_of_memory; resolved[i] = .{ .name = pkg_name, .version_str = version_str }; }
const content = blk: { const file = std.fs.cwd().openFile(pkg_json_str, .{ .mode = .read_only }) catch |err| { if (err == error.FileNotFound) break :blk "{}"; c.setError("Failed to open package.json"); return .io_error; }; defer file.close(); break :blk file.readToEndAlloc(arena_alloc, 10 * 1024 * 1024) catch { c.setError("Failed to read package.json"); return .io_error; }; };
const parsed = std.json.parseFromSlice(std.json.Value, arena_alloc, content, .{}) catch { c.setError("Failed to parse package.json"); return .invalid_argument; }; defer parsed.deinit();
if (parsed.value != .object) { c.setError("Invalid package.json format"); return .invalid_argument; }
const target_key = if (dev) "devDependencies" else "dependencies";
var deps = if (parsed.value.object.get(target_key)) |d| if (d == .object) d.object else std.json.ObjectMap.init(arena_alloc) else std.json.ObjectMap.init(arena_alloc);
for (resolved) |entry| { const version_with_caret = std.fmt.allocPrint(arena_alloc, "^{s}", .{entry.version_str}) catch return .out_of_memory; deps.put(entry.name, .{ .string = version_with_caret }) catch return .out_of_memory; }
var writer = json.JsonWriter.init() catch return .out_of_memory; defer writer.deinit();
const root_obj = writer.createObject(); writer.setRoot(root_obj);
var found_target = false; for (parsed.value.object.keys(), parsed.value.object.values()) |key, value| { if (std.mem.eql(u8, key, target_key)) { found_target = true; const deps_obj = writer.createObject(); var dep_iter = deps.iterator(); while (dep_iter.next()) |entry| { if (entry.value_ptr.* == .string) { writer.objectAdd(deps_obj, entry.key_ptr.*, writer.createString(entry.value_ptr.string)); } } writer.objectAdd(root_obj, key, deps_obj); } else { const json_val = jsonValueToMut(&writer, value) catch continue; writer.objectAdd(root_obj, key, json_val); } }
if (!found_target) { const deps_obj = writer.createObject(); for (resolved) |entry| { const version_with_caret = std.fmt.allocPrint(arena_alloc, "^{s}", .{entry.version_str}) catch return .out_of_memory; writer.objectAdd(deps_obj, entry.name, writer.createString(version_with_caret)); } writer.objectAdd(root_obj, target_key, deps_obj); }
const pkg_json_z = arena_alloc.dupeZ(u8, pkg_json_str) catch return .out_of_memory;
writer.writeToFile(pkg_json_z) catch { c.setError("Failed to write package.json"); return .io_error; };
return .ok;}
fn jsonValueToMut(writer: *json.JsonWriter, value: std.json.Value) !*json.yyjson.yyjson_mut_val { return switch (value) { .null => writer.createNull(), .bool => |b| writer.createBool(b), .integer => |i| writer.createInt(i), .float => |f| writer.createReal(f), .string => |s| writer.createString(s), .array => |arr| blk: { const json_arr = writer.createArray(); for (arr.items) |item| { const item_val = try jsonValueToMut(writer, item); writer.arrayAppend(json_arr, item_val); } break :blk json_arr; }, .object => |obj| blk: { const json_obj = writer.createObject(); for (obj.keys(), obj.values()) |k, v| { const v_mut = try jsonValueToMut(writer, v); writer.objectAdd(json_obj, k, v_mut); } break :blk json_obj; }, .number_string => |s| writer.createString(s), };}
export fn pkg_remove( ctx: ?*PkgContext, package_json_path: [*:0]const u8, package_name: [*:0]const u8,) PkgError { const c = ctx orelse return .invalid_argument; _ = c.arena_state.reset(.retain_capacity); const arena_alloc = c.arena_state.allocator();
const pkg_json_str = std.mem.span(package_json_path); const name_str = std.mem.span(package_name);
const content = std.fs.cwd().readFileAlloc(arena_alloc, pkg_json_str, 10 * 1024 * 1024) catch { c.setError("Failed to read package.json"); return .io_error; };
const parsed = std.json.parseFromSlice(std.json.Value, arena_alloc, content, .{}) catch { c.setError("Failed to parse package.json"); return .invalid_argument; }; defer parsed.deinit();
if (parsed.value != .object) { c.setError("Invalid package.json format"); return .invalid_argument; }
const dep_keys = [_][]const u8{ "dependencies", "devDependencies", "peerDependencies", "optionalDependencies" };
const found = found: { for (dep_keys) |dep_key| { const deps = parsed.value.object.get(dep_key) orelse continue; if (deps != .object) continue; if (deps.object.get(name_str) != null) break :found true; } break :found false; };
if (!found) { c.setErrorFmt("Package {s} not found in dependencies", .{name_str}); return .not_found; }
var writer = json.JsonWriter.init() catch return .out_of_memory; defer writer.deinit();
const root_obj = writer.createObject(); writer.setRoot(root_obj);
for (parsed.value.object.keys(), parsed.value.object.values()) |key, value| { const is_dep_obj = for (dep_keys) |dk| { if (std.mem.eql(u8, key, dk)) break true; } else false;
if (!is_dep_obj or value != .object) { const val_mut = jsonValueToMut(&writer, value) catch continue; writer.objectAdd(root_obj, key, val_mut); continue; }
const filtered_obj = writer.createObject(); for (value.object.keys(), value.object.values()) |dk, dv| { if (std.mem.eql(u8, dk, name_str)) continue; const dv_mut = jsonValueToMut(&writer, dv) catch continue; writer.objectAdd(filtered_obj, dk, dv_mut); } writer.objectAdd(root_obj, key, filtered_obj); }
const pkg_json_z = arena_alloc.dupeZ(u8, pkg_json_str) catch return .out_of_memory; writer.writeToFile(pkg_json_z) catch { c.setError("Failed to write package.json"); return .io_error; };
return .ok;}
export fn pkg_error_string(ctx: ?*const PkgContext) [*:0]const u8 { if (ctx) |c| if (c.last_error) |e| return e.ptr; return "Unknown error";}
export fn pkg_cache_sync(ctx: ?*PkgContext) void { if (ctx) |c| if (c.cache_db) |db| db.sync();}
export fn pkg_cache_stats(ctx: ?*PkgContext, out: *CacheStats) PkgError { const c = ctx orelse return .invalid_argument; const db = c.cache_db orelse return .cache_error;
const stats = db.stats() catch return .cache_error; out.* = .{ .total_size = stats.cache_size, .db_size = stats.db_size, .package_count = @intCast(stats.entries), };
return .ok;}
export fn pkg_cache_prune(ctx: ?*PkgContext, max_age_days: u32) i32 { const c = ctx orelse return @intFromEnum(PkgError.invalid_argument); const db = c.cache_db orelse return @intFromEnum(PkgError.cache_error); const pruned = db.prune(max_age_days) catch return @intFromEnum(PkgError.cache_error); return @intCast(pruned);}
export fn pkg_get_bin_path( node_modules_path: [*:0]const u8, bin_name: [*:0]const u8, out_path: [*]u8, out_path_len: usize,) c_int { const nm_path = std.mem.span(node_modules_path); const full = std.mem.span(bin_name);
const start: usize = if (full.len > 0 and full[0] == '@') (std.mem.indexOfScalar(u8, full[1..], '/') orelse return -1) + 2 else 0; const name, const constraint_str = if (std.mem.indexOfScalar(u8, full[start..], '@')) |i| .{ full[0..start + i], full[start + i + 1..] } else .{ full, @as([]const u8, "") };
var path_buf: [std.fs.max_path_bytes]u8 = undefined; const bin_path = std.fmt.bufPrint(&path_buf, "{s}/.bin/{s}", .{ nm_path, name }) catch return -1;
std.fs.cwd().access(bin_path, .{}) catch return -1;
if (constraint_str.len > 0) { const constraint = resolver.Constraint.parse(constraint_str) catch return -1; if (constraint.kind != .any) { var pkg_buf: [std.fs.max_path_bytes]u8 = undefined; const pkg_path = std.fmt.bufPrint(&pkg_buf, "{s}/{s}/package.json", .{ nm_path, name }) catch return -1; const pkg_path_z = pkg_buf[0..pkg_path.len :0]; var doc = json.JsonDoc.parseFile(pkg_path_z) catch return -1; defer doc.deinit(); const version_str = doc.root().getString("version") orelse return -1; const installed = resolver.Version.parse(version_str) catch return -1; if (!constraint.satisfies(installed)) return -1; } }
var real_path_buf: [std.fs.max_path_bytes]u8 = undefined; const real_path = std.fs.cwd().realpath(bin_path, &real_path_buf) catch return -1;
if (real_path.len >= out_path_len) return -1;
@memcpy(out_path[0..real_path.len], real_path); out_path[real_path.len] = 0;
return @intCast(real_path.len);}
export fn pkg_list_bins( node_modules_path: [*:0]const u8, callback: ?*const fn ([*:0]const u8, ?*anyopaque) callconv(.c) void, user_data: ?*anyopaque,) c_int { const nm_path = std.mem.span(node_modules_path);
var path_buf: [std.fs.max_path_bytes]u8 = undefined; const bin_dir_path = std.fmt.bufPrint(&path_buf, "{s}/.bin", .{nm_path}) catch return -1;
var dir = std.fs.cwd().openDir(bin_dir_path, .{ .iterate = true }) catch return -1; defer dir.close();
var count: c_int = 0; var iter = dir.iterate(); while (iter.next() catch null) |entry| { if (entry.kind == .sym_link or entry.kind == .file) { if (callback) |cb| { var name_buf: [256]u8 = undefined; if (entry.name.len < name_buf.len) { @memcpy(name_buf[0..entry.name.len], entry.name); name_buf[entry.name.len] = 0; cb(@ptrCast(&name_buf), user_data); } } count += 1; } }
return count;}
export fn pkg_list_package_bins( node_modules_path: [*:0]const u8, package_name: [*:0]const u8, callback: ?*const fn ([*:0]const u8, ?*anyopaque) callconv(.c) void, user_data: ?*anyopaque,) c_int { const nm_path = std.mem.span(node_modules_path); const pkg_name = std.mem.span(package_name);
var path_buf: [std.fs.max_path_bytes]u8 = undefined; const pkg_json_path = std.fmt.bufPrint(&path_buf, "{s}/{s}/package.json", .{ nm_path, pkg_name }) catch return -1;
const file = std.fs.cwd().openFile(pkg_json_path, .{}) catch return -1; defer file.close();
const content = file.readToEndAlloc(global_allocator, 1024 * 1024) catch return -1; defer global_allocator.free(content);
var doc = json.JsonDoc.parse(content) catch return -1; defer doc.deinit();
const root_val = doc.root(); var count: c_int = 0;
if (root_val.getObject("bin")) |bin_obj| { var iter = bin_obj.objectIterator() orelse return 0; while (iter.next()) |entry| { if (callback) |cb| { var name_buf: [256]u8 = undefined; if (entry.key.len < name_buf.len) { @memcpy(name_buf[0..entry.key.len], entry.key); name_buf[entry.key.len] = 0; cb(@ptrCast(&name_buf), user_data); } } count += 1; } } else if (root_val.getString("bin")) |_| { const simple_name = if (std.mem.indexOf(u8, pkg_name, "/")) |slash| pkg_name[slash + 1 ..] else pkg_name;
if (callback) |cb| { var name_buf: [256]u8 = undefined; if (simple_name.len < name_buf.len) { @memcpy(name_buf[0..simple_name.len], simple_name); name_buf[simple_name.len] = 0; cb(@ptrCast(&name_buf), user_data); } } count = 1; }
return count;}
export fn pkg_get_script( package_json_path: [*:0]const u8, script_name: [*:0]const u8, out_script: [*]u8, out_script_len: usize,) c_int { const allocator = global_allocator; const name = std.mem.span(script_name);
var doc = json.JsonDoc.parseFile(std.mem.span(package_json_path)) catch return -1; defer doc.deinit(); const root_val = doc.root();
if (root_val.getObject("scripts")) |scripts_obj| { if (scripts_obj.getString(std.mem.span(script_name))) |script| { if (script.len >= out_script_len) return -1; @memcpy(out_script[0..script.len], script); out_script[script.len] = 0; return @intCast(script.len); } }
if (std.mem.eql(u8, name, "start")) { if (root_val.getString("main")) |main_file| { const script = std.fmt.allocPrint(allocator, "ant {s}", .{main_file}) catch return -1; defer allocator.free(script); if (script.len >= out_script_len) return -1; @memcpy(out_script[0..script.len], script); out_script[script.len] = 0; return @intCast(script.len); }
if (std.fs.cwd().access("server.js", .{})) |_| { const script = "ant server.js"; if (script.len >= out_script_len) return -1; @memcpy(out_script[0..script.len], script); out_script[script.len] = 0; return @intCast(script.len); } else |_| {} }
return -1;}
pub const ScriptResult = extern struct { exit_code: c_int, signal: c_int,};
fn runScriptCommand( allocator: std.mem.Allocator, script: []const u8, extra_args: ?[*:0]const u8, env_map: *std.process.EnvMap,) !ScriptResult { const final_script = if (extra_args) |args| blk: { const args_str = std.mem.span(args); if (args_str.len > 0) { break :blk try std.fmt.allocPrint(allocator, "{s} {s}", .{ script, args_str }); } break :blk try allocator.dupe(u8, script); } else try allocator.dupe(u8, script); defer allocator.free(final_script);
const script_z = try allocator.dupeZ(u8, final_script); defer allocator.free(script_z);
const shell_argv: []const []const u8 = if (builtin.os.tag == .windows) &[_][]const u8{ "cmd", "/c", script_z } else &[_][]const u8{ "sh", "-c", script_z };
var child = std.process.Child.init(shell_argv, allocator); child.env_map = env_map;
try child.spawn(); const term = try child.wait();
return switch (term) { .Exited => |code| .{ .exit_code = code, .signal = 0 }, .Signal => |sig| .{ .exit_code = -1, .signal = @intCast(sig) }, else => .{ .exit_code = -1, .signal = 0 }, };}
export fn pkg_run_script( package_json_path: [*:0]const u8, script_name: [*:0]const u8, node_modules_path: [*:0]const u8, extra_args: ?[*:0]const u8, result: ?*ScriptResult,) PkgError { const allocator = global_allocator; const name = std.mem.span(script_name);
var doc = json.JsonDoc.parseFile(std.mem.span(package_json_path)) catch return .io_error; defer doc.deinit(); const root_val = doc.root();
var script_buf: [8192]u8 = undefined; const script_len = pkg_get_script(package_json_path, script_name, &script_buf, script_buf.len); if (script_len < 0) return .not_found; const script = script_buf[0..@intCast(script_len)];
var pre_script: ?[]const u8 = null; var post_script: ?[]const u8 = null;
if (root_val.getObject("scripts")) |scripts_obj| { var pre_key_buf: [256]u8 = undefined; var post_key_buf: [256]u8 = undefined;
const pre_key = std.fmt.bufPrintZ(&pre_key_buf, "pre{s}", .{name}) catch null; const post_key = std.fmt.bufPrintZ(&post_key_buf, "post{s}", .{name}) catch null;
if (pre_key) |pk| pre_script = scripts_obj.getString(pk); if (post_key) |pk| post_script = scripts_obj.getString(pk); }
var env_map = std.process.getEnvMap(allocator) catch return .out_of_memory; defer env_map.deinit(); const nm_path = std.mem.span(node_modules_path);
const cwd = std.fs.cwd(); const abs_nm_path = cwd.realpathAlloc(allocator, nm_path) catch nm_path; defer if (abs_nm_path.ptr != nm_path.ptr) allocator.free(abs_nm_path);
const bin_path = std.fmt.allocPrint(allocator, "{s}/.bin", .{abs_nm_path}) catch return .out_of_memory; defer allocator.free(bin_path);
const current_path = env_map.get("PATH") orelse ""; const new_path = if (builtin.os.tag == .windows) std.fmt.allocPrint(allocator, "{s};{s}", .{ bin_path, current_path }) catch return .out_of_memory else std.fmt.allocPrint(allocator, "{s}:{s}", .{ bin_path, current_path }) catch return .out_of_memory; defer allocator.free(new_path);
env_map.put("PATH", new_path) catch return .out_of_memory; env_map.put("npm_lifecycle_event", name) catch {};
if (root_val.getObject("config")) |config_obj| { if (config_obj.objectIterator()) |*config_iter_ptr| { var config_iter = config_iter_ptr.*; while (config_iter.next()) |entry| { if (entry.value.asString()) |value| { const env_key = std.fmt.allocPrint(allocator, "npm_package_config_{s}", .{entry.key}) catch continue; defer allocator.free(env_key); env_map.put(env_key, value) catch {}; } } } }
if (root_val.getString("name")) |pkg_name| env_map.put("npm_package_name", pkg_name) catch {}; if (root_val.getString("version")) |pkg_version| env_map.put("npm_package_version", pkg_version) catch {};
if (pre_script) |pre| { const pre_event = std.fmt.allocPrint(allocator, "pre{s}", .{name}) catch name; defer if (pre_event.ptr != name.ptr) allocator.free(pre_event); env_map.put("npm_lifecycle_event", pre_event) catch {}; const pre_result = runScriptCommand(allocator, pre, null, &env_map) catch return .io_error; if (pre_result.exit_code != 0) { if (result) |r| r.* = pre_result; return .ok; } }
env_map.put("npm_lifecycle_event", name) catch {}; const main_result = runScriptCommand(allocator, script, extra_args, &env_map) catch return .io_error;
if (main_result.exit_code != 0) { if (result) |r| r.* = main_result; return .ok; }
if (post_script) |post| { const post_event = std.fmt.allocPrint(allocator, "post{s}", .{name}) catch name; defer if (post_event.ptr != name.ptr) allocator.free(post_event); env_map.put("npm_lifecycle_event", post_event) catch {}; const post_result = runScriptCommand(allocator, post, null, &env_map) catch return .io_error; if (result) |r| r.* = post_result; return .ok; }
if (result) |r| r.* = main_result; return .ok;}
pub const DepType = packed struct(u8) { peer: bool = false, dev: bool = false, optional: bool = false, direct: bool = false, _reserved: u4 = 0,};
pub const DepCallback = ?*const fn ( name: [*:0]const u8, version: [*:0]const u8, constraint: [*:0]const u8, dep_type: DepType, user_data: ?*anyopaque,) callconv(.c) void;
pub const WhyInfo = extern struct { target_version: [64]u8, found: bool, is_peer: bool, is_dev: bool, is_direct: bool,};
export fn pkg_why_info( lockfile_path: [*:0]const u8, package_name: [*:0]const u8, out: *WhyInfo,) c_int { const lf = lockfile.Lockfile.open(std.mem.span(lockfile_path)) catch return -1; defer @constCast(&lf).close();
const target_name = std.mem.span(package_name); out.found = false; out.is_peer = false; out.is_dev = false; out.is_direct = false; @memset(&out.target_version, 0);
for (lf.packages) |*pkg| { const pkg_name = pkg.name.slice(lf.string_table); if (std.mem.eql(u8, pkg_name, target_name)) { const ver_str = pkg.versionString(global_allocator, lf.string_table) catch return -1; defer global_allocator.free(ver_str); if (ver_str.len < out.target_version.len) { @memcpy(out.target_version[0..ver_str.len], ver_str); out.target_version[ver_str.len] = 0; } out.found = true; out.is_dev = pkg.flags.dev; out.is_direct = pkg.flags.direct; }
const deps = lf.getPackageDeps(pkg); for (deps) |dep| { const dep_pkg = &lf.packages[dep.package_index]; const dep_name = dep_pkg.name.slice(lf.string_table); if (std.mem.eql(u8, dep_name, target_name) and dep.flags.peer) { out.is_peer = true; } } } return 0;}
export fn pkg_why( lockfile_path: [*:0]const u8, package_name: [*:0]const u8, callback: DepCallback, user_data: ?*anyopaque,) c_int { const lf = lockfile.Lockfile.open(std.mem.span(lockfile_path)) catch return -1; defer @constCast(&lf).close();
const target_name = std.mem.span(package_name); var count: c_int = 0;
var name_buf: [512]u8 = undefined; var ver_buf: [64]u8 = undefined; var constraint_buf: [128]u8 = undefined;
for (lf.packages) |*pkg| { const deps = lf.getPackageDeps(pkg); for (deps) |dep| { const dep_pkg = &lf.packages[dep.package_index]; const dep_name = dep_pkg.name.slice(lf.string_table);
if (std.mem.eql(u8, dep_name, target_name)) { const pkg_name = pkg.name.slice(lf.string_table); const constraint = dep.constraint.slice(lf.string_table);
if (callback) |cb| { if (pkg_name.len < name_buf.len) { @memcpy(name_buf[0..pkg_name.len], pkg_name); name_buf[pkg_name.len] = 0;
const ver_str = pkg.versionString(global_allocator, lf.string_table) catch continue; defer global_allocator.free(ver_str); if (ver_str.len < ver_buf.len) { @memcpy(ver_buf[0..ver_str.len], ver_str); ver_buf[ver_str.len] = 0;
if (constraint.len < constraint_buf.len) { @memcpy(constraint_buf[0..constraint.len], constraint); constraint_buf[constraint.len] = 0;
const dep_type = DepType{ .peer = dep.flags.peer, .dev = dep.flags.dev or pkg.flags.dev, .optional = dep.flags.optional, .direct = pkg.flags.direct, }; cb(@ptrCast(&name_buf), @ptrCast(&ver_buf), @ptrCast(&constraint_buf), dep_type, user_data); } } } } count += 1; } } }
for (lf.packages) |*pkg| { const pkg_name = pkg.name.slice(lf.string_table); if (std.mem.eql(u8, pkg_name, target_name) and pkg.flags.direct) { if (callback) |cb| { const direct_str = "package.json"; var direct_buf: [16]u8 = undefined; @memcpy(direct_buf[0..direct_str.len], direct_str); direct_buf[direct_str.len] = 0;
var empty_buf: [1]u8 = .{0}; var dep_buf: [16]u8 = undefined; const constraint_str = "dependencies"; @memcpy(dep_buf[0..constraint_str.len], constraint_str); dep_buf[constraint_str.len] = 0;
const dep_type = DepType{ .peer = false, .dev = pkg.flags.dev, .optional = false, .direct = true, }; cb(@ptrCast(&direct_buf), @ptrCast(&empty_buf), @ptrCast(&dep_buf), dep_type, user_data); } count += 1; } }
return count;}
export fn pkg_list_scripts( package_json_path: [*:0]const u8, callback: ?*const fn ([*:0]const u8, [*:0]const u8, ?*anyopaque) callconv(.c) void, user_data: ?*anyopaque,) c_int { var doc = json.JsonDoc.parseFile(std.mem.span(package_json_path)) catch return -1; defer doc.deinit();
const root_val = doc.root(); const scripts_obj = root_val.getObject("scripts") orelse return 0;
var iter = scripts_obj.objectIterator() orelse return 0; defer iter.deinit();
var count: c_int = 0; while (iter.next()) |entry| { if (callback) |cb| { var name_buf: [256]u8 = undefined; var cmd_buf: [4096]u8 = undefined;
if (entry.key.len < name_buf.len) { @memcpy(name_buf[0..entry.key.len], entry.key); name_buf[entry.key.len] = 0;
if (entry.value.asString()) |cmd| { if (cmd.len < cmd_buf.len) { @memcpy(cmd_buf[0..cmd.len], cmd); cmd_buf[cmd.len] = 0; cb(@ptrCast(&name_buf), @ptrCast(&cmd_buf), user_data); } } } } count += 1; }
return count;}
export fn pkg_info( ctx: ?*PkgContext, package_spec: [*:0]const u8, out: *PkgInfo,) PkgError { const c = ctx orelse return .invalid_argument; c.clearInfo(); _ = c.arena_state.reset(.retain_capacity); const arena = c.arena_state.allocator();
const http = c.http orelse return .network_error; const spec = std.mem.span(package_spec); var name: []const u8 = spec; var requested_version: ?[]const u8 = null; if (std.mem.lastIndexOf(u8, spec, "@")) |at_idx| { if (at_idx > 0) { name = spec[0..at_idx]; requested_version = spec[at_idx + 1..]; } }
const data = http.fetchMetadataFull(name, true, c.allocator) catch |err| { c.setErrorFmt("Failed to fetch package info: {}", .{err}); return .network_error; }; defer c.allocator.free(data);
var doc = json.JsonDoc.parse(data) catch { c.setError("Failed to parse package metadata"); return .resolve_error; }; defer doc.deinit(); const root = doc.root(); const versions_obj = root.getObject("versions") orelse { c.setError("No versions found"); return .not_found; };
var versions_iter = versions_obj.objectIterator() orelse return .resolve_error; defer versions_iter.deinit(); var version_count: u32 = 0; while (versions_iter.next()) |_| version_count += 1;
var version_str: []const u8 = ""; if (requested_version) |rv| { version_str = rv; } else if (root.getObject("dist-tags")) |tags| { version_str = tags.getString("latest") orelse ""; }
const version_z = arena.dupeZ(u8, version_str) catch return .out_of_memory;
const version_obj = versions_obj.getObject(version_z) orelse { c.setErrorFmt("Version {s} not found", .{version_str}); return .not_found; };
var dep_count: u32 = 0; if (version_obj.getObject("dependencies")) |deps| { var deps_iter = deps.objectIterator() orelse return .resolve_error; defer deps_iter.deinit(); while (deps_iter.next()) |entry| { dep_count += 1; if (entry.value.asString()) |ver| { c.info_dependencies.append(c.allocator, .{ .name = c.storeInfoString(entry.key) catch continue, .version = c.storeInfoString(ver) catch continue, }) catch continue; } } }
const dist = version_obj.getObject("dist"); const unpacked_size: u64 = if (dist) |d| @as(u64, @intCast(d.getInt("unpackedSize") orelse 0)) else 0;
var keywords_buf = std.ArrayListUnmanaged(u8){}; defer keywords_buf.deinit(c.allocator); if (version_obj.getArray("keywords")) |kw_arr| { var kw_iter = kw_arr.arrayIterator() orelse return .resolve_error; defer kw_iter.deinit(); var first = true; while (kw_iter.next()) |kw_val| { if (kw_val.asString()) |kw| { if (!first) keywords_buf.appendSlice(c.allocator, ", ") catch {}; keywords_buf.appendSlice(c.allocator, kw) catch {}; first = false; } } }
out.* = .{ .name = c.storeInfoString(root.getString("name") orelse name) catch return .out_of_memory, .version = c.storeInfoString(version_str) catch return .out_of_memory, .description = c.storeInfoString(version_obj.getString("description") orelse "") catch return .out_of_memory, .license = c.storeInfoString(version_obj.getString("license") orelse "") catch return .out_of_memory, .homepage = c.storeInfoString(version_obj.getString("homepage") orelse "") catch return .out_of_memory, .tarball = c.storeInfoString(if (dist) |d| d.getString("tarball") orelse "" else "") catch return .out_of_memory, .shasum = c.storeInfoString(if (dist) |d| d.getString("shasum") orelse "" else "") catch return .out_of_memory, .integrity = c.storeInfoString(if (dist) |d| d.getString("integrity") orelse "" else "") catch return .out_of_memory, .keywords = c.storeInfoString(keywords_buf.items) catch return .out_of_memory, .published = c.storeInfoString(if (root.getObject("time")) |t| t.getString(version_z) orelse "" else "") catch return .out_of_memory, .dep_count = dep_count, .version_count = version_count, .unpacked_size = unpacked_size, };
if (root.getObject("dist-tags")) |tags| { var tags_iter = tags.objectIterator() orelse return .ok; defer tags_iter.deinit(); while (tags_iter.next()) |entry| { if (entry.value.asString()) |ver| { c.info_dist_tags.append(c.allocator, .{ .tag = c.storeInfoString(entry.key) catch continue, .version = c.storeInfoString(ver) catch continue, }) catch continue; } } }
if (root.getArray("maintainers")) |maint_arr| { var maint_iter = maint_arr.arrayIterator() orelse return .ok; defer maint_iter.deinit(); while (maint_iter.next()) |maint_val| { const maint_name = maint_val.getString("name") orelse continue; const maint_email = maint_val.getString("email") orelse ""; c.info_maintainers.append(c.allocator, .{ .name = c.storeInfoString(maint_name) catch continue, .email = c.storeInfoString(maint_email) catch continue, }) catch continue; } }
return .ok;}
export fn pkg_info_dist_tag_count(ctx: ?*const PkgContext) u32 { const c = ctx orelse return 0; return @intCast(c.info_dist_tags.items.len);}
export fn pkg_info_get_dist_tag(ctx: ?*const PkgContext, index: u32, out: *DistTag) PkgError { const c = ctx orelse return .invalid_argument; if (index >= c.info_dist_tags.items.len) return .invalid_argument; out.* = c.info_dist_tags.items[index]; return .ok;}
export fn pkg_info_maintainer_count(ctx: ?*const PkgContext) u32 { const c = ctx orelse return 0; return @intCast(c.info_maintainers.items.len);}
export fn pkg_info_get_maintainer(ctx: ?*const PkgContext, index: u32, out: *Maintainer) PkgError { const c = ctx orelse return .invalid_argument; if (index >= c.info_maintainers.items.len) return .invalid_argument; out.* = c.info_maintainers.items[index]; return .ok;}
export fn pkg_info_dependency_count(ctx: ?*const PkgContext) u32 { const c = ctx orelse return 0; return @intCast(c.info_dependencies.items.len);}
export fn pkg_info_get_dependency(ctx: ?*const PkgContext, index: u32, out: *Dependency) PkgError { const c = ctx orelse return .invalid_argument; if (index >= c.info_dependencies.items.len) return .invalid_argument; out.* = c.info_dependencies.items[index]; return .ok;}
const BinSelection = struct { err: PkgError, name: []const u8 = "",};
fn packageSimpleName(pkg_name: []const u8) []const u8 { if (std.mem.lastIndexOfScalar(u8, pkg_name, '/')) |slash| { return pkg_name[slash + 1 ..]; } return pkg_name;}
fn normalizedBinTarget(path: []const u8) []const u8 { if (std.mem.startsWith(u8, path, "./")) return path[2..]; return path;}
fn appendBinName(list: *std.ArrayList(u8), allocator: std.mem.Allocator, name: []const u8) !void { if (list.items.len > 0) try list.appendSlice(allocator, ", "); try list.appendSlice(allocator, name);}
fn selectPackageBinName( c: *PkgContext, allocator: std.mem.Allocator, node_modules_path: []const u8, pkg_name: []const u8,) BinSelection { const simple_name = packageSimpleName(pkg_name);
const pkg_json_path = std.fmt.allocPrint(allocator, "{s}/{s}/package.json", .{ node_modules_path, pkg_name, }) catch return .{ .err = .out_of_memory };
const file = std.fs.cwd().openFile(pkg_json_path, .{}) catch { c.setErrorFmt("Package '{s}' was installed, but its package.json could not be opened", .{pkg_name}); return .{ .err = .io_error }; }; defer file.close();
const content = file.readToEndAlloc(allocator, 1024 * 1024) catch { c.setErrorFmt("Package '{s}' was installed, but its package.json could not be read", .{pkg_name}); return .{ .err = .io_error }; };
var doc = json.JsonDoc.parse(content) catch { c.setErrorFmt("Package '{s}' was installed, but its package.json could not be parsed", .{pkg_name}); return .{ .err = .io_error }; }; defer doc.deinit();
const root_val = doc.root();
if (root_val.getString("bin")) |_| { const selected = allocator.dupe(u8, simple_name) catch return .{ .err = .out_of_memory }; return .{ .err = .ok, .name = selected }; }
const bin_obj = root_val.getObject("bin") orelse { c.setErrorFmt("Package '{s}' does not declare any binaries", .{pkg_name}); return .{ .err = .not_found }; };
var iter = bin_obj.objectIterator() orelse { c.setErrorFmt("Package '{s}' does not declare any usable binaries", .{pkg_name}); return .{ .err = .not_found }; };
var valid_count: usize = 0; var first_name: []const u8 = ""; var first_target: []const u8 = ""; var package_named_bin: ?[]const u8 = null; var all_targets_same = true; var names: std.ArrayList(u8) = .empty;
while (iter.next()) |entry| { const target = entry.value.asString() orelse continue;
if (valid_count == 0) { first_name = entry.key; first_target = normalizedBinTarget(target); } else if (!std.mem.eql(u8, normalizedBinTarget(target), first_target)) { all_targets_same = false; }
appendBinName(&names, allocator, entry.key) catch return .{ .err = .out_of_memory }; valid_count += 1;
if (std.mem.eql(u8, entry.key, simple_name)) { package_named_bin = entry.key; } }
const selected = package_named_bin orelse if (valid_count == 1 or all_targets_same) first_name else ""; if (selected.len > 0) { const selected_copy = allocator.dupe(u8, selected) catch return .{ .err = .out_of_memory }; return .{ .err = .ok, .name = selected_copy }; }
if (valid_count == 0) { c.setErrorFmt("Package '{s}' does not declare any usable binaries", .{pkg_name}); } else { c.setErrorFmt("Package '{s}' exposes multiple binaries ({s}) and no default could be inferred", .{ pkg_name, names.items, }); }
return .{ .err = .not_found };}
export fn pkg_exec_temp( ctx: ?*PkgContext, package_spec: [*:0]const u8, out_bin_path: [*]u8, out_bin_path_len: usize,) PkgError { const c = ctx orelse return .invalid_argument; _ = c.arena_state.reset(.retain_capacity); const arena_alloc = c.arena_state.allocator();
const spec_str = std.mem.span(package_spec); var pkg_name: []const u8 = spec_str; var bin_name: []const u8 = spec_str; var version_constraint: []const u8 = "latest";
if (std.mem.indexOf(u8, spec_str, "@")) |at_idx| { if (at_idx == 0) { if (std.mem.indexOfPos(u8, spec_str, 1, "@")) |second_at| { pkg_name = spec_str[0..second_at]; version_constraint = spec_str[second_at + 1 ..]; } } else { pkg_name = spec_str[0..at_idx]; version_constraint = spec_str[at_idx + 1 ..]; } }
if (std.mem.lastIndexOfScalar(u8, pkg_name, '/')) |slash| { bin_name = pkg_name[slash + 1 ..]; } else { bin_name = pkg_name; }
const exec_base = std.fmt.allocPrint(arena_alloc, "{s}/exec", .{c.cache_dir}) catch return .out_of_memory; const temp_nm_path = std.fmt.allocPrint(arena_alloc, "{s}/{s}", .{exec_base, pkg_name}) catch return .out_of_memory; const temp_pkg_json = std.fmt.allocPrint(arena_alloc, "{s}/package.json", .{temp_nm_path}) catch return .out_of_memory; const temp_nm_dir = std.fmt.allocPrint(arena_alloc, "{s}/node_modules", .{temp_nm_path}) catch return .out_of_memory; const temp_lockfile = std.fmt.allocPrint(arena_alloc, "{s}/ant.lockb", .{temp_nm_path}) catch return .out_of_memory;
if (std.fs.cwd().openDir(exec_base, .{ .iterate = true })) |dir| { var d = dir; defer d.close(); const stat = d.statFile(pkg_name) catch null; if (stat) |s| { const now: i128 = std.time.nanoTimestamp(); const mtime: i128 = s.mtime; const age_ns = now - mtime; const hours_24_ns: i128 = 24 * 60 * 60 * 1_000_000_000; if (age_ns > hours_24_ns) { debug.log("exec: cleaning stale cache for {s} (age: {d}h)", .{ pkg_name, @divFloor(age_ns, 60 * 60 * 1_000_000_000), }); d.deleteTree(pkg_name) catch {}; } } } else |_| {}
std.fs.cwd().makePath(temp_nm_path) catch {};
const pkg_json_content = std.fmt.allocPrint(arena_alloc, \\{{"dependencies":{{"{s}":"{s}"}}}} , .{pkg_name, version_constraint}) catch return .out_of_memory;
const pkg_json_file = std.fs.cwd().createFile(temp_pkg_json, .{}) catch { c.setError("Failed to create temp package.json"); return .io_error; }; pkg_json_file.writeAll(pkg_json_content) catch { pkg_json_file.close(); c.setError("Failed to write temp package.json"); return .io_error; }; pkg_json_file.close();
const http = c.http orelse return .network_error; const db = c.cache_db orelse return .cache_error;
var interleaved = InterleavedContext.init(c.allocator, arena_alloc, db, http, c); defer interleaved.deinit();
var res = resolver.Resolver.init( arena_alloc, c.allocator, &c.string_pool, http, db, if (c.options.registry_url) |url| std.mem.span(url) else "https://registry.npmjs.org", &c.metadata_cache, ); defer res.deinit();
res.setOnPackageResolved(InterleavedContext.onPackageResolved, &interleaved); res.resolveFromPackageJson(temp_pkg_json) catch |err| { setResolveError(c, pkg_name, err); return .resolve_error; };
debug.log("exec: resolved {d} packages, queued {d} tarballs", .{ interleaved.callbacks_received, interleaved.tarballs_queued, });
http.run() catch {};
var pkg_linker = linker.Linker.init(c.allocator); defer pkg_linker.deinit();
pkg_linker.setNodeModulesPath(temp_nm_dir) catch |err| { c.setErrorFmt("Failed to set up exec directory: {}", .{err}); return .io_error; };
for (interleaved.extract_contexts.items) |ectx| { defer ectx.ext.deinit(); if (ectx.has_error) continue;
const stats = ectx.ext.stats(); db.insert(&.{ .integrity = ectx.integrity, .path = ectx.cache_path, .unpacked_size = stats.bytes, .file_count = stats.files, .cached_at = std.time.timestamp(), }, ectx.pkg_name, ectx.version_str) catch continue;
pkg_linker.linkPackage(.{ .cache_path = ectx.cache_path, .node_modules_path = temp_nm_dir, .name = ectx.pkg_name, .parent_path = ectx.parent_path, .file_count = stats.files, .has_bin = ectx.has_bin, }) catch continue; }
var resolved_iter = res.resolved.valueIterator(); while (resolved_iter.next()) |pkg_ptr| { const pkg = pkg_ptr.*; if (db.lookup(&pkg.integrity)) |cache_entry| { var entry = cache_entry; defer entry.deinit(); const pkg_cache_path = arena_alloc.dupe(u8, entry.path) catch continue; pkg_linker.linkPackage(.{ .cache_path = pkg_cache_path, .node_modules_path = temp_nm_dir, .name = pkg.name.slice(), .parent_path = pkg.parent_path, .file_count = entry.file_count, .has_bin = pkg.has_bin, }) catch continue; } }
res.writeLockfile(temp_lockfile) catch {};
var trusted = std.StringHashMap(void).init(arena_alloc); var resolved_iter2 = res.resolved.valueIterator(); while (resolved_iter2.next()) |pkg_ptr| { trusted.put(pkg_ptr.*.name.slice(), {}) catch continue; } runTrustedPostinstall(c, &trusted, temp_nm_dir, arena_alloc);
const selected_bin = selectPackageBinName(c, arena_alloc, temp_nm_dir, pkg_name); if (selected_bin.err != .ok) return selected_bin.err; bin_name = selected_bin.name;
var bin_path_buf: [std.fs.max_path_bytes]u8 = undefined; const bin_link_path = std.fmt.bufPrint(&bin_path_buf, "{s}/.bin/{s}", .{ temp_nm_dir, bin_name }) catch return .io_error;
debug.log("exec: looking for bin at {s}", .{bin_link_path});
std.fs.cwd().access(bin_link_path, .{}) catch { c.setErrorFmt("Binary '{s}' not found in package", .{bin_name}); return .not_found; };
var real_path_buf: [std.fs.max_path_bytes]u8 = undefined; const real_path = std.fs.cwd().realpath(bin_link_path, &real_path_buf) catch return .io_error;
if (real_path.len >= out_bin_path_len) return .io_error;
@memcpy(out_bin_path[0..real_path.len], real_path); out_bin_path[real_path.len] = 0;
return .ok;}
fn getGlobalDir(allocator: std.mem.Allocator) ![]const u8 { if (builtin.os.tag != .windows) { if (try getLegacyAntDirIfExists(allocator)) |dir| { defer allocator.free(dir); return std.fmt.allocPrint(allocator, "{s}/pkg/global", .{dir}); } if (getAbsoluteEnv("XDG_DATA_HOME")) |base| { return std.fmt.allocPrint(allocator, "{s}/ant/pkg/global", .{base}); } const home = try getHomeDir(allocator); defer allocator.free(home); return std.fmt.allocPrint(allocator, "{s}/.local/share/ant/pkg/global", .{home}); }
const home = try getHomeDir(allocator); defer allocator.free(home); return std.fmt.allocPrint(allocator, "{s}/.ant/pkg/global", .{home});}
fn getGlobalBinDir(allocator: std.mem.Allocator) ![]const u8 { const home = try getHomeDir(allocator); defer allocator.free(home); if (builtin.os.tag != .windows) { if (try getLegacyAntDirIfExists(allocator)) |dir| { defer allocator.free(dir); return std.fmt.allocPrint(allocator, "{s}/bin", .{dir}); } return std.fmt.allocPrint(allocator, "{s}/.local/bin", .{home}); } return std.fmt.allocPrint(allocator, "{s}/.ant/bin", .{home});}
fn ensureGlobalPackageJson(allocator: std.mem.Allocator, global_dir: []const u8) !void { const pkg_json_path = try std.fmt.allocPrint(allocator, "{s}/package.json", .{global_dir}); defer allocator.free(pkg_json_path); std.fs.cwd().access(pkg_json_path, .{}) catch { std.fs.cwd().makePath(global_dir) catch {}; const file = try std.fs.cwd().createFile(pkg_json_path, .{}); defer file.close(); try file.writeAll("{\"dependencies\":{}}\n"); };}
fn linkGlobalBins(allocator: std.mem.Allocator, nm_path: []const u8, pkg_name: []const u8) void { const bin_dir = getGlobalBinDir(allocator) catch return; defer allocator.free(bin_dir); std.fs.cwd().makePath(bin_dir) catch return; const pkg_bin_dir = std.fmt.allocPrint(allocator, "{s}/{s}", .{nm_path, pkg_name}) catch return; defer allocator.free(pkg_bin_dir); const pkg_json_path = std.fmt.allocPrint(allocator, "{s}/package.json", .{pkg_bin_dir}) catch return; defer allocator.free(pkg_json_path); const content = std.fs.cwd().readFileAlloc(allocator, pkg_json_path, 1024 * 1024) catch return; defer allocator.free(content); const parsed = std.json.parseFromSlice(std.json.Value, allocator, content, .{}) catch return; defer parsed.deinit(); const bin_val = parsed.value.object.get("bin") orelse return; switch (bin_val) { .string => |s| { const base_name = if (std.mem.lastIndexOfScalar(u8, pkg_name, '/')) |idx| pkg_name[idx + 1..] else pkg_name; linkSingleBin(allocator, bin_dir, nm_path, pkg_name, base_name, s); }, .object => |obj| { for (obj.keys(), obj.values()) |bin_name, path_val| { if (path_val == .string) linkSingleBin(allocator, bin_dir, nm_path, pkg_name, bin_name, path_val.string); } }, else => {}, }}
fn linkSingleBin(allocator: std.mem.Allocator, bin_dir: []const u8, nm_path: []const u8, pkg_name: []const u8, bin_name: []const u8, bin_rel_path: []const u8) void { const target = std.fmt.allocPrint(allocator, "{s}/{s}/{s}", .{nm_path, pkg_name, bin_rel_path}) catch return; defer allocator.free(target); const link_path = std.fmt.allocPrint(allocator, "{s}/{s}", .{bin_dir, bin_name}) catch return; defer allocator.free(link_path); std.fs.cwd().deleteFile(link_path) catch {}; linker.createSymlinkAbsolute(target, link_path); debug.log("linked global bin: {s} -> {s}", .{link_path, target});}
fn unlinkGlobalBins(allocator: std.mem.Allocator, pkg_name: []const u8) void { const bin_dir = getGlobalBinDir(allocator) catch return; defer allocator.free(bin_dir); var dir = std.fs.cwd().openDir(bin_dir, .{ .iterate = true }) catch return; defer dir.close(); var iter = dir.iterate(); while (iter.next() catch null) |entry| { if (entry.kind != .sym_link) continue; var target_buf: [std.fs.max_path_bytes]u8 = undefined; const target = dir.readLink(entry.name, &target_buf) catch continue;
const pattern = std.fmt.allocPrint(allocator, "/{s}/", .{pkg_name}) catch continue; defer allocator.free(pattern); const pattern_end = std.fmt.allocPrint(allocator, "/{s}", .{pkg_name}) catch continue; defer allocator.free(pattern_end);
if (std.mem.indexOf(u8, target, pattern) != null or std.mem.endsWith(u8, target, pattern_end)) { dir.deleteFile(entry.name) catch continue; debug.log("unlinked global bin: {s}", .{entry.name}); } }}
export fn pkg_add_global( ctx: ?*PkgContext, package_spec: [*:0]const u8,) PkgError { const specs = [_][*:0]const u8{package_spec}; return pkg_add_global_many(ctx, &specs, 1);}
export fn pkg_add_global_many( ctx: ?*PkgContext, package_specs: [*]const [*:0]const u8, count: u32,) PkgError { const c = ctx orelse return .invalid_argument; const allocator = c.allocator;
const global_dir = getGlobalDir(allocator) catch { c.setError("HOME not set"); return .invalid_argument; }; defer allocator.free(global_dir); ensureGlobalPackageJson(allocator, global_dir) catch { c.setError("Failed to create global package.json"); return .io_error; }; const pkg_json_path = std.fmt.allocPrintSentinel(allocator, "{s}/package.json", .{global_dir}, 0) catch return .out_of_memory; defer allocator.free(pkg_json_path); const lockfile_path = std.fmt.allocPrintSentinel(allocator, "{s}/ant.lockb", .{global_dir}, 0) catch return .out_of_memory; defer allocator.free(lockfile_path); const nm_path = std.fmt.allocPrintSentinel(allocator, "{s}/node_modules", .{global_dir}, 0) catch return .out_of_memory; defer allocator.free(nm_path); const add_result = pkg_add_many(c, pkg_json_path.ptr, package_specs, count, false); if (add_result != .ok) return add_result; const install_result = pkg_resolve_and_install(c, pkg_json_path.ptr, lockfile_path.ptr, nm_path.ptr); if (install_result != .ok) return install_result; for (0..count) |i| { const spec_str = std.mem.span(package_specs[i]); var pkg_name: []const u8 = spec_str; if (std.mem.indexOf(u8, spec_str, "@")) |at_idx| { if (at_idx == 0) { if (std.mem.indexOfPos(u8, spec_str, 1, "@")) |second_at| pkg_name = spec_str[0..second_at]; } else pkg_name = spec_str[0..at_idx]; } linkGlobalBins(allocator, nm_path, pkg_name); } return .ok;}
export fn pkg_remove_global( ctx: ?*PkgContext, package_name: [*:0]const u8,) PkgError { const c = ctx orelse return .invalid_argument; const allocator = c.allocator;
const global_dir = getGlobalDir(allocator) catch { c.setError("HOME not set"); return .invalid_argument; }; defer allocator.free(global_dir); const pkg_json_path = std.fmt.allocPrintSentinel(allocator, "{s}/package.json", .{global_dir}, 0) catch return .out_of_memory; defer allocator.free(pkg_json_path); const lockfile_path = std.fmt.allocPrintSentinel(allocator, "{s}/ant.lockb", .{global_dir}, 0) catch return .out_of_memory; defer allocator.free(lockfile_path); const nm_path = std.fmt.allocPrintSentinel(allocator, "{s}/node_modules", .{global_dir}, 0) catch return .out_of_memory; defer allocator.free(nm_path); const name_str = std.mem.span(package_name); unlinkGlobalBins(allocator, name_str); const remove_result = pkg_remove(c, pkg_json_path.ptr, package_name); if (remove_result != .ok and remove_result != .not_found) return remove_result; if (remove_result == .not_found) return .not_found; const install_result = pkg_resolve_and_install(c, pkg_json_path.ptr, lockfile_path.ptr, nm_path.ptr); if (install_result != .ok) return install_result; return .ok;}
export fn pkg_count_local(ctx: ?*PkgContext) u32 { var pd = cli.get_dependencies(ctx, null, true) orelse return 0; defer pd.deinit(); return pd.count();}
export fn pkg_count_global(ctx: ?*PkgContext) u32 { const global_dir = getGlobalDir(global_allocator) catch return 0; var pd = cli.get_dependencies(ctx, global_dir, false) orelse return 0; defer pd.deinit(); return pd.count();}
export fn pkg_list_local( ctx: ?*PkgContext, callback: ?*const fn (name: [*:0]const u8, version: [*:0]const u8, user_data: ?*anyopaque) callconv(.c) void, user_data: ?*anyopaque,) PkgError { var pd = cli.get_dependencies(ctx, null, true) orelse return .ok; defer pd.deinit(); if (callback) |cb| cli.list_dependencies(&pd, cb, user_data); return .ok;}
export fn pkg_list_global( ctx: ?*PkgContext, callback: ?*const fn (name: [*:0]const u8, version: [*:0]const u8, user_data: ?*anyopaque) callconv(.c) void, user_data: ?*anyopaque,) PkgError { const global_dir = getGlobalDir(global_allocator) catch return .invalid_argument; var pd = cli.get_dependencies(ctx, global_dir, false) orelse return .ok; defer pd.deinit(); if (callback) |cb| cli.list_dependencies(&pd, cb, user_data); return .ok;}