🔒 Repository is read-only – file editing is disabled.
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235323632373238323932403241324232433244324532463247324832493250325132523253325432553256325732583259326032613262326332643265326632673268326932703271327232733274327532763277327832793280328132823283328432853286328732883289329032913292329332943295329632973298329933003301330233033304330533063307330833093310331133123313331433153316331733183319332033213322332333243325332633273328332933303331333233333334333533363337333833393340334133423343334433453346334733483349335033513352335333543355335633573358335933603361336233633364336533663367336833693370337133723373337433753376337733783379338033813382338333843385338633873388338933903391339233933394339533963397339833993400340134023403340434053406340734083409341034113412341334143415341634173418341934203421342234233424342534263427342834293430343134323433343434353436343734383439344034413442344334443445344634473448344934503451345234533454345534563457345834593460346134623463346434653466346734683469347034713472347334743475347634773478347934803481348234833484348534863487348834893490349134923493349434953496349734983499350035013502350335043505350635073508350935103511351235133514351535163517351835193520352135223523352435253526352735283529353035313532353335343535353635373538353935403541354235433544354535463547354835493550355135523553355435553556355735583559356035613562356335643565356635673568356935703571357235733574357535763577357835793580358135823583358435853586358735883589359035913592359335943595359635973598359936003601360236033604360536063607360836093610361136123613361436153616361736183619362036213622362336243625362636273628362936303631363236333634363536363637363836393640364136423643364436453646364736483649365036513652365336543655365636573658365936603661366236633664366536663667366836693670367136723673367436753676367736783679368036813682368336843685368636873688368936903691369236933694369536963697369836993700370137023703370437053706370737083709371037113712371337143715371637173718371937203721372237233724372537263727372837293730373137323733373437353736373737383739374037413742374337443745374637473748374937503751375237533754375537563757375837593760376137623763376437653766376737683769377037713772377337743775377637773778377937803781378237833784378537863787378837893790379137923793379437953796379737983799380038013802380338043805380638073808380938103811381238133814381538163817381838193820382138223823382438253826382738283829383038313832383338343835383638373838383938403841384238433844384538463847384838493850385138523853385438553856385738583859386038613862386338643865386638673868386938703871387238733874387538763877387838793880388138823883388438853886388738883889389038913892389338943895389638973898389939003901390239033904390539063907390839093910391139123913391439153916391739183919392039213922392339243925392639273928392939303931393239333934393539363937393839393940394139423943394439453946394739483949395039513952395339543955395639573958395939603961396239633964396539663967396839693970397139723973397439753976397739783979398039813982398339843985398639873988398939903991399239933994399539963997399839994000400140024003400440054006400740084009401040114012401340144015401640174018401940204021402240234024402540264027402840294030403140324033403440354036403740384039404040414042404340444045404640474048404940504051405240534054405540564057405840594060406140624063406440654066406740684069407040714072407340744075407640774078407940804081408240834084408540864087408840894090409140924093409440954096409740984099410041014102410341044105410641074108410941104111411241134114411541164117411841194120412141224123412441254126412741284129413041314132413341344135413641374138413941404141414241434144414541464147414841494150415141524153415441554156415741584159416041614162416341644165416641674168416941704171417241734174417541764177417841794180418141824183418441854186418741884189419041914192419341944195419641974198419942004201420242034204420542064207420842094210421142124213421442154216421742184219422042214222422342244225422642274228422942304231423242334234423542364237423842394240424142424243424442454246424742484249425042514252425342544255425642574258425942604261426242634264426542664267426842694270427142724273427442754276427742784279428042814282428342844285428642874288428942904291429242934294429542964297429842994300430143024303430443054306430743084309431043114312431343144315431643174318431943204321432243234324432543264327432843294330433143324333433443354336433743384339434043414342434343444345434643474348434943504351435243534354435543564357435843594360436143624363436443654366436743684369437043714372437343744375437643774378437943804381438243834384438543864387438843894390439143924393439443954396439743984399440044014402440344044405440644074408440944104411441244134414441544164417441844194420442144224423442444254426442744284429443044314432443344344435443644374438443944404441444244434444444544464447444844494450445144524453445444554456445744584459446044614462446344644465446644674468446944704471447244734474447544764477447844794480448144824483448444854486448744884489449044914492449344944495449644974498449945004501450245034504450545064507450845094510451145124513451445154516451745184519452045214522452345244525452645274528452945304531453245334534453545364537453845394540454145424543454445454546454745484549455045514552455345544555455645574558455945604561456245634564456545664567456845694570457145724573457445754576457745784579458045814582458345844585458645874588458945904591459245934594459545964597459845994600460146024603460446054606460746084609461046114612461346144615461646174618461946204621462246234624462546264627462846294630463146324633463446354636463746384639464046414642464346444645464646474648464946504651465246534654465546564657465846594660466146624663466446654666466746684669467046714672467346744675467646774678467946804681468246834684468546864687468846894690469146924693469446954696469746984699470047014702470347044705470647074708470947104711471247134714471547164717471847194720472147224723472447254726472747284729473047314732473347344735473647374738473947404741474247434744474547464747474847494750475147524753475447554756475747584759476047614762476347644765476647674768476947704771477247734774477547764777477847794780478147824783478447854786478747884789479047914792479347944795479647974798479948004801480248034804480548064807480848094810481148124813481448154816481748184819482048214822482348244825482648274828482948304831483248334834483548364837483848394840484148424843484448454846484748484849485048514852485348544855485648574858485948604861486248634864486548664867486848694870487148724873487448754876487748784879488048814882488348844885488648874888488948904891489248934894489548964897489848994900490149024903490449054906490749084909491049114912491349144915491649174918491949204921492249234924492549264927492849294930493149324933493449354936493749384939494049414942494349444945494649474948494949504951495249534954495549564957495849594960496149624963496449654966496749684969497049714972497349744975497649774978497949804981498249834984498549864987498849894990499149924993499449954996499749984999500050015002500350045005500650075008500950105011501250135014501550165017501850195020502150225023502450255026502750285029503050315032503350345035503650375038503950405041504250435044504550465047504850495050505150525053505450555056505750585059506050615062506350645065506650675068506950705071507250735074507550765077507850795080508150825083508450855086508750885089509050915092509350945095509650975098509951005101510251035104510551065107510851095110511151125113511451155116511751185119512051215122512351245125512651275128512951305131513251335134513551365137513851395140514151425143514451455146514751485149515051515152515351545155515651575158515951605161516251635164516551665167516851695170517151725173517451755176517751785179518051815182518351845185518651875188518951905191519251935194519551965197519851995200520152025203520452055206520752085209521052115212521352145215521652175218521952205221522252235224522552265227522852295230523152325233523452355236523752385239524052415242524352445245524652475248524952505251525252535254525552565257525852595260526152625263526452655266526752685269527052715272527352745275527652775278527952805281528252835284528552865287528852895290529152925293529452955296529752985299530053015302530353045305530653075308530953105311531253135314531553165317531853195320532153225323532453255326532753285329533053315332533353345335533653375338533953405341534253435344534553465347534853495350535153525353535453555356535753585359536053615362536353645365536653675368536953705371537253735374537553765377537853795380538153825383538453855386538753885389539053915392539353945395539653975398539954005401540254035404540554065407540854095410541154125413541454155416541754185419542054215422542354245425542654275428542954305431543254335434543554365437543854395440544154425443544454455446544754485449545054515452545354545455545654575458545954605461546254635464546554665467546854695470547154725473547454755476547754785479548054815482548354845485548654875488548954905491549254935494549554965497549854995500550155025503550455055506550755085509551055115512551355145515551655175518551955205521552255235524552555265527552855295530553155325533553455355536553755385539554055415542554355445545554655475548554955505551555255535554555555565557555855595560556155625563556455655566556755685569557055715572557355745575557655775578557955805581558255835584558555865587558855895590559155925593559455955596559755985599560056015602560356045605560656075608560956105611561256135614561556165617561856195620562156225623562456255626562756285629563056315632563356345635563656375638563956405641564256435644564556465647564856495650565156525653565456555656565756585659566056615662566356645665566656675668566956705671567256735674567556765677567856795680568156825683568456855686568756885689569056915692569356945695569656975698569957005701570257035704570557065707570857095710571157125713571457155716571757185719572057215722572357245725572657275728572957305731573257335734573557365737573857395740574157425743574457455746574757485749575057515752575357545755575657575758575957605761576257635764576557665767576857695770577157725773577457755776577757785779578057815782578357845785578657875788578957905791579257935794579557965797579857995800580158025803580458055806580758085809581058115812581358145815581658175818581958205821582258235824582558265827582858295830583158325833583458355836583758385839584058415842584358445845584658475848584958505851585258535854585558565857585858595860586158625863586458655866586758685869587058715872587358745875587658775878587958805881588258835884588558865887588858895890589158925893589458955896589758985899590059015902590359045905590659075908590959105911591259135914591559165917591859195920592159225923592459255926592759285929593059315932593359345935593659375938593959405941594259435944594559465947594859495950595159525953595459555956595759585959596059615962596359645965596659675968596959705971597259735974597559765977597859795980598159825983598459855986598759885989599059915992599359945995599659975998599960006001600260036004600560066007600860096010601160126013601460156016601760186019602060216022602360246025602660276028602960306031603260336034603560366037603860396040604160426043604460456046604760486049605060516052605360546055605660576058605960606061606260636064606560666067606860696070607160726073607460756076607760786079608060816082608360846085608660876088608960906091609260936094609560966097609860996100610161026103610461056106610761086109611061116112611361146115611661176118611961206121612261236124612561266127612861296130613161326133613461356136613761386139614061416142614361446145614661476148614961506151615261536154615561566157615861596160616161626163616461656166616761686169617061716172617361746175617661776178617961806181618261836184618561866187618861896190619161926193619461956196619761986199620062016202620362046205620662076208620962106211621262136214621562166217621862196220622162226223622462256226622762286229623062316232623362346235623662376238623962406241624262436244624562466247624862496250625162526253625462556256625762586259626062616262626362646265626662676268626962706271627262736274627562766277627862796280628162826283628462856286628762886289629062916292629362946295629662976298629963006301630263036304630563066307630863096310631163126313631463156316631763186319632063216322632363246325632663276328632963306331633263336334633563366337633863396340634163426343634463456346634763486349635063516352635363546355635663576358635963606361636263636364636563666367636863696370637163726373637463756376637763786379638063816382638363846385638663876388638963906391639263936394639563966397639863996400640164026403640464056406640764086409641064116412641364146415641664176418641964206421642264236424642564266427642864296430643164326433643464356436643764386439644064416442644364446445644664476448644964506451645264536454645564566457645864596460646164626463646464656466646764686469647064716472647364746475647664776478647964806481648264836484648564866487648864896490649164926493649464956496649764986499650065016502650365046505650665076508650965106511651265136514651565166517651865196520652165226523652465256526652765286529653065316532653365346535653665376538653965406541654265436544654565466547654865496550655165526553655465556556655765586559656065616562656365646565656665676568656965706571657265736574657565766577657865796580658165826583658465856586658765886589659065916592659365946595659665976598659966006601660266036604660566066607660866096610661166126613661466156616661766186619662066216622662366246625662666276628662966306631663266336634663566366637663866396640664166426643664466456646664766486649665066516652665366546655665666576658665966606661666266636664666566666667666866696670667166726673667466756676667766786679668066816682668366846685668666876688668966906691669266936694669566966697669866996700670167026703670467056706670767086709671067116712671367146715671667176718671967206721672267236724672567266727672867296730673167326733673467356736673767386739674067416742674367446745674667476748674967506751675267536754675567566757675867596760676167626763676467656766676767686769677067716772677367746775677667776778677967806781678267836784678567866787678867896790679167926793679467956796679767986799680068016802680368046805680668076808680968106811681268136814681568166817681868196820682168226823682468256826682768286829683068316832683368346835683668376838683968406841684268436844684568466847684868496850685168526853685468556856685768586859686068616862686368646865686668676868686968706871687268736874687568766877687868796880688168826883688468856886688768886889689068916892689368946895689668976898689969006901690269036904690569066907690869096910691169126913691469156916691769186919692069216922692369246925692669276928692969306931693269336934693569366937693869396940694169426943694469456946694769486949695069516952695369546955695669576958695969606961696269636964696569666967696869696970697169726973697469756976697769786979698069816982698369846985698669876988698969906991699269936994699569966997699869997000700170027003700470057006700770087009701070117012701370147015701670177018701970207021702270237024702570267027702870297030703170327033703470357036703770387039704070417042704370447045704670477048704970507051705270537054705570567057705870597060706170627063706470657066706770687069707070717072707370747075707670777078707970807081708270837084708570867087708870897090709170927093709470957096709770987099710071017102710371047105710671077108710971107111711271137114711571167117711871197120712171227123712471257126712771287129713071317132713371347135713671377138713971407141714271437144714571467147714871497150715171527153715471557156715771587159716071617162716371647165716671677168716971707171717271737174717571767177717871797180718171827183718471857186718771887189719071917192719371947195719671977198719972007201720272037204720572067207720872097210721172127213721472157216721772187219722072217222722372247225722672277228722972307231723272337234723572367237723872397240724172427243724472457246724772487249725072517252725372547255725672577258725972607261726272637264726572667267726872697270727172727273727472757276727772787279728072817282728372847285728672877288728972907291729272937294729572967297729872997300730173027303730473057306730773087309731073117312731373147315731673177318731973207321732273237324732573267327732873297330733173327333733473357336733773387339734073417342734373447345734673477348734973507351735273537354735573567357735873597360736173627363736473657366736773687369737073717372737373747375737673777378737973807381738273837384738573867387738873897390739173927393739473957396739773987399740074017402740374047405740674077408740974107411741274137414741574167417741874197420742174227423742474257426742774287429743074317432743374347435743674377438743974407441744274437444744574467447744874497450745174527453745474557456745774587459746074617462746374647465746674677468746974707471747274737474747574767477747874797480748174827483748474857486748774887489749074917492749374947495749674977498749975007501750275037504750575067507750875097510751175127513751475157516751775187519752075217522752375247525752675277528752975307531753275337534753575367537753875397540754175427543754475457546754775487549755075517552755375547555755675577558755975607561756275637564756575667567756875697570757175727573757475757576757775787579758075817582758375847585758675877588758975907591759275937594759575967597759875997600760176027603760476057606760776087609761076117612761376147615761676177618761976207621762276237624762576267627762876297630763176327633763476357636763776387639764076417642764376447645764676477648764976507651765276537654765576567657765876597660766176627663766476657666766776687669767076717672767376747675767676777678767976807681768276837684768576867687768876897690769176927693769476957696769776987699770077017702770377047705770677077708770977107711771277137714771577167717771877197720772177227723772477257726772777287729773077317732773377347735773677377738773977407741774277437744774577467747774877497750775177527753775477557756775777587759776077617762776377647765776677677768776977707771777277737774777577767777777877797780778177827783778477857786778777887789779077917792779377947795779677977798779978007801780278037804780578067807780878097810781178127813781478157816781778187819782078217822782378247825782678277828782978307831783278337834783578367837783878397840784178427843784478457846784778487849785078517852785378547855785678577858785978607861786278637864786578667867786878697870787178727873787478757876787778787879788078817882788378847885788678877888788978907891789278937894789578967897789878997900790179027903790479057906790779087909791079117912791379147915791679177918791979207921792279237924792579267927792879297930793179327933793479357936793779387939794079417942794379447945794679477948794979507951795279537954795579567957795879597960796179627963796479657966796779687969797079717972797379747975797679777978797979807981798279837984798579867987798879897990799179927993799479957996799779987999800080018002800380048005800680078008800980108011801280138014801580168017801880198020802180228023802480258026802780288029803080318032803380348035803680378038803980408041804280438044804580468047804880498050805180528053805480558056805780588059806080618062806380648065806680678068806980708071807280738074807580768077807880798080808180828083808480858086808780888089809080918092809380948095809680978098809981008101810281038104810581068107810881098110811181128113811481158116811781188119812081218122812381248125812681278128812981308131813281338134813581368137813881398140814181428143814481458146814781488149815081518152815381548155815681578158815981608161816281638164816581668167816881698170817181728173817481758176817781788179818081818182818381848185818681878188818981908191819281938194819581968197819881998200820182028203820482058206820782088209821082118212821382148215821682178218821982208221822282238224822582268227822882298230823182328233823482358236823782388239824082418242824382448245824682478248824982508251825282538254825582568257825882598260826182628263826482658266826782688269827082718272827382748275827682778278827982808281828282838284828582868287828882898290829182928293829482958296829782988299830083018302830383048305830683078308830983108311831283138314831583168317831883198320832183228323832483258326832783288329833083318332833383348335833683378338833983408341834283438344834583468347834883498350835183528353835483558356835783588359836083618362836383648365836683678368836983708371837283738374837583768377837883798380838183828383838483858386838783888389839083918392839383948395839683978398839984008401840284038404840584068407840884098410841184128413841484158416841784188419842084218422842384248425842684278428842984308431843284338434843584368437843884398440844184428443844484458446844784488449845084518452845384548455845684578458845984608461846284638464846584668467846884698470847184728473847484758476847784788479848084818482848384848485848684878488848984908491849284938494849584968497849884998500850185028503850485058506850785088509851085118512851385148515851685178518851985208521852285238524852585268527852885298530853185328533853485358536853785388539854085418542854385448545854685478548854985508551855285538554855585568557855885598560856185628563856485658566856785688569857085718572857385748575857685778578857985808581858285838584858585868587858885898590859185928593859485958596859785988599860086018602860386048605860686078608860986108611861286138614861586168617861886198620862186228623862486258626862786288629863086318632863386348635863686378638863986408641864286438644864586468647864886498650865186528653865486558656865786588659866086618662866386648665866686678668866986708671867286738674867586768677867886798680868186828683868486858686868786888689869086918692869386948695869686978698869987008701
#!/usr/bin/env python3
"""
╔══════════════════════════════════════════════════════════════════════════════╗
║ PAG - Pagan Linux Package Manager v4.2.2 ║
║ Produkcyjny menedżer pakietów – atomowy, bezpieczny, i18n ║
╚══════════════════════════════════════════════════════════════════════════════╝
KLUCZOWE CECHY:
- Transakcja grupowa: staging CAŁEJ grupy → commit (błąd paczki nie psuje systemu)
- Snapshoty btrfs przed transakcją + wpisy GRUB (rollback przy starcie)
- Atomowa instalacja przez staging (tmpdir → rename) – brak pół-instalacji
- Bezpieczne usuwanie – sprawdza czy plik nie jest współdzielony
- SQLite dla bazy plików – miliony plików bez problemu
- GPG: weryfikacja repo.json + podpisy pakietów + pinning fingerprintu
- Hooki: pre/post-install, pre/post-remove (piaskownica env, timeout, audit)
- Głęboka weryfikacja SHA256 per-plik
- Pełny rollback – cofa fizyczne pliki
- Blokada flock – tylko jedna instancja
- Transakcje z migawkami + rejestr wykonanych hooków
- Cache HTTP (ETag/If-Modified-Since)
- Wielojęzyczność (i18n) – PL, EN
FORMAT PAKIETU (.pag):
├── data.tar.xz – pliki + sums.json (SHA256 per plik)
├── metadata.json – nazwa, wersja, zależności
└── hooks/ – pre-install, post-install, pre-remove, post-remove
MODEL ZAUFANIA / BEZPIECZEŃSTWO:
- Repozytorium MUSI być zaufane: podpisy GPG zweryfikowane; fingerprint
klucza przypiętego do repo (TOFU przy pierwszym użyciu, potem pinning).
- Hooki uruchamiają dowolny plik z pakietu jako ROOT (jak apt/pacman).
Ograniczamy je (czyste env, timeout, PAG_NO_HOOKS=1, log do
/var/log/pag/audit.log) i rejestrujemy w transakcji, ale ostatecznie
instalujesz kod, któremu ufasz.
- self-update: weryfikacja podpisu + SHA256 + składnia, atomowa podmiana.
"""
import os, sys, json, copy, shutil, hashlib, tarfile, tempfile, subprocess, time, fcntl, locale, re, difflib
def _early(en, pl):
return pl if os.environ.get("LANG", "")[:2] == "pl" else en
# Twarde moduły Pythona. Zamiast tracebacku dajemy jasny komunikat, bo brak
# tych modułów oznacza zwykle niezadeklarowaną zależność pakietu (sqlite/xz).
try:
import sqlite3
except ImportError:
sys.stderr.write(_early("pag: Python without sqlite3 module – install the sqlite "
"package (libsqlite3) and rebuild python.\n",
"pag: Python bez modułu sqlite3 – zainstaluj pakiet sqlite "
"(libsqlite3) i przebuduj python.\n"))
sys.exit(1)
try:
import lzma # noqa: F401 – potrzebny do paczek .pag (XZ)
except ImportError:
sys.stderr.write(_early("pag: Python without lzma module – install the xz "
"package (liblzma) and rebuild python.\n",
"pag: Python bez modułu lzma – zainstaluj pakiet xz "
"(liblzma) i przebuduj python.\n"))
sys.exit(1)
# Fix TLS trust inside the Pagan chroot: point Python at the CA bundle that
# pag ships, otherwise urlopen() fails with "unable to get local issuer
# certificate" (no default capath/cafile is resolved in the chroot).
for _cafile in (
"/etc/ssl/certs/ca-certificates.crt",
"/etc/ssl/cert.pem",
):
if os.path.isfile(_cafile):
os.environ["SSL_CERT_FILE"] = _cafile
break
from pathlib import Path
from datetime import datetime, timezone
from typing import Dict, List, Optional, Tuple, Set
from concurrent.futures import ThreadPoolExecutor, as_completed
from urllib.request import urlopen, Request
import threading, itertools
import uuid # serialNumber SBOM (CycloneDX)
# Wersja klienta – do porównania z repo.json["pag_version"] (self-update)
PAG_VERSION = "4.3.0"
from urllib.error import URLError, HTTPError
# =============================================================================
# Pagan progress — animowany pasek „Drakkar” (własny motyw Pagan/Loki)
# -----------------------------------------------------------------------------
# Zamiast statycznego „█” pasek jest animowany: łódź wikingów płynie po
# falującym morzu, a za nią ciągnie się smuga z wędrującym refleksem. Animacja
# jest funkcją czasu, więc „płynie” nawet gdy postęp stoi w miejscu (długa
# instalacja jednego pakietu, przerwa między fragmentami pobierania).
#
# Konfiguracja (zmienne środowiskowe):
# PAG_NO_ANIM=1 – wyłącz animację (zostaje klasyczny statyczny pasek)
# PAG_BAR_STYLE=<styl> – drakkar (domyślnie) | snake | classic
# Poza TTY animacja jest automatycznie wyłączona (czyste logi w plikach).
# =============================================================================
_PAGAN_ANIM = os.environ.get("PAG_NO_ANIM", "") not in ("1", "true", "yes", "on")
_PAGAN_STYLE = os.environ.get("PAG_BAR_STYLE", "drakkar").strip().lower()
_DRAW_LOCK = threading.Lock() # serializacja zapisów wielu pasków
# Dwie fazy fali – przesuwane w czasie dają wrażenie ruchu morza.
_WAVE_PHASES = ("~_", "_~")
# Zapas kolumn przy rysowaniu paska: ostatnia kolumna terminala wywołuje
# „auto-wrap”, a glify szerokie (np. emoji 📦) liczą się jako 1 w `len()`, ale
# zajmują 2 kolumny – margines chroni przed zawinięciem linii.
_BAR_MARGIN = 2
def _term_width(stream=None, default: int = 80) -> int:
"""Szerokość terminala (w kolumnach) dla strumienia paska.
Pasek MUSI zmieścić się w jednej linii: gdy jest szerszy niż terminal, ten
sam go zawija i KAŻDA aktualizacja trafia do nowej linii zamiast nadpisywać
poprzednią. Pytamy o rozmiar konkretnego `stream` (pasek pisze na stderr),
a nie domyślnego stdout – inaczej przy przekierowanym stdout dostalibyśmy
fałszywe 80 kolumn.
"""
fd = None
if stream is not None:
try:
fd = stream.fileno()
except Exception:
fd = None
if fd is not None:
try:
cols = os.get_terminal_size(fd).columns
if cols > 0:
return cols
except OSError:
pass
try:
cols = shutil.get_terminal_size((default, 24)).columns
except Exception:
cols = default
return cols if cols > 0 else default
def _classic_bar(pct: float, width: int) -> str:
"""Klasyczny statyczny pasek █/░ (fallback dla logów i PAG_NO_ANIM)."""
filled = int(round(width * max(0.0, min(100.0, pct)) / 100.0))
return "█" * filled + "░" * (width - filled)
def _fmt_size(n: float) -> str:
"""Rozmiar w czytelnych jednostkach (1.2 MB, 345.6 KB)."""
for unit in ("B", "KB", "MB", "GB"):
if n < 1024:
return f"{n:.1f} {unit}"
n /= 1024
return f"{n:.1f} TB"
def _fmt_eta(seconds: float) -> str:
"""Czas pozostały w zwięzłej formie: 8s, 1.4m, 2.1h."""
if seconds < 60:
return f"{seconds:.0f}s"
if seconds < 3600:
return f"{seconds / 60:.1f}m"
return f"{seconds / 3600:.1f}h"
def _shrink_text(text: str, room: int) -> str:
"""Skróć `text` do `room` kolumn (wielokropek na końcu)."""
if room <= 0:
return ""
if len(text) <= room:
return text
return "…" if room == 1 else text[:room - 1] + "…"
def _fit_widget_line(line: str, stream) -> str:
"""Przytnij linię panelu do szerokości terminala (bez zawijania).
Zawinięta linia rozjeżdża wielolinijkowy panel: kolejne odświeżenia
trafiają do nowych wierszy zamiast nadpisywać poprzednie.
"""
cap = _term_width(stream) - _BAR_MARGIN
if cap <= 0 or len(line) <= cap:
return line
keep = cap - 1
head = (keep + 1) // 2
tail = keep - head
return line[:head] + "…" + (line[-tail:] if tail > 0 else "")
def _drakkar_bar(pct: float, width: int, t: float, filled: int) -> str:
"""Drakkar (łódź wikingów) płynący po falującym morzu.
- przed łodzią: falujące morze (~ _ przesuwane w czasie),
- dziób łodzi: » (kolumna = bieżący postęp),
- za łodzią: smuga z wędrującym refleksem światła.
"""
done = pct >= 100.0
wave = _WAVE_PHASES[int(t * 6) % len(_WAVE_PHASES)]
ship = min(filled, width - 1)
glow = int(t * 10) % ship if ship > 0 else -1
out = []
for i in range(width):
if done:
out.append("»" if i == width - 1 else "█") # łódź zacumowana
elif i < ship:
out.append("█" if i == glow else "▓")
elif i == ship:
out.append("»")
else:
out.append(wave[i & 1])
return "".join(out)
def _snake_bar(pct: float, width: int, t: float, filled: int) -> str:
"""Jörmungandr – wąż sunący przez pasek (głowa @, łuski o/~, ogon ·)."""
done = pct >= 100.0
head = min(filled, width - 1)
out = []
for i in range(width):
if done:
out.append("@" if i == width - 1 else "o")
elif i < head:
out.append("o" if (i + int(t * 6)) & 1 else "~")
elif i == head:
out.append("@")
else:
out.append("·")
return "".join(out)
def _pagan_bar(pct: float, width: int = 30, t: float = 0.0,
style: Optional[str] = None, animated: bool = True) -> str:
"""Zwraca jednoliniowy pasek postępu o STAŁEJ szerokości `width`.
`pct` – postęp 0..100
`t` – czas (s); różne `t` → inna klatka animacji
`animated` – False wymusza klasyczny statyczny pasek (np. brak TTY)
"""
width = max(6, int(width))
pct = max(0.0, min(100.0, float(pct)))
style = style or _PAGAN_STYLE
if not animated or not _PAGAN_ANIM or style == "classic":
return _classic_bar(pct, width)
filled = int(round(width * pct / 100.0))
if style == "snake":
return _snake_bar(pct, width, t, filled)
return _drakkar_bar(pct, width, t, filled)
class _Bar:
"""Baza animowanych pasków: rysują JEDNĄ nadpisywaną linię na `stream`.
Gdy mamy TTY, wątek w tle odświeża pasek ~10×/s, dzięki czemu morze faluje
także wtedy, gdy postęp chwilowo się nie zmienia.
"""
def __init__(self, width: int, stream=None):
self.width = width
self.stream = stream if stream is not None else sys.stderr
self.tty = self.stream.isatty()
self._lock = threading.RLock()
self._last_len = 0
self._stop = threading.Event()
self._thread = None
# -- wątek animacji -------------------------------------------------------
def _start_anim(self):
if _PAGAN_ANIM and self.tty and self._thread is None:
self._thread = threading.Thread(target=self._anim_loop, daemon=True)
self._thread.start()
def _anim_loop(self):
while not self._stop.wait(0.1):
with self._lock:
if self._stop.is_set():
break
self._write(self._line())
def _stop_anim(self):
self._stop.set()
if self._thread is not None:
self._thread.join(timeout=0.3)
self._thread = None
# -- rysowanie ------------------------------------------------------------
def _cap(self) -> int:
"""Maksymalna liczba kolumn jednej linii paska (z zapasem na wrap)."""
return _term_width(self.stream) - _BAR_MARGIN
def _shrink(self, text: str, fixed: int) -> str:
"""Skróć `text` tak, by `text` + `fixed` kolumn zmieściło się w linii."""
room = self._cap() - fixed
if room >= 1 and len(text) > room:
return "…" if room == 1 else text[:room - 1] + "…"
return text
def _fit(self, line: str) -> str:
"""Ostatnia linia obrony: przytnij linię do szerokości terminala.
Wycinamy ŚRODEK (wielokropek), więc widoczne zostają początek (nazwa)
i koniec (%, prędkość, ETA). Bez tego zawinięta linia = nowa linia przy
każdym odświeżeniu zamiast nadpisywania poprzedniej.
"""
cap = self._cap()
if cap <= 0 or len(line) <= cap:
return line
keep = cap - 1 # miejsce na wielokropek „…”
head = (keep + 1) // 2
tail = keep - head
return line[:head] + "…" + (line[-tail:] if tail > 0 else "")
def _write(self, line: str):
line = self._fit(line)
clear = " " * max(0, self._last_len - len(line))
with _DRAW_LOCK:
self.stream.write(f"\r{line}{clear}")
self.stream.flush()
self._last_len = len(line)
def _line(self) -> str:
raise NotImplementedError
def _clear_line(self):
if self.tty and self._last_len:
with _DRAW_LOCK:
self.stream.write("\r" + " " * self._last_len + "\r")
self.stream.flush()
self._last_len = 0
def _newline(self):
if self.tty and self._last_len:
self.stream.write("\n")
self.stream.flush()
self._last_len = 0
class ProgressBar(_Bar):
"""Pasek postępu dla N elementów — animowany („drakkar”) na TTY."""
def __init__(self, total: int, desc: str = "", unit: str = "", width: int = 30):
super().__init__(width)
self.total = max(total, 1)
self.desc = desc
self.unit = unit
self.n = 0
self.suffix = ""
self.start = time.time()
self._start_anim()
def _line(self) -> str:
pct = self.n / self.total * 100
elapsed = time.time() - self.start
speed = self.n / elapsed if elapsed > 0 else 0
if self.n >= self.total:
eta_str = _("done")
elif speed > 0:
eta_str = _fmt_eta((self.total - self.n) / speed)
else:
eta_str = "?..."
bar = _pagan_bar(pct, self.width, time.time(), animated=self.tty)
tail = f" [{bar}] {self.n}/{self.total} ({pct:.0f}%) ETA {eta_str}{self.suffix}"
desc = self._shrink(self.desc, 2 + len(tail))
return f" {desc}{tail}"
def update(self, n: Optional[int] = None, suffix: str = ""):
with self._lock:
if n is not None:
self.n = n
else:
self.n += 1
self.suffix = suffix
if self.tty:
self._write(self._line())
elif (self.n == 1 or self.n >= self.total
or self.n % max(1, self.total // 10) == 0):
# Bez TTY – tylko kamienie milowe (czysty log)
print(self._line(), file=self.stream)
def close(self):
self._stop_anim()
with self._lock:
self._newline()
def __enter__(self):
return self
def __exit__(self, *args):
self.close()
class DownloadBar(_Bar):
"""Animowany pasek pobierania (na podstawie Content-Length)."""
def __init__(self, filename: str, total_bytes: int):
super().__init__(25)
self.filename = filename
self.total = total_bytes
self.downloaded = 0
self.start = time.time()
self._start_anim()
def _line(self) -> str:
pct = self.downloaded / self.total * 100 if self.total > 0 else 0.0
elapsed = time.time() - self.start
speed = self.downloaded / elapsed if elapsed > 0 else 0
if self.total > 0 and speed > 0:
eta_str = _fmt_eta((self.total - self.downloaded) / speed)
else:
eta_str = "?..."
bar = _pagan_bar(pct, self.width, time.time(), animated=self.tty)
sz = _fmt_size(self.total)
spd = _fmt_size(int(speed))
tail = f" [{bar}] {pct:.0f}% {sz} {spd}/s ETA {eta_str}"
# Nazwa pliku bywa długa (np. linux-firmware-…-1.pag) i wtedy CAŁA linia
# nie mieści się w terminalu (zawijanie → nowa linia przy każdym %).
# Skracamy WYŁĄCZNIE nazwę – pełny pasek, prędkość i ETA zostają.
name = self._shrink(self.filename, 4 + len(tail)) # prefiks „ ↓ ” = 4 kolumny
return f" ↓ {name}{tail}"
def update(self, chunk_size: int):
with self._lock:
self.downloaded += chunk_size
if self.tty and self.total > 0:
self._write(self._line())
def close(self):
self._stop_anim()
with self._lock:
if self.total > 0:
self._newline()
class _ParallelDownloadDisplay:
"""Panel pobierania równoległego: pasek zbiorczy + linia na każde pobranie.
Linia pobrania pokazuje procent, a w nawiasie nazwę pakietu, liczbę
pobranych bajtów i ETA – czyli dokładnie to, czego brakowało przy
równoległym pobieraniu:
⏬ [████»~~~~] 4/12 (33%)
↓ [███»~~~~~~] 38% (mesa: 12.3/29.1 MB, ETA 8s)
↓ [█████»~~~~] 67% (glibc: 8.8/10.0 MB, ETA 3s)
Na TTY panel jest rysowany „w miejscu” (ANSI): pasek zbiorczy i aktywne
pobrania są nadpisywane, a ukończone pobrania zostają wypisane na stałe
nad panelem. Poza TTY nie ruszamy kursora – log dostaje linię startu,
kamienie milowe (25/50/75%) i wynik, więc pozostaje czytelny.
"""
BAR_W = 20
_POLL = 0.1
def __init__(self, total: int, stream=None):
self.stream = stream if stream is not None else sys.stderr
self.tty = self.stream.isatty()
self.total = max(1, int(total))
self.completed = 0
self._lock = threading.RLock()
self._slots: Dict[int, dict] = {}
self._next_id = 0
self._drawn = 0
self._stop = threading.Event()
self._thread = None
self._cursor_hidden = False
if self.tty:
self._emit("\x1b[?25l") # ukryj kursor na czas panelu
self._cursor_hidden = True
self._thread = threading.Thread(target=self._anim_loop, daemon=True)
self._thread.start()
# -- rysowanie -----------------------------------------------------------
def _emit(self, text: str):
with _DRAW_LOCK:
self.stream.write(text)
self.stream.flush()
def _cap(self) -> int:
return _term_width(self.stream) - _BAR_MARGIN
def _clear_panel(self):
"""Wyczyść panel i ustaw kursor na początku jego pierwszej linii."""
if not self.tty or self._drawn <= 0:
return
out = ["\r\x1b[2K"]
out.extend("\x1b[1A\r\x1b[2K" for _ in range(self._drawn - 1))
self._emit("".join(out))
self._drawn = 0
def _render_locked(self):
if not self.tty:
return
self._clear_panel()
lines = [self._overall_line()]
lines.extend(self._slot_line(s) for s in self._slots.values())
self._emit("\n".join(lines))
self._drawn = len(lines)
def _render(self):
with self._lock:
self._render_locked()
def _anim_loop(self):
while not self._stop.wait(self._POLL):
self._render()
def _overall_line(self) -> str:
pct = self.completed / self.total * 100.0
bar = _pagan_bar(pct, self.BAR_W, time.time(), animated=self.tty)
line = f" ⏬ [{bar}] {self.completed}/{self.total} ({pct:.0f}%)"
return _fit_widget_line(line, self.stream)
def _slot_line(self, s: dict) -> str:
total = int(s.get("total") or 0)
done = int(s.get("downloaded") or 0)
pct = (done / total * 100.0) if total > 0 else 0.0
elapsed = time.time() - s["start"]
speed = done / elapsed if elapsed > 0 else 0.0
finished = total > 0 and done >= total
if finished:
eta = _("done")
elif total > 0 and speed > 0:
eta = _fmt_eta((total - done) / speed)
else:
eta = "?…"
bar = _pagan_bar(pct, self.BAR_W, time.time(), animated=self.tty)
prefix = f" ↓ [{bar}] {pct:3.0f}% "
size = (f"{_fmt_size(done)}/{_fmt_size(total)}" if total > 0
else _fmt_size(done))
suffix = (f": {size}, {eta})" if finished
else f": {size}, ETA {eta})")
# Nazwa bywa długa – skracamy TYLKO ją, zostawiając %, rozmiar i ETA.
room = self._cap() - len(prefix) - 1 - len(suffix)
name = _shrink_text(s["name"], room)
return _fit_widget_line(f"{prefix}({name}{suffix}", self.stream)
# -- API wątków pobierających --------------------------------------------
def start(self, name: str, expected_size: int = 0) -> int:
with self._lock:
sid = self._next_id
self._next_id += 1
self._slots[sid] = {
"name": name,
"downloaded": 0,
"total": int(expected_size or 0),
"start": time.time(),
"milestone": -1,
}
if self.tty:
self._render_locked()
else:
self._emit(f" ↓ {name}\n")
return sid
def progress(self, sid: int, downloaded: int, total: int = 0):
with self._lock:
s = self._slots.get(sid)
if s is None:
return
s["downloaded"] = int(downloaded)
if total and total > 0:
s["total"] = int(total)
if self.tty:
return # odświeży wątek animacji
total = s["total"]
pct = downloaded / total * 100.0 if total > 0 else 0.0
step = int(pct // 25) * 25
if step > s["milestone"]:
s["milestone"] = step
if total > 0:
detail = f"{_fmt_size(downloaded)}/{_fmt_size(total)}"
else:
detail = _fmt_size(downloaded)
self._emit(f" ↓ {s['name']}: {pct:.0f}% ({detail})\n")
def finish(self, sid: int, ok: bool = True):
with self._lock:
s = self._slots.pop(sid, None)
if s is None:
return
self.completed += 1
line = self._done_line(s, ok)
if self.tty:
self._clear_panel()
self._emit(line + "\n")
self._render_locked()
else:
self._emit(line + "\n")
def log(self, text: str):
"""Wypisz komunikat (np. ponowienie pobierania) bez psucia panelu."""
with self._lock:
if self.tty:
self._clear_panel()
self._emit(text + "\n")
self._render_locked()
else:
self._emit(text + "\n")
def _done_line(self, s: dict, ok: bool) -> str:
if not ok:
return f" ❌ {s['name']}: {_('download_fail')}"
total = int(s.get("total") or 0)
size = _fmt_size(total if total > 0 else s.get("downloaded", 0))
elapsed = _fmt_eta(time.time() - s["start"])
return _fit_widget_line(f" ✅ {s['name']} ({size}, {elapsed})",
self.stream)
def close(self):
self._stop.set()
if self._thread is not None:
self._thread.join(timeout=0.3)
self._thread = None
with self._lock:
if self.tty:
self._clear_panel()
if self._cursor_hidden:
self._emit("\x1b[?25h") # przywróć kursor
self._cursor_hidden = False
class _StepBar(_Bar):
"""Animowany pasek dla pętli „krok po kroku” (instalacja/aktualizacja).
Pasek nie skacze skokowo co pakiet – między krokami łagodnie „dopełza”
w stronę kolejnego progu (jak w instalatorach), więc rośnie w sposób
ciągły. Wątek animacji odświeża go ~10×/s.
"""
def __init__(self, total: int, icon: str = "", width: int = 25,
creep_tau: float = 3.0):
super().__init__(width)
self.total = max(total, 1)
self.icon = icon
self.creep_tau = creep_tau # „stała czasu” dopełzania (s)
self.idx = 0
self.label = ""
self.t0 = time.time()
self._step_t = time.time() # start bieżącego pakietu
self._start_anim()
def _frac(self) -> float:
"""Ukończona część [0..1]: kroki + wygładzone dopełzanie w bieżącym."""
done = max(0, self.idx - 1)
if done >= self.total:
return 1.0
# 0.5 ** (dt/tau): 0 → ~1 asymptotycznie; cap 0.9, by krok był widoczny
creep = 1.0 - 0.5 ** ((time.time() - self._step_t) / self.creep_tau)
return (done + min(creep, 0.9)) / self.total
def _line(self) -> str:
pct = self._frac() * 100.0
eta_s = ""
if self.idx > 1:
avg = (time.time() - self.t0) / (self.idx - 1)
rem = avg * (self.total - self.idx + 1)
eta_s = f" ~{rem:.0f}s" if rem < 60 else f" ~{rem/60:.1f}m"
bar = _pagan_bar(pct, self.width, time.time(), animated=self.tty)
tail = f"[{bar}] {self.idx}/{self.total} ({pct:.0f}%) "
label = self._shrink(self.label, 2 + len(self.icon) + len(tail) + len(eta_s))
return f" {self.icon}{tail}{label}{eta_s}"
def step(self, idx: int, label: str):
with self._lock:
self.idx = idx
self.label = label
self._step_t = time.time()
if self.tty:
self._write(self._line())
else:
print(self._line(), file=self.stream)
def end(self):
self._stop_anim()
with self._lock:
self._clear_line()
# =============================================================================
# GPG – BEZPIECZNE WYWOŁYWANIE (odporne na brak binarki gpg)
# =============================================================================
GPG_BINARY = shutil.which("gpg2") or shutil.which("gpg") or "gpg"
GPG_HOME = "/etc/pag/gpg" # izolowany keyring (działa z keyboxd GPG 2.4+)
def _ssl_ok() -> bool:
"""Czy Python ma działający moduł ssl (HTTPS w urllib).
Bez niego urllib nie zna schematu https i każda operacja sieciowa kończy
się „unknown url type: https” – myląco, bo wygląda jak błąd adresu.
"""
try:
import ssl # noqa: F401
return True
except Exception:
return False
def _gpg_run(*args, timeout: int = 30, **kwargs) -> subprocess.CompletedProcess:
"""
Bezpieczne wywołanie GPG – przechwytuje FileNotFoundError,
gdyby gpg/gpg2 nie było zainstalowane w minimalnym środowisku.
Wymusza LC_ALL=C aby komunikaty GPG były zawsze po angielsku
(niezależnie od locale systemu) – kluczowe dla parsowania stderr.
"""
env = kwargs.pop("env", None) or os.environ.copy()
env["LC_ALL"] = "C"
env["GNUPGHOME"] = GPG_HOME
_text = bool(kwargs.get("text") or kwargs.get("universal_newlines"))
try:
return subprocess.run([GPG_BINARY, *args], timeout=timeout, env=env, **kwargs)
except FileNotFoundError:
# GPG nie jest dostępne – zwróć błąd z komunikatem
# (szanuj text=True – inaczej caller dostaje bytes i może wybuchnąć TypeError)
_text = bool(kwargs.get("text") or kwargs.get("universal_newlines"))
_msg = _("gpg_binary_not_found", GPG_BINARY)
return subprocess.CompletedProcess(
[GPG_BINARY, *args], 127,
stdout=("" if _text else b""),
stderr=(_msg if _text else _msg.encode()),
)
except subprocess.TimeoutExpired:
_msg = _("gpg_timeout")
return subprocess.CompletedProcess(
[GPG_BINARY, *args], 124,
stdout=("" if _text else b""),
stderr=(_msg if _text else _msg.encode())
)
def _load_trust_db() -> dict:
"""Mapa repo_url → fingerprint klucza podpisującego (baza zaufania)."""
try:
with open(TRUST_DB) as f:
return json.load(f)
except (FileNotFoundError, json.JSONDecodeError):
return {}
def _save_trust_db(db: dict):
os.makedirs(os.path.dirname(TRUST_DB), exist_ok=True)
with open(TRUST_DB, "w") as f:
json.dump(db, f, indent=2)
def _gpg_verify_fp(sig_path: str, data_path: str, timeout: int = 30):
"""Weryfikuje podpis i odczytuje fingerprint podpisującego.
Używa --status-fd=1 i linii VALIDSIG <fingerprint>. Zwraca (ok, fingerprint).
FAIL-CLOSED: OK tylko gdy GPG zwrócił 0 ORAZ w statusie maszynowym jest
linia VALIDSIG. Nie zakładamy sukcesu na podstawie samego kodu wyjścia –
gdyby format --status-fd się zmienił, wolimy odrzucić podpis niż przyjąć
niezaufany pakiet (wywołujący traktuje fp=None jako brak potwierdzenia).
"""
env = os.environ.copy()
res = _gpg_run("--verify", "--status-fd", "1", sig_path, data_path,
capture_output=True, text=True, timeout=timeout, env=env)
out = res.stdout or ""
m = re.search(r"\[GNUPG:\]\s+VALIDSIG\s+([0-9A-Fa-f]{16,})", out)
if not m:
m = re.search(r"\bVALIDSIG\s+([0-9A-Fa-f]{16,})", out)
if res.returncode != 0 or not m:
return False, None
return True, m.group(1).upper()
def _verify_local_pkg_signature(pkg_path: str) -> bool:
"""Weryfikuje lokalny .pag tym samym kluczem co zaufane repo."""
# PAG_INSECURE=1 – spójnie z _verify_repo_sig() i _verify_pkg_signature().
# Potrzebne w środowisku BUILDA: instalator buduje własne .pag (np. `kernel`)
# lokalnie, nie ma dla nich pliku .asc, a klucza prywatnego repo celowo NIE ma
# na maszynie budującej. Wcześniej ta funkcja jako jedyna ignorowała
# PAG_INSECURE, więc obejście używane przez resztę builda tu nie działało.
if os.environ.get("PAG_INSECURE", "") == "1":
print(_(' ⚠ PAG_INSECURE=1 – skipping local package signature verification'))
return True
sig_path = next((pkg_path + ext for ext in (".asc", ".sig")
if os.path.isfile(pkg_path + ext)), "")
if not sig_path:
print(_(' ❌ No signature for package: {arg1}', arg1=(pkg_path)))
print(_(' A .pag.asc/.pag.sig file from the same source is required.'))
return False
ok, fingerprint = _gpg_verify_fp(sig_path, pkg_path)
if not ok or not fingerprint:
print(_(' ❌ Invalid package signature: {arg1}', arg1=(pkg_path)))
return False
expected = _repo_pinned_fp(DEFAULT_REPOS[0])
if not expected:
print(_(' ❌ No pinned repo key for the local package.'))
print(_(' Run first: sudo pag sync'))
return False
if fingerprint != expected.upper():
print(_(' ❌ [SECURITY ERROR] Package was signed with a different repo key.'))
print(_(' Expected: {arg1}', arg1=(expected)))
print(_(' Received: {arg1}', arg1=(fingerprint)))
return False
print(_(' 🔐 Package signature OK ({arg1})', arg1=(fingerprint)))
return True
# =============================================================================
# i18n – WIELOJĘZYCZNOŚĆ
# =============================================================================
LANG = os.environ.get("LANG", "en_US.UTF-8")[:2] # pl, en, de...
COLOR = os.environ.get("NO_COLOR", "") == "" and sys.stdout.isatty()
def _c(code: str, text: str) -> str:
"""Dodaje kody ANSI jeśli kolor jest włączony."""
if not COLOR:
return text
colors = {
"green": "\033[32m", "red": "\033[31m", "yellow": "\033[33m",
"cyan": "\033[36m", "bold": "\033[1m", "dim": "\033[2m",
"reset": "\033[0m",
}
return f"{colors.get(code,'')}{text}{colors['reset']}"
T = {
"en": {
"root_required": "pag requires root privileges (sudo).",
"db_locked": "Another pag instance is running.",
"db_lock_hint": "If no other pag process is running, wait a moment and retry.",
"no_index": "Cannot fetch repository indexes. Run 'pag update'.",
"cache_ro": "Repo cache is read-only ({cache}) – using local index (may be outdated).\n Refresh as root: sudo pag sync",
"all_installed": "All packages are already installed.",
"to_install": "To install: {} packages ({:.2f} MB)",
"new": "NEW",
"continue_q": "Continue? [Y/n] ",
"no_tty": "No TTY / stdin closed (EOF) – cancelling.",
"cancelled": "Cancelled.",
"not_found": "not found in repos",
"pkg_not_found": "Package not found: {} (not in any repo)",
"not_found_hint": "Check the spelling or run 'pag search <query>'.",
"downloading": "Downloading",
"done": "done",
"wroom_terminal": "PAG WROOM needs an interactive terminal – run: pag wroom",
"wroom_too_small": "Enlarge the terminal (min. {arg1}x{arg2})",
"wroom_tagline": "PAGAN RACING 4.2.2 · 38911 BYTES FREE",
"wroom_controls": "←/→ lane ↑/↓ gas/brake P pause Q quit",
"wroom_press": "PRESS SPACE TO RACE",
"wroom_over": "RACE OVER",
"wroom_score": "Score: {arg1}",
"wroom_best": "Best: {arg1}",
"wroom_restart": "R / SPACE – race again Q – quit",
"wroom_paused": "PAUSED",
"wroom_hud": "SCORE {arg1:06d} SPEED {arg2:3d} km/h LIVES {arg3}",
"download_fail": "download failed",
"gpg_fail": "GPG verification failed",
"sha256_mismatch": "SHA256 mismatch",
"install_failed": "installation failed",
"installed": "Installed {} packages.",
"rollback_restored": "Restored previous state from snapshot.",
"rollback_files": "Rolled back {} files.",
"no_history": "No transaction history.",
"pinned_list": "Pinned packages ({}):",
"no_pinned": "No pinned packages.",
"pinned_to": "pinned to",
"unpinned": "unpinned.",
"not_pinned": "was not pinned.",
"repo_added": "Added repository: {}",
"repo_exists": "Repository already exists: {}",
"updated_done": "Index refresh complete. {} packages cached.",
"indexes_refreshed": "Indexes refreshed.",
"updates_available": "⚠ {} packages have updates – run: pag update",
"upgrading": "Upgrading: {} packages",
"all_up_to_date": "All packages are up to date.",
"removing": "Removing",
"orphans_found": "Orphaned dependencies ({}): {}",
"flatpak_missing": "Flatpak is not installed.",
"flatpak_adding": "Adding Flathub remote...",
"flatpak_searching": "Searching Flathub for '{}'...",
"flatpak_found": "Found {} results:",
"flatpak_not_found": "not found on Flathub",
"flatpak_install_prompt": "Install {}? [Y/n] ",
"flatpak_installing": "Installing {}...",
"flatpak_installed": "Flatpak {} installed.",
"flatpak_removed": "Flatpak {} removed.",
"flatpak_not_installed": "Flatpak {} is not installed.",
"flatpak_info_id": "ID",
"flatpak_info_version": "Version",
"flatpak_info_branch": "Branch",
"flatpak_info_origin": "Origin",
"flatpak_info_size": "Installed size",
"flatpak_info_desc": "Description",
"flatpak_updated": "Flatpaks updated.",
"flatpak_update_failed": "Flatpak update failed (details above).",
"flatpak_usage": "Usage: pag flatpak <search|install|remove|list|update|info> [args]",
"flatpak_scope": "Installation",
"flatpak_menu_hint": "Installed and verified, but this session may not show it in the menu: Flatpak exports are missing from XDG_DATA_DIRS.",
"flatpak_menu_fix": "Add /var/lib/flatpak/exports/share to XDG_DATA_DIRS (and .../exports/bin to PATH) in your session, then re-login – PaganDE does this in session/pagande-session.",
"key_imported": "Key imported successfully.",
"key_removed": "Key removed: {}",
"no_keys": "No trusted GPG keys.",
"gpg_missing": "GNUPG MISSING – install gnupg and retry",
"ssl_broken": "Python has no working ssl module (HTTPS impossible) – fix the python/openssl packages (e.g. sudo pag install -f python).",
"key_add_failed": "Key import failed (gpg error) – key was NOT added.",
"verify_ok": "All {} files intact.",
"verify_errors": "{} problems found:",
"cache_cleared": "{} files ({:.2f} MB) cleared from cache.",
"deployments_list": "Deployments ({}):",
"no_deployments": "No deployments.",
"active_deployment": "ACTIVE",
"deploy_rollback_ok": "Switched to deployment: {}",
"deploy_rollback_fail": "No previous deployment.",
"deploy_cleanup_ok": "Removed {} old deployments.",
"deploy_cleanup_none": "No deployments to clean (minimum {}).",
"snapshot_none": "No system snapshots.",
"snapshot_list": "System snapshots ({}):",
"snapshot_created": "Snapshot created: {}.",
"snapshot_deleted": "Snapshot removed: {}.",
"snapshot_not_found": "Snapshot not found: {}",
"snapshot_unsupported": "Snapshots unavailable: {}",
"snapshot_rollback_next": "Next boot set to snapshot: {}",
"snapshot_rollback_hint": "Select this entry in the GRUB menu: {}",
"staging_prepare": "Preparing {} packages in staging (system unchanged)...",
"staging_failed": "Staging failed – the system was NOT modified.",
"staging_commit": "All packages prepared – applying changes...",
"grub_refreshed": "GRUB menu refreshed.",
"grub_failed": "GRUB: {}",
"grub_no_initrd": "GRUB: boot entry has no initramfs – check /boot/initramfs-*.img",
"crlf_fixed": "{}: CRLF removed (it broke grub-mkconfig).",
"initramfs_links_fixed": "initramfs symlinks repaired.",
"no_user_sessions": "no active user sessions – user units load at next login.",
"dry_run_done": "Dry run – nothing was changed.",
"dry_run_plan": "Dry run – transaction plan (no changes):",
"why_explicit": "explicitly installed",
"why_dependency": "dependency of",
"why_not_installed": "not installed",
"rdepends_title": "Reverse dependencies of {} ({}):",
"rdepends_none": "nothing depends on it.",
"optional_deps": "Optional dependencies (not installed automatically):",
"autoremove_ok": "Removed {} orphaned packages.",
"autoremove_none": "No orphaned packages.",
"downloaded": "Downloaded {} to cache ({:.2f} MB).",
"provides_mapped": "{} → {} (provides)",
"stats_title": "PAG Statistics",
"stats_packages": "Installed packages",
"stats_files": "Tracked files",
"stats_size": "Total size",
"stats_cache": "Cache size",
"stats_history": "Transactions",
"stats_last_update": "Last update",
# Komunikaty bezpieczeństwa (baza EN; PL w tabeli "pl" jako sec_*_pl)
"sec_downgrade": "Downgrade blocked: {pkg} {new} < {old}",
"sec_suid": "SUID stripped from {path}",
"sec_https": "HTTPS required for repos",
"sec_badname": "Invalid package name: {name}",
"sec_toobig": "Package too large: {size_mb}MB > {max_mb}MB",
"sec_conflict": "File conflict: {path} owned by {owner}",
"sec_audit": "{pkg} installed by {user}",
"sec_locked": "Another pag process is running",
# Konfiguracja (/etc) – zachowanie zmian użytkownika
"conf_pacnew": "Modified config kept; new version saved as {path}",
"conf_pacsave": "Modified config kept as {path}",
# Zależności wirtualne (provides)
"provides_conflict": "Multiple providers for '{name}' ({providers}) – using '{chosen}'",
# Base baked into the ISO image (pag base / base adopt)
"base_title": "Base from the ISO image",
"base_no_manifest": "This system carries no base manifest (/usr/share/pag/base.json) – nothing to adopt.",
"base_iso_version": "Image version",
"base_total": "Base packages (from image)",
"base_tracked": "Managed by pag",
"base_adoptable": "Adoptable from repo",
"base_unmatched": "No counterpart in repo",
"base_adopt_hint": "Adopt them (image files get replaced by repo packages): sudo pag base adopt",
"base_unmatched_hint": "These stay at the image version (no such package in repo):",
"base_more": "more",
"base_nothing_selected": "None of the given names is on the adopt list.",
"base_all_managed": "Every base package is already managed by pag.",
"base_adopt_plan": "Adopting {} base packages from the repo (~{:.0f} MB):",
"base_dry_run": "Dry run – nothing was installed.",
"base_unmanaged_hint": "{} packages from the ISO image are not managed by pag yet – 'sudo pag base adopt' replaces them with repo packages (only then does 'pag upgrade' update them).",
"base_overwrite": "{} comes from the ISO image – its files will be replaced (backup kept for 'pag rollback').",
"base_reboot_hint": "Base adopted from the repo – reboot before using the new libraries/toolchain.",
"base_register_ok": "Registered {} base packages in the package DB ({} were already tracked).",
"base_register_plan": "Dry run – would register {} base packages.",
"base_register_nocache": "No cached repo index – builder names kept as-is (run 'sudo pag sync' and 'pag base register' again to map them to repo names).",
"base_register_renamed": "{} names were matched to their repo package names.",
"stats_base": "Base (image) managed",
},
"pl": {
"root_required": "pag wymaga uprawnień root (sudo).",
"db_locked": "Inna instancja pag jest uruchomiona.",
"db_lock_hint": "Jeśli żaden inny proces pag nie działa, poczekaj chwilę i spróbuj ponownie.",
"no_index": "Nie można pobrać indeksów repozytoriów. Uruchom 'pag update'.",
"cache_ro": "Cache repozytoriów jest tylko-do-odczytu ({cache}) – używam lokalnego indeksu (może być nieaktualny).\n Odśwież jako root: sudo pag sync",
"all_installed": "Wszystkie pakiety są już zainstalowane.",
"to_install": "Do zainstalowania: {} pakietów ({:.2f} MB)",
"new": "NOWY",
"continue_q": "Kontynuować? [T/n] ",
"no_tty": "Brak terminala (EOF) – anuluję.",
"cancelled": "Anulowano.",
"not_found": "brak w repozytoriach",
"pkg_not_found": "Nie znaleziono pakietu: {} (brak w repozytoriach)",
"not_found_hint": "Sprawdź pisownię lub uruchom 'pag search <fraza>'.",
"downloading": "Pobieranie",
"done": "gotowe",
"wroom_terminal": "PAG WROOM wymaga terminala – uruchom: pag wroom",
"wroom_too_small": "Powiększ terminal (min. {arg1}x{arg2})",
"wroom_tagline": "PAGAN RACING 4.2.2 · 38911 BAJTÓW WOLNE",
"wroom_controls": "←/→ pas ↑/↓ gaz/hamulec P pauza Q wyjście",
"wroom_press": "NACIŚNIJ SPACJĘ, ABY RUSZYĆ",
"wroom_over": "KONIEC WYŚCIGU",
"wroom_score": "Wynik: {arg1}",
"wroom_best": "Rekord: {arg1}",
"wroom_restart": "R / SPACJA – jeszcze raz Q – wyjście",
"wroom_paused": "PAUZA",
"wroom_hud": "WYNIK {arg1:06d} PRĘDKOŚĆ {arg2:3d} km/h ŻYCIA {arg3}",
"download_fail": "błąd pobierania",
"gpg_fail": "błąd weryfikacji GPG",
"sha256_mismatch": "niezgodność SHA256",
"install_failed": "błąd instalacji",
"installed": "Zainstalowano {} pakietów.",
"rollback_restored": "Przywrócono poprzedni stan z migawki.",
"rollback_files": "Wycofano {} plików.",
"no_history": "Brak historii transakcji.",
"pinned_list": "Przypięte pakiety ({}):",
"no_pinned": "Brak przypiętych pakietów.",
"pinned_to": "przypięty do",
"unpinned": "odpięty.",
"not_pinned": "nie był przypięty.",
"repo_added": "Dodano repozytorium: {}",
"repo_exists": "Repozytorium już istnieje: {}",
"updated_done": "Odświeżanie zakończone. {} pakietów w cache.",
"indexes_refreshed": "Indeksy odświeżone.",
"updates_available": "⚠ jest {} pakietów do zaktualizowania – wpisz: pag update",
"upgrading": "Aktualizacje: {} pakietów",
"all_up_to_date": "Wszystkie pakiety są aktualne.",
"removing": "Usuwanie",
"orphans_found": "Osierocone zależności ({}): {}",
"flatpak_missing": "Flatpak nie jest zainstalowany.",
"flatpak_adding": "Dodaję zdalne repozytorium Flathub...",
"flatpak_searching": "Szukam '{}' we Flathub...",
"flatpak_found": "Znaleziono {} wyników:",
"flatpak_not_found": "nie znaleziono we Flathub",
"flatpak_install_prompt": "Zainstalować {}? [T/n] ",
"flatpak_installing": "Instalowanie {}...",
"flatpak_installed": "Flatpak {} zainstalowany.",
"flatpak_removed": "Flatpak {} usunięty.",
"flatpak_not_installed": "Flatpak {} nie jest zainstalowany.",
"flatpak_info_id": "ID",
"flatpak_info_version": "Wersja",
"flatpak_info_branch": "Gałąź",
"flatpak_info_origin": "Źródło",
"flatpak_info_size": "Rozmiar",
"flatpak_info_desc": "Opis",
"flatpak_updated": "Flapaki zaktualizowane.",
"flatpak_update_failed": "Aktualizacja flatpaków nie powiodła się (szczegóły wyżej).",
"flatpak_usage": "Użycie: pag flatpak <search|install|remove|list|update|info> [args]",
"flatpak_scope": "Instalacja",
"flatpak_menu_hint": "Zainstalowano i zweryfikowano, ale sesja może jej nie pokazać w menu: brak eksportów Flatpaka w XDG_DATA_DIRS.",
"flatpak_menu_fix": "Dodaj /var/lib/flatpak/exports/share do XDG_DATA_DIRS (a .../exports/bin do PATH) w sesji i zaloguj się ponownie – PaganDE robi to w session/pagande-session.",
"key_imported": "Klucz zaimportowany pomyślnie.",
"key_removed": "Klucz usunięty: {}",
"no_keys": "Brak zaufanych kluczy GPG.",
"gpg_missing": "BRAK GNUPG – zainstaluj gnupg i spróbuj ponownie",
"ssl_broken": "Python bez działającego modułu ssl (HTTPS niemożliwe) – napraw pakiety python/openssl (np. sudo pag install -f python).",
"key_add_failed": "Import klucza nie powiódł się (błąd gpg) – klucz NIE został dodany.",
"verify_ok": "Wszystkie {} plików sprawne.",
"verify_errors": "Znaleziono {} problemów:",
"cache_cleared": "{} plików ({:.2f} MB) usuniętych z cache.",
"deployments_list": "Deploymenty ({}):",
"no_deployments": "Brak deploymentów.",
"active_deployment": "AKTYWNY",
"deploy_rollback_ok": "Przełączono na deployment: {}",
"deploy_rollback_fail": "Brak poprzedniego deploymentu.",
"deploy_cleanup_ok": "Usunięto {} starych deploymentów.",
"deploy_cleanup_none": "Nie ma deploymentów do wyczyszczenia (minimum {}).",
"snapshot_none": "Brak snapshotów systemu.",
"snapshot_list": "Snapshoty systemu ({}):",
"snapshot_created": "Utworzono snapshot: {}.",
"snapshot_deleted": "Usunięto snapshot: {}.",
"snapshot_not_found": "Nie znaleziono snapshotu: {}",
"snapshot_unsupported": "Snapshoty niedostępne: {}",
"snapshot_rollback_next": "Następny start ustawiono na snapshot: {}",
"snapshot_rollback_hint": "Wybierz ten wpis w menu GRUB: {}",
"staging_prepare": "Przygotowuję {} pakietów w stagingu (system bez zmian)...",
"staging_failed": "Etap przygotowania nieudany – system NIE został zmieniony.",
"staging_commit": "Wszystkie pakiety przygotowane – nakładam zmiany...",
"grub_refreshed": "Menu GRUB odświeżone.",
"grub_failed": "GRUB: {}",
"grub_no_initrd": "GRUB: wpis startowy bez initramfs – sprawdź /boot/initramfs-*.img",
"crlf_fixed": "{}: usunięto CRLF (psuło grub-mkconfig).",
"initramfs_links_fixed": "Naprawiono dowiązania initramfs.",
"no_user_sessions": "brak aktywnych sesji użytkownika – jednostki wczytają się przy logowaniu.",
"dry_run_done": "Dry-run – nic nie zmieniono.",
"dry_run_plan": "Dry-run – plan transakcji (bez zmian):",
"why_explicit": "zainstalowany jawnie",
"why_dependency": "zależność od",
"why_not_installed": "niezainstalowany",
"rdepends_title": "Odwrotne zależności {} ({}):",
"rdepends_none": "nic od niego nie zależy.",
"optional_deps": "Opcjonalne zależności (nie są instalowane automatycznie):",
"autoremove_ok": "Usunięto {} osieroconych pakietów.",
"autoremove_none": "Brak osieroconych pakietów.",
"downloaded": "Pobrano {} do cache ({:.2f} MB).",
"sec_downgrade": "Downgrade blocked: {pkg} {new} < {old}",
"sec_suid": "SUID stripped from {path}",
"sec_https": "HTTPS required for repos",
"sec_badname": "Invalid package name: {name}",
"sec_toobig": "Package too large: {size_mb}MB > {max_mb}MB",
"sec_conflict": "File conflict: {path} owned by {owner}",
"sec_audit": "{pkg} installed by {user}",
"sec_locked": "Another pag process is running",
"sec_downgrade_pl": "Blokada downgrade: {pkg} {new} < {old}",
"sec_suid_pl": "SUID usuniety z {path}",
"sec_https_pl": "Repozytorium wymaga HTTPS",
"sec_badname_pl": "Nieprawidlowa nazwa pakietu: {name}",
"sec_toobig_pl": "Paczka za duza: {size_mb}MB > {max_mb}MB",
"sec_conflict_pl": "Konflikt plikow: {path} nalezy do {owner}",
"sec_audit_pl": "{pkg} zainstalowany przez {user}",
"sec_locked_pl": "Inny proces pag juz dziala",
"provides_mapped": "{} → {} (provides)",
"stats_title": "Statystyki PAG",
"stats_packages": "Zainstalowane pakiety",
"stats_files": "Śledzone pliki",
"stats_size": "Całkowity rozmiar",
"stats_cache": "Rozmiar cache",
"stats_history": "Transakcje",
"stats_last_update": "Ostatnia aktualizacja",
"conf_pacnew": "Zmieniony plik konfiguracyjny zachowany; nowa wersja: {path}",
"conf_pacsave": "Zmieniony plik konfiguracyjny zachowany jako {path}",
"provides_conflict": "Wielu dostawców dla '{name}' ({providers}) – używam '{chosen}'",
# Baza wypalona w obrazie ISO (pag base / base adopt)
"base_title": "Baza z obrazu ISO",
"base_no_manifest": "Ten system nie ma manifestu bazy (/usr/share/pag/base.json) – nie ma czego adoptować.",
"base_iso_version": "Wersja obrazu",
"base_total": "Pakiety bazy (z obrazu)",
"base_tracked": "Zarządzane przez pag",
"base_adoptable": "Do adoptowania z repo",
"base_unmatched": "Bez odpowiednika w repo",
"base_adopt_hint": "Adoptuj (pliki z obrazu zostaną zastąpione pakietami z repo): sudo pag base adopt",
"base_unmatched_hint": "Te zostaną w wersji z obrazu (brak takiego pakietu w repo):",
"base_more": "więcej",
"base_nothing_selected": "Żadna z podanych nazw nie jest na liście do adoptowania.",
"base_all_managed": "Wszystkie pakiety bazy są już zarządzane przez pag.",
"base_adopt_plan": "Adoptowanie {} pakietów bazy z repo (~{:.0f} MB):",
"base_dry_run": "Próba na sucho – nic nie zainstalowano.",
"base_unmanaged_hint": "{} pakietów z obrazu ISO nie jest jeszcze zarządzanych przez pag – 'sudo pag base adopt' zamieni je na pakiety z repo (dopiero wtedy 'pag upgrade' je aktualizuje).",
"base_overwrite": "{} pochodzi z obrazu ISO – pliki zostaną zastąpione (kopia zapasowa dla 'pag rollback').",
"base_reboot_hint": "Baza zaadoptowana z repo – zrestartuj system, zanim zaczniesz używać nowych bibliotek/narzędzi.",
"base_register_ok": "Zarejestrowano {} pakietów bazy w bazie pakietów ({} już było).",
"base_register_plan": "Dry-run – zarejestrowałbym {} pakietów bazy.",
"base_register_nocache": "Brak cache indeksu repo – zostawiono nazwy z buildera (uruchom 'sudo pag sync' i ponownie 'pag base register', aby je zmapować).",
"base_register_renamed": "{} nazw dopasowano do nazw pakietów w repo.",
"stats_base": "Baza (obraz) zarządzana",
},
}
# ── i18n: komunikaty CLI (msgid = tekst EN) ─────────────────────────────
_EXTRA_I18N = {
' ⚠ PAG_INSECURE=1 – skipping local package signature verification': ' ⚠ PAG_INSECURE=1 – pomijam weryfikację podpisu pakietu lokalnego',
' ❌ No signature for package: {arg1}': ' ❌ Brak podpisu dla pakietu: {arg1}',
' A .pag.asc/.pag.sig file from the same source is required.': ' Wymagany jest plik .pag.asc/.pag.sig z tego samego źródła.',
' ❌ Invalid package signature: {arg1}': ' ❌ Nieprawidłowy podpis pakietu: {arg1}',
' ❌ No pinned repo key for the local package.': ' ❌ Brak przypiętego klucza repo dla lokalnego pakietu.',
' Run first: sudo pag sync': ' Uruchom najpierw: sudo pag sync',
' ❌ [SECURITY ERROR] Package was signed with a different repo key.': ' ❌ [SECURITY ERROR] Pakiet podpisano innym kluczem repo.',
' Expected: {arg1}': ' Oczekiwany: {arg1}',
' Received: {arg1}': ' Otrzymany: {arg1}',
' 🔐 Package signature OK ({arg1})': ' 🔐 Podpis pakietu OK ({arg1})',
' ⚡ Copying the active deployment...': ' ⚡ Kopiowanie aktywnego deploymentu...',
' ✅ Deployment: {arg1} ({arg2})': ' ✅ Deployment: {arg1} ({arg2})',
' ✅ First deployment: {arg1}': ' ✅ Pierwszy deployment: {arg1}',
' ⚠ Cannot create {arg1}: {arg2}': ' ⚠ Nie mogę utworzyć {arg1}: {arg2}',
' ⚠ Failed to create snapshot: {arg1}': ' ⚠ Nie udało się utworzyć snapshotu: {arg1}',
' ⚠ btrfs snapshot failed: {arg1}': ' ⚠ btrfs snapshot nie udał się: {arg1}',
' 📸 System snapshot: {arg1} (subvol={arg2})': ' 📸 Snapshot systemu: {arg1} (subvol={arg2})',
' ❌ Invalid snapshot path – refusing to delete.': ' ❌ Nieprawidłowa ścieżka snapshotu – odmawiam usunięcia.',
' ⏪ Snapshot: {arg1}': ' ⏪ Snapshot: {arg1}',
' 💡 Reboot the system – GRUB will boot the selected snapshot.': ' 💡 Zrestartuj system – GRUB uruchomi wybrany snapshot.',
' 💡 At boot, choose an entry in the GRUB menu (snapshots section).': ' 💡 Przy starcie wybierz wpis w menu GRUB (sekcja snapshotów).',
'❌ Another pag update is in progress – try again later.': '❌ Inna aktualizacja pag jest w toku – spróbuj ponownie później.',
' ⚠ Failed to extract {arg1}: {arg2}': ' ⚠ Nie rozpakowano {arg1}: {arg2}',
' ⚠ Corrupted index cache {arg1}: {arg2}': ' ⚠ Uszkodzony cache indeksu {arg1}: {arg2}',
' ❌ {arg1}: cannot refresh index – {arg2} is read-only': ' ❌ {arg1}: nie można odświeżyć indeksu – {arg2} jest tylko-do-odczytu',
' ⚠ HTTP {arg1} for {arg2}': ' ⚠ HTTP {arg1} dla {arg2}',
' ⚠ Failed to download index {arg1}: {arg2}': ' ⚠ Błąd pobierania indeksu {arg1}: {arg2}',
' ⚠ Index downloaded, but failed to save cache ({arg1}): {arg2}': ' ⚠ Indeks pobrany, ale nie udało się zapisać cache ({arg1}): {arg2}',
' ❌ {arg1}: no GPG keys – verification impossible!': ' ❌ {arg1}: brak kluczy GPG – weryfikacja niemożliwa!',
' Set PAG_INSECURE=1 to skip (not recommended)': ' Ustaw PAG_INSECURE=1 aby pominąć (niezalecane)',
' ❌ {arg1}: CANNOT DOWNLOAD SIGNATURE repo.json.asc/.sig!': ' ❌ {arg1}: NIE MOŻNA POBRAĆ PODPISU repo.json.asc/.sig!',
' 🔑 Imported repo key from {arg1}/paganos.asc': ' 🔑 Importowano klucz repo z {arg1}/paganos.asc',
' ⚠ {arg1}: invalid GPG signature (PAG_INSECURE – ignoring)': ' ⚠ {arg1}: nieprawidłowy podpis GPG (PAG_INSECURE – ignoruję)',
' ❌ {arg1}: GPG is not installed – cannot verify the signature!': ' ❌ {arg1}: GPG nie jest zainstalowane – nie można zweryfikować podpisu!',
' Install gnupg or set PAG_INSECURE=1 (not recommended)': ' Zainstaluj gnupg lub ustaw PAG_INSECURE=1 (niezalecane)',
' ❌ {arg1}: INVALID GPG SIGNATURE of the repository index!': ' ❌ {arg1}: NIEPRAWIDŁOWY PODPIS GPG indeksu repozytorium!',
' ⚠ {arg1}: cannot read signature fingerprint (PAG_INSECURE – ignoring)': ' ⚠ {arg1}: nie można odczytać fingerprintu (PAG_INSECURE – ignoruję)',
' ❌ [SECURITY ERROR] {arg1}: cannot read signature fingerprint!': ' ❌ [SECURITY ERROR] {arg1}: nie można odczytać fingerprintu podpisu!',
' Pinned key: {arg1} – rejecting the index.': ' Przypięty klucz: {arg1} – odrzucam indeks.',
' ⚠ {arg1}: SIGNING KEY CHANGED (PAG_INSECURE – ignoring)': ' ⚠ {arg1}: ZMIENIONY KLUCZ PODPISU (PAG_INSECURE – ignoruję)',
' ❌ [SECURITY ERROR] {arg1}: Repository signing key has changed!': ' ❌ [SECURITY ERROR] {arg1}: Klucz podpisujący repo uległ zmianie!',
' If this is an intentional key rotation: pag key-trust {arg1}': ' Jeśli to celowa rotacja klucza: pag key-trust {arg1}',
' 🔐 Pinned repo fingerprint {arg1}: {arg2}': ' 🔐 Przypięto fingerprint repo {arg1}: {arg2}',
' (TOFU – first trust. If the key changes, pag will refuse updates.)': ' (TOFU – pierwsze zaufanie. Gdy klucz się zmieni, pag odmówi aktualizacji.)',
' To avoid TOFU, add the fingerprint to /etc/pag/repos.conf.': ' Aby uniknąć TOFU, dopisz fingerprint w /etc/pag/repos.conf.',
'❌ Download error: {arg1}': '❌ Błąd pobierania: {arg1}',
'🔐 Pinning repo key {arg1}...': '🔐 Przypinam klucz repo {arg1}...',
' ❌ Cannot read signature fingerprint (missing/failed).': ' ❌ Nie można odczytać fingerprintu podpisu (brak/nieudany).',
' Make sure the repo key is in the keyring (pag key-add <url|file>).': ' Upewnij się, że klucz repo jest w keyringu (pag key-add <url|file>).',
' ✅ Pinned {arg1} for {arg2}': ' ✅ Przypięto {arg1} dla {arg2}',
' From now on, a key change will be reported as SECURITY ERROR.': ' Od teraz zmiana klucza zostanie zgłoszona jako SECURITY ERROR.',
' ℹ {arg1} has no pinned fingerprint.': ' ℹ {arg1} nie ma przypiętego fingerprintu.',
' ✅ Removed pin for {arg1}.': ' ✅ Usunięto przypięcie dla {arg1}.',
' ❌ {arg1}: preparation stage failed ({arg2})': ' ❌ {arg1}: etap przygotowania nieudany ({arg2})',
' ❌ {arg1}: commit error – {arg2}': ' ❌ {arg1}: błąd commit – {arg2}',
' ⚠ ldconfig not found — linker cache was not refreshed.': ' ⚠ Nie znaleziono ldconfig — cache linkera nie został odświeżony.',
' ⚠ Failed to refresh ld.so cache: {arg1}': " ⚠ Nie udało się odświeżyć cache'a ld.so: {arg1}",
' ⚠ {arg1} shared files preserved': ' ⚠ {arg1} plików współdzielonych zachowanych',
' ⚠ {arg1} sensitive system files preserved': ' ⚠ {arg1} wrażliwych plików systemowych zachowanych',
' 🧹 Removed {arg1} obsolete files ({arg2})': ' 🧹 Usunięto {arg1} nieaktualnych plików ({arg2})',
' 🛠 Interrupted transaction detected – restored {arg1} missing files.': ' 🛠 Wykryto przerwana transakcje – przywrocono {arg1} brakujacych plikow.',
' ⚠ Hook skipped (PAG_NO_HOOKS=1): {arg1} for {arg2}': ' ⚠ Hook pominięty (PAG_NO_HOOKS=1): {arg1} dla {arg2}',
' ⚠ Hook {arg1} for {arg2} exited with code {arg3}': ' ⚠ Hook {arg1} dla {arg2} zakończony z kodem {arg3}',
' ⚠ Hook {arg1} for {arg2} timed out ({arg3}s)': ' ⚠ Hook {arg1} dla {arg2} przekroczył timeout ({arg3}s)',
' Increase PAG_HOOK_TIMEOUT (e.g. PAG_HOOK_TIMEOUT=1800) and retry.': ' Zwiększ PAG_HOOK_TIMEOUT (np. PAG_HOOK_TIMEOUT=1800) i spróbuj ponownie.',
' ⚠ Hook {arg1} for {arg2}: {arg3}': ' ⚠ Hook {arg1} dla {arg2}: {arg3}',
'Recent transactions ({arg1}):': 'Ostatnie transakcje ({arg1}):',
'❌ No snapshot to restore.': '❌ Brak snapshotu do przywrócenia.',
'⏪ Rolling back: {arg1} ({arg2})': '⏪ Wycofywanie: {arg1} ({arg2})',
' Packages: {arg1}': ' Pakiety: {arg1}',
' ❌ Package not found: {arg1}': ' ❌ Nie znaleziono pakietu: {arg1}',
' ❌ {arg1}: missing metadata.json': ' ❌ {arg1}: brak metadata.json',
' ❌ {arg1}: failed to read package ({arg2})': ' ❌ {arg1}: nie udało się odczytać pakietu ({arg2})',
' ↩ Preparation stage failed – the system was NOT changed.': ' ↩ Etap przygotowania nieudany – system NIE został zmieniony.',
' ↓ {arg1}-{arg2} (local) ... ': ' ↓ {arg1}-{arg2} (lokalny) ... ',
' ❌ Not enough disk space: need ~{arg1} MB, free {arg2} MB ({arg3})': ' ❌ Za mało miejsca na dysku: potrzeba ~{arg1} MB, wolne {arg2} MB ({arg3})',
' ⚠ Low disk space: {arg1} MB free, packages ~{arg2} MB (extracted will take more)': ' ⚠ Mało miejsca na dysku: wolne {arg1} MB, pakiety ~{arg2} MB (rozpakowane zajmą więcej)',
' ❌ {arg1} is mounted read-only – cannot install.': ' ❌ {arg1} jest zamontowane tylko-do-odczytu – nie można instalować.',
'❌ Cannot continue – {arg1} missing dependencies.': '❌ Nie można kontynuować – {arg1} brakujących zależności.',
' Install the missing packages or add repositories.': ' Zainstaluj brakujące pakiety lub dodaj repozytoria.',
' Install the library provider or update the repository.': ' Zainstaluj dostawcę biblioteki lub zaktualizuj repozytorium.',
'\n 🏗️ Creating a new deployment...': '\n 🏗️ Tworzenie nowego deploymentu...',
'\n ⏬ Downloading {arg1} packages in parallel...': '\n ⏬ Pobieranie {arg1} pakietów równolegle...',
'\n 🐧 Finalizing kernel/driver update (DKMS → depmod → initramfs → GRUB)...': '\n 🐧 Finalizuję aktualizację jądra/sterowników (DKMS → depmod → initramfs → GRUB)...',
'\n 🐧 Finalizing kernel/driver update in deployment (depmod + initramfs)...': '\n 🐧 Finalizuję aktualizację jądra/sterowników w deploymencie (depmod + initramfs)...',
' ↩ Aborted BEFORE installation – no package was changed.': ' ↩ Przerwano PRZED instalacją – żadna paczka nie została zmieniona.',
' ❌ Failed to create snapshot (--snapshot mode) – aborting.': ' ❌ Nie udało się utworzyć snapshotu (tryb --snapshot) – przerywam.',
'\n ↩ Rolling back transaction ({arg1} errors)...': '\n ↩ Cofanie transakcji ({arg1} błędów)...',
'\n 🔄 Switching to deployment {arg1}...': '\n 🔄 Przełączanie na deployment {arg1}...',
' ✅ Active deployment: {arg1}': ' ✅ Aktywny deployment: {arg1}',
' 💡 Restart required to reload the system.': ' 💡 Restart wymagany do przeładowania systemu.',
' ⚠ {arg1}: not installed': ' ⚠ {arg1}: nie zainstalowano',
'✅ ({arg1} files)': '✅ ({arg1} plików)',
'\n✅ Removed {arg1}.': '\n✅ Usunięto {arg1}.',
" 'pag remove-orphans' to clean up.": " Uruchom 'pag remove-orphans', aby posprzątać.",
' ⚡ Trigger: {arg1} ({arg2})': ' ⚡ Wyzwalacz: {arg1} ({arg2})',
' ⚠ trigger {arg1} timed out (120 s)': ' ⚠ trigger {arg1} przekroczył limit czasu (120 s)',
' ⚠ trigger {arg1}: {arg2}': ' ⚠ wyzwalacz {arg1}: {arg2}',
'❌ No repositories configured.': '❌ Brak repozytoriów w konfiguracji.',
'🔄 Checking for pag update from {arg1}...': '🔄 Sprawdzam aktualizację pag z {arg1}...',
' ❌ Cannot download pag: {arg1}': ' ❌ Nie można pobrać pag: {arg1}',
' ⚠ Invalid update signature (PAG_INSECURE – ignoring)': ' ⚠ Nieprawidłowy podpis aktualizacji (PAG_INSECURE – ignoruję)',
' ❌ Invalid update signature – not updating.': ' ❌ Nieprawidłowy podpis aktualizacji – nie aktualizuję.',
' ❌ Cannot confirm the update signature fingerprint.': ' ❌ Nie można potwierdzić fingerprintu podpisu aktualizacji.',
' ⚠ Update signed with a different key (PAG_INSECURE – ignoring)': ' ⚠ Podpis aktualizacji innym kluczem (PAG_INSECURE – ignoruję)',
' ❌ [SECURITY ERROR] Update signed with a different key than the repo!': ' ❌ [SECURITY ERROR] Podpis aktualizacji innym kluczem niż repo!',
' Expected: {arg1}, received: {arg2}': ' Oczekiwany: {arg1}, Otrzymany: {arg2}',
' ❌ SHA256 mismatch! Expected {arg1}, got {arg2}': ' ❌ SHA256 niezgodny! Oczekiwano {arg1}, jest {arg2}',
' ✅ SHA256 matches': ' ✅ SHA256 zgodny',
' ❌ Syntax error in new pag: {arg1}': ' ❌ Błąd składni w nowym pag: {arg1}',
' ✅ Downloaded pag {arg1} (current {arg2}), signature verified': ' ✅ Pobrano pag {arg1} (obecny {arg2}), podpis zweryfikowany',
' ✅ Installed new pag. Old version kept as {arg1}': ' ✅ Zainstalowano nowy pag. Stary zachowany jako {arg1}',
' ⚠ A different pag is first in PATH: {arg1} (updated {arg2})': ' ⚠ W PATH pierwszy jest inny pag: {arg1} (zaktualizowano {arg2})',
' Remove the old copy: sudo rm {arg1}': ' Usuń starą kopię: sudo rm {arg1}',
' Restart pag to use the new version.': ' Uruchom ponownie pag, aby użyć nowej wersji.',
'🔄 Refreshing indexes...': '🔄 Odświeżanie indeksów...',
' {arg1} {arg2}: {arg3} packages {arg4}': ' {arg1} {arg2}: {arg3} pakietów {arg4}',
' ⚠ New pag version {arg1} available – run: pag self-update': ' ⚠ Nowa wersja pag {arg1} dostępna – uruchom: pag self-update',
' 🐧 Rebuilding initramfs (newer kernel)...': ' 🐧 Przebudowa initramfs (nowsze jądro)...',
'No packages installed.': 'Brak zainstalowanych pakietów.',
'Installed ({arg1}):': 'Zainstalowane ({arg1}):',
'Available ({arg1}):': 'Dostępne ({arg1}):',
'❌ No results for: {arg1}': '❌ Brak wyników dla: {arg1}',
"Results for '{arg1}' ({arg2}):": "Wyniki dla '{arg1}' ({arg2}):",
"\n ❌ '{arg1}' — not found.": "\n ❌ '{arg1}' — nie znaleziono.",
' PaganOS repo: pag search {arg1}': ' Repo PaganOS: pag search {arg1}',
' Flathub: pag flatpak search {arg1}': ' Flathub: pag flatpak search {arg1}',
' Add repo: pag repo-add <url>': ' Dodaj repo: pag repo-add <url>',
' ... and {arg1} more (pag search {arg2})': ' ... i {arg1} więcej (pag search {arg2})',
' ... and {arg1} more (pag flatpak search {arg2})': ' ... i {arg1} więcej (pag flatpak search {arg2})',
' ✓ {arg1} is already installed ({arg2})': ' ✓ {arg1} jest już zainstalowany ({arg2})',
"❌ '{arg1}' not found.": "❌ Nie znaleziono '{arg1}'.",
' Version (repo): {arg1}': ' Wersja (repo): {arg1}',
' Description: {arg1}': ' Opis: {arg1}',
' Size: {arg1:.1f} MB': ' Rozmiar: {arg1:.1f} MB',
' SHA256: {arg1}...': ' SHA256: {arg1}...',
' GPG: {arg1}': ' GPG: {arg1}',
' Dependencies: {arg1}': ' Zależności: {arg1}',
' Installed: {arg1} ({arg2})': ' Zainstalowany: {arg1} ({arg2})',
"❌ '{arg1}' not installed.": "❌ '{arg1}' nie jest zainstalowany.",
'Files in {arg1} ({arg2}):': 'Pliki w {arg1} ({arg2}):',
'Nothing to repair (no packages installed).': 'Nic do naprawy (brak zainstalowanych pakietow).',
'✅ All files are in place – nothing to repair.': '✅ Wszystkie pliki na miejscu – nic do naprawy.',
'🔧 Packages with missing files: {arg1} (total {arg2} files)': '🔧 Pakiety z brakujacymi plikami: {arg1} (lacznie {arg2} plikow)',
'\n(--dry-run: nothing is changed)': '\n(--dry-run: nic nie zmieniam)',
'\n🔧 repair: {arg1}': '\n🔧 naprawa: {arg1}',
'⚠ Repaired {arg1}/{arg2}. Failed: {arg3}': '⚠ Naprawiono {arg1}/{arg2}. Nie udalo sie: {arg3}',
'✅ Repaired {arg1} packages.': '✅ Naprawiono {arg1} pakietow.',
'Nothing to verify.': 'Nie ma czego weryfikować.',
'✅ No orphans.': 'Brak osieroconych pakietów.',
'Orphans ({arg1}):': 'Osierocone ({arg1}):',
' ⚠ Search error: {arg1}': ' ⚠ Błąd wyszukiwania: {arg1}',
'\n Choose a number (1-{arg1}) or press Enter to cancel:': '\n Wybierz numer (1-{arg1}) lub Enter aby anulować: ',
" 📦 {arg1} – already installed (use 'pag flatpak info {arg2}' for details)": " 📦 {arg1} – już zainstalowany (szczegóły: 'pag flatpak info {arg2}')",
"\n Multiple matches for '{arg1}':": "\n Wiele dopasowań dla '{arg1}':",
'\n Choose a number (1-{arg1}) or press Enter:': '\n Wybierz numer (1-{arg1}) lub Enter: ',
' ... and {arg1} more. Refine your query.': ' ... i {arg1} więcej. Doprecyzuj zapytanie.',
'\n Choose a number to install (1-{arg1}) or press Enter to cancel:': '\n Wybierz numer do zainstalowania (1-{arg1}) lub Enter aby anulować: ',
' (no installed flatpaks)': ' (brak zainstalowanych flatpaków)',
'Installed flatpaks ({arg1}):': ' Zainstalowane flatpaki ({arg1}):',
' 🔄 Updating flatpaks...': ' 🔄 Aktualizacja flatpaków...',
'\n 💡 To install: pag flatpak install {arg1}': '\n 💡 Aby zainstalować: pag flatpak install {arg1}',
' 🔧 DKMS: rebuilding out-of-tree modules (nvidia/vbox)...': ' 🔧 DKMS: przebudowa modułów out-of-tree (nvidia/vbox)...',
' 🔧 Refreshing module dependencies (depmod)...': ' 🔧 Odświeżanie zależności modułów (depmod)...',
' 🔧 Rebuilding initramfs (pagan-initramfs)...': ' 🔧 Przebudowa initramfs (pagan-initramfs)...',
' 🔧 Rebuilding initramfs (dracut)...': ' 🔧 Przebudowa initramfs (dracut)...',
' 🔧 Rebuilding initramfs (mkinitcpio)...': ' 🔧 Przebudowa initramfs (mkinitcpio)...',
' ⚠ No dracut/mkinitcpio – initramfs was not rebuilt': ' ⚠ Brak dracut/mkinitcpio – initramfs nie został przebudowany',
' 🔧 Building initramfs for the deployment...': ' 🔧 Budowanie initramfs dla deploymentu...',
' ⚠ pag-initramfs-init not found – skipping initramfs build': ' ⚠ Nie znaleziono pag-initramfs-init – pomijam budowę initramfs',
" ⚠ No vmlinuz-* found in the deployment's /boot": ' ⚠ Nie znaleziono vmlinuz-* w /boot deploymentu',
' 🐧 Kernel: {arg1}': ' 🐧 Jądro: {arg1}',
' ⚠ Skipping unavailable files: {arg1}': ' ⚠ Pomijam niedostępne pliki: {arg1}',
' ⚠ Skipping unavailable file: {arg1}': ' ⚠ Pomijam niedostępny plik: {arg1}',
' ✅ initramfs.img ({arg1:.1f} MB) → {arg2}': ' ✅ initramfs.img ({arg1:.1f} MB) → {arg2}',
' ❌ initramfs build error: {arg1}': ' ❌ Błąd budowy initramfs: {arg1}',
'🏗️ Deployment: {arg1}': '🏗️ Deployment: {arg1}',
'✅ Initramfs updated.': '✅ Initramfs zaktualizowany.',
'❌ Initramfs update failed.': '❌ Błąd aktualizacji initramfs.',
' 📋 Regenerating GRUB (grub-mkconfig)...': ' 📋 Regeneracja GRUB (grub-mkconfig)...',
' ⚠ Could not detect the root partition – GRUB entries will have no root=.': ' ⚠ Nie udało się wykryć partycji root – wpisy GRUB nie dostaną root=.',
' Set PAG_ROOT_DEVICE=/dev/... (or PAG_GRUB_ROOT) and retry.': ' Ustaw PAG_ROOT_DEVICE=/dev/... (lub PAG_GRUB_ROOT) i powtórz.',
' 📋 GRUB config updated – entries for each deployment': ' 📋 GRUB config zaktualizowany – wpisy dla każdego deploymentu',
'📋 Updating GRUB configuration...': '📋 Aktualizacja konfiguracji GRUB...',
'✅ GRUB updated.': '✅ GRUB zaktualizowany.',
' +{arg1} more...': ' +{arg1} więcej...',
'❌ Deployment {arg1} does not exist on disk': '❌ Deployment {arg1} nie istnieje na dysku',
'⏪ Restoring deployment: {arg1}': '⏪ Przywracanie deploymentu: {arg1}',
'\n❌ {arg1} – cannot install:': '\n❌ {arg1} – nie można zainstalować:',
' {arg1} → needs {arg2} (missing from repositories)': ' {arg1} → potrzebuje {arg2} (brak w repozytoriach)',
'\n⚠ {arg1} – will be installed as dependencies:': '\n⚠ {arg1} – zostaną doinstalowane:',
' {arg1} → {arg2} ({arg3} – will be downloaded)': ' {arg1} → {arg2} ({arg3} – będzie pobrane)',
' {arg1} → requires {arg2} – no package provides this version': ' {arg1} → wymaga {arg2} – żaden pakiet nie dostarcza tej wersji',
' ↻ Retrying download of {arg1} ({arg2}/{arg3})...': ' ↻ Ponawiam pobieranie {arg1} ({arg2}/{arg3})...',
' ⚠ Download error {arg1}: {arg2}': ' ⚠ Błąd pobierania {arg1}: {arg2}',
'❌ Format: spdx | cyclonedx': '❌ Format: spdx | cyclonedx',
' ✓ {arg1} ({arg2} keys)': ' ✓ {arg1} ({arg2} kluczy)',
'Usage: pag search <query>': 'Użycie: pag search <query>',
'Usage: pag info <pkg>': 'Użycie: pag info <pkg>',
'Usage: pag files <pkg>': 'Użycie: pag files <pkg>',
'Usage: pag why <pkg>': 'Użycie: pag why <pkg>',
'Usage: pag rdepends <pkg>': 'Użycie: pag rdepends <pkg>',
'Usage: pag flatpak-search <query>': 'Użycie: pag flatpak-search <query>',
'Usage: pag flatpak-info <id>': 'Użycie: pag flatpak-info <id>',
"❌ Unknown command: '{arg1}'. Did you mean '{arg2}'?": "❌ Nieznana komenda: '{arg1}'. Czy chodziło o '{arg2}'?",
" Run 'pag' without arguments to see the command list.": " Uruchom 'pag' bez argumentów, aby zobaczyć listę komend.",
'Usage: pag unpin <pkg>': 'Użycie: pag unpin <pkg>',
'Usage: pag repo-add <url> [name]': 'Użycie: pag repo-add <url> [name]',
'Usage: pag key-add <url|file>': 'Użycie: pag key-add <url|file>',
'Usage: pag key-remove <id>': 'Użycie: pag key-remove <id>',
'Usage: pag key-trust <repo_url>': 'Użycie: pag key-trust <repo_url>',
'Usage: pag key-untrust <repo_url>': 'Użycie: pag key-untrust <repo_url>',
'Usage: pag flatpak-install <app>': 'Użycie: pag flatpak-install <app>',
'Usage: pag flatpak-remove <app>': 'Użycie: pag flatpak-remove <app>',
'Usage: pag snapshot-delete <id>': 'Użycie: pag snapshot-delete <id>',
'\n ⚠ Interrupted (Ctrl-C).': '\n ⚠ Przerwano (Ctrl-C).',
}
for _msgid, _pl in _EXTRA_I18N.items():
T["en"].setdefault(_msgid, _msgid)
T["pl"].setdefault(_msgid, _pl)
_AUX_I18N = {
'installed_marker': ('installed', 'zainstalowany'),
'none_value': ('none', 'brak'),
'none_parenthesized': ('(none)', '(brak)'),
'stats_top': ('Top 5:', 'Największe 5:'),
'never': ('never', 'nigdy'),
'action_install': ('install', 'instalacja'),
'action_upgrade': ('upgrade', 'aktualizacja'),
'action_remove': ('remove', 'usunięcie'),
'action_rollback': ('rollback', 'wycofanie'),
'action_manual': ('manual', 'ręczny'),
'action_repair': ('repair', 'naprawa'),
'flatpak_searching_any': ('Searching Flathub...', 'Szukam we Flathub...'),
'upgrade_marker': ('[upgrade]', '[aktualizacja]'),
'hardlink_method': ('hardlinks', 'hardlinki'),
'copy_method': ('full copy', 'pełna kopia'),
'reflink_method': ('CoW (reflink)', 'CoW (reflink)'),
'verify_missing_file': (' ❌ {}: missing {}', ' ❌ {}: brakuje {}'),
'verify_sha_mismatch': (' ❌ {}: SHA256 mismatch {}', ' ❌ {}: niezgodność SHA256 {}'),
'gpg_binary_not_found': ('GPG binary not found ({})', 'Nie znaleziono binarki GPG ({})'),
'gpg_timeout': ('GPG operation timed out', 'Operacja GPG przekroczyła limit czasu'),
'audio_services_reloaded': (' ⚡ audio services reloaded for sessions: {}', ' ⚡ przeładowano usługi audio dla sesji: {}'),
'grub_fallback_label': ('Pagan Linux – fallback (plain root)', 'Pagan Linux – fallback (zwykły root)'),
'done': ('done', 'gotowe'),
'deploy_copy_failed': ('Failed to copy the deployment by any method', 'Nie udało się skopiować deploymentu żadną metodą'),
'pkg_missing_data_tar': ('missing data.tar.xz in package', 'brak data.tar.xz w pakiecie'),
'pkg_sha_mismatch': ('SHA256 mismatch: {}', 'niezgodność SHA256: {}'),
'repo_index_invalid': ("missing 'packages' list", "brak listy 'packages'"),
}
for _k, (_en, _pl) in _AUX_I18N.items():
T["en"].setdefault(_k, _en)
T["pl"].setdefault(_k, _pl)
# ── Tłumaczenia z PLIKÓW (nadpisują/rozszerzają wbudowane PL/EN) ─────────────
# Kolejność: PAG_LANG_DIR (env) → /etc/pag/lang → /usr/share/pag/lang →
# ./pag-lang obok binarki (dev). Brak plików NIE jest błędem – zostaje
# wbudowany słownik T (fallback), więc pag zawsze działa.
# Przykład pliku (pag-lang/pl.json): {"app_title": "...", "usage": "..."}.
def _load_lang_files() -> None:
# PAG_LANG_NO_FILES=1 → pomiń pliki (używane przy eksporcie --lang-extract,
# żeby wyeksportować CZYSTE wbudowane słowniki, bez starych nadpisań).
if os.environ.get("PAG_LANG_NO_FILES") == "1":
return
dirs = []
_env = os.environ.get("PAG_LANG_DIR")
if _env:
dirs.append(_env)
# __file__ bywa niedostępne, gdy moduł jest exec/frozen (np. harness
# instalacyjny) – liczymy wtedy od ścieżki programu, zamiast wywalać
# NameError przy samym imporcie.
_self = globals().get("__file__") or sys.argv[0] or "pag"
dirs += ["/etc/pag/lang", "/usr/share/pag/lang",
os.path.join(os.path.dirname(os.path.abspath(_self)), "pag-lang")]
for _d in dirs:
for _code in list(T.keys()) + ["pl", "en", "de"]:
_p = os.path.join(_d, f"{_code}.json")
try:
with open(_p, "r", encoding="utf-8") as _fh:
_data = json.load(_fh)
if isinstance(_data, dict):
# Merge (nie replace): klucze nieobecne w pliku zachowują
# wbudowane tłumaczenie. Puste wartości pomijamy, żeby
# niekompletny/uszkodzony plik nie wyczyścił komunikatu.
_clean = {str(k): str(v) for k, v in _data.items()
if str(v).strip()}
T.setdefault(_code, {}).update(_clean)
except (OSError, ValueError):
continue
_load_lang_files()
def _(key: str, *args, **kwargs) -> str:
"""Tłumaczy klucz i formatuje argumenty.
Dla LANG=pl preferuje wariant „<key>_pl” (np. komunikaty bezpieczeństwa
mają krótkie wersje PL obok bazy EN), potem zwykły klucz, potem EN/klicz.
"""
if LANG == "pl":
_pl = T.get("pl", {})
msg = _pl.get(key + "_pl") or _pl.get(key) or T["en"].get(key, key)
else:
msg = T.get(LANG, T["en"]).get(key, T["en"].get(key, key))
if args or kwargs:
return msg.format(*args, **kwargs)
return msg
def _ask_confirm() -> bool:
"""Pytanie potwierdzające (T/n). PAG_YES=1 → zawsze tak.
EOF/brak terminala (stdin zamknięty, np. ssh bez TTY, cron, subprocess
panelu webowego) → NIE – anuluj, nie wykonuj operacji bez potwierdzenia
(inaczej input() rzuca EOFError i pag pada tracebackiem).
Enter → tak (domyślne Y/n).
"""
if os.environ.get("PAG_YES", "") == "1":
print(_("continue_q") + " t (--yes)")
return True
try:
ans = input(_("continue_q")).strip().lower()
except (EOFError, KeyboardInterrupt):
print(f"\n ⚠ {_('no_tty')}")
return False
return not ans or ans in ("t", "y")
# =============================================================================
# ŚCIEŻKI
# =============================================================================
PAG_ROOT = os.environ.get("PAG_ROOT", "/")
PAG_DB = "/var/lib/pag"
PAG_CACHE = "/var/cache/pag"
PAG_CONF = "/etc/pag"
REPO_CACHE = "/var/cache/pag/repos"
REPOS_CONF = "/etc/pag/repos.conf"
REPOS_DIR = PAG_CONF + "/repos" # drop-in: /etc/pag/repos/<nazwa>.conf
INSTALLED_DB = "/var/lib/pag/installed.json"
FILES_DB_SQL = "/var/lib/pag/files.db" # SQLite!
WORLD_FILE = "/var/lib/pag/world"
PINNED_FILE = "/var/lib/pag/pinned.json"
HISTORY_FILE = "/var/lib/pag/history.json"
LOCK_FILE = "/var/lib/pag/pag.lock"
STAGING_DIR = "/.pag_staging" # na tej samej partycji co / (unikamy EXDEV)
PKG_EXT = ".pag"
REPO_CACHE_TTL = 3600
MAX_PKG_SIZE = 2 * 1024 * 1024 * 1024 # 2 GB – maksymalny rozmiar paczki
BASE_MANIFEST = "/usr/share/pag/base.json" # baza z obrazu ISO (pag base/adopt)
# ── UPRZYWILEJOWANE PLIKI ────────────────────────────────────────────────────
# Domyślnie pag zdejmuje bit SUID i wymusza właściciela root:root. Niektóre
# programy MUSZĄ jednak zachować setuid/setgid albo grupę inną niż root
# (/usr/bin/sudo, /usr/bin/passwd, /usr/bin/unix_chkpwd,
# /usr/lib/dbus-daemon-launch-helper). Bez tego tracą możliwość działania
# po aktualizacji przez pag (np. użytkownik nie zmieni hasła).
#
# Bezpieczeństwo: zawartość pakietu jest uwierzytelniona (podpis GPG repo +
# przypięty fingerprint + SHA256 całego pakietu), więc metadane w nim są
# zaufane tak samo jak same pliki. Zachowujemy uprawnienia WYŁĄCZNIE dla
# ścieżek z tej listy (albo z pola `privileged:` receptury, które pagbuild
# zapisuje w metadata.json).
PRIVILEGED_PATHS = frozenset({
"/usr/bin/cdda2wav", "/usr/bin/cdrecord",
"/usr/bin/chage", "/usr/bin/expiry",
"/usr/bin/fcrondyn", "/usr/bin/fcronsighup", "/usr/bin/fcrontab",
"/usr/bin/firejail", "/usr/bin/fping",
"/usr/bin/fusermount", "/usr/bin/fusermount3",
"/usr/bin/gpasswd", "/usr/bin/ksu", "/usr/bin/lockfile",
"/usr/bin/mount", "/usr/bin/mount.nfs",
"/usr/bin/newgidmap", "/usr/bin/newuidmap",
"/usr/bin/passwd", "/usr/bin/ping", "/usr/bin/ping6",
"/usr/bin/procmail", "/usr/bin/readcd", "/usr/bin/rscsi",
"/usr/bin/screen", "/usr/bin/screen-5.0.2",
"/usr/bin/sg", "/usr/bin/su", "/usr/bin/sudo", "/usr/bin/traceroute",
"/usr/bin/umount", "/usr/bin/unix_chkpwd", "/usr/bin/wall",
"/usr/lib/dbus-daemon-launch-helper",
"/usr/lib/httpd/suexec",
"/usr/lib/utempter/utempter",
"/usr/lib/xscreensaver/xscreensaver-auth",
"/usr/libexec/libgtop_server2",
"/usr/libexec/qemu-bridge-helper",
"/usr/libexec/ssh-keysign",
"/usr/libexec/xf86-video-intel-backlight-helper",
"/opt/google/chrome/chrome-sandbox",
"/opt/gitkraken/chrome-sandbox",
"/opt/VirtualBox/VBoxHeadless", "/opt/VirtualBox/VBoxNetAdpCtl",
"/opt/VirtualBox/VBoxNetDHCP", "/opt/VirtualBox/VBoxVolInfo",
"/opt/VirtualBox/VirtualBoxVM",
})
ALLOWED_PKG_RE = re.compile(r'^[a-zA-Z0-9][a-zA-Z0-9._+@-]*$')
# Bezpieczeństwo / audyt
AUDIT_LOG = "/var/log/pag/audit.log" # dziennik operacji krytycznych (hooki, self-update)
TRUST_DB = "/etc/pag/trusted.json" # mapa repo_url → fingerprint klucza podpisującego
HOOK_API_VERSION = "1" # wersjonowane API hooków (env PKG_HOOK_API)
# =============================================================================
# IMMUTABLE OS – DEPLOYMENTY
# =============================================================================
# Model: zamiast mutować /, każda operacja tworzy NOWY deployment.
# /var, /etc, /home są współdzielone między deploymentami.
#
# STRUKTURA:
# /.deployments/
# active → 20260723T120000 (symlink do aktywnego)
# 20260723T120000/
# usr/ bin/ lib/ lib64/ ... (pełny system)
# var → /var (symlink do współdzielonego)
# etc → /etc
# home → /home
# ...
#
# Jak to działa:
# 1. pag install → kopiuje active → nowy deployment + nakłada zmiany → switch symlinka
# 2. pag remove → kopiuje active → nowy deployment - usuwa pliki → switch symlinka
# 3. pag deploy-rollback → przełącza active symlink na poprzedni deployment
# 4. Przy starcie systemu: initrd montuje /.deployments/active jako /
# =============================================================================
DEPLOYMENTS_DIR = "/.deployments"
ACTIVE_LINK = "/.deployments/active"
DEPLOYMENTS_DB = "/var/lib/pag/deployments.json"
# Snapshoty systemu (CoW). Na btrfs każdy snapshot jest osobnym subwolumenem,
# więc zajmuje tylko zmienione bloki, a GRUB potrafi uruchomić system z wybranej
# migawki (rootflags=subvol=...). Na ext4/xfs nie ma snapshotów CoW – zostaje
# atomowy staging + backup nadpisywanych plików.
SNAPSHOTS_DIR = "/.pag_snapshots"
SNAPSHOTS_DB = "/var/lib/pag/snapshots.json"
GRUB_SNAPSHOT_SCRIPT = "/etc/grub.d/40_pagan_snapshots"
# Ścieżki współdzielone – NIE wchodzą do deploymentu (są symlinkami do /...)
SHARED_PATHS = {
"/var", "/etc", "/home", "/root", "/tmp", "/run",
"/dev", "/proc", "/sys", "/mnt", "/media", "/srv",
# /boot współdzielone: jądro + initramfs są wspólne dla wszystkich
# deploymentów (inaczej każdy trzyma własną ~50-100 MB kopię). GRUB
# wskazuje na /.deployments/<id>/boot → symlink do /boot.
"/boot",
"/.deployments", "/.pag_staging",
}
def _is_shared_path(rel: str) -> bool:
"""Sprawdza czy ścieżka należy do katalogów współdzielonych (poza deploymentem)."""
for sp in SHARED_PATHS:
if rel == sp or rel.startswith(sp + "/"):
return True
return False
def _is_config_path(rel: str) -> bool:
"""Czy ścieżka to plik konfiguracyjny (/etc/...)?
Dla takich plików stosujemy .pacnew/.pacsave (zachowanie zmian użytkownika)
zamiast bezwarunkowego nadpisania/usunięcia."""
p = rel.lstrip("/")
return p == "etc" or p.startswith("etc/")
# Wrażliwa konfiguracja auth/systemowa – NIGDY nie nadpisujemy jej po cichu.
# Nadpisanie /etc/pam.d/system-* przez pakiet (np. shadow) potrafi zablokować
# logowanie/sudo („account validation failure”); dla tych ścieżek zawsze robimy
# .pacnew, gdy treść na dysku różni się od tej z pakietu.
_SENSITIVE_CONFIG_RE = re.compile(
r'^(pam\.d/|security/|sudoers$|sudoers\.d/|shadow$|gshadow$|passwd$|group$|'
r'login\.defs$|nsswitch\.conf$|default/useradd$)')
def _is_sensitive_config(rel: str) -> bool:
"""Czy rel to wrażliwy plik /etc (PAM, sudoers, shadow, login.defs…)?"""
p = rel.lstrip("/")
if not p.startswith("etc/"):
return False
return bool(_SENSITIVE_CONFIG_RE.match(p[4:]))
def _get_deployment_root() -> str:
"""Zwraca ścieżkę do aktywnego deploymentu, lub PAG_ROOT jeśli tryb niemutowalny wyłączony."""
if os.environ.get("PAG_IMMUTABLE", "") in ("0", "no", "false", ""):
return PAG_ROOT
if os.path.islink(ACTIVE_LINK):
return os.readlink(ACTIVE_LINK)
if os.path.isdir(ACTIVE_LINK):
return ACTIVE_LINK
# Brak deploymentów – użyj /
return PAG_ROOT
def _load_deployments() -> List[dict]:
"""Wczytuje historię deploymentów."""
if not os.path.exists(DEPLOYMENTS_DB):
return []
try:
return json.load(open(DEPLOYMENTS_DB))
except Exception:
return []
def _save_deployments(deployments: List[dict]):
os.makedirs(os.path.dirname(DEPLOYMENTS_DB), exist_ok=True)
json.dump(deployments, open(DEPLOYMENTS_DB, "w"), indent=2)
def _create_deployment(pkg_names: List[str], action: str) -> Tuple[str, str]:
"""
Tworzy nowy deployment przez skopiowanie aktywnego (CoW) i zwraca jego ścieżkę.
Zwraca (deployment_dir, deployment_id).
"""
deploy_id = datetime.now().strftime("%Y%m%dT%H%M%S")
deploy_dir = os.path.join(DEPLOYMENTS_DIR, deploy_id)
os.makedirs(DEPLOYMENTS_DIR, exist_ok=True)
active = _get_deployment_root()
if os.path.isdir(active) and active != PAG_ROOT:
# Trójstopniowa strategia kopiowania deploymentu:
# 1. reflink (CoW – btrfs, xfs) → 0 MB kopiowane
# 2. hardlink (linki twarde) → 0 MB kopiowane, tylko inody
# 3. zwykłe cp (ostateczność) → pełna kopia
print(_(' ⚡ Copying the active deployment...'))
copied = False
for method, cmd, label in [
("reflink", ["cp", "--reflink=auto", "-a", active + "/.", deploy_dir + "/"], _("reflink_method")),
("hardlink", ["cp", "-al", active + "/.", deploy_dir + "/"], _("hardlink_method")),
("copy", ["cp", "-a", active + "/.", deploy_dir + "/"], _("copy_method")),
]:
try:
subprocess.run(cmd, check=True, timeout=600, capture_output=True)
print(_(' ✅ Deployment: {arg1} ({arg2})', arg1=(deploy_id), arg2=(label)))
copied = True
break
except subprocess.CalledProcessError:
if method == "copy":
raise # ostatnia deska – niech leci wyjątek
continue
if not copied:
raise RuntimeError(_("deploy_copy_failed"))
else:
# Pierwszy deployment – tylko katalogi szkieletowe
# /boot celowo POMINIĘTE – jest współdzielone (SHARED_PATHS); poniższa
# pętla utworzy w deploymencie symlink boot → /boot.
for d in ["/usr", "/lib", "/lib64", "/bin", "/sbin", "/opt"]:
if os.path.isdir(d):
dest = os.path.join(deploy_dir, d.lstrip("/"))
os.makedirs(dest, exist_ok=True)
print(_(' ✅ First deployment: {arg1}', arg1=(deploy_id)))
# Utwórz symlinki do współdzielonych katalogów
for sp in SHARED_PATHS:
link_dst = os.path.join(deploy_dir, sp.lstrip("/"))
if not os.path.lexists(link_dst) and os.path.isdir(sp):
os.symlink(sp, link_dst)
# Zapisz w bazie deploymentów
deployments = _load_deployments()
deployments.append({
"id": deploy_id,
"action": action,
"packages": pkg_names,
"timestamp": datetime.now().isoformat(),
"active": True,
})
# Oznacz poprzednie jako nieaktywne
for d in deployments[:-1]:
d["active"] = False
_save_deployments(deployments)
return deploy_dir, deploy_id
def _switch_deployment(deploy_dir: str) -> bool:
"""Atomowo przełącza aktywny deployment przez podmianę symlinka."""
tmp_link = ACTIVE_LINK + ".new"
if os.path.lexists(tmp_link):
os.remove(tmp_link)
os.symlink(deploy_dir, tmp_link)
os.rename(tmp_link, ACTIVE_LINK) # atomowe na tym samym FS
return True
# =============================================================================
# SNAPSHOTY SYSTEMU (CoW – btrfs)
# =============================================================================
# Snapshot powstaje PRZED transakcją. Na btrfs to subwolumen (kilka KB
# metadanych, reszta to współdzielone bloki), więc nie kopiujemy całego
# systemu. Wpis GRUB pozwala uruchomić system z wybranej migawki.
# Na ext4/xfs nie ma CoW – instalacja nadal jest atomowa dzięki stagingowi,
# a rollback opiera się na backupie nadpisywanych plików.
def _btrfs_bin() -> str:
"""Ścieżka do btrfs (PATH bywa okrojony w chroocie/instalatorze)."""
found = shutil.which("btrfs")
if found:
return found
for cand in ("/usr/bin/btrfs", "/usr/sbin/btrfs", "/sbin/btrfs", "/bin/btrfs"):
if os.path.exists(cand):
return cand
return ""
def _root_fstype() -> str:
try:
r = subprocess.run(["findmnt", "-n", "-o", "FSTYPE", "/"],
capture_output=True, text=True, timeout=5)
fs = r.stdout.strip().splitlines()[0].strip() if r.stdout.strip() else ""
if fs:
return fs
except Exception:
pass
try:
r = subprocess.run(["stat", "-f", "-c", "%T", "/"],
capture_output=True, text=True, timeout=5)
return r.stdout.strip()
except Exception:
return ""
def _btrfs_root_path() -> str:
"""Ścieżka aktywnego subwolumenu root względem top-level btrfs."""
btrfs = _btrfs_bin()
if btrfs:
try:
r = subprocess.run([btrfs, "subvolume", "show", "/"],
capture_output=True, text=True, timeout=5)
if r.returncode == 0:
for line in r.stdout.splitlines():
line = line.strip()
if line.lower().startswith("path:"):
p = line.split(":", 1)[1].strip()
if p in ("", "/"):
return "/"
return p.strip("/")
except Exception:
pass
try:
r = subprocess.run(["findmnt", "-n", "-o", "FSROOT", "/"],
capture_output=True, text=True, timeout=5)
p = r.stdout.strip()
if p and p != "/":
return p.strip("/")
except Exception:
pass
return "/"
def _snapshot_support() -> Tuple[bool, str]:
fs = _root_fstype()
if fs != "btrfs":
return False, (f"root jest na {fs or 'nieznanym systemie plików'} – "
f"snapshoty CoW wymagają btrfs")
if not _btrfs_bin():
return False, "brak narzędzia btrfs (zainstaluj pakiet btrfs-progs)"
return True, ""
def _load_snapshots() -> List[dict]:
if not os.path.exists(SNAPSHOTS_DB):
return []
try:
data = load_json(SNAPSHOTS_DB)
return data if isinstance(data, list) else []
except Exception:
return []
def _save_snapshots(items: List[dict]):
os.makedirs(os.path.dirname(SNAPSHOTS_DB), exist_ok=True)
save_json(SNAPSHOTS_DB, items)
def _snapshot_label(snap: dict) -> str:
"""Czytelna etykieta GRUB (bez znaków, które psują menu)."""
pkgs = list(snap.get("packages") or [])
p = ", ".join(pkgs[:3])
if len(pkgs) > 3:
p += f" +{len(pkgs) - 3}"
base = f"Pagan Linux snapshot {snap.get('id', '?')}"
if snap.get("label"):
base += f" - {snap['label']}"
if p:
base += f" - {p}"
# GRUB: usuń apostrofy i znaki kontrolne.
return re.sub(r"[\x00-\x1f']", "", base)[:120]
def _root_boot_arg() -> str:
"""`root=UUID=...` dla wpisu GRUB (stabilne po zmianie nazw urządzeń)."""
dev = _detect_root_device()
if not dev:
return ""
if dev.startswith(("UUID=", "PARTUUID=", "LABEL=", "PARTLABEL=")):
return f" root={dev}"
uuid = ""
try:
r = subprocess.run(["blkid", "-s", "UUID", "-o", "value", dev],
capture_output=True, text=True, timeout=5)
uuid = r.stdout.strip().splitlines()[0].strip() if r.stdout.strip() else ""
except Exception:
uuid = ""
return f" root=UUID={uuid}" if uuid else f" root={dev}"
def _initrd_for_kernel(boot_dir: str, kernel: str) -> str:
"""Nazwa initramfs pasująca do jądra (initramfs.img / initramfs-<ver>.img…)."""
if not kernel or not os.path.isdir(boot_dir):
return ""
ver = kernel[len("vmlinuz-"):] if kernel.startswith("vmlinuz-") else ""
candidates = []
if ver:
candidates += [f"initramfs-{ver}.img", f"initrd.img-{ver}"]
candidates += ["initramfs.img", "initrd.img"]
for c in candidates:
if os.path.isfile(os.path.join(boot_dir, c)):
return c
for f in sorted(os.listdir(boot_dir)):
if f.startswith(("initramfs", "initrd")):
return f
return ""
def _pick_kernel_initrd(boot_dir: str) -> Tuple[str, str]:
kernels = sorted(
[f for f in os.listdir(boot_dir) if f.startswith("vmlinuz-")],
reverse=True,
) if os.path.isdir(boot_dir) else []
if not kernels:
return "", ""
k = kernels[0]
return k, _initrd_for_kernel(boot_dir, k)
def _grub_snapshot_entries() -> List[str]:
"""Wpisy menu GRUB dla snapshotów (dla `_update_grub_config` i grub.d)."""
snaps = _load_snapshots()
if not snaps:
return []
root_arg = _root_boot_arg()
try:
separate_boot = os.path.isdir("/boot") and os.path.ismount("/boot")
except OSError:
separate_boot = False
bp = _boot_prefix()
lines: List[str] = []
for snap in reversed(snaps):
path = snap.get("path") or ""
if not path or not os.path.isdir(path):
continue
if separate_boot:
# Osobne /boot jest współdzielone: użyj jądra ZAPISANEGO przy
# tworzeniu snapshotu (o ile nadal leży w /boot), a nie zawsze
# najnowszego – nowe jądro mogło być właśnie przyczyną problemu.
kname = snap.get("kernel") or ""
if not kname or not os.path.isfile(os.path.join("/boot", kname)):
kname, _ = _pick_kernel_initrd("/boot")
iname = _initrd_for_kernel("/boot", kname) if kname else ""
kernel = f"{bp}/{kname}" if kname else ""
initrd = f"{bp}/{iname}" if iname else ""
else:
snap_boot = os.path.join(path, "boot")
kname, iname = _pick_kernel_initrd(snap_boot)
# Kopia zapasowa: jądro z bieżącego /boot (np. gdy /boot nie
# było częścią snapshotu lub jest to bardzo stara migawka).
if not kname:
kname, iname = _pick_kernel_initrd("/boot")
kernel = f"{bp}/{kname}" if kname else ""
initrd = f"{bp}/{iname}" if iname else ""
else:
kernel = f"{path}/boot/{kname}"
initrd = f"{path}/boot/{iname}" if iname else ""
if not kernel:
continue
subvol = snap.get("subvol") or ""
flags = f" rootflags=subvol={subvol} rootfstype=btrfs" if subvol else ""
label = _snapshot_label(snap)
lines.append(f"menuentry '{label}' --class pagan --class gnu-linux --class os {{")
lines.append(f" linux {kernel}{root_arg}{flags} rw quiet")
if initrd:
lines.append(f" initrd {initrd}")
lines.append("}")
lines.append("")
return lines
def _ensure_snapshot_grub_script() -> bool:
"""Instaluje /etc/grub.d/40_pagan_snapshots (integracja z grub-mkconfig)."""
if not os.path.isdir("/etc/grub.d"):
return False
# Preferuj BIEŻĄCĄ binarkę (np. testy z repo), a nie starszy /usr/bin/pag:
# stary pag nie zna `snapshot-grub` i uruchomiłby smart-search.
_self = os.path.abspath(sys.argv[0]) if sys.argv[0] else ""
exe = _self if _self and os.path.isfile(_self) else (shutil.which("pag") or "/usr/bin/pag")
if not exe or not os.path.exists(exe):
exe = "/usr/bin/pag"
quoted = exe.replace("'", "'\\''")
script = (
"#!/bin/sh\n"
"# Pagan Linux – wpisy GRUB dla snapshotów systemu (wygenerowane przez pag)\n"
"# Usuń ten plik, aby ukryć snapshoty w menu GRUB.\n"
f"PAG_BIN='{quoted}'\n"
'if [ ! -x "$PAG_BIN" ]; then\n'
' PAG_BIN="$(command -v pag 2>/dev/null || true)"\n'
"fi\n"
'[ -x "$PAG_BIN" ] || exit 0\n'
'# Tylko pag >= 4.1 zna komendę snapshot-grub (starszy zrobiłby\n'
'# smart-search i mógłby zawiesić grub-mkconfig na sieci).\n'
'case "$("$PAG_BIN" --version 2>/dev/null)" in\n'
' "pag 4."[1-9]*|"pag "[5-9]*|"pag "[1-9][0-9]*) ;;\n'
' *) exit 0 ;;\n'
'esac\n'
'exec "$PAG_BIN" snapshot-grub\n'
)
try:
with open(GRUB_SNAPSHOT_SCRIPT, "w", encoding="utf-8") as fh:
fh.write(script)
os.chmod(GRUB_SNAPSHOT_SCRIPT, 0o755)
return True
except OSError:
return False
def _create_system_snapshot(packages: List[str], action: str,
label: str = "") -> Optional[dict]:
"""Tworzy snapshot root (btrfs) i zapisuje go w bazie.
Zwraca dict snapshotu albo None. Nie przerywa instalacji – o tym decyduje
wywołujący (tryb --snapshot wymaga sukcesu, tryb auto tylko ostrzega).
"""
ok, why = _snapshot_support()
if not ok:
return None
btrfs = _btrfs_bin()
try:
os.makedirs(SNAPSHOTS_DIR, exist_ok=True)
except OSError as e:
print(_(' ⚠ Cannot create {arg1}: {arg2}', arg1=(SNAPSHOTS_DIR), arg2=(e)), file=sys.stderr)
return None
base_id = datetime.now().strftime("%Y%m%dT%H%M%S")
snap_id = base_id
n = 1
while os.path.lexists(os.path.join(SNAPSHOTS_DIR, snap_id)):
snap_id = f"{base_id}-{n}"
n += 1
snap_path = os.path.join(SNAPSHOTS_DIR, snap_id)
try:
r = subprocess.run([btrfs, "subvolume", "snapshot", "/", snap_path],
capture_output=True, text=True, timeout=600)
except Exception as e:
print(_(' ⚠ Failed to create snapshot: {arg1}', arg1=(e)), file=sys.stderr)
return None
if r.returncode != 0:
msg = (r.stderr or r.stdout or "").strip().splitlines()
print(_(' ⚠ btrfs snapshot failed: {arg1}', arg1=(msg[-1] if msg else r.returncode)),
file=sys.stderr)
return None
rootp = _btrfs_root_path()
if rootp in ("", "/"):
subvol = f"/.pag_snapshots/{snap_id}"
else:
subvol = f"{rootp}/.pag_snapshots/{snap_id}"
# Zapamiętaj jądro/initramfs z chwili snapshotu – przy osobnym /boot
# dzięki temu uruchomimy migawkę ze STARYM (działającym) jądrem.
_kn, _ir = _pick_kernel_initrd("/boot")
snap = {
"id": snap_id,
"path": snap_path,
"subvol": subvol,
"created": datetime.now().isoformat(),
"action": action,
"label": label,
"packages": list(packages)[:100],
"kernel": _kn,
"initrd": _ir,
}
items = _load_snapshots()
items.append(snap)
_save_snapshots(items)
_ensure_snapshot_grub_script()
print(_(' 📸 System snapshot: {arg1} (subvol={arg2})', arg1=(snap_id), arg2=(subvol)))
return snap
def _find_snapshot(snap_id: str) -> Optional[dict]:
items = _load_snapshots()
if not snap_id:
return items[-1] if items else None
for s in items:
if s.get("id") == snap_id:
return s
for s in items:
if str(s.get("id", "")).startswith(snap_id):
return s
return None
def cmd_snapshot_list():
items = _load_snapshots()
if not items:
print(_("snapshot_none"))
return 0
print(_("snapshot_list", len(items)))
for s in reversed(items):
pkgs = list(s.get("packages") or [])
listed = ", ".join(pkgs[:4])
if len(pkgs) > 4:
listed += f" +{len(pkgs) - 4}"
print(f" {s.get('id', '?')} [{_action_label(s.get('action', ''))}]")
if listed:
print(f" {listed}")
print(f" {s.get('created', '')}")
print(f" {s.get('path', '')}")
return 0
def cmd_snapshot_grub():
"""Wypisuje menuentry dla grub-mkconfig (wywoływane z 40_pagan_snapshots)."""
for line in _grub_snapshot_entries():
print(line)
return 0
def cmd_snapshot_create(label: str = ""):
ok, why = _snapshot_support()
if not ok:
print(f" ❌ {_('snapshot_unsupported', why)}")
return 1
snap = _create_system_snapshot([], "manual", label=label)
if not snap:
return 1
_ensure_snapshot_grub_script()
_refresh_bootloader()
print(f" ✅ {_('snapshot_created', snap['id'])}")
return 0
def cmd_snapshot_delete(snap_id: str):
snap = _find_snapshot(snap_id)
if not snap:
print(f" ❌ {_('snapshot_not_found', snap_id)}")
return 1
path = snap.get("path") or ""
if not path.startswith(SNAPSHOTS_DIR + "/"):
print(_(' ❌ Invalid snapshot path – refusing to delete.'))
return 1
if os.path.isdir(path):
btrfs = _btrfs_bin()
if not btrfs:
print(f" ❌ {_('snapshot_unsupported', 'brak btrfs')}")
return 1
r = subprocess.run([btrfs, "subvolume", "delete", path],
capture_output=True, text=True, timeout=120)
if r.returncode != 0:
print(f" ❌ btrfs: {(r.stderr or '').strip()[:200]}")
return 1
_save_snapshots([s for s in _load_snapshots() if s.get("id") != snap.get("id")])
_refresh_bootloader()
print(f" ✅ {_('snapshot_deleted', snap.get('id', ''))}")
return 0
def cmd_snapshot_rollback(snap_id: str = ""):
"""Ustawia snapshot jako następny start (albo pokazuje wybór w GRUB)."""
snap = _find_snapshot(snap_id)
if not snap:
print(f" ❌ {_('snapshot_not_found', snap_id or '(brak)' )}")
return 1
if not os.path.isdir(snap.get("path") or ""):
print(f" ❌ {_('snapshot_not_found', snap.get('id', ''))}")
return 1
label = _snapshot_label(snap)
print(_(' ⏪ Snapshot: {arg1}', arg1=(snap.get('id', ''))))
print(f" {snap.get('created', '')}")
pkgs = list(snap.get("packages") or [])
if pkgs:
print(f" {', '.join(pkgs[:8])}{' …' if len(pkgs) > 8 else ''}")
if not _ask_confirm():
return 0
_ensure_snapshot_grub_script()
_refresh_bootloader()
grub_reboot = shutil.which("grub-reboot") or shutil.which("grub2-reboot")
if grub_reboot:
r = subprocess.run([grub_reboot, label], capture_output=True, text=True)
if r.returncode == 0:
print(f" ✅ {_('snapshot_rollback_next', label)}")
print(_(' 💡 Reboot the system – GRUB will boot the selected snapshot.'))
return 0
print(f" ℹ {_('snapshot_rollback_hint', label)}")
print(_(' 💡 At boot, choose an entry in the GRUB menu (snapshots section).'))
return 0
DEFAULT_REPOS = [
"https://repo.paganlinux.eu/stable/",
]
# =============================================================================
# INICJALIZACJA
# =============================================================================
def _require_dir(d: str) -> None:
"""Utwórz katalog, a przy istniejącej NIE-katalogowej ścieżce podaj powód.
`os.makedirs(..., exist_ok=True)` nie wystarcza: gdy `mkdir` zwróci EEXIST,
Python sprawdza `os.path.isdir(path)`, a dla MARTWEGO dowiązania to False –
wyjątek leci dalej. Objaw: `pag update` kończył się tracebackiem
`FileExistsError: /var/cache/pag -> /home/pagan-build/cache-pag` (cel
dowiązania został skasowany).
"""
try:
os.makedirs(d, exist_ok=True)
return
except FileExistsError:
pass
except OSError as e:
print(f"❌ Nie mogę utworzyć {d}: {e}")
sys.exit(1)
if os.path.islink(d) and not os.path.exists(d):
print(f"❌ {d} jest martwym dowiązaniem → {os.readlink(d)}")
print(f" Usuń dowiązanie (rm {d}) albo utwórz katalog docelowy.")
else:
print(f"❌ {d} istnieje, ale nie jest katalogiem.")
sys.exit(1)
def ensure_dirs():
for d in [PAG_DB, PAG_CACHE, PAG_CONF, REPO_CACHE, REPOS_DIR, STAGING_DIR, DEPLOYMENTS_DIR]:
_require_dir(d)
for f, default in [
(REPOS_CONF, "\n".join(DEFAULT_REPOS) + "\n"),
(INSTALLED_DB, "{}"),
(PINNED_FILE, "{}"),
(HISTORY_FILE, "[]"),
]:
if not os.path.exists(f):
with open(f, "w") as fh: fh.write(default)
if not os.path.exists(WORLD_FILE):
Path(WORLD_FILE).touch()
if not os.path.exists(GPG_HOME):
os.makedirs(GPG_HOME, exist_ok=True)
os.chmod(GPG_HOME, 0o700)
_gpg_run("--list-keys", capture_output=True)
# Inicjalizuj SQLite
_db_init()
# Wyczyść staging po poprzednim przerwanym buildzie/instalacji
if os.path.isdir(STAGING_DIR):
for entry in os.listdir(STAGING_DIR):
if entry == "backups":
continue # backupy starych wersji – potrzebne do `pag rollback`
path = os.path.join(STAGING_DIR, entry)
try:
if os.path.isfile(path) or os.path.islink(path):
os.unlink(path)
elif os.path.isdir(path):
shutil.rmtree(path, ignore_errors=True)
except OSError:
pass
# =============================================================================
# SQLITE – BAZA PLIKÓW (poprawne zarządzanie połączeniami)
# =============================================================================
from contextlib import contextmanager
@contextmanager
def _db_session(readonly: Optional[bool] = None):
"""Context manager – gwarantuje zamknięcie połączenia.
Gdy katalog bazy nie jest zapisywalny (np. komenda read-only uruchomiona
jako zwykły user), otwieramy połączenie w trybie read-only. Inaczej
`PRAGMA journal_mode=WAL` próbuje pisać i kończy się błędem
„attempt to write a readonly database” zamiast zwrócić wynik.
"""
if readonly is None:
readonly = not os.access(os.path.dirname(FILES_DB_SQL) or ".", os.W_OK)
if readonly:
# Katalog bazy nie jest zapisywalny (np. komenda read-only uruchomiona
# jako zwykły user). Baza jest w trybie WAL, więc SQLite przy `mode=ro`
# próbuje utworzyć plik `-shm` w katalogu – bez prawa zapisu kończy się
# to błędem „attempt to write a readonly database” nawet przy SELECT.
# Dlatego próbujemy zwykłego `mode=ro`, a gdy zawiedzie, otwieramy z
# `immutable=1` (SQLite pomija wtedy WAL/SHM i czyta ostatni
# checkpoint). Przy równoległym zapisie roota odczyt może być chwilowo
# nieaktualny – dla komend diagnostycznych (files/list/verify) to OK.
conn = sqlite3.connect(f"file:{FILES_DB_SQL}?mode=ro", uri=True, timeout=15)
try:
conn.execute("SELECT 1 FROM sqlite_master LIMIT 1")
except sqlite3.OperationalError:
conn.close()
conn = sqlite3.connect(
f"file:{FILES_DB_SQL}?mode=ro&immutable=1", uri=True, timeout=15)
else:
conn = sqlite3.connect(FILES_DB_SQL, timeout=15)
conn.execute("PRAGMA journal_mode=WAL")
conn.execute("PRAGMA synchronous=NORMAL")
conn.execute("PRAGMA foreign_keys=ON")
conn.execute("PRAGMA busy_timeout=15000")
conn.row_factory = sqlite3.Row
try:
yield conn
if not readonly:
conn.commit()
except Exception:
if not readonly:
conn.rollback()
raise
finally:
conn.close()
def _db_init():
"""Tworzy tabele SQLite jeśli nie istnieją."""
with _db_session() as db:
db.execute("""
CREATE TABLE IF NOT EXISTS files (
id INTEGER PRIMARY KEY AUTOINCREMENT,
path TEXT NOT NULL,
package TEXT NOT NULL,
sha256 TEXT,
size INTEGER,
is_symlink INTEGER DEFAULT 0,
symlink_target TEXT,
UNIQUE(path, package)
)
""")
db.execute("CREATE INDEX IF NOT EXISTS idx_files_path ON files(path)")
db.execute("CREATE INDEX IF NOT EXISTS idx_files_pkg ON files(package)")
db.execute("""
CREATE TABLE IF NOT EXISTS file_checksums (
path TEXT PRIMARY KEY,
sha256 TEXT NOT NULL,
installed_at TEXT
)
""")
db.commit()
def _db_record_files(pkg_name: str, files: List[dict]):
"""Zapisuje pliki do SQLite (obsługuje symlinki)."""
with _db_session() as db:
# Jawna transakcja – atomowość obu zapisów i szybsze wykrycie blokady
try:
db.execute("BEGIN IMMEDIATE")
except sqlite3.OperationalError:
pass # transakcja już otwarta (implicit)
db.executemany(
"INSERT OR REPLACE INTO files (path, package, sha256, size, is_symlink, symlink_target) "
"VALUES (?,?,?,?,?,?)",
[(f["path"], pkg_name, f.get("sha256",""), f.get("size",0),
f.get("is_symlink", 0), f.get("symlink_target", ""))
for f in files]
)
db.executemany(
"INSERT OR REPLACE INTO file_checksums (path, sha256, installed_at) VALUES (?,?,?)",
[(f["path"], f.get("sha256",""), datetime.now().isoformat())
for f in files if f.get("sha256")]
)
def _db_get_package_files(pkg_name: str) -> List[str]:
with _db_session() as db:
return [r["path"] for r in db.execute(
"SELECT DISTINCT path FROM files WHERE package=?", (pkg_name,)
)]
def _db_get_file_owners(filepath: str) -> List[str]:
"""Zwraca listę pakietów będących właścicielami pliku."""
with _db_session() as db:
return [r["package"] for r in db.execute(
"SELECT package FROM files WHERE path=?", (filepath,)
)]
def _db_remove_package_files(pkg_name: str):
with _db_session() as db:
db.execute("DELETE FROM files WHERE package=?", (pkg_name,))
db.commit()
def _db_get_all_file_checksums() -> Dict[str, str]:
with _db_session() as db:
return {r["path"]: r["sha256"] for r in db.execute("SELECT path, sha256 FROM file_checksums")}
def _db_get_package_checksums(pkg_name: str) -> Dict[str, str]:
"""Sumy SHA256 zapisane dla plików należących do pakietu.
Używane do wykrycia, czy użytkownik zmodyfikował plik konfiguracyjny
(porównanie z sumą z chwili instalacji) – serce mechanizmu .pacnew/.pacsave.
"""
with _db_session() as db:
return {r["path"]: r["sha256"] for r in db.execute(
"SELECT fc.path AS path, fc.sha256 AS sha256 FROM file_checksums fc "
"JOIN files f ON f.path = fc.path WHERE f.package=?", (pkg_name,))}
def _db_count_files() -> int:
with _db_session() as db:
return db.execute("SELECT COUNT(*) FROM files").fetchone()[0]
# =============================================================================
# BLOKADA
# =============================================================================
class DatabaseLock:
"""Blokada plikowa (flock) – jądro zwalnia ją AUTOMATYCZNIE, gdy proces
ginie (kill -9, twardy reset). Stary PID-file miał race condition: po
śmierci pag PID mógł zostać przydzielony obcemu procesowi (PID reuse)
i pag odmawiał działania na zawsze („baza zablokowana”).
"""
def __init__(self):
self._f = None
def __enter__(self):
os.makedirs(os.path.dirname(LOCK_FILE), exist_ok=True)
self._f = open(LOCK_FILE, "w")
try:
# LOCK_NB: rzuca wyjątek zamiast czekać w nieskończoność
fcntl.flock(self._f, fcntl.LOCK_EX | fcntl.LOCK_NB)
except BlockingIOError:
print(f"❌ {_('db_locked')}", file=sys.stderr)
print(f" {_('db_lock_hint', LOCK_FILE)}", file=sys.stderr)
sys.exit(1)
self._f.write(str(os.getpid()))
self._f.flush()
return self
def __exit__(self, *args):
if self._f:
try:
fcntl.flock(self._f, fcntl.LOCK_UN)
except OSError:
pass
self._f.close()
self._f = None
# Uwaga: NIE usuwamy pliku blokady. Stały plik + flock na inode to jedyny
# bezpieczny wzorzec – os.remove(), gdy inny proces trzyma blokadę na starym
# inode, otwiera wyścig (nowy proces blokowałby nowo utworzony inode).
class SelfUpdateLock:
"""Blokada podmiany binarki pag podczas self-update.
Niezależna od DatabaseLock (inny plik) – cmd_self_update może zostać
wywołane poza globalną blokadą (np. z zewnętrznego skryptu), a dwie
równoległe aktualizacje pisałyby do tego samego `dst.new`; `os.replace`
mógłby wtedy podmienić plik w trakcie wykonywania (uszkodzony pag).
"""
def __init__(self):
self._f = None
def __enter__(self):
lock_path = LOCK_FILE + ".self-update"
os.makedirs(os.path.dirname(lock_path), exist_ok=True)
self._f = open(lock_path, "w")
try:
fcntl.flock(self._f, fcntl.LOCK_EX | fcntl.LOCK_NB)
except BlockingIOError:
self._f.close()
self._f = None
print(_('❌ Another pag update is in progress – try again later.'),
file=sys.stderr)
sys.exit(1)
self._f.write(str(os.getpid()))
self._f.flush()
return self
def __exit__(self, *args):
if self._f:
try:
fcntl.flock(self._f, fcntl.LOCK_UN)
except OSError:
pass
self._f.close()
self._f = None
# =============================================================================
# POMOCNICZE
# =============================================================================
# Katalogi systemowe. /bin, /sbin i /lib64 to na usrmerge symlinki do
# /usr/bin, /usr/bin i /usr/lib64 – bez nich pag pomijał CAŁĄ zawartość
# pakietów, które pakują pliki „starymi” ścieżkami (np. busybox: 386 plików
# w ./bin/, w tym sam ./bin/busybox → "BLOCKED: ./bin/ls" i spółka).
_ALLOWED_PREFIXES = ("/usr/", "/etc/", "/var/", "/opt/",
"/boot/", "/lib/", "/lib64/", "/run/",
"/bin/", "/sbin/", # usrmerge: bin→usr/bin, sbin→usr/bin
# Pliki wewnętrzne paczki .pkg.tar.xz
"metadata.json", "data.tar.xz", "hooks/",
"sums.json")
def _check_path_safety(name: str) -> bool:
# Normalizuj – usuń leading ./
if name.startswith("./"):
name = name[2:]
if name in (".", ""):
return True
# Porównuj z prefiksami BEZ wiodącego '/', by zarówno "/usr/bin/ls", jak i
# wewnętrzne pliki pakietu ("hooks/pre-install", "data.tar.xz") przechodziły.
norm = name.lstrip("/")
for prefix in _ALLOWED_PREFIXES:
p = prefix.lstrip("/").rstrip("/")
if norm == p or norm.startswith(p + "/"):
return True
return False
def _validate_pkg_name(name):
return bool(ALLOWED_PKG_RE.match(name))
def _audit(msg):
from datetime import datetime, timezone
os.makedirs(os.path.dirname(AUDIT_LOG), exist_ok=True)
with open(AUDIT_LOG, "a") as f:
f.write(datetime.now(timezone.utc).isoformat() + " " + msg + "\n")
def _strip_suid(path):
try:
st = os.stat(path)
if st.st_mode & 0o4000:
os.chmod(path, st.st_mode & ~0o4000)
print(f" {_("sec_suid", path=path)}")
except OSError:
pass
def _check_downgrade(pkg_name, new_ver, installed_db):
if pkg_name in installed_db:
old = installed_db[pkg_name].get("version", "0")
if new_ver < old:
print(f" {_("sec_downgrade", pkg=pkg_name, new=new_ver, old=old)}")
return False
return True
def _safe_extractall(tar: tarfile.TarFile, dest: str, *, preserve_perms: bool = True,
privileged=frozenset()):
"""
Bezpieczne rozpakowanie archiwum tar z ochroną przed Directory Traversal.
Działa na Python < 3.12 (gdzie parametr 'filter' w extractall nie istnieje)
oraz na Python 3.12+. W przeciwieństwie do filtra 'data' z Pythona 3.12,
zachowuje bity uprawnień POSIX (SUID, SGID, sticky) – preserve_perms=True.
Ochrona oparta jest na FINALNEJ ścieżce (os.path.realpath), nie tylko na
prostym sprawdzaniu stringa:
- Blokuje ścieżki absolutne i z '..' (path traversal)
- Blokuje symlinki/hardlinki, których cel wychodzi poza dest
- Blokuje zapis "przez" złośliwy symlink, który został wcześniej
rozpakowany (np. katalog → /etc, potem zapis katalog/plik)
- Zachowuje oryginalne uprawnienia plików
"""
dest_real = os.path.realpath(dest)
os.makedirs(dest_real, exist_ok=True)
def _target_within(path: str) -> bool:
try:
return os.path.commonpath([dest_real, os.path.realpath(path)]) == dest_real
except ValueError:
# różne napędy / ścieżki nie da się wspólnie porównać → odrzuć
return False
for member in tar.getmembers():
name = member.name
# --- Ochrona przed Directory Traversal (szybkie string-checki) ---
if name.startswith('/'):
continue
if '..' in name.split('/'):
continue
# Zablokuj bajt NUL i backslash (bugi/obejścia tarfile na niektórych platformach)
if '\x00' in name or '\\' in name:
continue
if not _check_path_safety(name):
print(f" BLOCKED: {name}")
continue
target = os.path.join(dest, name)
# --- Ochrona na podstawie finalnej ścieżki ---
# Jeśli którykolwiek komponent nadrzędny jest (złośliwym) symlinkiem
# wskazującym poza dest, realpath to wykryje – zablokuj zapis.
if not _target_within(target):
print(f" BLOCKED (escape): {name}")
continue
# --- Ochrona dla symlinków i hardlinków ---
if member.issym() or member.islnk():
link = member.linkname
if '\x00' in link:
continue
# Link absolutny jest POPRAWNY, gdy cel jest ścieżką systemową
# (np. usr/bin/librewolf -> /usr/lib/librewolf/librewolf). Wcześniej
# odrzucaliśmy wszystkie takie linki po cichu, przez co w systemie
# brakowalo np. /usr/bin/librewolf — a wpis .desktop z TryExec nie
# pojawiał się w menu. Odrzucamy tylko cele spoza dozwolonych prefiksów.
if link.startswith('/'):
if not _check_path_safety(link):
print(f" BLOCKED (link target): {name} -> {link}")
continue
# Cel absolutny zostaje bez zmian – po instalacji wskazuje
# właściwą ścieżkę w systemie (sprawdzenie _target_within
# dotyczy ścieżki RELATYWNEJ i tutaj nie ma zastosowania).
else:
# UWAGA: '..' w relatywnym celu linku jest POPRAWNE i częste
# (np. busybox: bin/ls -> ../usr/bin/busybox). Wcześniej taki
# link byl po cichu pomijany, przez co busybox instalowal
# 3 pliki zamiast 388. Decyduje realny cel — _target_within().
link_target = os.path.join(os.path.dirname(target), link)
if not _target_within(link_target):
print(f" BLOCKED (link escape): {name} -> {link}")
continue
# Rozpakuj z zachowaniem metadanych. Python 3.12+ wymaga jawnego
# `filter=` (inaczej DeprecationWarning, a w 3.14+ błąd).
# UWAGA: 'fully_trusted' CELOWO pomija wbudowane filtry bezpieczeństwa
# Pythona – to nie przeoczenie. Nasza walidacja powyżej (path traversal,
# NUL/backslash, escape przez symlink, linki wychodzące poza dest) jest
# równoważna lub ostrzejsza, a 'fully_trusted' pozwala zachować bity
# SUID/SGID/sticky, które filtr 'data' by usunął (np. /usr/bin/sudo).
# SUID jest i tak zdejmowany przez _strip_suid() tuż po rozpakowaniu.
try:
if hasattr(tarfile, 'data_filter'):
# Python 3.12+
tar.extract(member, dest, set_attrs=preserve_perms, numeric_owner=False,
filter='fully_trusted')
else:
tar.extract(member, dest, set_attrs=preserve_perms, numeric_owner=False)
except Exception as e:
print(_(' ⚠ Failed to extract {arg1}: {arg2}', arg1=(name), arg2=(e)))
continue
# Pliki z listy uprzywilejowanej zachowują SUID/SGID; reszta jest
# czyszczona (ochrona przed SUID niespodziewanym w pakiecie).
if "/" + os.path.relpath(target, dest_real) not in privileged:
_strip_suid(target)
def _sha256_file(path: str) -> str:
"""SHA256 pliku. Na Python ≥3.11 używa hashlib.file_digest (pętla w C);
starsze wersje mają fallback z pętlą chunków."""
with open(path, "rb") as f:
if hasattr(hashlib, "file_digest"):
return hashlib.file_digest(f, "sha256").hexdigest()
h = hashlib.sha256()
for chunk in iter(lambda: f.read(65536), b""):
h.update(chunk)
return h.hexdigest()
def _split_version(v: str):
"""Rozdziela wersję na (release_parts, prerelease_parts).
Przykład: '1.2.0-rc1' → ([1,2,0], ['rc','1']).
"""
v = v.strip().lower().lstrip("v")
# build metadata po '+' jest ignorowane przy porównywaniu (semver)
v = v.split("+", 1)[0]
# prerelease po '-' lub '_' (np. 1.2.0-rc1, 1.2.0_rc1)
if "-" in v:
rel, pre = v.split("-", 1)
elif "_" in v:
rel, pre = v.split("_", 1)
else:
rel, pre = v, ""
nums = []
for part in rel.split("."):
m = re.match(r"(\d+)", part)
nums.append(int(m.group(1)) if m else 0)
pre_parts = [p for p in pre.split(".") if p]
return nums, pre_parts
def _cmp_pre(a, b):
"""Porównuje ciągi identyfikatorów prerelease (reguły semver)."""
for i in range(max(len(a), len(b))):
if i >= len(a):
return -1 # krótszy prerelease jest niższy
if i >= len(b):
return 1
ia, ib = a[i], b[i]
if ia == ib:
continue
na, nb = ia.isdigit(), ib.isdigit()
if na and nb:
return 1 if int(ia) > int(ib) else -1
if na != nb:
return -1 if na else 1 # identyfikator liczbowy < alfanumeryczny
return 1 if ia > ib else -1
return 0
def _cmp_version(a: str, b: str) -> int:
"""Porównuje dwie wersje; zwraca -1/0/1. Obsługuje prerelease (rc1, beta...)."""
a_rel, a_pre = _split_version(a)
b_rel, b_pre = _split_version(b)
# Porównaj część release (brakujące komponenty traktuj jako 0)
for i in range(max(len(a_rel), len(b_rel))):
xa = a_rel[i] if i < len(a_rel) else 0
xb = b_rel[i] if i < len(b_rel) else 0
if xa != xb:
return 1 if xa > xb else -1
# Część release równa → decyduje prerelease.
# Wersja finalna (bez prerelease) jest ZAWSZE nowsza od prerelease.
if not a_pre and not b_pre:
return 0
if not a_pre:
return 1
if not b_pre:
return -1
return _cmp_pre(a_pre, b_pre)
def _version_newer(a: str, b: str) -> bool:
"""True gdy wersja a jest nowsza od b (z poprawną obsługą prerelease)."""
try:
return _cmp_version(a, b) > 0
except Exception:
return a != b
def load_json(path):
try:
with open(path) as f:
return json.load(f)
except (FileNotFoundError, json.JSONDecodeError):
return {}
def save_json(path, data):
with open(path, "w") as f:
json.dump(data, f, indent=2)
class PackageInfo:
__slots__ = ("name","version","release","description","dependencies",
"optdepends","size_bytes","sha256","gpg_fp","repo_url","filename",
"provides","license","provides_so","requires_so","privileged")
def __init__(self, d, repo=""):
self.name = d.get("name","?")
self.version = d.get("version","0")
self.release = d.get("release", 1)
self.description = d.get("description","")
self.dependencies = d.get("dependencies", d.get("depends", []))
# Opcjonalne zależności (flatpak, btrfs-progs, grub, ...) – tylko
# informacyjne; `pag install` NIE instaluje ich automatycznie.
self.optdepends = d.get("optdepends", []) or []
self.size_bytes = d.get("size",0)
self.sha256 = d.get("sha256","")
self.gpg_fp = d.get("gpg_fingerprint","")
self.repo_url = repo
self.filename = d.get("filename", f"{self.name}-{self.version}{PKG_EXT}")
self.provides = d.get("provides", []) or []
self.license = d.get("license", []) or []
self.provides_so = d.get("provides_so", []) or []
self.requires_so = d.get("requires_so", []) or []
# Ścieżki, którym wolno zachować setuid/setgid i grupę (z receptury).
self.privileged = d.get("privileged", []) or []
# =============================================================================
# REPOZYTORIA (cache, ETag, GPG)
# =============================================================================
def _parse_repos_config():
"""Parsuje repozytoria z /etc/pag/repos.conf oraz /etc/pag/repos/*.conf.
Format linii: <url> [fingerprint]
Opcjonalny `fingerprint` (40 znaków hex) pozwala przypiąć klucz
podpisujący repo do konkretnego adresu – wtedy TOFU (auto-zaufanie przy
pierwszym użyciu) nie jest potrzebne, a zmiana klucza = błąd bezpieczeństwa.
Drop-iny (np. stable.conf) są czytane alfabetycznie – pozwalają na
wygodne dodawanie repo bez dotykania głównego repos.conf
(np. `echo 'https://repo.paganlinux.eu/stable' > /etc/pag/repos/stable.conf`).
"""
entries = []
def _read_lines(path):
if not os.path.exists(path):
return
for line in open(path):
line = line.strip()
if not line or line.startswith("#"):
continue
parts = line.split()
url = parts[0].rstrip("/")
fp = parts[1].lower() if len(parts) > 1 else ""
entries.append({"url": url, "fingerprint": fp or None})
# 1) Legacy: pojedynczy plik /etc/pag/repos.conf
_read_lines(REPOS_CONF)
# 2) Drop-in: /etc/pag/repos/<nazwa>.conf (sortowane, stabilna kolejność)
if os.path.isdir(REPOS_DIR):
for drop in sorted(os.listdir(REPOS_DIR)):
if drop.endswith(".conf"):
_read_lines(os.path.join(REPOS_DIR, drop))
# Dedupe po URL (zachowaj pierwszy wpis – może mieć fingerprint)
seen, unique = set(), []
for e in entries:
if e["url"] not in seen:
seen.add(e["url"])
unique.append(e)
if not unique:
for url in DEFAULT_REPOS:
# rstrip: get_repos()/_repo_pinned_fp() kluczują URL-e bez ukośnika
unique.append({"url": url.rstrip("/"), "fingerprint": None})
return unique
def get_repos():
return [e["url"] for e in _parse_repos_config()]
def _repo_pinned_fp(repo_url):
"""Zwraca przypięty fingerprint klucza dla repo (z konfiguracji lub trust DB)."""
# Normalizacja ukośnika: _parse_repos_config() i trust DB kluczują URL-e BEZ
# końcowego „/”, a wywołujący podają często DEFAULT_REPOS[0] Z ukośnikiem.
# Bez tego przypięty klucz nie był znajdowany i lokalny .pag dostawał
# fałszywe „Brak przypiętego klucza repo” mimo poprawnego wpisu w trusted.json.
repo_url = repo_url.rstrip("/")
by_url = {e["url"]: e["fingerprint"] for e in _parse_repos_config()}
if by_url.get(repo_url):
return by_url[repo_url]
db = _load_trust_db()
fp = db.get(repo_url)
return fp.lower() if fp else None
def _repo_cache_path(url):
return os.path.join(REPO_CACHE, url.replace("://","_").replace("/","_").replace(".","_") + ".json")
def _repo_etag_path(url): return _repo_cache_path(url) + ".etag"
def _repo_ts_path(url): return _repo_cache_path(url) + ".ts"
# Informacja (raz na uruchomienie), gdy cache repozytoriów jest tylko-do-odczytu –
# np. komendy read-only (`pag info`, `pag search`…) jako zwykły user: nie ma sensu
# ani prawa odświeżać /var/cache/pag/repos, więc używamy lokalnej kopii indeksu.
_cache_ro_notice_done = False
def _cache_ro_notice():
global _cache_ro_notice_done
if _cache_ro_notice_done:
return
_cache_ro_notice_done = True
print(f" ⚠ {_('cache_ro', cache=REPO_CACHE)}", file=sys.stderr)
def _load_repo_cache(cp: str) -> Optional[list]:
"""Wczytuje cache indeksu repo; zwraca None gdy brak albo uszkodzony.
Partial write (crash w trakcie zapisu) mógł zostawić obcięty JSON. Zamiast
zwracać pustą listę pakietów (użytkownik myśli, że repo jest puste)
sygnalizujemy None – wywołujący ponowi pobranie albo pokaże ostrzeżenie."""
if not os.path.exists(cp):
return None
try:
with open(cp, "r", encoding="utf-8") as fh:
data = json.load(fh)
pkgs = data.get("packages")
if not isinstance(pkgs, list):
raise ValueError(_("repo_index_invalid"))
return pkgs
except (OSError, ValueError) as e:
print(_(' ⚠ Corrupted index cache {arg1}: {arg2}', arg1=(cp), arg2=(e)), file=sys.stderr)
return None
def fetch_repo_index(repo_url, force=False):
cp = _repo_cache_path(repo_url)
ep = _repo_etag_path(repo_url)
tp = _repo_ts_path(repo_url)
if not force and os.path.exists(cp) and os.path.exists(tp):
try:
if time.time() - float(open(tp).read().strip()) < REPO_CACHE_TTL:
cached = _load_repo_cache(cp)
if cached is not None:
return cached
# uszkodzony cache – spróbuj odświeżyć z sieci
except (OSError, ValueError):
pass
# --- Cache tylko-do-odczytu (np. `pag info` jako zwykły user) ---
# /var/cache/pag/repos należy do roota. Nie próbuj odświeżać ani pisać –
# zwykły user i tak nie zapisze indeksu; użyj lokalnej kopii (może być
# nieaktualna). Pełne odświeżenie indeksu: sudo pag sync
if not (os.path.isdir(REPO_CACHE) and os.access(REPO_CACHE, os.W_OK)):
if force:
print(_(' ❌ {arg1}: cannot refresh index – {arg2} is read-only', arg1=(repo_url), arg2=(REPO_CACHE)),
file=sys.stderr)
return None
_cache_ro_notice()
cached = _load_repo_cache(cp)
if cached is not None:
return cached
return None
headers = {"User-Agent": "pag/3.0"}
if os.path.exists(tp) and not force:
try:
lm = datetime.fromtimestamp(float(open(tp).read().strip()), tz=timezone.utc)
# Wymuś lokalizację C/POSIX dla nagłówków HTTP, aby unikać problemów z nazwami dni/miesięcy
try:
old_locale = locale.setlocale(locale.LC_TIME)
locale.setlocale(locale.LC_TIME, 'C')
headers["If-Modified-Since"] = lm.strftime("%a, %d %b %Y %H:%M:%S GMT")
locale.setlocale(locale.LC_TIME, old_locale)
except (locale.Error, ValueError):
# Jeśli ustawienie lokalizacji się nie powiedzie, użyj domyślnej
headers["If-Modified-Since"] = lm.strftime("%a, %d %b %Y %H:%M:%S GMT")
except: pass
if os.path.exists(ep) and not force:
try: headers["If-None-Match"] = open(ep).read().strip()
except: pass
# --- Pobranie indeksu (błędy SIECI nie są błędami zapisu cache) ---
try:
req = Request(f"{repo_url}/repo.json", headers=headers)
with urlopen(req, timeout=30) as resp:
etag = resp.headers.get("ETag","")
raw = resp.read()
data = json.loads(raw.decode())
except HTTPError as e:
if e.code == 304:
# Serwer: indeks bez zmian – odśwież tylko znacznik czasu (best-effort)
try:
open(tp,"w").write(str(time.time()))
except OSError:
pass
cached = _load_repo_cache(cp)
if cached is not None:
return cached
# uszkodzona kopia – potraktuj jak brak (ostrzeżenie niżej)
print(_(' ⚠ HTTP {arg1} for {arg2}', arg1=(e.code), arg2=(repo_url)), file=sys.stderr)
return None
except Exception as e:
print(_(' ⚠ Failed to download index {arg1}: {arg2}', arg1=(repo_url), arg2=(e)), file=sys.stderr)
return _load_repo_cache(cp)
# Indeks pobrany – zapisz SUROWE bajty (nie re-serializuj! podpis GPG jest
# nad oryginalnymi bajtami repo.json z serwera) i zweryfikuj podpis.
# Najpierw zapis tymczasowy + weryfikacja GPG, dopiero potem podmiana cp:
# błąd zapisu (np. pełny dysk) nie niszczy starej, zweryfikowanej kopii
# i NIGDY nie zwracamy danych, które nie przeszły weryfikacji.
tmp_path = cp + ".tmp"
try:
with open(tmp_path, "wb") as f:
f.write(raw)
if not _verify_repo_sig(repo_url, tmp_path):
return None # weryfikacja nie powiodła się – stary cache zostaje
os.replace(tmp_path, cp)
# przenieś podpis obok docelowego pliku (marker „repo ma podpis")
for _ext in (".asc", ".sig"):
if os.path.exists(tmp_path + _ext):
try:
os.replace(tmp_path + _ext, cp + _ext)
except OSError:
pass
break
if etag:
try:
open(ep,"w").write(etag)
except OSError:
pass
try:
open(tp,"w").write(str(time.time()))
except OSError:
pass
return data.get("packages",[])
except OSError as e:
print(_(' ⚠ Index downloaded, but failed to save cache ({arg1}): {arg2}', arg1=(REPO_CACHE), arg2=(e)),
file=sys.stderr)
# cp nie został podmieniony (podmiana jest po weryfikacji) – lokalna kopia
# to wciąż stare, zweryfikowane dane
return _load_repo_cache(cp)
finally:
for _p in (tmp_path, tmp_path + ".asc", tmp_path + ".sig"):
try:
os.unlink(_p)
except OSError:
pass
def _verify_repo_sig(repo_url, cache_path) -> bool:
"""Weryfikuje podpis GPG indeksu repozytorium i przypina fingerprint.
FAIL-CLOSED: brak/nieprawidłowy podpis = False (chyba że PAG_INSECURE=1).
Zwraca True jeśli indeks jest zaufany, False jeśli należy go odrzucić.
Model zaufania (TOFU + pinning):
- Pierwszy raz (brak przypiętego fingerprintu) → klucz jest importowany,
a fingerprint zapisywany w /etc/pag/trusted.json z JAWNYM ostrzeżeniem.
To świadomy kompromis wygody i bezpieczeństwa.
- Kolejne uruchomienia: fingerprint jest porównywany z przypiętym.
Zmiana klucza = ❌ SECURITY ERROR (fail-closed), wymagane ręczne:
pag key-trust <repo_url> (po weryfikacji nowego klucza)
"""
insecure = os.environ.get("PAG_INSECURE", "") == "1"
if not os.path.exists(GPG_HOME):
if insecure:
return True # brak GPG home – tryb insecure, akceptuj
print(_(' ❌ {arg1}: no GPG keys – verification impossible!', arg1=(repo_url)))
print(_(' Set PAG_INSECURE=1 to skip (not recommended)'))
os.remove(cache_path)
return False
sig_path = cache_path + ".sig"
# Podpisy generowane jako .asc (armored) – próbuj .asc, potem .sig
sig_data = None
sig_ext = ""
for ext in (".asc", ".sig"):
try:
req = Request(f"{repo_url}/repo.json{ext}", headers={"User-Agent":"pag/3.0"})
with urlopen(req, timeout=15) as resp:
sig_data = resp.read()
sig_ext = ext
break
except Exception:
continue
if not sig_data:
if insecure:
return True # tryb insecure – akceptuj bez podpisu
print(_(' ❌ {arg1}: CANNOT DOWNLOAD SIGNATURE repo.json.asc/.sig!', arg1=(repo_url)))
print(_(' Set PAG_INSECURE=1 to skip (not recommended)'))
os.remove(cache_path)
return False
sig_path = cache_path + sig_ext
with open(sig_path, "wb") as f:
f.write(sig_data)
ok, fingerprint = _gpg_verify_fp(sig_path, cache_path)
if not ok:
# Automatyczny import klucza repo przy pierwszym uruchomieniu (TOFU,
# jak apt) – gdy w keyringu brakuje klucza (No public key).
res = _gpg_run("--verify", sig_path, cache_path,
capture_output=True, text=True, timeout=30)
_stderr = res.stderr.decode(errors="replace") if isinstance(res.stderr, bytes) else (res.stderr or "")
if "public key" in _stderr.lower() and "no public key" in _stderr.lower():
try:
with urlopen(Request(f"{repo_url}/paganos.asc", headers={"User-Agent": "pag/3.0"}), timeout=20) as r:
keydata = r.read()
with tempfile.NamedTemporaryFile(delete=False, suffix=".asc") as tmp:
tmp.write(keydata)
tmp.flush()
_gpg_run("--import", tmp.name, capture_output=True, timeout=30)
os.unlink(tmp.name)
print(_(' 🔑 Imported repo key from {arg1}/paganos.asc', arg1=(repo_url)))
ok, fingerprint = _gpg_verify_fp(sig_path, cache_path)
except Exception:
pass
if not ok:
if insecure:
print(_(' ⚠ {arg1}: invalid GPG signature (PAG_INSECURE – ignoring)', arg1=(repo_url)))
return True
os.remove(cache_path)
if not shutil.which(GPG_BINARY):
print(_(' ❌ {arg1}: GPG is not installed – cannot verify the signature!', arg1=(repo_url)))
print(_(' Install gnupg or set PAG_INSECURE=1 (not recommended)'))
else:
print(_(' ❌ {arg1}: INVALID GPG SIGNATURE of the repository index!', arg1=(repo_url)))
return False
# --- Wymuś przypięty fingerprint (TOFU + pinning) ---
pinned = _repo_pinned_fp(repo_url)
if pinned:
if not fingerprint:
if insecure:
print(_(' ⚠ {arg1}: cannot read signature fingerprint (PAG_INSECURE – ignoring)', arg1=(repo_url)))
return True
os.remove(cache_path)
print(_(' ❌ [SECURITY ERROR] {arg1}: cannot read signature fingerprint!', arg1=(repo_url)))
print(_(' Pinned key: {arg1} – rejecting the index.', arg1=(pinned)))
return False
if fingerprint != pinned.upper():
if insecure:
print(_(' ⚠ {arg1}: SIGNING KEY CHANGED (PAG_INSECURE – ignoring)', arg1=(repo_url)))
return True
os.remove(cache_path)
print(_(' ❌ [SECURITY ERROR] {arg1}: Repository signing key has changed!', arg1=(repo_url)))
print(_(' Expected: {arg1}', arg1=(pinned)))
print(_(' Received: {arg1}', arg1=(fingerprint)))
print(_(' If this is an intentional key rotation: pag key-trust {arg1}', arg1=(repo_url)))
return False
return True
if fingerprint:
# Brak przypiętego fingerprintu → TOFU: zapisz go w bazie zaufania.
db = _load_trust_db()
if db.get(repo_url) != fingerprint:
_save_trust_db({**db, repo_url: fingerprint})
print(_(' 🔐 Pinned repo fingerprint {arg1}: {arg2}', arg1=(repo_url), arg2=(fingerprint)))
print(_(' (TOFU – first trust. If the key changes, pag will refuse updates.)'))
print(_(' To avoid TOFU, add the fingerprint to /etc/pag/repos.conf.'))
return True
def fetch_all_packages(force=False):
all_pkgs = {}
for repo_url in get_repos():
pkgs = fetch_repo_index(repo_url, force)
if pkgs:
for pdata in pkgs:
name = pdata.get("name", pdata.get("filename","?").split("-")[0])
pkg = PackageInfo(pdata, repo_url)
if name not in all_pkgs or _version_newer(pkg.version, all_pkgs[name].version):
all_pkgs[name] = pkg
return all_pkgs
# =============================================================================
# GPG
# =============================================================================
def _verify_pkg_gpg(pkg_path, repo_url=None):
"""Weryfikuje podpis GPG pakietu i (jeśli znamy repo) przypięty fingerprint.
FAIL-CLOSED: brak podpisu = odrzucenie (chyba że PAG_INSECURE=1).
Zwraca (passed: bool, message: str).
"""
insecure = os.environ.get("PAG_INSECURE", "") == "1"
# Brak gnupg = weryfikacja niemożliwa. Bez tej gałęzi użytkownik dostawał
# mylące „NIEPRAWIDŁOWY PODPIS GPG”, mimo że paczka i podpis są w porządku.
if not shutil.which(GPG_BINARY):
if insecure:
return True, "(gpg missing – PAG_INSECURE)"
return False, _("gpg_missing")
sig_path = pkg_path + ".sig"
if not os.path.exists(sig_path) and os.path.exists(pkg_path + ".asc"):
sig_path = pkg_path + ".asc"
if not os.path.exists(sig_path):
if insecure:
return True, "(no signature – PAG_INSECURE)"
return False, "BRAK PODPISU – pakiet odrzucony (ustaw PAG_INSECURE=1 aby pominąć)"
ok, fp = _gpg_verify_fp(sig_path, pkg_path)
if not ok:
if insecure:
return True, "(invalid signature – PAG_INSECURE)"
return False, "NIEPRAWIDŁOWY PODPIS GPG"
# Opcjonalnie: sprawdź, czy podpis pochodzi od klucza przypiętego dla repo.
if repo_url:
pinned = _repo_pinned_fp(repo_url)
if pinned and fp and fp != pinned.upper():
if insecure:
return True, "(pkg signer mismatch – PAG_INSECURE)"
return False, f"PAKIET PODPISANY INNYM KLUCZEM niż repo (oczekiwano {pinned})"
return True, "GPG verified"
def cmd_key_add(source):
ensure_dirs()
if not shutil.which(GPG_BINARY):
print(f"❌ {_('gpg_missing')}"); return 1
if source.startswith("http"):
try:
with urlopen(Request(source, headers={"User-Agent":"pag/3.0"}), timeout=30) as resp:
keydata = resp.read()
with tempfile.NamedTemporaryFile(delete=False, suffix=".gpg") as tmp:
tmp.write(keydata); tmp.flush()
res = _gpg_run("--import", tmp.name, capture_output=True, timeout=30)
os.unlink(tmp.name)
if res.returncode != 0:
print(f"❌ {_('key_add_failed')}"); return 1
except Exception as e:
print(_('❌ Download error: {arg1}', arg1=(e))); return 1
else:
res = _gpg_run("--import", source, capture_output=True, timeout=30)
if res.returncode != 0:
print(f"❌ {_('key_add_failed')}"); return 1
print(f"✅ {_('key_imported')}")
def cmd_key_list():
if not shutil.which(GPG_BINARY):
print(f"❌ {_('gpg_missing')}"); return
if not os.path.exists(GPG_HOME):
print(_("no_keys")); return
result = _gpg_run("--list-keys", "--keyid-format", "LONG",
capture_output=True, text=True, timeout=30)
if result.returncode != 0:
print(f"❌ {_('gpg_missing')}"); return
print(result.stdout or _("no_keys"))
def cmd_key_remove(key_id):
_gpg_run("--batch", "--yes", "--delete-key", key_id,
capture_output=True, timeout=30)
print(f"✅ {_('key_removed', key_id)}")
def _repo_signer_fp(repo_url):
"""Pobiera repo.json + podpis i zwraca fingerprint podpisującego (bez pinningu)."""
repo_url = repo_url.rstrip("/")
try:
with urlopen(Request(f"{repo_url}/repo.json", headers={"User-Agent":"pag/3.0"}), timeout=30) as r:
data = r.read()
except Exception:
return None
sig = None
sig_ext = ".asc"
for ext in (".asc", ".sig"):
try:
with urlopen(Request(f"{repo_url}/repo.json{ext}", headers={"User-Agent":"pag/3.0"}), timeout=20) as r:
sig = r.read()
sig_ext = ext
break
except Exception:
continue
if not sig:
return None
with tempfile.NamedTemporaryFile(delete=False, suffix=".json") as tf:
tf.write(data); tf.flush()
data_path = tf.name
sig_path = data_path + sig_ext
try:
with open(sig_path, "wb") as f:
f.write(sig)
ok, fp = _gpg_verify_fp(sig_path, data_path)
finally:
for p in (data_path, sig_path):
try: os.unlink(p)
except OSError: pass
return fp if ok else None
def cmd_key_trust(repo_url):
"""Przypina fingerprint klucza podpisującego repo (koniec z TOFU dla tego repo)."""
repo_url = repo_url.rstrip("/")
print(_('🔐 Pinning repo key {arg1}...', arg1=(repo_url)))
fp = _repo_signer_fp(repo_url)
if not fp:
print(_(' ❌ Cannot read signature fingerprint (missing/failed).'))
print(_(' Make sure the repo key is in the keyring (pag key-add <url|file>).'))
return 1
db = _load_trust_db()
_save_trust_db({**db, repo_url: fp})
print(_(' ✅ Pinned {arg1} for {arg2}', arg1=(fp), arg2=(repo_url)))
print(_(' From now on, a key change will be reported as SECURITY ERROR.'))
return 0
def cmd_key_untrust(repo_url):
"""Usuwa przypięcie fingerprintu dla repo (wraca do TOFU)."""
repo_url = repo_url.rstrip("/")
db = _load_trust_db()
if repo_url not in db:
print(_(' ℹ {arg1} has no pinned fingerprint.', arg1=(repo_url)))
return 0
del db[repo_url]
_save_trust_db(db)
print(_(' ✅ Removed pin for {arg1}.', arg1=(repo_url)))
return 0
def cmd_key_trusted():
"""Listuje przypięte fingerprinty repozytoriów."""
db = _load_trust_db()
if not db:
print(_("no_keys"))
return
for url, fp in sorted(db.items()):
print(f" {url}\n {fp}")
# =============================================================================
# ATOMOWA INSTALACJA (STAGING)
# =============================================================================
def _safe_rename(src: str, dst: str) -> bool:
"""
Atomowe przeniesienie pliku. Jeśli src i dst są na różnych
systemach plików (EXDEV), kopiuje + usuwa źródło.
"""
try:
os.rename(src, dst)
return True
except OSError as e:
if e.errno == 18: # EXDEV – cross-device link
shutil.copy2(src, dst)
os.remove(src)
return True
raise
def _install_file(src: str, rel: str, data_staging: str, sums: dict,
staging: str, journal: list, installed_files: list,
deploy_dir: str = "", backup_dir: str = "",
backup_journal: Optional[list] = None,
old_checksums: Optional[dict] = None,
privileged=frozenset()) -> bool:
"""
Instaluje pojedynczy plik (zwykły lub symlink).
Obsługuje: cross-device rename, symlinki, weryfikację SHA256.
Jeśli deploy_dir jest podany (tryb immutable), pliki systemowe trafiają
do deploymentu, a współdzielone (/var, /etc, ...) bezpośrednio do /.
Jeśli backup_dir jest podany, a pod dst istnieje już plik (upgrade/reinstall),
stara wersja jest przenoszona do backup_dir, by rollback mógł ją przywrócić.
old_checksums: {ścieżka: sha256 z chwili instalacji}. Gdy podane i plik /etc
został zmodyfikowany przez użytkownika, nowa wersja ląduje jako .pacnew
(stary plik NIE jest ruszany) – wzorzec jak w pacmanie.
"""
# W trybie immutable: pliki współdzielone idą do /, reszta do deploymentu
if deploy_dir and _is_shared_path("/" + rel):
dst_root = PAG_ROOT
elif deploy_dir:
dst_root = deploy_dir
else:
dst_root = PAG_ROOT
dst = os.path.join(dst_root, rel)
# --- SYMLINK ---
if os.path.islink(src):
link_target = os.readlink(src)
# Weryfikuj sums.json dla symlinka (hash ścieżki docelowej)
expected = sums.get("/" + rel, "")
if expected:
link_hash = hashlib.sha256(link_target.encode()).hexdigest()
if expected and link_hash != expected:
return False
os.makedirs(os.path.dirname(dst), exist_ok=True)
# Backup istniejącego symlinka (upgrade) – dla poprawnego rollbacku
if backup_dir and backup_journal is not None and os.path.lexists(dst):
try:
backup_path = os.path.join(backup_dir, rel)
os.makedirs(os.path.dirname(backup_path), exist_ok=True)
os.replace(dst, backup_path)
backup_journal.append((backup_path, "/" + rel))
journal.append(("backup", backup_path, dst))
except OSError:
pass
# Jeśli docelowy symlink już istnieje, usuń go
if os.path.islink(dst) or os.path.exists(dst):
os.remove(dst)
os.symlink(link_target, dst)
journal.append(("symlink", "", dst))
installed_files.append({
"path": "/" + rel,
"sha256": hashlib.sha256(link_target.encode()).hexdigest(),
"size": len(link_target),
"is_symlink": True,
"symlink_target": link_target,
})
return True
# --- ZWYKŁY PLIK ---
# Oblicz SHA256
try:
file_sha = _sha256_file(src)
except Exception:
file_sha = ""
# Weryfikuj sums.json
expected = sums.get("/" + rel, "")
if expected and file_sha and file_sha != expected:
return False
# --- .pacnew: NIE nadpisuj pliku konfiguracyjnego, którego nie wolno zgubić ---
# Robimy `<plik>.pacnew`, gdy:
# a) plik jest śledzony i użytkownik go zmodyfikował (hash != zapisanej sumy),
# b) to wrażliwa konfiguracja (/etc/pam.d, /etc/security, sudoers, shadow…),
# a treść na dysku różni się od tej z pakietu – chroni auth przed
# cichym nadpisaniem przez `install`/`upgrade` (np. przez shadow).
# NIE robimy .pacnew, jeśli plik na dysku jest identyczny z nowym albo był
# niezmieniony od instalacji (wtedy nadpisanie jest bezpieczne).
old_sha = (old_checksums or {}).get("/" + rel, "")
if file_sha and _is_config_path(rel) and os.path.isfile(dst) and not os.path.islink(dst):
tracked_modified = bool(old_sha) and file_sha != old_sha
if tracked_modified or _is_sensitive_config(rel):
try:
cur_sha = _sha256_file(dst)
except OSError:
cur_sha = ""
if cur_sha and cur_sha != file_sha and not (old_sha and cur_sha == old_sha):
pacnew = dst + ".pacnew"
try:
_safe_rename(src, pacnew)
try:
os.chown(pacnew, 0, 0)
except (OSError, PermissionError):
pass
# Journal (do cofnięcia przy nieudanej transakcji) – ale NIE
# zapisujemy .pacnew w bazie plików: to artefakt użytkownika.
journal.append(("file", src, pacnew))
print(f" ⚠ {_('conf_pacnew', path=pacnew)}")
return True
except OSError:
pass # nie udało się – kontynuuj normalną instalację
# Utwórz katalog docelowy
os.makedirs(os.path.dirname(dst), exist_ok=True)
# Backup istniejącego pliku (upgrade) – dla poprawnego rollbacku
if backup_dir and backup_journal is not None and os.path.lexists(dst):
try:
backup_path = os.path.join(backup_dir, rel)
os.makedirs(os.path.dirname(backup_path), exist_ok=True)
os.replace(dst, backup_path)
backup_journal.append((backup_path, "/" + rel))
journal.append(("backup", backup_path, dst))
except OSError:
pass
# Atomowe przeniesienie (z fallbackiem dla cross-device).
# Zachowuje bity uprawnień (SUID/SGID/sticky) – NIE używamy filter='data'.
_safe_rename(src, dst)
if "/" + rel in privileged:
# Plik uprzywilejowany: zostaw właściciela, grupę i bity z pakietu
# (np. sudo 4755 root:root, qemu-bridge-helper 4750 root:kvm).
try:
st = os.stat(dst)
if st.st_mode & 0o6000:
_audit(f"privileged {dst} mode={oct(st.st_mode & 0o7777)} "
f"uid={st.st_uid} gid={st.st_gid}")
except OSError:
pass
else:
# Wymuś właściciela root:root. UWAGA: os.chown() NIE czyści bitów SUID/SGID.
try:
os.chown(dst, 0, 0)
except (OSError, PermissionError):
# Na niektórych systemach plików (tmpfs, fat) chown może się nie powieść
pass
journal.append(("file", src, dst))
installed_files.append({
"path": "/" + rel,
"sha256": file_sha,
"size": os.path.getsize(dst),
"is_symlink": False,
})
return True
def _stage_package(pkg_path: str, pkg: PackageInfo) -> Optional[dict]:
"""Rozpakowuje pakiet do stagingu, NIE dotykając systemu.
Zwraca dict: staging, data, sums, hooks. None przy błędzie.
To pierwsza faza transakcji grupowej: najpierw przygotowujemy WSZYSTKIE
pakiety (np. całe GNOME – 50 paczek). Dopiero gdy każda się rozpakuje i
przejdzie weryfikację SHA256, przechodzimy do fazy commit. Błąd jednej
paczki nie zostawia więc systemu w połowie instalacji.
"""
staging = tempfile.mkdtemp(dir=STAGING_DIR, prefix=f".stage-{pkg.name}-")
try:
with tarfile.open(pkg_path, "r:xz") as tf:
_safe_extractall(tf, staging)
data_tar = os.path.join(staging, "data.tar.xz")
if not os.path.exists(data_tar):
raise RuntimeError(_("pkg_missing_data_tar"))
data_staging = os.path.join(staging, "data")
os.makedirs(data_staging, exist_ok=True)
priv = PRIVILEGED_PATHS | frozenset(pkg.privileged or ())
with tarfile.open(data_tar, "r:xz") as tf:
_safe_extractall(tf, data_staging, privileged=priv)
sums_path = os.path.join(data_staging, "sums.json")
sums = json.load(open(sums_path)) if os.path.exists(sums_path) else {}
# Weryfikacja SHA256 JUŻ w stagingu – uszkodzona paczka nie dojdzie
# do fazy commit, więc nie zdąży nadpisać żadnego pliku w systemie.
_bad: List[str] = []
for _root, _dirs, _files in os.walk(data_staging):
for _name in list(_dirs) + _files:
if _name == "sums.json":
continue
_fp = os.path.join(_root, _name)
_rel = "/" + os.path.relpath(_fp, data_staging)
_expected = sums.get(_rel, "")
if not _expected:
continue
try:
if os.path.islink(_fp):
_actual = hashlib.sha256(
os.readlink(_fp).encode()).hexdigest()
elif os.path.isfile(_fp):
_actual = _sha256_file(_fp)
else:
continue
except OSError:
_actual = ""
if _actual != _expected:
_bad.append(_rel)
if len(_bad) >= 5:
break
if len(_bad) >= 5:
break
if _bad:
raise RuntimeError(_("pkg_sha_mismatch", ", ".join(_bad[:5])))
return {
"staging": staging,
"data": data_staging,
"sums": sums,
"hooks": os.path.join(staging, "hooks"),
}
except Exception as e:
shutil.rmtree(staging, ignore_errors=True)
print(_(' ❌ {arg1}: preparation stage failed ({arg2})', arg1=(pkg.name), arg2=(e)))
return None
def _discard_staged(staged: Optional[dict]):
"""Usuwa katalog stagingu przygotowanego pakietu (bez zmian w systemie)."""
if staged and staged.get("staging"):
shutil.rmtree(staged["staging"], ignore_errors=True)
def _apply_staged_package(staged: dict, pkg: PackageInfo, deploy_dir: str = "",
backup_dir: str = "",
old_checksums: Optional[dict] = None
) -> Tuple[bool, List[dict], List[Tuple[str, str]]]:
"""Faza commit: przenosi przygotowany pakiet do systemu.
Hooki pre/post-install uruchamiane są tutaj – dopiero po tym, jak cała
grupa pakietów została poprawnie rozpakowana w stagingu.
"""
staging = staged["staging"]
data_staging = staged["data"]
sums = staged["sums"]
hooks_dir = staged["hooks"]
priv = PRIVILEGED_PATHS | frozenset(pkg.privileged or ())
journal: List[tuple] = []
installed_files: List[dict] = []
backup_journal: List[Tuple[str, str]] = []
try:
# Hook pre-install (przed przeniesieniem plików do systemu)
_run_hook(hooks_dir, "pre-install", pkg)
# Przenieś pliki: staging/data/* → /
for root, dirs, files in os.walk(data_staging):
# Symlink do katalogu (np. /lib → usr/lib) os.walk zwraca w `dirs`.
# Nie wolno tworzyć z niego prawdziwego katalogu – przekieruj do
# pętli plików, gdzie _install_file odtworzy symlink.
for _d in list(dirs):
if os.path.islink(os.path.join(root, _d)):
dirs.remove(_d)
files.append(_d)
# Odtwórz katalogi z pakietu – w tym PUSTE (np. /etc/pulse/default.pa.d).
for d in dirs:
src_dir = os.path.join(root, d)
rel_dir = os.path.relpath(src_dir, data_staging)
if deploy_dir and _is_shared_path("/" + rel_dir):
dst_root = PAG_ROOT
elif deploy_dir:
dst_root = deploy_dir
else:
dst_root = PAG_ROOT
dst_dir = os.path.join(dst_root, rel_dir)
if not os.path.isdir(dst_dir):
try:
os.makedirs(dst_dir, exist_ok=True)
except OSError:
pass
for fname in files:
if fname == "sums.json":
continue
src = os.path.join(root, fname)
rel = os.path.relpath(src, data_staging)
ok = _install_file(src, rel, data_staging, sums,
staging, journal, installed_files, deploy_dir,
backup_dir, backup_journal,
old_checksums=old_checksums,
privileged=priv)
if not ok:
# Cofnij wszystkie operacje
_rollback_journal(journal, staging)
return False, [], backup_journal
# Odbuduj cache ikon GTK dla motywów dotkniętych instalacją.
_icon_dirs = set()
for f in installed_files:
fp = f.get("path", "") or ""
if fp.startswith("/usr/share/icons/"):
_rest = fp[len("/usr/share/icons/"):]
_theme = _rest.split("/", 1)[0]
if _theme:
_icon_dirs.add(os.path.join(PAG_ROOT, "usr/share/icons", _theme))
if _icon_dirs:
try:
subprocess.run(["gtk-update-icon-cache", "--version"],
capture_output=True, timeout=10)
for _d in sorted(_icon_dirs):
if os.path.isdir(_d):
subprocess.run(["gtk-update-icon-cache", "-f", "-q", _d],
capture_output=True, timeout=300)
except Exception:
pass
# Uruchom hooki post-install
_run_hook(hooks_dir, "post-install", pkg)
# Zachowaj hooki na wypadek usunięcia pakietu (pre/post-remove)
try:
if os.path.isdir(hooks_dir):
persisted = os.path.join(PAG_DB, "hooks", pkg.name)
shutil.rmtree(persisted, ignore_errors=True)
shutil.copytree(hooks_dir, persisted)
except Exception:
pass
# Zapisz do SQLite
_db_record_files(pkg.name, installed_files)
shutil.rmtree(staging, ignore_errors=True)
return True, installed_files, backup_journal
except Exception as e:
_rollback_journal(journal, staging)
print(_(' ❌ {arg1}: commit error – {arg2}', arg1=(pkg.name), arg2=(e)))
return False, [], backup_journal
def _atomic_install(pkg_path: str, pkg: PackageInfo, deploy_dir: str = "",
backup_dir: str = "",
old_checksums: Optional[dict] = None
) -> Tuple[bool, List[dict], List[Tuple[str, str]]]:
"""Instaluje pojedynczy pakiet dwufazowo: staging → commit.
Zachowane jako publiczny wrapper dla instalacji pojedynczych plików
lokalnych; transakcja grupowa w cmd_install przygotowuje staging dla
całej grupy i wywołuje _apply_staged_package bezpośrednio.
"""
staged = _stage_package(pkg_path, pkg)
if not staged:
return False, [], []
return _apply_staged_package(staged, pkg, deploy_dir, backup_dir, old_checksums)
def _refresh_dynamic_linker_cache(deploy_dir: str = "") -> bool:
"""Odświeża cache ld.so po udanej instalacji pakietów."""
ldconfig = shutil.which("ldconfig")
if not ldconfig:
print(_(' ⚠ ldconfig not found — linker cache was not refreshed.'),
file=sys.stderr)
return False
target_root = deploy_dir or PAG_ROOT
command = [ldconfig]
if target_root != "/":
command.extend(["-r", target_root])
try:
subprocess.run(command, check=True, timeout=60,
stdout=subprocess.DEVNULL, stderr=subprocess.PIPE,
text=True)
return True
except (OSError, subprocess.CalledProcessError, subprocess.TimeoutExpired) as exc:
detail = getattr(exc, "stderr", None) or str(exc)
print(_(' ⚠ Failed to refresh ld.so cache: {arg1}', arg1=(detail.strip())),
file=sys.stderr)
return False
def _rollback_journal(journal: list, staging_path: str):
"""Cofa wszystkie operacje z journala (odwrotna kolejność)."""
for entry in reversed(journal):
op = entry[0]
if op == "file":
_, src, dst = entry
try:
if os.path.exists(dst) or os.path.islink(dst):
_safe_rename(dst, src)
except Exception:
pass
elif op == "symlink":
_, _, dst = entry
try:
if os.path.islink(dst) or os.path.exists(dst):
os.remove(dst)
except Exception:
pass
elif op == "backup":
# Przywróć starą wersję pliku z backupu (upgrade)
_, bpath, dst = entry
try:
if os.path.lexists(bpath):
os.replace(bpath, dst)
except Exception:
pass
shutil.rmtree(staging_path, ignore_errors=True)
# =============================================================================
# BEZPIECZNE USUWANIE
# =============================================================================
def _safe_remove_files(pkg_name: str, installed_db: dict) -> Tuple[int, List[str]]:
"""
Usuwa pliki pakietu, ale tylko jeśli NIE są współdzielone z innym pakietem.
Zwraca (liczba usuniętych, [lista usuniętych ścieżek]).
"""
pkg_files = _db_get_package_files(pkg_name)
recorded = _db_get_package_checksums(pkg_name)
removed = []
skipped_shared = []
skipped_sensitive = []
for fpath in pkg_files:
owners = _db_get_file_owners(fpath)
# Sprawdź czy inny ZAINSTALOWANY pakiet też jest właścicielem
other_owners = [o for o in owners if o != pkg_name and o in installed_db]
if other_owners:
# Plik współdzielony – tylko usuń wpis w DB, nie kasuj pliku
skipped_shared.append(fpath)
continue
full = os.path.join(PAG_ROOT, fpath.lstrip("/"))
if os.path.isfile(full) or os.path.islink(full):
# Wrażliwej konfiguracji systemowej (/etc/pam.d, sudoers, shadow…)
# NIE kasujemy przy `remove` – jej brak potrafi zablokować logowanie
# i sudo (np. usunięcie system-auth/system-account). Zostaje wpis w bazie.
if _is_sensitive_config(fpath):
skipped_sensitive.append(fpath)
continue
# .pacsave: zachowaj ZMIENIONY plik konfiguracyjny zamiast kasować
# (porównanie z sumą z chwili instalacji), wzorzec jak w pacmanie.
if not os.path.islink(full) and _is_config_path(fpath):
old_sha = recorded.get(fpath, "")
if old_sha:
try:
cur_sha = _sha256_file(full)
except OSError:
cur_sha = ""
if cur_sha and cur_sha != old_sha:
pacsave = full + ".pacsave"
try:
os.replace(full, pacsave)
print(f" ⚠ {_('conf_pacsave', path=pacsave)}")
removed.append(fpath)
continue
except OSError:
pass
os.remove(full)
removed.append(fpath)
# Usuń puste katalogi (od najgłębszych)
dirs = set()
for fpath in removed + skipped_shared:
parent = os.path.dirname(fpath)
while parent and parent != "/":
dirs.add(parent)
parent = os.path.dirname(parent)
for d in sorted(dirs, key=len, reverse=True):
full_d = os.path.join(PAG_ROOT, d.lstrip("/"))
if os.path.isdir(full_d):
try:
os.rmdir(full_d)
except OSError:
pass # nie jest pusty – OK
# Usuń z SQLite
_db_remove_package_files(pkg_name)
if skipped_shared:
print(_(' ⚠ {arg1} shared files preserved', arg1=(len(skipped_shared))))
if skipped_sensitive:
print(_(' ⚠ {arg1} sensitive system files preserved', arg1=(len(skipped_sensitive))))
return len(removed) + len(skipped_shared) + len(skipped_sensitive), removed
def _remove_stale_files(pkg_name: str, old_files: List[str], new_paths: List[str],
installed_db: dict, deploy_dir: str = "",
backup_dir: str = "", backup_journal: Optional[list] = None) -> Tuple[int, List[str]]:
"""
Po upgrade usuwa pliki starej wersji, których nie ma w nowej.
- Pliki współdzielone z innym zainstalowanym pakietem są ZACHOWYWANE
(usuwany jest tylko wpis z bazy `files` dla tego pakietu).
- Sprząta puste katalogi i wpisy SQLite starej wersji.
Zwraca (liczba usuniętych, [usunięte ścieżki]).
"""
new_set = set(new_paths)
# Warianty /usr/lib <-> /usr/lib64: plik obecny w nowej wersji pod równoważną
# ścieżką NIE jest przestarzały. Bez tego upgrade kasował właśnie
# zainstalowany plik, gdy stara i nowa wersja używały różnych libdir
# (kolizja lib/lib64).
new_effective = set()
for _p in new_set:
new_effective.add(_p)
if _p.startswith("/usr/lib64/"):
new_effective.add("/usr/lib/" + _p[len("/usr/lib64/"):])
elif _p.startswith("/usr/lib/"):
new_effective.add("/usr/lib64/" + _p[len("/usr/lib/"):])
stale = [f for f in old_files if f not in new_effective]
if not stale:
return 0, []
root = deploy_dir or PAG_ROOT
removed = []
skipped = 0
for fpath in stale:
owners = _db_get_file_owners(fpath)
other_owners = [o for o in owners if o != pkg_name and o in installed_db]
if other_owners:
# Współdzielony z innym pakietem – tylko usuń wpis z DB dla tego pakietu
skipped += 1
else:
# Wrażliwych plików systemowych NIE kasujemy, gdy nowy pakiet ich już
# nie dostarcza (np. shadow przestaje pakować system-*). Ich brak
# blokuje login/sudo; usuwamy więc tylko wpis w bazie.
if _is_sensitive_config(fpath):
skipped += 1
else:
# Gdy nowa wersja pliku /etc trafiła do .pacnew, plik użytkownika
# MUSI zostać – nie jest „przestarzały”. Zachowujemy też wpis w bazie
# (stara suma), by kolejny upgrade dalej wykrywał zmiany użytkownika.
if _is_config_path(fpath):
_cfg_full = os.path.join(PAG_ROOT, fpath.lstrip("/"))
if os.path.lexists(_cfg_full + ".pacnew"):
skipped += 1
continue
full = os.path.join(root, fpath.lstrip("/"))
if os.path.isfile(full) or os.path.islink(full):
try:
if backup_dir and backup_journal is not None:
backup_path = os.path.join(backup_dir, fpath.lstrip("/"))
os.makedirs(os.path.dirname(backup_path), exist_ok=True)
os.replace(full, backup_path) # przenieś do backupu (rollback)
backup_journal.append((backup_path, fpath))
else:
os.remove(full)
removed.append(fpath)
except OSError:
pass
# Usuń wpis `files` dla tego pakietu (stara wersja już go nie zawiera)
with _db_session() as db:
db.execute("DELETE FROM files WHERE package=? AND path=?", (pkg_name, fpath))
# Usuń puste katalogi (od najgłębszych)
dirs = set()
for fpath in removed:
parent = os.path.dirname(fpath)
while parent and parent != "/":
dirs.add(parent)
parent = os.path.dirname(parent)
for d in sorted(dirs, key=len, reverse=True):
full_d = os.path.join(root, d.lstrip("/"))
if os.path.isdir(full_d):
try:
os.rmdir(full_d)
except OSError:
pass # nie jest pusty – OK
if removed:
print(_(' 🧹 Removed {arg1} obsolete files ({arg2})', arg1=(len(removed)), arg2=(pkg_name)))
if skipped:
print(_(' ⚠ {arg1} shared files preserved', arg1=(skipped)))
return len(removed), removed
def _new_transaction_backup_root() -> str:
"""Katalog na backupy NADPISYWANYCH plików dla bieżącej transakcji.
Tworzony dla KAŻDEJ transakcji, nie tylko upgrade: „świeża” instalacja
pakietu też potrafi nadpisać pliki spoza bazy pag (baza rootfs/ISO).
Gdy transakcja padnie, rollback MUSI mieć co przywrócić – inaczej kasuje
te pliki (tak zniknął m.in. libpam.so.0 i przestał działać sudo)."""
txn = datetime.now().strftime("%Y%m%dT%H%M%S") + "-" + str(os.getpid())
root = os.path.join(STAGING_DIR, "backups", txn)
os.makedirs(root, exist_ok=True)
return root
def _purge_old_backups(keep_root: str = ""):
"""Usuwa backupy starszych transakcji (zostawia bieżący – dla `pag rollback`)."""
base = os.path.join(STAGING_DIR, "backups")
if not os.path.isdir(base):
return
for entry in os.listdir(base):
p = os.path.join(base, entry)
if p != keep_root and os.path.isdir(p):
shutil.rmtree(p, ignore_errors=True)
def _recover_interrupted_transactions(verbose=True) -> int:
"""Przywraca pliki po transakcji PRZERWANEJ w polowie (crash / kill -9).
Backup transakcji (/.pag_staging/backups/<txn>) powstaje, ZANIM pliki zostana
podmienione. Jesli pag zginie w trakcie, czesc plikow jest juz przeniesiona do
backupu, a nowych jeszcze nie ma -> system zostaje bez pliku.
Dla kazdego katalogu backupu, ktory NIE jest zapisany w historii jako UDANA
transakcja (`upgrade_backup_root` przy `success=true`; takie zostawiamy dla
`pag rollback`), przywracamy pliki nieobecne w systemie. Potem odswiezamy
cache linkera.
"""
base = os.path.join(STAGING_DIR, "backups")
if not os.path.isdir(base):
return 0
try:
history = load_json(HISTORY_FILE) or []
except Exception:
history = []
done_roots = {
e.get("upgrade_backup_root") for e in history
if isinstance(e, dict) and e.get("success") and e.get("upgrade_backup_root")
}
restored = 0
for txn in sorted(os.listdir(base)):
root = os.path.join(base, txn)
if not os.path.isdir(root) or root in done_roots:
continue
for dirpath, _dirs, files in os.walk(root):
for fn in files:
src = os.path.join(dirpath, fn)
rel = os.path.relpath(src, root)
dst = os.path.join(PAG_ROOT, rel)
if os.path.lexists(dst):
continue
try:
os.makedirs(os.path.dirname(dst), exist_ok=True)
if os.path.islink(src):
os.symlink(os.readlink(src), dst)
else:
shutil.copy2(src, dst)
restored += 1
except OSError:
pass
if restored:
try:
subprocess.run(["ldconfig"], capture_output=True, timeout=120)
except Exception:
pass
if verbose:
print(_(' 🛠 Interrupted transaction detected – restored {arg1} missing files.', arg1=(restored)))
return restored
# =============================================================================
# HOOKI
# =============================================================================
# Hooki uruchamiają dowolny plik z pakietu jako root — to naturalna cecha
# menedżera pakietów (apt/pacman też tak mają), dlatego MUSISZ ufać repozytorium.
# Aby ograniczyć ryzyko:
# - hook dostaje minimalne, "czyste" środowisko (bez LD_PRELOAD, BASH_ENV itp.)
# - hooki można wyłączyć (PAG_NO_HOOKS=1) i ustawić timeout (PAG_HOOK_TIMEOUT)
# - każde uruchomienie jest logowane do /var/log/pag/audit.log
# - hook ma wersjonowane API (PKG_HOOK_API)
# =============================================================================
# Lista wykonanych hooków — trafia do wpisu transakcji (informacja w rejestrze).
_HOOKS_RUN: List[str] = []
def _hook_env(pkg: PackageInfo, hook_name: str) -> dict:
"""Buduje minimalne środowisko dla hooka (bez niebezpiecznych zmiennych)."""
return {
"PATH": "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
"HOME": "/root",
"LANG": "C.UTF-8",
"LC_ALL": "C.UTF-8",
"PKG_NAME": pkg.name,
"PKG_VERSION": pkg.version,
"PKG_ACTION": hook_name,
"PKG_HOOK_API": HOOK_API_VERSION,
}
def _hook_timeout() -> int:
"""Timeout hooka w sekundach.
Domyślnie 900 s, bo hooki jądra/NVIDIA budują moduły DKMS i initramfs –
na wolniejszych maszynach to kilka minut. Krótszy limit (dawniej 60 s)
zabijał hook w połowie i zostawiał /boot bez aktualnego initramfs.
Nadpisz przez `PAG_HOOK_TIMEOUT`.
"""
try:
return max(1, int(os.environ.get("PAG_HOOK_TIMEOUT", "900")))
except Exception:
return 900
def _run_hook(hooks_dir: str, hook_name: str, pkg: PackageInfo) -> bool:
"""Uruchamia skrypt hooka jeśli istnieje.
Zwraca True jeśli hook został WYKONANY (istniał i uruchomiono go), False w
pozostałych przypadkach (brak pliku, wyłączone hooki, błąd). Obsługuje
ograniczone środowisko, timeout, logowanie do audytu i rejestr w transakcji.
"""
hook_path = os.path.join(hooks_dir, hook_name)
if not os.path.exists(hook_path):
return False
if os.environ.get("PAG_NO_HOOKS", "") == "1":
print(_(' ⚠ Hook skipped (PAG_NO_HOOKS=1): {arg1} for {arg2}', arg1=(hook_name), arg2=(pkg.name)))
_audit(f"hook SKIP {hook_name} {pkg.name}-{pkg.version} (PAG_NO_HOOKS=1)")
return False
os.chmod(hook_path, 0o755)
env = _hook_env(pkg, hook_name)
tag = f"{hook_name} {pkg.name}-{pkg.version}"
try:
result = subprocess.run([hook_path], env=env, timeout=_hook_timeout(),
check=False, capture_output=True, text=True,
cwd="/")
_HOOKS_RUN.append(tag)
if result.returncode != 0:
print(_(' ⚠ Hook {arg1} for {arg2} exited with code {arg3}', arg1=(hook_name), arg2=(pkg.name), arg3=(result.returncode)))
if result.stderr:
print(f" {result.stderr.strip()[-200:]}")
_audit(f"hook FAIL {tag} rc={result.returncode}")
else:
_audit(f"hook OK {tag}")
return True
except subprocess.TimeoutExpired:
print(_(' ⚠ Hook {arg1} for {arg2} timed out ({arg3}s)', arg1=(hook_name), arg2=(pkg.name), arg3=(_hook_timeout())))
print(_(' Increase PAG_HOOK_TIMEOUT (e.g. PAG_HOOK_TIMEOUT=1800) and retry.'))
_audit(f"hook TIMEOUT {tag}")
return False
except Exception as e:
print(_(' ⚠ Hook {arg1} for {arg2}: {arg3}', arg1=(hook_name), arg2=(pkg.name), arg3=(e)))
_audit(f"hook ERROR {tag}: {e}")
return False
# =============================================================================
# TRANSAKCJE I ROLLBACK
# =============================================================================
def _record_transaction(action, packages, success, snapshot, file_journal=None, hooks=None,
upgrade_backups=None, upgrade_backup_root="", snapshot_id=""):
history = load_json(HISTORY_FILE) if os.path.exists(HISTORY_FILE) else []
# Rejestr wykonanych hooków – informacja o tym, że uruchomiono kod pakietu
# jako root. Trafia do historii, by dało się później sprawdzić, co się działo.
executed_hooks = list(_HOOKS_RUN) if hooks is None else hooks
_HOOKS_RUN.clear()
entry = {
"action": action, "packages": packages, "success": success,
"timestamp": datetime.now().isoformat(),
"snapshot": snapshot,
"file_journal": file_journal, # lista plików do wycofania
"hooks": executed_hooks, # wykonane hooki (pre/post-install/remove)
}
if snapshot_id:
# Snapshot systemu (btrfs) z chwili PRZED transakcją – można z niego
# uruchomić system z menu GRUB albo podejrzeć `pag snapshot-list`.
entry["snapshot_id"] = snapshot_id
if upgrade_backups:
entry["upgrade_backups"] = upgrade_backups # {dst: backup_path}
entry["upgrade_backup_root"] = upgrade_backup_root
history.append(entry)
if len(history) > 50:
history = history[-50:]
save_json(HISTORY_FILE, history)
def _action_label(action):
key = "action_" + str(action)
return _(key) if key in T.get("en", {}) else str(action)
def cmd_history():
if not os.path.exists(HISTORY_FILE):
print(_("no_history")); return
history = load_json(HISTORY_FILE)
if not history:
print(_("no_history")); return
print(_('Recent transactions ({arg1}):', arg1=(len(history))))
for i, e in enumerate(reversed(history), 1):
icon = "✅" if e["success"] else "❌"
pkgs = ", ".join(e["packages"][:5])
if len(e["packages"]) > 5: pkgs += f" (+{len(e['packages'])-5})"
print(f" {i}. {icon} {_action_label(e['action'])}: {pkgs}")
print(f" {e['timestamp']}")
def cmd_rollback():
if not os.path.exists(HISTORY_FILE):
print(_("no_history")); return 1
history = load_json(HISTORY_FILE)
if not history:
print(_("no_history")); return 1
last = None
for e in reversed(history):
if e["success"] and e.get("snapshot"):
last = e; break
if not last:
print(_('❌ No snapshot to restore.')); return 1
print(_('⏪ Rolling back: {arg1} ({arg2})', arg1=(_action_label(last['action'])), arg2=(last['timestamp'])))
print(_(' Packages: {arg1}', arg1=(', '.join(last['packages'][:10]))))
if not _ask_confirm():
return 0
# Przywróć installed.json
save_json(INSTALLED_DB, last["snapshot"])
# Wycofaj fizyczne pliki (jeśli zapisano journal)
# Deduplikacja: pakiet może zgłosić ten sam plik więcej niż raz (np. przez
# `provides` lub wspólną ścieżkę), a journal z historii mógł zostać zapisany
# przed dodaniem deduplikacji.
file_journal = list(dict.fromkeys(last.get("file_journal", [])))
upgrade_backups = last.get("upgrade_backups", {}) or {}
backup_root = last.get("upgrade_backup_root", "")
# Przywróć stare wersje z backupów (upgrade) – nadpisane i usunięte stale pliki
for dst, bpath in upgrade_backups.items():
full = os.path.join(PAG_ROOT, dst.lstrip("/"))
if bpath and os.path.lexists(bpath):
try:
os.makedirs(os.path.dirname(full), exist_ok=True)
os.replace(bpath, full)
except OSError:
pass
# Usuń nowe pliki (które nie miały poprzedniej wersji)
backed = set(upgrade_backups)
if file_journal:
for fpath in reversed(file_journal):
if fpath in backed:
continue
full = os.path.join(PAG_ROOT, fpath.lstrip("/"))
if os.path.exists(full) or os.path.islink(full):
os.remove(full)
print(f" {_('rollback_files', len(file_journal))}")
# Sprzątanie pustych katalogów + katalogu backupów
dirs = set()
for fpath in file_journal:
parent = os.path.dirname(fpath)
while parent and parent != "/":
dirs.add(parent)
parent = os.path.dirname(parent)
for d in sorted(dirs, key=len, reverse=True):
full_d = os.path.join(PAG_ROOT, d.lstrip("/"))
if os.path.isdir(full_d):
try:
os.rmdir(full_d)
except OSError:
pass
if backup_root:
shutil.rmtree(backup_root, ignore_errors=True)
print(f"✅ {_('rollback_restored')}")
_record_transaction("rollback", last["packages"], True, None)
return 0
# =============================================================================
# INSTALACJA
# =============================================================================
def _install_local_pkg_files(paths, install_succeeded):
"""Instaluje lokalne pliki .pag (bez repozytorium).
Najpierw przygotowuje WSZYSTKIE paczki w stagingu, potem je nakłada.
Dzięki temu uszkodzony plik w środku grupy nie zostawia systemu
w połowie instalacji. Zwraca (failed_count, installed_files).
"""
failed = 0
prepared = []
for p in paths:
p = os.path.abspath(p)
if not os.path.isfile(p):
print(_(' ❌ Package not found: {arg1}', arg1=(p)))
failed += 1
break
if not _verify_local_pkg_signature(p):
failed += 1
break
try:
with tarfile.open(p, "r:xz") as tf:
meta = tf.extractfile("metadata.json")
if meta is None:
print(_(' ❌ {arg1}: missing metadata.json', arg1=(p)))
failed += 1
break
data = json.loads(meta.read())
except Exception as e:
print(_(' ❌ {arg1}: failed to read package ({arg2})', arg1=(p), arg2=(e)))
failed += 1
break
pkg = PackageInfo(data, repo="local")
staged = _stage_package(p, pkg)
if not staged:
failed += 1
break
prepared.append((pkg, staged))
if failed:
for _pkg, _st in prepared:
_discard_staged(_st)
print(_(' ↩ Preparation stage failed – the system was NOT changed.'))
return failed, []
all_files = []
for pkg, staged in prepared:
print(_(' ↓ {arg1}-{arg2} (local) ... ', arg1=(pkg.name), arg2=(pkg.version)), end="", flush=True)
ok, files, _ = _apply_staged_package(staged, pkg)
if ok:
install_succeeded(pkg, files)
all_files.extend(f["path"] for f in files)
print("✅")
else:
print("❌")
failed += 1
return failed, all_files
def _preflight_disk(total_bytes: int) -> bool:
"""Pre-flight przed transakcją: wolne miejsce + mount read-only.
Zwraca False (przerywa instalację) gdy na partycji docelowej brakuje
miejsca na pakiety albo katalog stagingu jest zamontowany read-only
(inaczej instalacja rwałaby się w połowie, zostawiając uszkodzony system).
"""
target = PAG_ROOT or "/"
try:
st = os.statvfs(target)
free = st.f_bavail * st.f_frsize
except OSError:
return True # nie da się sprawdzić – nie blokuj
need_mb = total_bytes // 1048576
free_mb = free // 1048576
if free < total_bytes:
print(_(' ❌ Not enough disk space: need ~{arg1} MB, free {arg2} MB ({arg3})', arg1=(need_mb), arg2=(free_mb), arg3=(target)))
return False
if free < total_bytes * 3:
print(_(' ⚠ Low disk space: {arg1} MB free, packages ~{arg2} MB (extracted will take more)', arg1=(free_mb), arg2=(need_mb)))
# Wykryj mount read-only (test zapisu w stagingu)
try:
probe = os.path.join(STAGING_DIR, ".pag-probe")
with open(probe, "w") as f:
f.write("x")
os.remove(probe)
except OSError:
print(_(' ❌ {arg1} is mounted read-only – cannot install.', arg1=(target)))
return False
return True
def cmd_install(package_names, as_dep=False, upgrade=False):
ensure_dirs()
installed_db = load_json(INSTALLED_DB)
world = load_world()
pinned = load_json(PINNED_FILE)
# Obsługa lokalnych plików .pkg.tar.xz (zbudowanych przez pagbuild) –
# nie wymaga repozytorium ani GPG.
local_files = [p for p in package_names if p.endswith(PKG_EXT) or
(os.sep in p and os.path.isfile(os.path.abspath(p)))]
if local_files:
_local_need = sum(
os.path.getsize(os.path.abspath(p))
for p in local_files if os.path.isfile(os.path.abspath(p))
)
if not _preflight_disk(_local_need):
return 1
def _ok(pkg, files):
installed_db[pkg.name] = {
"version": pkg.version, "release": pkg.release, "description": pkg.description,
"dependencies": pkg.dependencies, "size_bytes": pkg.size_bytes,
"sha256": pkg.sha256, "installed_at": datetime.now().isoformat(),
"repo": "local",
"provides": getattr(pkg, "provides", None) or [],
"provides_so": getattr(pkg, "provides_so", None) or [],
"requires_so": getattr(pkg, "requires_so", None) or [],
}
world.add(pkg.name)
failed_local, _fl = _install_local_pkg_files(local_files, _ok)
save_json(INSTALLED_DB, installed_db)
save_world(world)
if failed_local:
return 1
_refresh_dynamic_linker_cache()
package_names = [n for n in package_names if n not in
[os.path.abspath(x) for x in local_files] and
n not in local_files]
to_install = []
if not package_names:
return 0
# pozostałe argumenty to nazwy pakietów z repo – kontynuuj
repo_pkgs = fetch_all_packages()
if not repo_pkgs:
print(f"❌ {_('no_index')}"); return 1
for name in list(package_names):
if name in pinned:
print(f"⚠ {name} {_('pinned_to')} {pinned[name]} – skipping")
package_names.remove(name)
to_install, missing_deps = _resolve_deps(package_names, repo_pkgs, installed_db)
# ── Pakiety, których NIE MA w repo ani nie są zainstalowane ──
# Zgłoś od razu zamiast mylącego „Do zainstalowania: N (0.00 MB)”
# i prośby o potwierdzenie (np. `pag install steam` gdy steam nie istnieje).
not_found = []
for n in package_names:
real = _resolve_provides(n, repo_pkgs, installed_db)
if real not in repo_pkgs and real not in installed_db \
and not os.path.exists(os.path.abspath(n)):
not_found.append(n)
if not_found:
print(f"\n ❌ {_('pkg_not_found', ', '.join(not_found))}")
print(f" {_('not_found_hint')}")
return 1
# --- Tryb upgrade: pakiety już zainstalowane MUSZĄ zostać ponownie
# zainstalowane z nowszej wersji (zastąpienie w tej samej transakcji).
if upgrade:
# `pag update` przekazuje tu tylko pakiety z NOWSZĄ wersją (już
# przefiltrowane w _pending_updates), a `pag install -f` wymusza
# reinstalację nawet tej SAMEJ wersji – dlatego nie filtrujemy po
# _version_newer.
upgrade_targets = [
name for name in package_names
if name in repo_pkgs
and name in installed_db
and name not in pinned
]
for name in upgrade_targets:
if name not in to_install:
to_install.append(name)
if not to_install and not missing_deps:
print(f"✅ {_('all_installed')}"); return 0
# ── WERYFIKACJA ZALEŻNOŚCI ──────────────────────────────────────────
fatal_missing = _verify_dependencies(to_install, repo_pkgs, installed_db)
if fatal_missing > 0:
print(_('❌ Cannot continue – {arg1} missing dependencies.', arg1=(fatal_missing)))
print(_(' Install the missing packages or add repositories.'))
return 1
so_missing = _verify_so_deps(to_install, repo_pkgs, installed_db)
if so_missing > 0:
print(_(' Install the library provider or update the repository.'))
return 1
if not to_install:
print(f"✅ {_('all_installed')}"); return 0
MAX_MB = MAX_PKG_SIZE // 1048576
for n in to_install:
if not _validate_pkg_name(n):
print(f" {_("sec_badname", name=n)}")
return 1
sz = repo_pkgs[n].size_bytes if n in repo_pkgs else 0
if sz > MAX_PKG_SIZE:
mb = sz // 1048576
print(f" {_("sec_toobig", size_mb=mb, max_mb=MAX_MB)}")
return 1
total_size = sum(repo_pkgs[n].size_bytes for n in to_install if n in repo_pkgs)
if not _preflight_disk(total_size):
return 1
print(f"\n📦 {_('to_install', len(to_install), total_size/1048576)}")
for name in to_install:
p = repo_pkgs.get(name)
if p:
if name in installed_db:
marker = f" {_('upgrade_marker')}" if upgrade else ""
else:
marker = f" [{_('new')}]"
print(f" {name}-{p.version}{marker}")
# Pakiet z bazy obrazu ISO (nie w installed.json) → ostrzeż, że pliki z ISO
# zostaną zastąpione pakietem z repo (kopia do `pag rollback`).
_base_warn_overwrite(to_install)
if not as_dep and not upgrade:
if not _ask_confirm():
print(_("cancelled")); return 0
# `--dry-run`: pokaż plan i wyjdź. Nic nie jest pobierane, rozpakowywane
# ani zmieniane – bezpieczne sprawdzenie, co zrobiłaby transakcja.
if os.environ.get("PAG_DRY_RUN", "") == "1":
print(f"\n 🧪 {_('dry_run_plan')}")
for _n in to_install:
_p = repo_pkgs.get(_n)
if _p:
_mark = f" {_('upgrade_marker')}" if _n in installed_db else f" [{_('new')}]"
print(f" {_n}-{_p.version}{_mark}")
print(f" {_('dry_run_done')}")
return 0
snapshot = copy.deepcopy(installed_db)
all_installed_files = []
failed = []
# Pary (pkg, stare_pliki, nowe_pliki) do usunięcia martwych plików po upgrade
stale_candidates = []
# Katalog backupów nadpisywanych plików – dla poprawnego rollbacku.
# Dla KAŻDEJ transakcji: instalacja „nowego” pakietu także nadpisuje pliki
# spoza bazy pag (baza rootfs/ISO), a rollback bez backupu by je skasował.
backup_root = ""
all_backups: List[Tuple[str, str]] = [] # (backup_path, dst)
if to_install:
backup_root = _new_transaction_backup_root()
# --- Dziennik transakcji (dla pełnej atomowości) ---
# Jeśli którykolwiek pakiet zawiedzie, cofamy WSZYSTKIE zainstalowane
# w tej transakcji przez _rollback_transaction().
transaction_journal: List[Tuple[str, str, str]] = [] # (op, src, dst)
# --- Tryb immutable: utwórz nowy deployment ---
immutable = os.environ.get("PAG_IMMUTABLE", "") == "1"
deploy_dir = ""
deploy_id = ""
if immutable:
print(_('\n 🏗️ Creating a new deployment...'))
deploy_dir, deploy_id = _create_deployment(to_install, "upgrade" if upgrade else "install")
target_root = deploy_dir
else:
target_root = ""
# --- Faza 1: Równoległe pobieranie wszystkich pakietów ---
to_download = [repo_pkgs[name] for name in to_install if name in repo_pkgs]
if len(to_download) > 1:
print(_('\n ⏬ Downloading {arg1} packages in parallel...', arg1=(len(to_download))))
downloaded = _download_packages_parallel(to_download)
else:
downloaded = {}
# --- Faza 1b: WERYFIKACJA WSZYSTKICH paczek PRZED instalacją ---
# KLUCZOWE: GPG i SHA256 sprawdzamy dla WSZYSTKICH paczek, ZANIM
# zainstalujemy choćby jedną. Inaczej instalowany pakiet może podmienić
# bibliotekę używaną przez sam gpg (np. libassuan 3.0.1 zmienił namespace
# symboli LIBASSUAN_1.0 -> LIBASSUAN_2.0) i wtedy weryfikacja kolejnych
# paczek w tej samej transakcji pada, dając fałszywe
# „NIEPRAWIDŁOWY PODPIS GPG".
verified = {}
_vfail = []
for _name in to_install:
_pkg = repo_pkgs.get(_name)
if not _pkg:
_vfail.append((_name, _('not_found')))
continue
_pp = downloaded.get(_name)
if not _pp:
_pp = _download_pkg(_pkg)
if not _pp:
_vfail.append((_name, _('download_fail')))
continue
_gok, _gmsg = _verify_pkg_gpg(_pp, repo_url=_pkg.repo_url)
if not _gok:
_vfail.append((_name, f"{_('gpg_fail')}: {_gmsg[:60]}"))
continue
if _pkg.sha256 and _sha256_file(_pp) != _pkg.sha256:
_vfail.append((_name, _('sha256_mismatch')))
continue
verified[_name] = _pp
if _vfail:
for _n, _m in _vfail:
print(f" ❌ {_n}: {_m}")
print(_(' ↩ Aborted BEFORE installation – no package was changed.'))
return 1
# --- Snapshot systemu PRZED transakcją (btrfs CoW) ---
# Tworzymy go PO pobraniu i weryfikacji paczek, ale PRZED rozpakowaniem
# czegokolwiek do systemu. Domyślnie `auto`: tylko na btrfs. `--snapshot`
# wymusza migawkę (i przerywa, gdy się nie uda), `--no-snapshot` wyłącza.
snapshot_mode = (os.environ.get("PAG_SNAPSHOT") or "auto").strip().lower()
sys_snap: Optional[dict] = None
if to_install and snapshot_mode not in ("never", "no", "0", "off"):
_snap_ok, _snap_why = _snapshot_support()
if _snap_ok:
sys_snap = _create_system_snapshot(
to_install, "upgrade" if upgrade else "install")
if sys_snap:
_refresh_bootloader()
elif snapshot_mode in ("always", "require", "1", "yes"):
print(_(' ❌ Failed to create snapshot (--snapshot mode) – aborting.'))
return 1
elif snapshot_mode in ("always", "require", "1", "yes"):
print(f" ❌ {_('snapshot_unsupported', _snap_why)}")
return 1
else:
print(f" ℹ {_('snapshot_unsupported', _snap_why)}")
# --- Faza 1c: PRZYGOTOWANIE CAŁEJ GRUPY W STAGINGU ---
# Rozpakowujemy WSZYSTKIE pakiety do `/.pag_staging/.stage-*`, zanim
# dotkniemy systemu. Jeśli jedna z 50 paczek (np. GNOME) jest uszkodzona,
# transakcja kończy się tutaj – na dysku nie ma żadnych zmian.
atomic = os.environ.get("PAG_ATOMIC", "1") != "0"
staged_pkgs: List[Tuple[str, PackageInfo, Optional[dict]]] = []
if atomic and to_install:
print(f"\n 🧰 {_('staging_prepare', len(to_install))}")
_sbar = _StepBar(len(to_install), icon="🧰 ", width=25)
_stage_failed: List[str] = []
for _si, _name in enumerate(to_install, 1):
_pkg = repo_pkgs.get(_name)
_pp = verified.get(_name)
if not _pkg or not _pp:
_stage_failed.append(_name)
break
_sbar.step(_si, f"{_name}-{_pkg.version}")
_st = _stage_package(_pp, _pkg)
if not _st:
_stage_failed.append(_name)
break
staged_pkgs.append((_name, _pkg, _st))
_sbar.end()
if _stage_failed:
for _n, _p, _st in staged_pkgs:
_discard_staged(_st)
print(f" ↩ {_('staging_failed')}")
if backup_root:
shutil.rmtree(backup_root, ignore_errors=True)
_record_transaction("upgrade" if upgrade else "install", to_install, False,
snapshot,
snapshot_id=sys_snap["id"] if sys_snap else "")
return 1
print(f" ✅ {_('staging_commit')}")
elif to_install:
staged_pkgs = [(n, repo_pkgs[n], None) for n in to_install]
# --- Faza 2: Instalacja – JEDNA nadpisywana linia postępu (jak przy
# pobieraniu), bez ściany tekstu na każdy pakiet. W trybie
# nieinteraktywnym (logi, netinstall instalatora) wypisujemy linię na
# pakiet – tam to pożądane do logu.
t0 = time.time()
stdout_tty = sys.stdout.isatty()
# Animowany pasek postępu („drakkar”) – jedna nadpisywana linia; morze
# faluje nawet wtedy, gdy pojedynczy pakiet instaluje się długo.
_pbar = _StepBar(len(to_install), icon="📦 ", width=25)
def _bar_draw(idx: int, name: str) -> None:
_pbar.step(idx, name)
def _bar_end() -> None:
_pbar.end()
for _pkg_i, (name, pkg, _staged) in enumerate(staged_pkgs, 1):
if not pkg:
_bar_end()
print(f" ❌ {name}: {_('not_found')}")
failed.append(name)
break
_bar_draw(_pkg_i, f"{name}-{pkg.version}")
# Przed instalacją zapamiętaj pliki starej wersji (potrzebne w upgrade)
old_files = _db_get_package_files(name) if name in installed_db else []
# Stare sumy SHA256 – do wykrycia zmian użytkownika w plikach /etc (.pacnew)
old_checksums = _db_get_package_checksums(name) if name in installed_db else None
# Commit przygotowanego pakietu (w upgrade backupuje nadpisywane pliki).
# Tryb `PAG_ATOMIC=0` zachowuje starą ścieżkę pojedynczą (staging per pakiet).
if _staged is not None:
ok, files, backup_j = _apply_staged_package(
_staged, pkg, deploy_dir,
backup_dir=backup_root,
old_checksums=old_checksums)
else:
# Ścieżka pobrana i ZWERYFIKOWANA w fazie 1b.
pkg_path = verified.get(name)
if not pkg_path:
_bar_end()
print(f" ❌ {name}: {_('download_fail')}")
failed.append(name)
break # przerwij transakcję
ok, files, backup_j = _atomic_install(
pkg_path, pkg, deploy_dir,
backup_dir=backup_root,
old_checksums=old_checksums)
if ok:
installed_db[name] = {
"version": pkg.version, "release": pkg.release, "description": pkg.description,
"dependencies": pkg.dependencies, "size_bytes": pkg.size_bytes,
"sha256": pkg.sha256, "installed_at": datetime.now().isoformat(),
"repo": pkg.repo_url,
"provides": getattr(pkg, "provides", None) or [],
"provides_so": getattr(pkg, "provides_so", None) or [],
"requires_so": getattr(pkg, "requires_so", None) or [],
}
if not as_dep and name in package_names:
world.add(name)
if not stdout_tty:
print(f" ✓ {name}-{pkg.version}", flush=True)
all_installed_files.extend(f["path"] for f in files)
all_backups.extend(backup_j)
# Upgrade: zapamiętaj stare pliki, by po sukcesie usunąć te,
# których nie ma już w nowej wersji.
if upgrade and old_files:
stale_candidates.append((name, old_files, [f["path"] for f in files]))
else:
_bar_end()
print(f" ❌ {name}: {_('install_failed')}")
failed.append(name)
break # PRZERWIJ – błąd instalacji
# Deduplikacja journalu – ten sam plik może trafić tu dwukrotnie (np. przez
# `provides`); rollback i historia nie potrzebują duplikatów.
all_installed_files = list(dict.fromkeys(all_installed_files))
# --- Rollback całej transakcji jeśli cokolwiek zawiodło ---
if failed:
_bar_end()
print(_('\n ↩ Rolling back transaction ({arg1} errors)...', arg1=(len(failed))))
for _n, _p, _st in staged_pkgs:
_discard_staged(_st)
_rollback_transaction(installed_db, snapshot, all_installed_files,
deploy_dir, immutable, backups=all_backups)
if backup_root:
shutil.rmtree(backup_root, ignore_errors=True)
_record_transaction("upgrade" if upgrade else "install", to_install, False,
snapshot,
snapshot_id=sys_snap["id"] if sys_snap else "")
return 1
save_json(INSTALLED_DB, installed_db)
save_world(world)
# --- Po ZAPISANIU bazy: usuń nieaktualne pliki starych wersji (upgrade).
# Kolejność ma znaczenie: najpierw utrwalamy stan nowej wersji w bazie, a
# dopiero potem kasujemy pliki, których nowa wersja nie zawiera. Odwrotna
# kolejność (kasowanie przed zapisem) przy przerwaniu zostawiała system bez
# plików. Usunięte pliki trafiają do backupu, aby `pag rollback` mógł je
# przywrócić.
for pkg_name, old_files, new_paths in stale_candidates:
_remove_stale_files(pkg_name, old_files, new_paths, installed_db, deploy_dir,
backup_root, all_backups)
_record_transaction("upgrade" if upgrade else "install", to_install, True, snapshot,
file_journal=all_installed_files,
upgrade_backups={dst: bp for bp, dst in all_backups} if all_backups else None,
upgrade_backup_root=backup_root,
snapshot_id=sys_snap["id"] if sys_snap else "")
# Zachowaj backupy bieżącej transakcji (dla `pag rollback`), usuń starsze.
if backup_root:
_purge_old_backups(keep_root=backup_root)
_bar_end()
# --- Tryb immutable: przełącz na nowy deployment ---
if immutable and not failed:
_refresh_dynamic_linker_cache(deploy_dir)
# Initramfs dla deploymentu budujemy RAZ – po wszystkich pakietach,
# żeby zawierał też moduły nvidia/vbox dołożone w tej transakcji.
if any(_needs_initramfs_refresh(_n) for _n in to_install):
print(_('\n 🐧 Finalizing kernel/driver update in deployment (depmod + initramfs)...'))
_refresh_depmod(deploy_dir)
_rebuild_initramfs(deploy_dir)
print(_('\n 🔄 Switching to deployment {arg1}...', arg1=(deploy_id)))
_switch_deployment(deploy_dir)
print(_(' ✅ Active deployment: {arg1}', arg1=(deploy_id)))
_update_grub_config()
cmd_deploy_cleanup(keep=5) # Zostawia 5 najnowszych deploymentów
print(_(' 💡 Restart required to reload the system.'))
else:
_refresh_dynamic_linker_cache()
# Hooki zbiorcze – raz na transakcję (fc-cache itp.), tylko gdy pliki
# trafiły do realnego systemu (nie do deploymentu).
_process_triggers(all_installed_files)
# Jądro/sterowniki zmienione na ZWYKŁEJ instalacji → DKMS + initramfs +
# GRUB, dokładnie RAZ i po wszystkich pakietach. Hook pakietu nie może
# odświeżyć GRUB-a (trzymany lock PAG-a), a wcześniejsza przebudowa
# initramfs w pętli dawała fałszywe ETA i dublowała pracę.
if any(_needs_initramfs_refresh(_n) for _n in to_install):
print(_('\n 🐧 Finalizing kernel/driver update (DKMS → depmod → initramfs → GRUB)...'))
_post_kernel_hooks()
elif sys_snap:
# Snapshot istnieje, ale nie było zmiany jądra – odśwież menu GRUB,
# żeby wpis migawki był widoczny przy najbliższym starcie.
_ensure_snapshot_grub_script()
_refresh_bootloader()
print(f"\n✅ {_('installed', len(to_install))} ({(time.time()-t0):.0f}s)")
return 0
def _rollback_transaction(installed_db: dict, snapshot: dict,
installed_files: List[str],
deploy_dir: str, is_immutable: bool,
backups: Optional[List[Tuple[str, str]]] = None):
"""
Cofa WSZYSTKIE pakiety zainstalowane w bieżącej transakcji.
Przywraca installed_db do stanu sprzed transakcji.
Usuwa fizyczne pliki z systemu (lub deploymentu w trybie immutable).
Jeśli podano `backups` (upgrade) – przywraca stare wersje nadpisanych plików.
"""
# Przywróć installed_db
installed_db.clear()
installed_db.update(snapshot)
root = deploy_dir if is_immutable else PAG_ROOT
backup_map = {dst: src for src, dst in (backups or [])}
# Przywróć stare wersje z backupów (upgrade)
for dst, bpath in backup_map.items():
full = os.path.join(root, dst.lstrip("/"))
if os.path.lexists(bpath):
try:
os.makedirs(os.path.dirname(full), exist_ok=True)
os.replace(bpath, full)
except OSError:
pass
# Usuń nowe pliki (które nie miały poprzedniej wersji)
for fpath in reversed(installed_files):
if fpath in backup_map:
continue
full = os.path.join(root, fpath.lstrip("/"))
if os.path.isfile(full) or os.path.islink(full):
try:
os.remove(full)
except OSError:
pass
# Wyczyść puste katalogi
dirs_to_check = set()
for fpath in installed_files:
parent = os.path.dirname(fpath)
while parent and parent != "/":
dirs_to_check.add(parent)
parent = os.path.dirname(parent)
for d in sorted(dirs_to_check, key=len, reverse=True):
full_d = os.path.join(root, d.lstrip("/"))
if os.path.isdir(full_d):
try:
os.rmdir(full_d)
except OSError:
pass
# W trybie immutable: usuń nieudany deployment
if is_immutable and deploy_dir:
shutil.rmtree(deploy_dir, ignore_errors=True)
save_json(INSTALLED_DB, snapshot)
# =============================================================================
# USUWANIE
# =============================================================================
def cmd_remove(package_names):
installed_db = load_json(INSTALLED_DB)
world = load_world()
snapshot = copy.deepcopy(installed_db)
removed = []
removed_files = []
total = len(package_names)
for i, name in enumerate(package_names, 1):
if name not in installed_db:
print(_(' ⚠ {arg1}: not installed', arg1=(name))); continue
# Pasek postępu (animowany „drakkar” na TTY)
pct = (i - 1) / total * 100
bar = _pagan_bar(pct, 25, time.time(), animated=sys.stderr.isatty())
print(f" 🗑 [{bar}] {i}/{total} ({pct:.0f}%) ", end="\r", file=sys.stderr, flush=True)
print(f"🗑 {name}-{installed_db[name]['version']} ...", end=" ", flush=True)
# Pre-remove hook (jeśli dostępny w staging)
_run_hook_for_installed(name, "pre-remove")
count, rm_files = _safe_remove_files(name, installed_db)
del installed_db[name]
world.discard(name)
removed.append(name)
removed_files.extend(rm_files)
print(_('✅ ({arg1} files)', arg1=(count)))
# Post-remove hook + sprzątanie zapisanych hooków
_run_hook_for_installed(name, "post-remove")
shutil.rmtree(os.path.join(PAG_DB, "hooks", name), ignore_errors=True)
save_json(INSTALLED_DB, installed_db)
save_world(world)
_record_transaction("remove", removed, True, snapshot)
print(file=sys.stderr) # wyczyść linię paska postępu
if not removed: return 0
print(_('\n✅ Removed {arg1}.', arg1=(len(removed))))
_process_triggers(removed_files)
orphans = _find_orphans(installed_db, world)
if orphans:
print(f"\n💡 {_('orphans_found', len(orphans), ', '.join(sorted(orphans)[:10]))}")
print(_(" 'pag remove-orphans' to clean up."))
return 0
def _run_hook_for_installed(pkg_name, hook_name):
"""Próbuje uruchomić hook z katalogu pakietu (jeśli został zapisany)."""
hook_dir = os.path.join(PAG_DB, "hooks", pkg_name)
if os.path.isdir(hook_dir):
ver = load_json(INSTALLED_DB).get(pkg_name, {}).get("version", "")
_run_hook(hook_dir, hook_name, PackageInfo({"name": pkg_name, "version": ver}))
# =============================================================================
# TRIGGERS – hooki zbiorcze (raz na transakcję, nie per pakiet)
# =============================================================================
# Wzorem pacman/dpkg: pakiet/administrator deklaruje zainteresowanie ścieżkami,
# a pasujący trigger uruchamia się DOKŁADNIE RAZ na końcu transakcji
# (np. fc-cache, glib-compile-schemas, update-desktop-database) zamiast po
# każdym pakiecie z osobna.
TRIGGERS_DIR = PAG_CONF + "/triggers"
DEFAULT_TRIGGERS = [
{"name": "font-cache", "paths": ["/usr/share/fonts/", "/usr/local/share/fonts/"],
"run": "fc-cache -fs"},
{"name": "glib-schemas", "paths": ["/usr/share/glib-2.0/schemas/"],
"run": "glib-compile-schemas /usr/share/glib-2.0/schemas"},
{"name": "desktop-database", "paths": ["/usr/share/applications/"],
"run": "update-desktop-database -q /usr/share/applications"},
{"name": "mime-database", "paths": ["/usr/share/mime/"],
"run": "update-mime-database /usr/share/mime"},
{"name": "systemd-daemon-reload", "paths": ["/usr/lib/systemd/system/"],
"run": "systemctl daemon-reload"},
# `systemctl --global daemon-reload` NIE istnieje – --global dotyczy tylko
# enable/disable jednostek. Przeładowanie robi _user_daemon_reload()
# (per zalogowany użytkownik), a "run" zostaje jako opis/cel audytu.
{"name": "systemd-user-daemon-reload", "paths": ["/usr/lib/systemd/user/"],
"internal": "user-daemon-reload",
"run": "systemctl --user daemon-reload"},
{"name": "udev-reload", "paths": ["/usr/lib/udev/rules.d/"],
"run": "udevadm control --reload-rules"},
]
def _load_triggers() -> List[dict]:
"""Ładuje triggery: domyślne (tylko gdy binarka istnieje) + /etc/pag/triggers/*.json."""
out = []
for t in DEFAULT_TRIGGERS:
bin_name = t["run"].split()[0]
if shutil.which(bin_name):
out.append(dict(t))
if os.path.isdir(TRIGGERS_DIR):
for fn in sorted(os.listdir(TRIGGERS_DIR)):
if not fn.endswith(".json"):
continue
try:
with open(os.path.join(TRIGGERS_DIR, fn)) as f:
data = json.load(f)
except (OSError, json.JSONDecodeError):
continue
if isinstance(data, dict):
data = [data]
for t in data:
if isinstance(t, dict) and t.get("name") and t.get("paths") and t.get("run"):
out.append(t)
return out
def _logged_in_users() -> List[tuple]:
"""[(uid, user)] aktywnych logowań wg loginctl. Best-effort."""
try:
r = subprocess.run(["loginctl", "list-users", "--no-legend"],
capture_output=True, text=True, timeout=30)
except Exception:
return []
out = []
for ln in (r.stdout or "").splitlines():
parts = ln.split()
if len(parts) < 2 or not parts[0].isdigit():
continue
out.append((parts[0], parts[1]))
return out
def _user_daemon_reload() -> int:
"""Przeładowuje menedżery systemd ZALOGOWANYCH użytkowników.
`systemctl --user` działa tylko w kontekście danego użytkownika (sesyjny
D-Bus), więc dla roota trzeba wejść w jego sesję. Zwraca liczbę udanych
przeładowań; brak sesji to nie błąd – jednostki wczytają się przy logowaniu.
"""
done = 0
for uid, user in _logged_in_users():
rt = f"/run/user/{uid}"
if not os.path.isdir(rt):
continue
try:
if shutil.which("runuser"):
r = subprocess.run(
["runuser", "-u", user, "--", "env", f"XDG_RUNTIME_DIR={rt}",
"systemctl", "--user", "daemon-reload"],
capture_output=True, timeout=60)
else:
r = subprocess.run(
["su", "-", user, "-c",
f"XDG_RUNTIME_DIR={rt} systemctl --user daemon-reload"],
capture_output=True, timeout=60)
if r.returncode == 0:
done += 1
except Exception:
pass
return done
def _reload_user_media_services(touched_paths: List[str]) -> None:
"""Po aktualizacji multimediow przeladuj uslugi UZYTKOWNIKA (pipewire/wireplumber).
Nowe binarki/moduly sa juz na dysku, ale dzialajace sesje maja stare w
pamieci i probuja ladowac nieistniejace wersje modulow. Best-effort:
przeladowanie menedzerow systemd uzytkownikow + try-restart w sesjach.
"""
if os.environ.get("PAG_NO_HOOKS", "") == "1":
return
_pfx = ("/usr/lib/systemd/user/pipewire", "/usr/lib/systemd/user/wireplumber",
"/usr/bin/pipewire", "/usr/bin/wireplumber",
"/usr/lib/pipewire-0.3/", "/usr/lib64/pipewire-0.3/",
"/usr/lib/wireplumber-0.5/", "/usr/lib64/wireplumber-0.5/")
if not any(_p.startswith(_x) for _x in _pfx for _p in touched_paths):
return
_user_daemon_reload()
try:
_r = subprocess.run(["loginctl", "list-users", "--no-legend"],
capture_output=True, text=True, timeout=30)
_users = [ln.split()[1] for ln in (_r.stdout or "").splitlines()
if len(ln.split()) >= 2]
except Exception:
_users = []
_done = []
for _u in _users:
try:
_rr = subprocess.run(
["su", "-", _u, "-c",
"systemctl --user try-restart pipewire.socket pipewire.service "
"wireplumber.service"],
capture_output=True, timeout=60)
if _rr.returncode == 0:
_done.append(_u)
except Exception:
pass
if _done:
print(_("audio_services_reloaded", ", ".join(sorted(set(_done)))))
def _process_triggers(touched_paths: List[str]):
"""Uruchamia pasujące triggery RAZ na końcu transakcji (best-effort)."""
if not touched_paths:
return
if os.environ.get("PAG_NO_HOOKS", "") == "1":
return
import shlex as _shlex
matched = []
for trig in _load_triggers():
if any(path.startswith(p) for p in trig["paths"] for path in touched_paths):
matched.append(trig)
for trig in matched:
run = trig["run"]
print(_(' ⚡ Trigger: {arg1} ({arg2})', arg1=(trig['name']), arg2=(run)))
if trig.get("internal") == "user-daemon-reload":
_n = _user_daemon_reload()
_audit(f"TRIGGER {trig['name']}: user-daemon-reload ok={_n}")
if not _n:
print(" ℹ " + _('no_user_sessions'))
continue
try:
r = subprocess.run(_shlex.split(run), capture_output=True, text=True, timeout=120)
_audit(f"TRIGGER {trig['name']}: {run} rc={r.returncode}")
if r.returncode != 0:
print(f" ⚠ rc={r.returncode}: {(r.stderr or r.stdout or '').strip()[:160]}")
except subprocess.TimeoutExpired:
print(_(' ⚠ trigger {arg1} timed out (120 s)', arg1=(trig['name'])))
_audit(f"TRIGGER {trig['name']} TIMEOUT")
except Exception as e:
print(_(' ⚠ trigger {arg1}: {arg2}', arg1=(trig['name']), arg2=(e)))
_reload_user_media_services(touched_paths)
# =============================================================================
# UPDATE / UPGRADE / LIST / SEARCH / INFO / VERIFY
# =============================================================================
def _cleanup_tmp_files(*paths):
"""Usuwa tymczasowe pliki (np. .pag.new) po nieudanej operacji."""
for p in paths:
try:
if os.path.isfile(p):
os.remove(p)
except OSError:
pass
def cmd_self_update():
"""Aktualizuje samego klienta pag z repo (podpisany /stable/pag).
Kolejność: pobierz → weryfikacja GPG (+ fingerprint repo) → SHA256 →
kontrola składni (compile) → backup → atomowe os.replace.
Podmieniamy plik, z którego pag ZOSTAŁ URUCHOMIONY (a nie hardkodowane
/usr/local/bin/pag): gdy pakiet instaluje /usr/bin/pag, a self-update
pisał do /usr/local/bin/pag, powstawały DWIE kopie o różnych wersjach
i zależnie od PATH `pag --version` pokazywał raz jedną, raz drugą."""
# Dedykowana blokada – patrz SelfUpdateLock. Chroni zapis dst.new oraz
# os.replace przed równoległą aktualizacją (np. cron + ręcznie).
with SelfUpdateLock():
return _self_update_impl()
def _self_update_impl():
repos = get_repos()
if not repos:
print(_('❌ No repositories configured.'))
return 1
# Aktualizuj bieżący plik (Python ≥3.9 ustawia __file__ jako ścieżkę
# bezwzględną). Poza /usr|/usr/local (np. uruchomienie z checkoutu)
# nie nadpisujemy niczego – wracamy do domyślnej lokalizacji instalacji.
dst = "/usr/local/bin/pag"
try:
cand = os.path.realpath(__file__)
if cand.startswith(("/usr/", "/usr/local/")):
dst = cand
except Exception:
pass
base = repos[0]
dst_new = dst + ".new"
dst_bak = dst + ".bak"
print(_('🔄 Checking for pag update from {arg1}...', arg1=(base)))
try:
with urlopen(Request(f"{base}/pag", headers={"User-Agent": "pag/3.0"}), timeout=20) as r:
data = r.read()
with urlopen(Request(f"{base}/pag.asc", headers={"User-Agent": "pag/3.0"}), timeout=20) as r:
sig = r.read()
except Exception as e:
print(_(' ❌ Cannot download pag: {arg1}', arg1=(e)))
return 1
# Zapisz nową wersję w katalogu docelowym (ta sama partycja → atomowy rename)
with open(dst_new, "wb") as f:
f.write(data)
with open(dst_new + ".asc", "wb") as f:
f.write(sig)
# --- 1. Weryfikacja podpisu GPG – bez tego nie instalujemy ---
insecure = os.environ.get("PAG_INSECURE", "") == "1"
ok, fp = _gpg_verify_fp(dst_new + ".asc", dst_new)
if not ok:
# Automatyczny import klucza (TOFU) – jak w _verify_repo_sig
res = _gpg_run("--verify", dst_new + ".asc", dst_new,
capture_output=True, text=True)
_stderr = res.stderr.decode(errors="replace") if isinstance(res.stderr, bytes) else (res.stderr or "")
if "public key" in _stderr.lower() and "no public key" in _stderr.lower():
try:
with urlopen(Request(f"{base}/paganos.asc", headers={"User-Agent": "pag/3.0"}), timeout=20) as r:
keydata = r.read()
with tempfile.NamedTemporaryFile(delete=False, suffix=".asc") as tmp:
tmp.write(keydata); tmp.flush()
_gpg_run("--import", tmp.name, capture_output=True, timeout=30)
os.unlink(tmp.name)
print(_(' 🔑 Imported repo key from {arg1}/paganos.asc', arg1=(base)))
ok, fp = _gpg_verify_fp(dst_new + ".asc", dst_new)
except Exception:
pass
if not ok:
if insecure:
print(_(' ⚠ Invalid update signature (PAG_INSECURE – ignoring)'))
else:
print(_(' ❌ Invalid update signature – not updating.'))
_cleanup_tmp_files(dst_new, dst_new + ".asc")
return 1
# Sprawdź fingerprint względem przypiętego klucza repo
pinned = _repo_pinned_fp(base)
if pinned:
if not fp:
print(_(' ❌ Cannot confirm the update signature fingerprint.'))
_cleanup_tmp_files(dst_new, dst_new + ".asc")
return 1
if fp != pinned.upper():
if insecure:
print(_(' ⚠ Update signed with a different key (PAG_INSECURE – ignoring)'))
else:
print(_(' ❌ [SECURITY ERROR] Update signed with a different key than the repo!'))
print(_(' Expected: {arg1}, received: {arg2}', arg1=(pinned), arg2=(fp)))
_cleanup_tmp_files(dst_new, dst_new + ".asc")
return 1
# --- 2. Weryfikacja SHA256 (jeśli repo publikuje pag.sha256) ---
try:
with urlopen(Request(f"{base}/pag.sha256", headers={"User-Agent": "pag/3.0"}), timeout=15) as r:
sha = r.read().decode().strip().split()[0]
if sha:
actual = hashlib.sha256(data).hexdigest()
if actual.lower() != sha.lower():
print(_(' ❌ SHA256 mismatch! Expected {arg1}, got {arg2}', arg1=(sha), arg2=(actual)))
_cleanup_tmp_files(dst_new, dst_new + ".asc")
return 1
print(_(' ✅ SHA256 matches'))
except Exception:
# Brak pag.sha256 w repo – opcjonalne; nie blokuj aktualizacji.
pass
# --- 3. Kontrola składni (nie uruchamiaj uszkodzonego/poddanego edycji pliku) ---
try:
compile(data, "pag", "exec")
except SyntaxError as e:
print(_(' ❌ Syntax error in new pag: {arg1}', arg1=(e)))
_cleanup_tmp_files(dst_new, dst_new + ".asc")
return 1
m = (re.search(rb'PAG_VERSION\s*=\s*"(\d+\.\d+\.\d+[a-z]?)"', data[:3000])
or re.search(rb"v(\d+\.\d+\.\d+[a-z]?)", data[:3000]))
new_ver = m.group(1).decode() if m else "?"
print(_(' ✅ Downloaded pag {arg1} (current {arg2}), signature verified', arg1=(new_ver), arg2=(PAG_VERSION)))
# --- 4. Backup + atomowa podmiana ---
if os.path.exists(dst):
shutil.copy2(dst, dst_bak)
os.chmod(dst_new, 0o755)
os.replace(dst_new, dst) # atomowe na tym samym FS
try:
if os.path.exists(dst_new + ".asc"):
os.remove(dst_new + ".asc")
except OSError:
pass
print(_(' ✅ Installed new pag. Old version kept as {arg1}', arg1=(dst_bak)))
# Ostrzeż, gdy w PATH pierwsza jest INNA kopia `pag` – inaczej
# `pag --version` dalej pokaże starą wersję i wygląda to jak brak update.
other = shutil.which("pag")
if other and os.path.realpath(other) != os.path.realpath(dst):
print(_(' ⚠ A different pag is first in PATH: {arg1} (updated {arg2})', arg1=(other), arg2=(dst)))
print(_(' Remove the old copy: sudo rm {arg1}', arg1=(other)))
print(_(' Restart pag to use the new version.'))
return 0
def _candidate_newer(rp, inst):
"""Czy pakiet z repo jest nowszy od zainstalowanego.
Porównuje (version, release): sam bump pkgrel (np. auto-rebuild modułów
po aktualizacji jądra: nvidia-kernel-618 610.57.04-1 -> -2) też musi być
widziany przez `pag update`. Stare rekordy instalacji (bez pola release)
traktujemy jak release=1 – nie generują churnu, dopóki nie wrócą do
reinstalacji/zmiany wersji."""
rv = getattr(rp, "version", "0")
iv = inst.get("version", "0")
if _version_newer(rv, iv):
return True
if rv != iv:
return False
rr = int(getattr(rp, "release", 1) or 1)
ir = int(inst.get("release", 1) or 1)
return rr > ir
def _pending_updates() -> List[str]:
"""Zainstalowane pakiety z nowszą wersją/release w repo (bez przypiętych)."""
installed = load_json(INSTALLED_DB)
pinned = load_json(PINNED_FILE)
repo = fetch_all_packages()
if not repo:
return []
return [n for n, i in installed.items()
if n not in pinned and (rp := repo.get(n)) and _candidate_newer(rp, i)]
# =============================================================================
# BAZA Z OBRAZU ISO → REPO (`pag base`) – pełny rolling
# =============================================================================
# ISO jest zbudowane ZE ŹRÓDEŁ (glibc, gcc, gtk, XFCE, …) – pag tych pakietów
# nie instalował, więc nie ma ich w installed.json/files.db. Skutki:
# • `pag upgrade` ich NIE dotyka (nie ma o nich pojęcia),
# • mimo to `pag install <nazwa>` je NADPISZE – pag robi kopię plików spoza
# swojej bazy (patrz _new_transaction_backup_root), więc nie są nietykalne.
#
# /usr/share/pag/base.json (wypalany przez build-pagan.sh) mówi, co jest w bazie
# obrazu i w jakiej wersji. `pag base` pokazuje stan, a `pag base adopt` dogrywa
# te pakiety z repo – po tym zabiegu pag zarządza nimi normalnie, więc
# `pag upgrade` aktualizuje CAŁY system (rolling), a nie tylko to, co sam
# wcześniej zainstalował.
#
# Nazwy z buildera różnią się od nazw pakietów w repo (builder buduje „libX11”,
# repo ma pakiet „xorg-libx11”), stąd aliasy poniżej. Nazwy bez odpowiednika
# w repo zostają w wersji z obrazu – raport mówi o tym wprost, zamiast udawać,
# że są aktualne.
BASE_NAME_ALIASES = {
"atk": "at-spi2-core",
"dejavu-fonts": "dejavu-ttf",
"fontconfig": "xorg-fontconfig",
"gtk": "gtk3",
"iceauth": "xorg-iceauth",
"libX11": "xorg-libx11",
"libXau": "xorg-libxau",
"libXdmcp": "xorg-libxdmcp",
"libXext": "xorg-libxext",
"libXft": "xorg-libxft",
"libdrm": "xorg-libdrm",
"libnspr": "nspr",
"libxkbfile": "xorg-libxkbfile",
"libxklavier": "xorg-libxklavier",
"linux-pam": "pam",
"pixman": "xorg-pixman",
"sdl2": "sdl",
"setxkbmap": "xorg-setxkbmap",
"xauth": "xorg-xauth",
"xf86-input-libinput": "xorg-xf86-input-libinput",
"xf86-video-fbdev": "xorg-xf86-video-fbdev",
"xinit": "xorg-xinit",
"xkbcomp": "xorg-xkbcomp",
"xkeyboard-config": "xorg-xkeyboard-config",
# Builder buduje wpa_supplicant (z podkreślnikiem), a repo ma wpa-supplicant
# (z myślnikiem) – bez tego aliasu pakiet nie dostawał aktualizacji z repo,
# mimo że repo.json zna DOKŁADNIE tę samą wersję.
"wpa_supplicant": "wpa-supplicant",
}
def _base_manifest() -> dict:
"""Manifest bazy z obrazu ({} gdy obraz go nie dostarcza)."""
_d = load_json(os.path.join(PAG_ROOT, BASE_MANIFEST.lstrip("/")))
return _d if isinstance(_d, dict) else {}
def _base_entries() -> list:
"""[(nazwa_z_buildera, wersja_z_obrazu), ...] z manifestu."""
_out = []
for _e in (_base_manifest().get("packages") or []):
if isinstance(_e, str):
if _e:
_out.append((_e, "?"))
elif isinstance(_e, dict) and _e.get("name"):
_out.append((str(_e["name"]), str(_e.get("version") or "?")))
return _out
def _base_repo_name(name: str, repo: dict, installed: dict) -> str:
"""Nazwa pakietu w repo dla nazwy z buildera (alias → provides → brak)."""
if name in repo:
return name
_alias = BASE_NAME_ALIASES.get(name)
if _alias and _alias in repo:
return _alias
_real = _resolve_provides(name, repo, installed)
return _real if _real in repo else ""
def _base_summary(repo: Optional[dict] = None) -> dict:
"""Klasyfikacja pakietów bazy z obrazu wobec repo.
repo=None → pobiera indeks repo (potrzebny do listy „do adoptowania”).
repo={} → bez sieci: rozpoznaje tylko to, czym pag już zarządza.
"""
_entries = _base_entries()
if not _entries:
return {"total": 0, "tracked": 0, "adoptable": [], "unmatched": []}
if repo is None:
repo = fetch_all_packages()
installed = load_json(INSTALLED_DB)
tracked, adoptable, unmatched = 0, [], []
for _n, _v in _entries:
_real = _base_repo_name(_n, repo, installed)
if _n in installed or (_real and _real in installed):
tracked += 1
elif _real:
adoptable.append((_n, _real, _v))
else:
unmatched.append(_n)
return {"total": len(_entries), "tracked": tracked,
"adoptable": adoptable, "unmatched": unmatched}
def _base_hint_unmanaged() -> None:
"""Jednozdaniowa informacja dla `pag sync/update/upgrade`."""
try:
_s = _base_summary()
except Exception:
return
if _s["adoptable"]:
print(f"\n ℹ {_('base_unmanaged_hint', len(_s['adoptable']))}")
def _base_warn_overwrite(names) -> None:
"""Ostrzeżenie w `pag install`, gdy pakiet pochodzi z bazy obrazu ISO."""
_entries = _base_entries()
if not _entries:
return
_known = set()
for _n, _v in _entries:
_known.add(_n)
_al = BASE_NAME_ALIASES.get(_n)
if _al:
_known.add(_al)
_hit = [n for n in names if n in _known]
if _hit:
_listed = ", ".join(_hit[:5]) + (" …" if len(_hit) > 5 else "")
print(f" ℹ {_('base_overwrite', _listed)}")
def cmd_base_status():
"""`pag base` / `pag base status` – co w systemie pochodzi z obrazu,
czym pag już zarządza i co da się zaadoptować z repo."""
_man = _base_manifest()
if not _man:
print(f" ℹ {_('base_no_manifest')}")
return 0
_s = _base_summary()
print(f"\n {_c('bold', _('base_title'))}")
print(f" {'─' * 46}")
_de = _man.get("de") or ""
print(f" {_('base_iso_version'):<34} {_man.get('iso_version', '?')}" + (f" ({_de})" if _de else ""))
print(f" {_('base_total'):<34} {_s['total']}")
print(f" {_('base_tracked'):<34} {_s['tracked']}")
print(f" {_('base_adoptable'):<34} {len(_s['adoptable'])}")
print(f" {_('base_unmatched'):<34} {len(_s['unmatched'])}")
if _s["adoptable"]:
print(f"\n {_('base_adopt_hint')}")
for _iso_n, _real, _v in _s["adoptable"][:10]:
_m = "" if _iso_n == _real else f" ({_iso_n})"
print(f" {_real}-{_v}{_m}")
if len(_s["adoptable"]) > 10:
print(f" … {len(_s['adoptable']) - 10} {_('base_more')}")
if _s["unmatched"]:
print(f"\n {_('base_unmatched_hint')}")
print(" " + ", ".join(_s["unmatched"][:12])
+ (f" … +{len(_s['unmatched']) - 12}" if len(_s["unmatched"]) > 12 else ""))
return 0
def cmd_base_adopt(args):
"""`pag base adopt [pkg...] [--dry-run]` – dograj bazę z obrazu z repo.
Pakiety bazy nie ma w installed.json, więc pag traktuje je jak NOWĄ
instalację: pliki z obrazu trafiają do kopii transakcji (działa
`pag rollback`), a po sukcesie pag zarządza nimi jak każdym innym pakietem.
"""
if not _base_manifest():
print(f" ℹ {_('base_no_manifest')}")
return 1
repo = fetch_all_packages()
if not repo:
print(f"❌ {_('no_index')}")
return 1
_want = [a for a in args if not a.startswith("-") and a != "adopt"]
_s = _base_summary(repo)
plan = _s["adoptable"]
if _want:
_sel = set(_want)
plan = [p for p in plan if p[0] in _sel or p[1] in _sel]
if not plan:
print(f" ℹ {_('base_nothing_selected')}")
return 0
if not plan:
print(f"✅ {_('base_all_managed')}")
return 0
_size = sum(repo[r].size_bytes for _i, r, _v in plan if r in repo)
print(f"\n {_('base_adopt_plan', len(plan), _size / 1048576)}")
for _iso_n, _real, _v in plan[:20]:
_p = repo.get(_real)
_rv = _p.version if _p else "?"
_rr = (getattr(_p, "release", "") or "") if _p else ""
_rvr = f"{_rv}-{_rr}" if _rr else _rv
_m = "" if _iso_n == _real else f" ({_iso_n} → {_real})"
print(f" {_real}: {_v} → {_rvr}{_m}")
if len(plan) > 20:
print(f" … {len(plan) - 20} {_('base_more')}")
if "-n" in args or "--dry-run" in args:
print(f" {_('base_dry_run')}")
return 0
_rc = cmd_install([r for _i, r, _v in plan])
if _rc == 0:
# Wymienione biblioteki/narzędzia (glibc, gcc, GTK…) są już nowe na dysku,
# ale działające procesy wciąż mają stare w pamięci – restart domyka.
print(f"\n ℹ {_('base_reboot_hint')}")
return _rc
def _base_cached_index() -> dict:
"""Indeks repo TYLKO z lokalnego cache (zero sieci) – do mapowania nazw.
Potrzebne dla `pag base register`: rejestracja bazy obrazu nie może zależeć
od sieci (odpala się w buildzie, w chroocie, bez DNS). Cache indeksu powstaje
przy okazji `pag sync`/`pag install` i po nim wystarcza.
"""
_out = {}
try:
for _r in get_repos():
_cp = _repo_cache_path(_r)
if not os.path.exists(_cp):
continue
for _pdata in (_load_repo_cache(_cp) or []):
_n = _pdata.get("name") or _pdata.get("filename", "?").split("-")[0]
_pkg = PackageInfo(_pdata, _r)
if _n not in _out or _version_newer(_pkg.version, _out[_n].version):
_out[_n] = _pkg
except Exception:
return _out
return _out
def cmd_base_register(args):
"""`pag base register [--force] [--dry-run]` – wpisz bazę obrazu do installed.json.
PO CO: pakietów zbudowanych przez builder (glibc, gcc, GTK, XFCE…) nie ma
w installed.json, więc `pag upgrade` ich NIE widzi i system nie da się
prowadzić w trybie rolling – trzeba by najpierw `pag base adopt`, czyli
ponownie ŚCIĄGNĄĆ całą bazę z repo. Rejestracja zamiast tego zapisuje je
jako zainstalowane **z wersją z obrazu** (to ona leży na dysku), więc
`pag upgrade` porówna ją z repo i podniesie tylko to, co nowsze.
Offline: nic nie pobiera. Cache indeksu repo (jeśli jest) służy WYŁĄCZNIE do
mapowania nazw builder → repo (BASE_NAME_ALIASES/provides) i metadanych
(release/opis/zależności). Nazwy bez odpowiednika w repo zostają jak są.
OGRANICZENIE: rejestracja nie zna listy plików pakietu (files.db), więc
dopóki pakiet nie zostanie zaktualizowany z repo, `pag verify`/`pag remove`
go nie obejmą (`pag base adopt` nadal jest drogą do pełnego przejęcia).
"""
_force = "-f" in args or "--force" in args
_dry = "-n" in args or "--dry-run" in args
_entries = _base_entries()
if not _entries:
print(f" ℹ {_('base_no_manifest')}")
return 1
_repo = _base_cached_index()
installed = load_json(INSTALLED_DB)
world = load_world()
_now = datetime.now().isoformat()
added, skipped, renamed = [], 0, 0
for _n, _v in _entries:
_real = _base_repo_name(_n, _repo, installed) if _repo else ""
_key = _real or _n
if _real and _real != _n:
renamed += 1
if _key in installed and not _force:
skipped += 1
continue
_pkg = _repo.get(_key)
installed[_key] = {
"version": _v or (getattr(_pkg, "version", "") or "?"),
"release": getattr(_pkg, "release", "") or "1",
"description": (getattr(_pkg, "description", "") or "")
or "Pagan Linux – pakiet bazy obrazu",
"dependencies": list(getattr(_pkg, "dependencies", []) or []),
"size_bytes": getattr(_pkg, "size_bytes", 0) or 0,
"sha256": "",
"installed_at": _now,
"repo": "base",
"provides": list(getattr(_pkg, "provides", []) or []),
"provides_so": list(getattr(_pkg, "provides_so", []) or []),
"requires_so": list(getattr(_pkg, "requires_so", []) or []),
}
world.add(_key)
added.append(_key)
if _dry:
print(f" ℹ {_('base_register_plan', len(added))}")
return 0
if added:
save_json(INSTALLED_DB, installed)
save_world(world)
print(f" ✅ {_('base_register_ok', len(added), skipped)}")
if renamed:
print(f" ℹ {_('base_register_renamed', renamed)}")
if not _repo:
print(f" ℹ {_('base_register_nocache')}")
return 0
def cmd_update(do_upgrade: bool = False):
"""`pag sync` / `pag update` – odświeżenie indeksów + raport aktualizacji.
sync → tylko odświeżenie indeksów + info: „jest X pakietów do
zaktualizowania – wpisz: pag update".
update → odświeżenie indeksów + AKTUALIZACJA PAKIETÓW (pakiety, nie system).
Pomijamy cache TTL (inaczej nowe pakiety/aktualizacje są niewidoczne nawet
przez godzinę). Pełne pobranie + weryfikacja GPG przy każdym odświeżeniu.
"""
force = True
print(_('🔄 Refreshing indexes...'))
for repo_url in get_repos():
pkgs = fetch_repo_index(repo_url, force=force)
cp = _repo_cache_path(repo_url)
has_sig = os.path.exists(cp + ".sig")
print(_(' {arg1} {arg2}: {arg3} packages {arg4}', arg1=('✅' if pkgs is not None else '❌'), arg2=(repo_url), arg3=(len(pkgs or [])), arg4=('🔐' if has_sig else '⚠')))
print(f"✅ {_('indexes_refreshed')}")
# Powiadomienie o nowszej wersji pag (repo.json["pag_version"])
try:
for r in get_repos():
cp = _repo_cache_path(r)
if os.path.exists(cp):
d = json.load(open(cp))
rv = d.get("pag_version", "")
if rv and rv != PAG_VERSION:
print(_(' ⚠ New pag version {arg1} available – run: pag self-update', arg1=(rv)))
except Exception:
pass
# Raport: pakiety do aktualizacji
pending = _kernel_group_updates(_pending_updates())
if not pending:
print(f"✅ {_('all_up_to_date')}")
# `pag upgrade` ma sens także wtedy, gdy pakiety pag są aktualne –
# Flatpaki żyją własnym cyklem wydawniczym.
if do_upgrade:
_flatpak_auto_update()
_base_hint_unmanaged()
return 0
print(f"{_('updates_available', len(pending))}")
installed = load_json(INSTALLED_DB)
repo = fetch_all_packages()
for n in pending:
_i = installed.get(n, {})
_ir = _i.get("release")
_nr = getattr(repo[n], "release", "") or ""
_old = f"{_i.get('version', '?')}-{_ir}" if _ir else _i.get("version", "?")
_new = f"{repo[n].version}-{_nr}" if _nr else repo[n].version
print(f" {n}: {_old} → {_new}")
if not do_upgrade:
_base_hint_unmanaged()
return 0 # sync: tylko informacja
if not _ask_confirm():
return 0
_rc = cmd_install(pending, upgrade=True)
_base_hint_unmanaged()
# Flatpaki PO pakietach pag: błąd Flatpaka nie zmienia wyniku transakcji.
_flatpak_auto_update()
return _rc
def _versioned_kernels(boot: str = "/boot") -> list:
"""Wersjonowane obrazy jąder z /boot (bez aliasu `vmlinuz-linux`)."""
try:
out = []
for n in os.listdir(boot):
if not n.startswith("vmlinuz-"):
continue
ver = n[len("vmlinuz-"):]
if not ver or not ver[0].isdigit():
continue # vmlinuz-linux to alias, nie wersja
if os.path.islink(os.path.join(boot, n)):
continue
out.append(ver)
return out
except Exception:
return []
def _initramfs_stale() -> bool:
"""Czy initramfs najnowszego (wersjonowanego) jądra wymaga przebudowy.
Uwaga: aliasy `initramfs.img` / `initramfs-linux.img` bywają martwymi
symlinkami — `os.path.exists()` zwraca wtedy False, co wcześniej kończyło
się wiecznym „stale” i przebudową w pętli. Patrzymy na KONKRETNY plik
`initramfs-<wersja>.img`.
"""
try:
if not os.path.isdir("/boot"):
return False
vers = _versioned_kernels()
if not vers:
return False
newest = max(vers, key=lambda v: os.path.getmtime(f"/boot/vmlinuz-{v}"))
img = f"/boot/initramfs-{newest}.img"
if not os.path.isfile(img):
return True
return os.path.getmtime(img) < os.path.getmtime(f"/boot/vmlinuz-{newest}")
except Exception:
return False
def cmd_upgrade():
"""`pag upgrade` – aktualizacja SYSTEMU: pakiety + kernel/initramfs/GRUB."""
rc = cmd_update(do_upgrade=True)
if rc != 0:
return rc
# System: dopilnuj initramfs (gdyby kernel był nowszy) + GRUB.
if _initramfs_stale():
print(_(' 🐧 Rebuilding initramfs (newer kernel)...'))
_rebuild_initramfs()
_refresh_bootloader()
return 0
def cmd_list(installed_only=False):
if installed_only:
db = load_json(INSTALLED_DB)
pinned = load_json(PINNED_FILE)
if not db: print(_('No packages installed.')); return
print(_('Installed ({arg1}):', arg1=(len(db))))
for n, i in sorted(db.items()):
pin = " 📌" if n in pinned else ""
print(f" {n}-{i['version']}{pin} – {i.get('description','')}")
else:
pkgs = fetch_all_packages()
installed = load_json(INSTALLED_DB)
pinned = load_json(PINNED_FILE)
print(_('Available ({arg1}):', arg1=(len(pkgs))))
for n, p in sorted(pkgs.items()):
m = "✓" if n in installed else " "
extra = f" [{_('installed_marker')}: {installed[n]['version']}]" if n in installed else ""
if n in pinned: extra += " 📌"
print(f" [{m}] {n}-{p.version} – {p.description}{extra}")
def cmd_search(query):
pkgs = fetch_all_packages()
results = [(n,p) for n,p in pkgs.items() if query.lower() in n.lower() or query.lower() in p.description.lower()]
if not results: print(_('❌ No results for: {arg1}', arg1=(query))); return
installed = load_json(INSTALLED_DB)
print(_("Results for '{arg1}' ({arg2}):", arg1=(query), arg2=(len(results))))
for n,p in sorted(results):
print(f" [{'✓' if n in installed else ' '}] {n}-{p.version}")
print(f" {p.description}")
def _smart_search(query: str) -> int:
"""
Inteligentne wyszukiwanie: repo PaganOS + Flathub.
Uruchamiane gdy użytkownik wpisze `pag <nazwa>` zamiast `pag install <nazwa>`.
Pokazuje dostępne źródła i sugeruje komendy instalacji.
"""
# 1. Repo PaganOS
try:
pkgs = fetch_all_packages()
except Exception:
pkgs = {}
repo_lower = [(n, p) for n, p in pkgs.items()
if query.lower() in n.lower() or query.lower() in p.description.lower()]
# 2. Flathub (jeśli dostępny)
flat = _flatpak_search_raw(query) if _check_flatpak(quiet=True) else []
if not repo_lower and not flat:
print(_("\n ❌ '{arg1}' — not found.", arg1=(query)))
print(_(' PaganOS repo: pag search {arg1}', arg1=(query)))
if _check_flatpak(quiet=True):
print(_(' Flathub: pag flatpak search {arg1}', arg1=(query)))
print(_(' Add repo: pag repo-add <url>'))
return 1
installed = load_json(INSTALLED_DB)
# ── Repo PaganOS ──
if repo_lower:
exact = [(n, p) for n, p in repo_lower if n.lower() == query.lower()]
show = (exact or repo_lower)[:6]
print(f"\n 📦 PaganOS — '{query}':")
for n, p in sorted(show):
mark = "✓" if n in installed else " "
desc = p.description[:70] if len(p.description) > 75 else p.description
print(f" [{mark}] {n}-{p.version}")
if desc:
print(f" {desc}")
if len(repo_lower) > 6:
print(_(' ... and {arg1} more (pag search {arg2})', arg1=(len(repo_lower) - 6), arg2=(query)))
# ── Flathub ──
if flat:
print(f"\n 📦 Flathub — '{query}':")
for r in flat[:5]:
mark = "✓" if r.get("installed") else " "
name = r.get("name") or r.get("application", "?")
desc = (r.get("description") or "")[:65]
print(f" [{mark}] {name}")
if desc:
print(f" {desc}")
if len(flat) > 5:
print(_(' ... and {arg1} more (pag flatpak search {arg2})', arg1=(len(flat) - 5), arg2=(query)))
# ── Sugestie instalacji ──
print()
if repo_lower:
best = sorted(repo_lower, key=lambda x: (x[0].lower() != query.lower(), -len(x[1].name if hasattr(x[1], 'name') else 0)))[0][0]
if best in installed:
print(_(' ✓ {arg1} is already installed ({arg2})', arg1=(best), arg2=(installed[best]['version'])))
else:
print(f" 💡 sudo pag install {best}")
if flat:
best_fp = flat[0].get("application") or flat[0].get("name", query)
print(f" 💡 pag flatpak install {best_fp}")
return 0
def cmd_info(name):
pkgs = fetch_all_packages()
p = pkgs.get(name)
info = load_json(INSTALLED_DB).get(name)
if not p and not info: print(_("❌ '{arg1}' not found.", arg1=(name))); return 1
print(f"📦 {name}")
if p:
print(_(' Version (repo): {arg1}', arg1=(p.version)))
print(_(' Description: {arg1}', arg1=(p.description)))
print(_(' Size: {arg1:.1f} MB', arg1=(p.size_bytes/1048576)))
print(_(' SHA256: {arg1}...', arg1=(p.sha256[:32])))
print(_(' GPG: {arg1}', arg1=(p.gpg_fp or _('none_value'))))
print(_(' Dependencies: {arg1}', arg1=((', '.join(p.dependencies)) if p.dependencies else _('none_parenthesized'))))
if p.optdepends:
print(f" {_('optional_deps')}")
for _od in p.optdepends:
print(f" - {_od}")
if info:
print(_(' Installed: {arg1} ({arg2})', arg1=(info['version']), arg2=(info.get('installed_at','?'))))
def cmd_files(name):
if name not in load_json(INSTALLED_DB):
print(_("❌ '{arg1}' not installed.", arg1=(name))); return 1
files = _db_get_package_files(name)
print(_('Files in {arg1} ({arg2}):', arg1=(name), arg2=(len(files))))
for f in sorted(files): print(f" {f}")
def cmd_repair(dry_run=False):
"""Naprawia system: reinstaluje pakiety, ktorych pliki zginely.
Przechodzi po bazie plikow (jak `verify`), zbiera pakiety z brakujacymi
plikami i dla kazdego robi REINSTALACJE z repozytorium (staging + GPG).
Reinstalacja nie rusza konfiguracji uzytkownika (.pacnew), a przywraca
brakujace pliki pakietu (np. qt6-declarative, accountsservice).
"""
installed = load_json(INSTALLED_DB)
if not installed:
print(_('Nothing to repair (no packages installed).'))
return 0
missing = {}
for name in installed:
cnt = 0
for fpath in _db_get_package_files(name):
full = os.path.join(PAG_ROOT, fpath.lstrip("/"))
if not (os.path.exists(full) or os.path.islink(full)):
cnt += 1
if cnt:
missing[name] = cnt
if not missing:
print(_('✅ All files are in place – nothing to repair.'))
return 0
total = sum(missing.values())
print(_('🔧 Packages with missing files: {arg1} (total {arg2} files)', arg1=(len(missing)), arg2=(total)))
for n, c in sorted(missing.items(), key=lambda kv: (-kv[1], kv[0])):
print(f" {n}: {c}")
if dry_run:
print(_('\n(--dry-run: nothing is changed)'))
return 0
if not _ask_confirm():
print(_("cancelled")); return 0
# Jedna migawka na całą naprawę – nie tworzymy snapshotu per pakiet.
_snap_ok, _ = _snapshot_support()
if _snap_ok:
_create_system_snapshot(list(missing), "repair")
_refresh_bootloader()
_prev_snap = os.environ.get("PAG_SNAPSHOT")
os.environ["PAG_SNAPSHOT"] = "never"
failed = []
try:
for n in sorted(missing, key=lambda x: (-missing[x], x)):
print(_('\n🔧 repair: {arg1}', arg1=(n)))
try:
rc = cmd_install([n], upgrade=True)
except SystemExit as e:
rc = e.code
except Exception as e:
print(f" ❌ {n}: {e}")
rc = 1
if rc:
failed.append(n)
finally:
if _prev_snap is None:
os.environ.pop("PAG_SNAPSHOT", None)
else:
os.environ["PAG_SNAPSHOT"] = _prev_snap
print()
ok = len(missing) - len(failed)
if failed:
print(_('⚠ Repaired {arg1}/{arg2}. Failed: {arg3}', arg1=(ok), arg2=(len(missing)), arg3=(', '.join(failed))))
return 1
print(_('✅ Repaired {arg1} packages.', arg1=(ok)))
return 0
def cmd_verify(deep=False):
installed = load_json(INSTALLED_DB)
if not installed: print(_('Nothing to verify.')); return
errors = []
# Wczytaj WSZYSTKIE sumy RAZ (nie w pętli!) – przy 50k plików wywołanie
# _db_get_all_file_checksums() per-plik dawało O(n²) i godziny zamiast sekund.
all_checksums = _db_get_all_file_checksums() if deep else {}
for name in installed:
for fpath in _db_get_package_files(name):
full = os.path.join(PAG_ROOT, fpath.lstrip("/"))
if not (os.path.exists(full) or os.path.islink(full)):
errors.append(_("verify_missing_file", name, fpath))
elif deep:
expected = all_checksums.get(fpath, "")
if expected:
actual = _sha256_file(full)
if actual != expected:
errors.append(_("verify_sha_mismatch", name, fpath))
if errors:
print(f"❌ {_('verify_errors', len(errors))}")
for e in errors: print(e)
return 1
total = _db_count_files()
print(f"✅ {_('verify_ok', total)}")
# =============================================================================
# PINNING / CLEAN / ORPHANS / REPO / FLATPAK
# =============================================================================
def cmd_pin(name, version=""):
pinned = load_json(PINNED_FILE)
if version:
pinned[name] = version
else:
info = load_json(INSTALLED_DB).get(name, {})
pinned[name] = info.get("version", "?")
save_json(PINNED_FILE, pinned)
print(f"📌 {name} {_('pinned_to')} {pinned[name]}")
def cmd_unpin(name):
pinned = load_json(PINNED_FILE)
if name in pinned:
del pinned[name]; save_json(PINNED_FILE, pinned)
print(f"🔓 {name} {_('unpinned')}")
else:
print(f"⚠ {name} {_('not_pinned')}")
def cmd_pinned():
pinned = load_json(PINNED_FILE)
if not pinned: print(_("no_pinned")); return
print(_("pinned_list", len(pinned)))
for n,v in sorted(pinned.items()): print(f" 📌 {n} = {v}")
def cmd_clean():
if os.path.isdir(PAG_CACHE):
count = size = 0
for f in os.listdir(PAG_CACHE):
fp = os.path.join(PAG_CACHE, f)
if os.path.isfile(fp):
size += os.path.getsize(fp); os.remove(fp); count += 1
print(f"✅ {_('cache_cleared', count, size/1048576)}")
def cmd_remove_orphans():
installed = load_json(INSTALLED_DB)
world = load_world()
orphans = _find_orphans(installed, world)
if not orphans: print(_('✅ No orphans.')); return
print(_('Orphans ({arg1}):', arg1=(len(orphans))))
for n in sorted(orphans): print(f" {n}-{installed[n]['version']}")
if not _ask_confirm():
return
cmd_remove(list(orphans))
# =============================================================================
# PROVIDES – PAKIETY WIRTUALNE
# =============================================================================
PROVIDES_MAP = {
"pkgconfig(glib-2.0)": "glib",
"pkgconfig(gobject-introspection-1.0)": "gobject-introspection",
"pkgconfig(gtk+-3.0)": "gtk",
"pkgconfig(gtk4)": "gtk",
"pkgconfig(zlib)": "zlib",
"pkgconfig(libffi)": "libffi",
"pkgconfig(expat)": "expat",
"pkgconfig(libsystemd)": "systemd",
"pkgconfig(dbus-1)": "dbus",
"pkgconfig(mount)": "util-linux",
"pkgconfig(blkid)": "util-linux",
"pkgconfig(libcap)": "libcap",
"pkgconfig(liblzma)": "xz",
"pkgconfig(libzstd)": "zstd",
"pkgconfig(bzip2)": "bzip2",
"pkgconfig(libcurl)": "curl",
"pkgconfig(openssl)": "openssl",
"pkgconfig(libpcre2-8)": "pcre2",
"pkgconfig(libxml-2.0)": "libxml2",
"pkgconfig(libxslt)": "libxslt",
"pkgconfig(freetype2)": "freetype",
"pkgconfig(fontconfig)": "fontconfig",
"pkgconfig(harfbuzz)": "harfbuzz",
"pkgconfig(cairo)": "cairo",
"pkgconfig(pango)": "pango",
"pkgconfig(xt)": "xorg-libxt",
"pkgconfig(xmu)": "xorg-libxmu",
"pkgconfig(ice)": "xorg-libice",
"pkgconfig(sm)": "xorg-libsm",
"pkgconfig(x11)": "xorg-libx11",
"pkgconfig(xext)": "xorg-libxext",
"pkgconfig(xrandr)": "xorg-libxrandr",
"pkgconfig(xfixes)": "xorg-libxfixes",
"pkgconfig(xcursor)": "xorg-libxcursor",
"pkgconfig(xinerama)": "xorg-libxinerama",
"pkgconfig(xrender)": "xorg-libxrender",
"pkgconfig(xau)": "xorg-libxau",
"pkgconfig(xcb)": "xorg-libxcb",
"pkgconfig(xdamage)": "xorg-libxdamage",
"pkgconfig(xcomposite)": "xorg-libxcomposite",
"pkgconfig(xft)": "xorg-libxft",
"pkgconfig(xss)": "xorg-libxss",
"pkgconfig(libsoup-3.0)": "libsoup3",
"pkgconfig(libsoup-2.4)": "libsoup2",
"pkgconfig(gdk-pixbuf-2.0)": "gdk-pixbuf2",
"pkgconfig(libpng)": "libpng",
"pkgconfig(libjpeg)": "libjpeg-turbo",
"pkgconfig(libtiff-4)": "libtiff",
"pkgconfig(ffi)": "libffi",
# ── system / baza ──
"pkgconfig(libcrypto)": "openssl",
"pkgconfig(libssl)": "openssl",
"pkgconfig(libudev)": "systemd",
"pkgconfig(libmount)": "util-linux",
"pkgconfig(libblkid)": "util-linux",
"pkgconfig(uuid)": "util-linux",
"pkgconfig(libexpat)": "expat",
"pkgconfig(libpcre)": "pcre",
"pkgconfig(ncursesw)": "ncurses",
"pkgconfig(tinfo)": "ncurses",
"pkgconfig(panel)": "ncurses",
"pkgconfig(readline)": "readline",
"pkgconfig(libseccomp)": "libseccomp",
"pkgconfig(pam)": "linux-pam",
"pkgconfig(libxcrypt)": "libxcrypt",
"pkgconfig(libcrypt)": "libxcrypt",
"pkgconfig(libnsl)": "libnsl",
"pkgconfig(liblz4)": "lz4",
"pkgconfig(libevent)": "libevent",
"pkgconfig(libarchive)": "libarchive",
"pkgconfig(sqlite3)": "sqlite",
"pkgconfig(libpq)": "postgresql",
"pkgconfig(mysqlclient)": "mariadb",
"pkgconfig(json-c)": "json-c",
"pkgconfig(json-glib-1.0)": "json-glib",
"pkgconfig(libunistring)": "libunistring",
"pkgconfig(libidn2)": "libidn2",
"pkgconfig(libpsl)": "libpsl",
"pkgconfig(icu-uc)": "icu",
"pkgconfig(icu-i18n)": "icu",
"pkgconfig(icu-io)": "icu",
"pkgconfig(gnutls)": "gnutls",
"pkgconfig(nettle)": "nettle",
"pkgconfig(hogweed)": "nettle",
"pkgconfig(libgcrypt)": "libgcrypt",
"pkgconfig(libgpg-error)": "libgpg-error",
"pkgconfig(libassuan)": "libassuan",
"pkgconfig(libusb-1.0)": "libusb",
"pkgconfig(libusb)": "libusb",
"pkgconfig(libgudev-1.0)": "libgudev",
"pkgconfig(gudev-1.0)": "libgudev",
"pkgconfig(polkit-gobject-1)": "polkit",
"pkgconfig(polkit-agent-1)": "polkit",
"pkgconfig(libpciaccess)": "libpciaccess",
"pkgconfig(pixman-1)": "pixman",
"pkgconfig(libdrm)": "libdrm",
"pkgconfig(libva)": "libva",
"pkgconfig(libva-drm)": "libva",
"pkgconfig(libva-x11)": "libva",
"pkgconfig(libva-wayland)": "libva",
"pkgconfig(vdpau)": "libvdpau",
"pkgconfig(libvdpau)": "libvdpau",
"pkgconfig(libinput)": "libinput",
"pkgconfig(libevdev)": "libevdev",
"pkgconfig(mtdev)": "mtdev",
# ── grafika / GL / multimedia ──
"pkgconfig(gbm)": "mesa",
"pkgconfig(gl)": "libglvnd",
"pkgconfig(egl)": "libglvnd",
"pkgconfig(glesv2)": "libglvnd",
"pkgconfig(glx)": "libglvnd",
"pkgconfig(vulkan)": "vulkan-loader",
"pkgconfig(libxkbcommon)": "libxkbcommon",
"pkgconfig(xkbcommon)": "libxkbcommon",
"pkgconfig(xkbcommon-x11)": "libxkbcommon",
"pkgconfig(xcb)": "xorg-libxcb",
"pkgconfig(xcb-util)": "xcb-util",
"pkgconfig(xcb-keysyms)": "xcb-util-keysyms",
"pkgconfig(xcb-icccm)": "xcb-util-wm",
"pkgconfig(xcb-cursor)": "xcb-util-cursor",
"pkgconfig(xcb-renderutil)": "xcb-util-renderutil",
"pkgconfig(xcb-image)": "xcb-util-image",
"pkgconfig(xcb-errors)": "xcb-util-errors",
"pkgconfig(wayland-client)": "wayland",
"pkgconfig(wayland-server)": "wayland",
"pkgconfig(wayland-cursor)": "wayland",
"pkgconfig(wayland-egl)": "wayland",
"pkgconfig(wayland-protocols)": "wayland-protocols",
"pkgconfig(gstreamer-1.0)": "gstreamer",
"pkgconfig(gstreamer-base-1.0)": "gstreamer",
"pkgconfig(gstreamer-check-1.0)": "gstreamer",
"pkgconfig(gstreamer-controller-1.0)": "gstreamer",
"pkgconfig(gstreamer-app-1.0)": "gst-plugins-base",
"pkgconfig(gstreamer-video-1.0)": "gst-plugins-base",
"pkgconfig(gstreamer-audio-1.0)": "gst-plugins-base",
"pkgconfig(gstreamer-pbutils-1.0)": "gst-plugins-base",
"pkgconfig(gstreamer-fft-1.0)": "gst-plugins-base",
"pkgconfig(gstreamer-riff-1.0)": "gst-plugins-base",
"pkgconfig(gstreamer-rtp-1.0)": "gst-plugins-base",
"pkgconfig(gstreamer-rtsp-1.0)": "gst-plugins-base",
"pkgconfig(gstreamer-sdp-1.0)": "gst-plugins-base",
"pkgconfig(gstreamer-net-1.0)": "gst-plugins-base",
"pkgconfig(gstreamer-gl-1.0)": "gst-plugins-base",
"pkgconfig(libpulse)": "libpulse",
"pkgconfig(libpulse-simple)": "libpulse",
"pkgconfig(libpulse-mainloop-glib)": "libpulse",
"pkgconfig(alsa)": "alsa-lib",
"pkgconfig(jack)": "jack2",
"pkgconfig(libsamplerate)": "libsamplerate",
"pkgconfig(sndfile)": "libsndfile",
"pkgconfig(libavcodec)": "ffmpeg",
"pkgconfig(libavformat)": "ffmpeg",
"pkgconfig(libavutil)": "ffmpeg",
"pkgconfig(libavfilter)": "ffmpeg",
"pkgconfig(libswscale)": "ffmpeg",
"pkgconfig(libswresample)": "ffmpeg",
"pkgconfig(libpostproc)": "ffmpeg",
"pkgconfig(SDL2)": "sdl2",
"pkgconfig(SDL)": "sdl",
"pkgconfig(SDL2_image)": "sdl2-image",
"pkgconfig(SDL2_ttf)": "sdl2-ttf",
"pkgconfig(SDL2_mixer)": "sdl2-mixer",
"pkgconfig(SDL2_net)": "sdl2-net",
"pkgconfig(libpng16)": "libpng",
"pkgconfig(libwebp)": "libwebp",
"pkgconfig(libwebpmux)": "libwebp",
"pkgconfig(libwebpdemux)": "libwebp",
"pkgconfig(libopenjp2)": "openjpeg2",
"pkgconfig(lcms2)": "lcms2",
"pkgconfig(libheif)": "libheif",
"pkgconfig(libde265)": "libde265",
"pkgconfig(x264)": "x264",
"pkgconfig(x265)": "x265",
# ── glib / gio ──
"pkgconfig(gio-unix-2.0)": "glib",
"pkgconfig(gmodule-2.0)": "glib",
"pkgconfig(gthread-2.0)": "glib",
"pkgconfig(girepository-2.0)": "gobject-introspection",
"pkgconfig(girepository-1.0)": "gobject-introspection",
"pkgconfig(libglib-2.0)": "glib",
"pkgconfig(libgobject-2.0)": "glib",
}
# Ostrzeżenia o wielu dostawcach tej samej wirtualnej nazwy – raz na proces.
_PROVIDES_WARNED = set()
# Cache indeksu provides dla danego obiektu repo: (repo_obj, {virtual: [pkg,...]}).
# Trzymamy referencję do repo, by uniknąć pomyłki przy ponownym użyciu id().
_provides_cache = (None, {})
def _provides_index(repo: dict) -> dict:
"""Buduje (i cache’uje) mapę wirtualna nazwa → lista dostawców w repo.
Pozwala wybrać dostawcę DETERMINISTYCZNIE (posortowanego) zamiast zależeć
od kolejności wstawiania w repo.json, oraz ostrzec o konflikcie provides."""
global _provides_cache
cached_repo, idx = _provides_cache
if cached_repo is repo:
return idx
idx = {}
for _pn, _p in repo.items():
for _prov in (getattr(_p, "provides", None) or []):
idx.setdefault(_prov, []).append(_pn)
for _prov, _pns in idx.items():
if len(_pns) > 1 and _prov not in _PROVIDES_WARNED:
_PROVIDES_WARNED.add(_prov)
_sorted = sorted(_pns)
print(f" ⚠ {_('provides_conflict', name=_prov, providers=', '.join(_sorted), chosen=_sorted[0])}",
file=sys.stderr)
_provides_cache = (repo, idx)
return idx
def _resolve_provides(name: str, repo: dict, installed: Optional[dict] = None) -> str:
"""Rozwija wirtualną nazwę pakietu do rzeczywistej nazwy.
Kolejność: repo → PROVIDES_MAP → wzorce → provides z repo.json →
provides ZAINSTALOWANYCH pakietów (lokalnie zbudowane poza repo też
dostarczają wirtualne zależności) → fallback pkgconfig (czyszczenie nazwy).
"""
if name in repo:
return name
if name in PROVIDES_MAP:
real = PROVIDES_MAP[name]
if real in repo:
return real
# Wzorce: moduły Qt (Qt5Core/Qt6Widgets) i GStreamer (gstreamer-video-1.0)
if name.startswith("pkgconfig(Qt5"):
real = "qt5"
if real in repo:
return real
if name.startswith("pkgconfig(Qt6"):
real = "qt6"
if real in repo:
return real
if name.startswith("pkgconfig(gstreamer-") and name.endswith("-1.0)"):
real = "gstreamer"
if real in repo:
return real
if name.startswith("pkgconfig(gst-"):
real = "gst-plugins-base"
if real in repo:
return real
# Dynamiczne provides z repo.json (sekcja provides: w PAGBUILD.yaml)
# Determinizm: przy wielu dostawcach wybieramy posortowanego pierwszego
# (i ostrzegamy raz), zamiast zależeć od kolejności w repo.json.
_idx = _provides_index(repo)
if name in _idx:
return min(_idx[name])
# provides ZAINSTALOWANYCH pakietów – lokalnie zbudowane (pagbuild, poza
# repo) też dostarczają wirtualne zależności i muszą być rozpoznawane.
if installed:
_inst_cands = [pn for pn, meta in installed.items()
if isinstance(meta, dict) and name in (meta.get("provides") or [])]
if _inst_cands:
return min(_inst_cands)
clean = name
if name.startswith("pkgconfig(") and ")" in name:
clean = name.split("(", 1)[1].rstrip(")")
elif name.startswith("pkgconfig32(") and ")" in name:
clean = name.split("(", 1)[1].rstrip(")")
if clean != name and clean in repo:
return clean
return name
def cmd_why(pkg_name: str):
"""Pokazuje dlaczego pakiet jest zainstalowany."""
installed = load_json(INSTALLED_DB)
world = load_world()
if pkg_name not in installed:
print(f" {pkg_name}: {_('why_not_installed')}"); return 1
if pkg_name in world:
print(f" {pkg_name}-{installed[pkg_name]['version']}: {_('why_explicit')}")
return 0
parents = set()
for w in world:
_find_dep_path(w, pkg_name, installed, set(), [], parents)
if parents:
for pp in sorted(parents):
print(f" {pkg_name}: {_('why_dependency')} {' → '.join(pp)}")
else:
print(f" {pkg_name}: {_('why_dependency')} (unknown/orphan)")
return 0
def _find_dep_path(cur, target, installed, visited, path, results):
if cur in visited: return
visited.add(cur); path.append(cur)
if cur == target:
results.add(tuple(path))
else:
for dep in installed.get(cur, {}).get("dependencies", []):
_find_dep_path(dep, target, installed, visited, path, results)
path.pop(); visited.discard(cur)
def cmd_rdepends(pkg_name: str):
"""Pokazuje które pakiety zależą od danego pakietu (reverse dependencies).
Odwrotność `pag why`: dla każdego zainstalowanego pakietu sprawdza, czy
któraś z jego zależności (także wirtualna, przez provides) wskazuje na
pkg_name. Przydatne przed `pag remove` – pokazuje, co przestanie działać.
"""
installed = load_json(INSTALLED_DB)
if pkg_name not in installed:
print(f" {pkg_name}: {_('why_not_installed')}"); return 1
world = load_world()
# Nazwy, które zależą od pkg_name – sama nazwa plus jej wirtualne provides.
provided = {pkg_name} | set(installed[pkg_name].get("provides") or [])
rev = []
for name, meta in installed.items():
if name == pkg_name:
continue
for dep in (meta.get("dependencies") or []):
if dep in provided or _resolve_provides(dep, {}, installed) == pkg_name:
rev.append(name); break
if not rev:
print(f" {pkg_name}: {_('rdepends_none')}")
return 0
print(f"🔗 {_('rdepends_title', pkg_name, len(rev))}")
for n in sorted(rev):
kind = _("why_explicit") if n in world else _("why_dependency")
print(f" {n}-{installed[n].get('version', '?')} ({kind})")
return 0
def cmd_autoremove():
"""Automatycznie usuwa osierocone zależności bez pytania."""
installed = load_json(INSTALLED_DB)
world = load_world()
orphans = _find_orphans(installed, world)
if not orphans: print(f"✅ {_('autoremove_none')}"); return 0
print(f"🗑 {_('orphans_found', len(orphans), ', '.join(sorted(orphans)[:10]))}")
return cmd_remove(list(orphans))
def cmd_download(package_names):
"""Pobiera pakiety do cache bez instalowania."""
ensure_dirs()
repo = fetch_all_packages()
if not repo: print(f"❌ {_('no_index')}"); return 1
total_size = 0; downloaded = []
for name in package_names:
pkg = repo.get(name)
if not pkg:
print(f" ❌ {name}: {_('not_found')}"); continue
print(f" ↓ {name}-{pkg.version} ...", end=" ", flush=True)
path = _download_pkg(pkg)
if path:
total_size += os.path.getsize(path)
downloaded.append(name)
print(_c("green", "✓"))
else:
print(_c("red", "✗"))
if downloaded:
print(f"\n✅ {_('downloaded', len(downloaded), total_size/1048576)}")
return 0 if len(downloaded) == len(package_names) else 1
def cmd_stats():
"""Wyświetla statystyki PAG."""
installed = load_json(INSTALLED_DB)
history = load_json(HISTORY_FILE) if os.path.exists(HISTORY_FILE) else []
total_size = sum(i.get("size_bytes", 0) for i in installed.values())
total_files = _db_count_files()
cache_size = sum(
os.path.getsize(os.path.join(PAG_CACHE, f))
for f in os.listdir(PAG_CACHE)
if os.path.isfile(os.path.join(PAG_CACHE, f))
) if os.path.isdir(PAG_CACHE) else 0
last_update = _("never")
for e in reversed(history):
if e.get("action") in ("install", "upgrade") and e.get("success"):
last_update = e.get("timestamp", "?")[:19]; break
print(f"\n {_c('bold', _('stats_title'))}")
print(f" {'─' * 40}")
print(f" {_('stats_packages'):<30} {len(installed)}")
print(f" {_('stats_files'):<30} {total_files}")
print(f" {_('stats_size'):<30} {total_size/1048576:.1f} MB")
print(f" {_('stats_cache'):<30} {cache_size/1048576:.1f} MB")
print(f" {_('stats_history'):<30} {len(history)}")
print(f" {_('stats_last_update'):<30} {last_update}")
_bs = _base_summary(repo={}) # bez sieci – tylko stan zarządzania bazą
if _bs["total"]:
_bt = f"{_bs['tracked']}/{_bs['total']}"
if _bs["tracked"] < _bs["total"]:
_bt += " (sudo pag base adopt)"
print(f" {_('stats_base'):<30} {_bt}")
by_size = sorted(installed.items(), key=lambda x: x[1].get("size_bytes", 0), reverse=True)[:5]
if by_size:
print(f"\n {_c('dim', _('stats_top'))}")
for n, i in by_size:
print(f" {n}-{i['version']} {i.get('size_bytes',0)/1048576:.1f} MB")
return 0
def cmd_repo_add(url, name=None):
if not url.startswith("https://") and not os.environ.get("PAG_INSECURE"):
print(f" {_('sec_https')}"); return 1
ensure_dirs()
url = url.rstrip("/")
repos = get_repos()
if url in repos: print(f"⚠ {_('repo_exists', url)}"); return
if name:
# Drop-in: /etc/pag/repos/<nazwa>.conf (jak `echo url > .../stable.conf`)
os.makedirs(REPOS_DIR, exist_ok=True)
target = os.path.join(REPOS_DIR, name.rstrip("/").replace("/", "_") + ".conf")
with open(target, "w") as f: f.write(f"{url}\n")
print(f"✅ {_('repo_added', url)} → {target}")
return
with open(REPOS_CONF, "a") as f: f.write(f"{url}\n")
print(f"✅ {_('repo_added', url)}")
def cmd_repo_list():
for i, url in enumerate(get_repos(), 1): print(f" {i}. {url}")
FLATPAK_REMOTE_URL = "https://flathub.org/repo/flathub.flatpakrepo"
def _check_flatpak(quiet: bool = False):
if not shutil.which("flatpak"):
if not quiet:
print(f"❌ {_('flatpak_missing')}")
return False
r = subprocess.run(["flatpak", "remotes"], capture_output=True, text=True)
if "flathub" not in r.stdout:
print(f"⚠ {_('flatpak_adding')}")
# Jako root dodajemy remote systemowy; bez roota – w instalacji użytkownika,
# żeby remote i miejsce instalacji były spójne (patrz _flatpak_do_install).
add = ["flatpak", "remote-add", "--if-not-exists"]
if os.geteuid() != 0:
add.append("--user")
subprocess.run(add + ["flathub", FLATPAK_REMOTE_URL], check=False)
return True
def _spinner(msg: str):
"""Prosty spinner „myślenia” w osobnym wątku. Zwraca funkcję stop()."""
stop = threading.Event()
def _spin():
for c in itertools.cycle("|/-\\"):
if stop.is_set():
break
sys.stdout.write(f"\r {msg} {c}")
sys.stdout.flush()
time.sleep(0.1)
t = threading.Thread(target=_spin, daemon=True)
t.start()
def _stop():
stop.set()
t.join(timeout=0.3)
sys.stdout.write("\r" + " " * (len(msg) + 4) + "\r")
sys.stdout.flush()
return _stop
def _flatpak_search_raw(query: str) -> List[dict]:
"""Szuka we Flathub i zwraca listę wyników jako słowniki."""
if not _check_flatpak():
return []
stop = _spinner(_("flatpak_searching_any"))
try:
try:
r = subprocess.run(
["flatpak", "search", "--columns=name,description,application,version,branch,remotes", query],
capture_output=True, text=True, timeout=120
)
finally:
stop()
if r.returncode != 0 and "No matches found" not in r.stdout and not r.stdout.strip():
print(f" ⚠ flatpak search: {r.stderr.strip()[:150]}")
results = []
for line in r.stdout.strip().split("\n"):
parts = line.split("\t")
if len(parts) >= 3:
results.append({
"name": parts[0].strip(),
"description": parts[1].strip() if len(parts) > 1 else "",
"app_id": parts[2].strip() if len(parts) > 2 else "",
"version": parts[3].strip() if len(parts) > 3 else "",
"branch": parts[4].strip() if len(parts) > 4 else "stable",
"origin": parts[5].strip() if len(parts) > 5 else "flathub",
})
return results
except Exception as e:
print(_(' ⚠ Search error: {arg1}', arg1=(e)), file=sys.stderr)
return []
def _flatpak_find_best(query: str) -> Optional[dict]:
"""
Szuka we Flathub i próbuje znaleźć najlepsze dopasowanie.
- Jeśli query dokładnie pasuje do app_id → zwraca od razu
- Jeśli query pasuje do nazwy → zwraca pierwsze
- Jeśli wiele wyników → wyświetla listę i pyta użytkownika
- Jeśli brak → zwraca None
"""
results = _flatpak_search_raw(query)
if not results:
return None
# Dokładne dopasowanie app_id
exact = [r for r in results if r["app_id"].lower() == query.lower()]
if exact:
return exact[0]
# Dokładne dopasowanie nazwy
exact_name = [r for r in results if r["name"].lower() == query.lower()]
if exact_name:
return exact_name[0]
# Jednoznaczne dopasowanie (tylko 1 wynik)
if len(results) == 1:
return results[0]
# Wiele wyników – pokaż użytkownikowi
print(f"\n {_('flatpak_found', len(results))}")
for i, r in enumerate(results):
print(f" {i+1}. {_c('bold', r['name'])} ({r['app_id']})")
if r["version"]:
print(f" {_('flatpak_info_version')}: {r['version']}")
if r["description"]:
desc = r["description"][:80] + ("..." if len(r["description"]) > 80 else "")
print(f" {desc}")
try:
choice = input(_('\n Choose a number (1-{arg1}) or press Enter to cancel:', arg1=(len(results)))).strip()
if not choice:
return None
idx = int(choice) - 1
if 0 <= idx < len(results):
return results[idx]
except (EOFError, ValueError, IndexError):
pass
return None
def _flatpak_get_installed_info(app_id: str) -> Optional[dict]:
"""Zwraca info o zainstalowanym flatpaku lub None."""
try:
r = subprocess.run(
["flatpak", "info", "--columns=name,version,branch,origin,installed-size,description", app_id],
capture_output=True, text=True, timeout=10
)
if r.returncode != 0:
return None
parts = r.stdout.strip().split("\t")
if len(parts) < 3:
return None
return {
"name": parts[0].strip(),
"version": parts[1].strip() if len(parts) > 1 else "",
"branch": parts[2].strip() if len(parts) > 2 else "",
"origin": parts[3].strip() if len(parts) > 3 else "",
"size": parts[4].strip() if len(parts) > 4 else "",
"description": parts[5].strip() if len(parts) > 5 else "",
}
except Exception:
return None
def _flatpak_is_installed(app_id: str) -> bool:
"""Sprawdza czy flatpak o danym ID jest zainstalowany."""
try:
r = subprocess.run(
["flatpak", "info", app_id],
capture_output=True, text=True, timeout=10
)
return r.returncode == 0
except Exception:
return False
# =============================================================================
# FLATPAK – KOMENDY GŁÓWNE (zunifikowany interfejs)
# =============================================================================
# pag flatpak <query> → szuka i proponuje instalację (jeśli nie zainstalowany)
# pag flatpak search <query> → tylko szuka
# pag flatpak install <query> → instaluje
# pag flatpak remove <id> → usuwa
# pag flatpak list → lista zainstalowanych
# pag flatpak update → aktualizuje wszystkie
# pag flatpak info <id> → szczegóły flatpaka
def cmd_flatpak(args: list):
"""
Główna komenda flatpak – inteligentnie rozpoznaje intencję:
pag flatpak firefox → szuka i instaluje (jeśli nieznaleziony → szuka)
pag flatpak search firefox → tylko wyszukiwanie
pag flatpak install ... → bezpośrednia instalacja
pag flatpak remove ... → odinstalowanie
pag flatpak list → lista
pag flatpak update → aktualizacja
pag flatpak info ... → szczegóły
"""
if not _check_flatpak():
return 1
if not args:
# Bez argumentów – domyślnie lista
return cmd_flatpak_list()
subcmd = args[0].lower()
rest = args[1:]
# ── Podkomendy jawne ────────────────────────────────────────────────
if subcmd == "search":
if not rest:
print(_("flatpak_usage")); return 1
return cmd_flatpak_search(" ".join(rest))
elif subcmd == "install":
if not rest:
print(_("flatpak_usage")); return 1
return _flatpak_smart_install(rest)
elif subcmd == "remove" or subcmd == "uninstall":
if not rest:
print(_("flatpak_usage")); return 1
return _flatpak_smart_remove(rest)
elif subcmd == "list":
return cmd_flatpak_list()
elif subcmd == "update":
return cmd_flatpak_update()
elif subcmd == "info":
if not rest:
print(_("flatpak_usage")); return 1
return cmd_flatpak_info(rest[0])
else:
# ── Inteligentne wykrywanie: pag flatpak <nazwa> ────────────────
# Sprawdź czy to zainstalowany flatpak → pokaż info
# Jeśli nie → szukaj i zaproponuj instalację
query = " ".join(args)
# Najpierw sprawdź czy już zainstalowany
if _flatpak_is_installed(query):
print(_(" 📦 {arg1} – already installed (use 'pag flatpak info {arg2}' for details)", arg1=(_c('green', query)), arg2=(query)))
return cmd_flatpak_info(query)
# Szukaj we Flathub
print(f" {_('flatpak_searching', query)}")
best = _flatpak_find_best(query)
if not best:
print(f" ❌ '{query}' – {_('flatpak_not_found')}")
return 1
print(f"\n {_c('cyan', best['name'])} ({best['app_id']})")
if best["version"]:
print(f" {_('flatpak_info_version')}: {best['version']}")
if best["description"]:
print(f" {best['description']}")
try:
ans = input(f"\n {_('flatpak_install_prompt', best['name'])}").strip().lower()
except (EOFError, KeyboardInterrupt):
print(f"\n ⚠ {_('no_tty')}")
return 0
if ans and ans not in ("t", "y"):
print(_("cancelled"))
return 0
return _flatpak_do_install(best["app_id"])
def _flatpak_smart_install(names: list) -> int:
"""Instaluje flatpaki – obsługuje nazwy częściowe (wyszukuje przed instalacją)."""
failed = 0
for name in names:
if "." in name and "/" not in name:
# Wygląda na pełne app_id (np. org.mozilla.firefox)
app_id = name
else:
# Szukaj najlepszego dopasowania
best = _flatpak_find_best(name)
if not best:
print(f" ❌ '{name}' – {_('flatpak_not_found')}")
failed += 1
continue
app_id = best["app_id"]
print(f" → {best['name']} ({app_id})")
if _flatpak_do_install(app_id) != 0:
failed += 1
return 1 if failed else 0
def _flatpak_export_dirs() -> List[str]:
"""Katalogi eksportów Flatpaka (system + użytkownika) obecne na dysku.
Instalacja użytkownika roota (/root/.local/share/flatpak) jest świadomie
POMIJANA – to wewnętrzny artefakt roota, którego sesja użytkownika nigdy
nie zobaczy (patrz _flatpak_do_install)."""
dirs = ["/var/lib/flatpak/exports"]
home = os.path.expanduser("~")
if home and home not in ("/root", "/"):
dirs.append(os.path.join(home, ".local", "share", "flatpak", "exports"))
return [d for d in dirs if os.path.isdir(d)]
def _flatpak_refresh_caches() -> None:
"""Odświeża cache pulpitu i ikon po zmianie w Flatpaku (best-effort).
Flatpak robi to sam, ale tylko gdy `update-desktop-database` jest w PATH.
Bez tego nowo zainstalowana aplikacja bywa nieobecna w menu."""
for exports in _flatpak_export_dirs():
apps = os.path.join(exports, "share", "applications")
if os.path.isdir(apps) and shutil.which("update-desktop-database"):
subprocess.run(["update-desktop-database", apps],
capture_output=True, check=False, timeout=60)
icons = os.path.join(exports, "share", "icons", "hicolor")
if os.path.isdir(icons) and shutil.which("gtk-update-icon-cache"):
subprocess.run(["gtk-update-icon-cache", "-q", "-t", "-f", icons],
capture_output=True, check=False, timeout=120)
def _flatpak_session_sees_exports() -> bool:
"""Czy bieżąca sesja ma eksporty Flatpaka w XDG_DATA_DIRS."""
raw = os.environ.get("XDG_DATA_DIRS", "")
dirs = {d for d in raw.split(":") if d} or {"/usr/local/share", "/usr/share"}
return any(os.path.join(e, "share") in dirs for e in _flatpak_export_dirs())
def _flatpak_warn_if_invisible() -> None:
"""Ostrzega, gdy sesja nie widzi eksportów – inaczej wygląda to jak
„zainstalowało się, ale nie ma go w menu / na PC”."""
if not _flatpak_session_sees_exports():
print(f" ⚠ {_('flatpak_menu_hint')}")
print(f" {_('flatpak_menu_fix')}")
def _flatpak_do_install(app_id: str) -> int:
"""Wykonuje właściwą instalację flatpaka.
Jako root wymuszamy instalację SYSTEMOWĄ (--system). Bez tego `flatpak`
uruchomiony jako root potrafi zainstalować aplikację w instalacji
użytkownika roota (/root/.local/share/flatpak) – widocznej dla roota, ale
nie dla zalogowanego użytkownika. To dokładnie efekt „instaluje, ale nie
mam tego na PC”. Bez roota próbujemy instalacji systemowej (polkit),
a w razie niepowodzenia cofamy się do instalacji użytkownika (--user).
Zakres (scope) ma znaczenie: instalacja SYSTEMOWA (--system) jest widoczna
dla wszystkich użytkowników, a --user tylko dla bieżącego (dla roota:
/root/.local/... → niewidoczna dla sesji). `flatpak list` bez flag pokazuje
oba zakresy, więc systemowa instalacja roota jest widoczna też dla
zwykłego użytkownika."""
print(f" {_('flatpak_installing', app_id)}")
if os.geteuid() == 0:
result = subprocess.run(
["flatpak", "install", "-y", "--system", "flathub", app_id],
check=False, timeout=600)
else:
result = subprocess.run(
["flatpak", "install", "-y", "flathub", app_id],
check=False, timeout=600)
if result.returncode != 0:
# Flathub tylko dla użytkownika / brak agenta polkit – instalacja
# lokalna użytkownika jest lepsza niż twardy błąd.
subprocess.run(
["flatpak", "remote-add", "--if-not-exists", "--user",
"flathub", FLATPAK_REMOTE_URL], check=False, timeout=60)
result = subprocess.run(
["flatpak", "install", "-y", "--user", "flathub", app_id],
check=False, timeout=600)
if result.returncode != 0:
print(f" ❌ {_('download_fail')}: {app_id}")
return 1
_flatpak_refresh_caches()
print(f" ✅ {_('flatpak_installed', app_id)}")
_flatpak_warn_if_invisible()
return 0
def _flatpak_smart_remove(names: list) -> int:
"""Usuwa flatpaki – obsługuje nazwy częściowe."""
# Pobierz listę zainstalowanych
try:
r = subprocess.run(
["flatpak", "list", "--columns=application,name"],
capture_output=True, text=True, timeout=10
)
installed = {}
for line in r.stdout.strip().split("\n"):
parts = line.split("\t")
if len(parts) >= 2:
installed[parts[0].strip()] = parts[1].strip()
except Exception:
installed = {}
failed = 0
for name in names:
app_id = name
# Jeśli nie podano pełnego ID – spróbuj dopasować
if name not in installed:
matches = {aid: aname for aid, aname in installed.items()
if name.lower() in aid.lower() or name.lower() in aname.lower()}
if len(matches) == 0:
print(f" ❌ '{name}' – {_('flatpak_not_installed', name)}")
failed += 1
continue
elif len(matches) == 1:
app_id = list(matches.keys())[0]
print(f" → {matches[app_id]} ({app_id})")
else:
print(_("\n Multiple matches for '{arg1}':", arg1=(name)))
for i, (aid, aname) in enumerate(sorted(matches.items()), 1):
print(f" {i}. {aname} ({aid})")
try:
choice = input(_('\n Choose a number (1-{arg1}) or press Enter:', arg1=(len(matches)))).strip()
if not choice:
failed += 1
continue
aid_list = sorted(matches.keys())
app_id = aid_list[int(choice) - 1]
except (EOFError, ValueError, IndexError):
failed += 1
continue
print(f" 🗑 {app_id} ...", end=" ", flush=True)
result = subprocess.run(
["flatpak", "uninstall", "-y", app_id],
capture_output=True, text=True, timeout=120
)
if result.returncode == 0:
print("✅")
print(f" {_('flatpak_removed', app_id)}")
else:
print("❌")
failed += 1
if not failed:
_flatpak_refresh_caches()
return 1 if failed else 0
def cmd_flatpak_search(q: str):
"""Wyszukuje we Flathub i wyświetla wyniki (z możliwością wyboru do instalacji)."""
if not _check_flatpak():
return 1
results = _flatpak_search_raw(q)
if not results:
print(f" ❌ '{q}' – {_('flatpak_not_found')}")
return 1
print(f"\n {_('flatpak_found', len(results))}")
shown = results[:30] # max 30 wyników
for i, r in enumerate(shown, 1):
installed = "📦 " if _flatpak_is_installed(r["app_id"]) else " "
print(f" {i:>2}. {installed}{_c('bold', r['name'])} ({r['app_id']})")
if r["version"]:
print(f" {_('flatpak_info_version')}: {r['version']} | {_('flatpak_info_branch')}: {r['branch']}")
if r["description"]:
desc = r["description"][:100] + ("..." if len(r["description"]) > 100 else "")
print(f" {_c('dim', desc)}")
if len(results) > 30:
print(_(' ... and {arg1} more. Refine your query.', arg1=(len(results) - 30)))
# Interaktywny wybór – wpisz numer, aby zainstalować (Enter = anuluj)
try:
ans = input(_('\n Choose a number to install (1-{arg1}) or press Enter to cancel:', arg1=(len(shown)))).strip()
except (EOFError, KeyboardInterrupt):
return 0
if ans:
try:
idx = int(ans) - 1
if 0 <= idx < len(shown):
return _flatpak_do_install(shown[idx]["app_id"])
print(_("cancelled"))
except (ValueError, IndexError):
print(_("cancelled"))
return 0
def cmd_flatpak_list():
"""Wyświetla zainstalowane flatpaki."""
if not _check_flatpak():
return 1
r = subprocess.run(
["flatpak", "list", "--columns=application,name,version,origin,installation,installed-size"],
capture_output=True, text=True, timeout=10
)
lines = [l for l in r.stdout.strip().split("\n") if l.strip()]
if not lines:
print(_(' (no installed flatpaks)'))
return 0
print(_('Installed flatpaks ({arg1}):', arg1=(len(lines))))
for line in lines:
parts = line.split("\t")
if len(parts) >= 3:
app_id, name, version = parts[0], parts[1], parts[2]
scope = parts[4] if len(parts) > 4 else ""
size = parts[5] if len(parts) > 5 else ""
size_str = f" ({size})" if size else ""
scope_str = f" [{scope}]" if scope else ""
print(f" 📦 {_c('bold', name)} {version}{scope_str}{size_str}")
print(f" {_c('dim', app_id)}")
return 0
def _flatpak_auto_update() -> int:
"""Aktualizuje flatpaki SYSTEMOWE po `pag update`/`pag upgrade`.
Best-effort i po cichu, gdy nie ma czego robić:
* brak `flatpak` w PATH → pomiń,
* brak zainstalowanych aplikacji → pomiń (żadnego ruchu sieciowego),
* `--no-flatpak` / PAG_FLATPAK=0 → pomiń,
* NIE dodaje Flathuba (inaczej niż `_check_flatpak`).
Aktualizuje instalację systemową (root). Instalacje `--user` należą do
użytkownika – te aktualizuje `pag flatpak update` uruchomiony bez sudo.
"""
if os.environ.get("PAG_FLATPAK", "") in ("0", "no", "false", "never"):
return 0
if not shutil.which("flatpak"):
return 0
try:
lst = subprocess.run(
["flatpak", "list", "--app", "--columns=application"],
capture_output=True, text=True, timeout=60,
)
except Exception:
return 0
if lst.returncode != 0 or not lst.stdout.strip():
return 0
print(_(' 🔄 Updating flatpaks...'))
try:
res = subprocess.run(["flatpak", "update", "-y"], check=False, timeout=1800)
except Exception:
print(f" ⚠ {_('flatpak_update_failed')}")
return 1
if res.returncode == 0:
_flatpak_refresh_caches()
print(f" ✅ {_('flatpak_updated')}")
else:
print(f" ⚠ {_('flatpak_update_failed')}")
return res.returncode
def cmd_flatpak_update():
"""Aktualizuje wszystkie flatpaki."""
if not _check_flatpak():
return 1
print(_(' 🔄 Updating flatpaks...'))
result = subprocess.run(["flatpak", "update", "-y"], check=False, timeout=600)
if result.returncode == 0:
_flatpak_refresh_caches()
print(f" ✅ {_('flatpak_updated')}")
return result.returncode
def cmd_flatpak_info(app_id: str):
"""Wyświetla szczegóły flatpaka (zainstalowanego lub z Flathub)."""
if not _check_flatpak():
return 1
# Najpierw sprawdź zainstalowany
info = _flatpak_get_installed_info(app_id)
if info:
print(f"\n 📦 {_c('bold', info['name'])} {_c('green', '[zainstalowany]')}")
print(f" {'─' * 45}")
print(f" {_('flatpak_info_id'):<16} {app_id}")
print(f" {_('flatpak_info_version'):<16} {info['version']}")
print(f" {_('flatpak_info_branch'):<16} {info['branch']}")
print(f" {_('flatpak_info_origin'):<16} {info['origin']}")
if info["size"]:
print(f" {_('flatpak_info_size'):<16} {info['size']}")
if info["description"]:
print(f" {_('flatpak_info_desc'):<16} {info['description']}")
return 0
# Szukaj we Flathub
results = _flatpak_search_raw(app_id)
exact = [r for r in results if r["app_id"].lower() == app_id.lower()]
if not exact:
# Spróbuj częściowego dopasowania
if results:
exact = [results[0]]
else:
print(f" ❌ '{app_id}' – {_('flatpak_not_found')}")
return 1
r = exact[0]
print(f"\n 📦 {_c('bold', r['name'])} (Flathub)")
print(f" {'─' * 45}")
print(f" {_('flatpak_info_id'):<16} {r['app_id']}")
print(f" {_('flatpak_info_version'):<16} {r['version']}")
if r["description"]:
print(f" {_('flatpak_info_desc'):<16} {r['description']}")
print(_('\n 💡 To install: pag flatpak install {arg1}', arg1=(r['app_id'])))
return 0
# =============================================================================
# IMMUTABLE OS – KOMENDY DEPLOYMENTOWE
# =============================================================================
# Pakiety jądra – po ich instalacji trzeba przebudować initramfs
KERNEL_PACKAGE_PATTERNS = ["linux", "kernel", "linux-kernel", "linux-lts"]
# Pakiety, po których initramfs MUSI zostać przebudowany: jądra oraz moduły
# out-of-tree (NVIDIA/VirtualBox). `pag` robi to raz, po całej transakcji.
INITRAMFS_PACKAGE_PATTERNS = tuple(KERNEL_PACKAGE_PATTERNS) + (
"nvidia-dkms", "nvidia-kernel",
"vboxhost-kernel", "virtualbox-host-modules", "virtualbox-guest-modules",
)
def _is_kernel_package(name: str) -> bool:
"""Sprawdza czy pakiet to jądro (wymaga przebudowy initramfs)."""
name_lower = name.lower()
return any(pattern in name_lower for pattern in KERNEL_PACKAGE_PATTERNS)
def _needs_initramfs_refresh(name: str) -> bool:
"""Czy po tym pakiecie trzeba przebudować initramfs (jądro lub moduły)."""
name_lower = name.lower()
return any(pattern in name_lower
for pattern in INITRAMFS_PACKAGE_PATTERNS)
# Towarzysze jądra – aktualizowani RAZEM z jądrem, jeśli są zainstalowani,
# żeby userspace i moduły jądra nie rozjechały się wersjami.
KERNEL_SIBLINGS = ("linux-headers", "nvidia-dkms", "nvidia-kernel", "dkms",
"virtualbox-host-modules", "virtualbox-guest-modules")
def _kernel_group_updates(pending):
"""Gdy w transakcji jest jądro, dołóż jego towarzyszy (jeśli zainstalowani)."""
if not any(_is_kernel_package(n) for n in pending):
return pending
try:
installed = load_json(INSTALLED_DB)
repo = fetch_all_packages()
except Exception:
return pending
out = list(pending)
for sib in KERNEL_SIBLINGS:
if sib in installed and sib in repo and sib not in out:
out.append(sib)
return out
def _post_kernel_hooks():
"""Po zmianie jądra na ZWYKŁEJ instalacji: DKMS → depmod → initramfs → GRUB.
Kolejność ma znaczenie: najpierw moduły out-of-tree (DKMS) pod nowe jądro,
potem depmod (żeby modules.dep zawierał też nvidia/vbox – pakiety jądra
potrafią dostarczyć własny, niepełny modules.dep), potem initramfs (żeby
zawierał już przebudowane moduły), na końcu wpisy GRUB. To JEDYNE miejsce,
które finalizuje jądro po transakcji.
"""
if shutil.which("dkms"):
try:
print(_(' 🔧 DKMS: rebuilding out-of-tree modules (nvidia/vbox)...'))
subprocess.run(["dkms", "autoinstall"],
capture_output=True, text=True, timeout=1800)
except Exception:
pass
_refresh_depmod()
try:
_rebuild_initramfs()
except Exception:
pass
_refresh_bootloader()
def _refresh_depmod(root: str = "") -> None:
"""Przelicz `modules.dep` dla wszystkich jąder w `<root>/usr/lib/modules`.
Niektóre pakiety jądra dostarczają własny modules.dep wygenerowany w chwili
budowy – bez modułów doinstalowanych później (np. nvidia-kernel). Po
reinstalacji jądra taki plik nadpisuje poprawny indeks i `modprobe`
przestaje widzieć nvidia*.ko, mimo że pliki są na dysku. Depmod po całej
transakcji naprawia to również dla kolejnych bootów.
"""
depmod = shutil.which("depmod") or "/usr/sbin/depmod"
if not os.path.exists(depmod):
return
base = os.path.join(root or PAG_ROOT, "usr/lib/modules")
try:
versions = sorted(os.listdir(base))
except OSError:
return
print(_(' 🔧 Refreshing module dependencies (depmod)...'))
for ver in versions:
if not os.path.isdir(os.path.join(base, ver)):
continue
cmd = [depmod, "-a"]
if root:
cmd += ["-b", root]
cmd.append(ver)
try:
subprocess.run(cmd, capture_output=True, text=True, timeout=120)
except Exception:
pass
def _rebuild_initramfs(deploy_dir: str = "") -> bool:
"""
Przebudowuje initramfs dla aktywnego (lub podanego) deploymentu.
Używa skryptu pag-initramfs lub ręcznego cpio.
"""
if deploy_dir:
root = deploy_dir
else:
root = _get_deployment_root()
if root == PAG_ROOT:
# Zwykły system – NAJPIERW natywne narzędzie PaganOS (per-wersja +
# root=UUID/PARTUUID/LABEL), potem dracut/mkinitcpio.
if shutil.which("pagan-initramfs"):
print(_(' 🔧 Rebuilding initramfs (pagan-initramfs)...'))
try:
r = subprocess.run(["pagan-initramfs"], capture_output=True,
text=True, timeout=1800)
if r.returncode == 0:
return True
except Exception:
pass
# Zwykły system – użyj dracut jeśli dostępny
if shutil.which("dracut"):
print(_(' 🔧 Rebuilding initramfs (dracut)...'))
result = subprocess.run(
["dracut", "--force", "/boot/initramfs.img"],
capture_output=True, text=True, timeout=600
)
return result.returncode == 0
elif shutil.which("mkinitcpio"):
print(_(' 🔧 Rebuilding initramfs (mkinitcpio)...'))
result = subprocess.run(
["mkinitcpio", "-g", "/boot/initramfs.img"],
capture_output=True, text=True, timeout=600
)
return result.returncode == 0
else:
print(_(' ⚠ No dracut/mkinitcpio – initramfs was not rebuilt'))
return False
# Tryb immutable – budujemy initramfs dla deploymentu
print(_(' 🔧 Building initramfs for the deployment...'))
# Sprawdź czy mamy nasz skrypt init
pag_init_script = "/usr/share/pag/initramfs-init"
if not os.path.exists(pag_init_script):
# Szukaj w źródłach (developerski fallback)
alt_paths = [
os.path.join(os.path.dirname(os.path.abspath(__file__)), "scripts", "initramfs-init"),
"/usr/share/pag/init",
]
for p in alt_paths:
if os.path.exists(p):
pag_init_script = p
break
if not os.path.exists(pag_init_script):
print(_(' ⚠ pag-initramfs-init not found – skipping initramfs build'))
return False
boot_dir = os.path.join(root, "boot")
os.makedirs(boot_dir, exist_ok=True)
# Znajdź jądro (vmlinuz-*)
kernels = sorted(
[f for f in os.listdir(boot_dir) if f.startswith("vmlinuz-")],
reverse=True
) if os.path.exists(boot_dir) else []
if not kernels:
print(_(" ⚠ No vmlinuz-* found in the deployment's /boot"))
return False
kernel_ver = kernels[0].replace("vmlinuz-", "")
print(_(' 🐧 Kernel: {arg1}', arg1=(kernel_ver)))
# Buduj initramfs ręcznie (cpio)
tmpdir = tempfile.mkdtemp(prefix="pag-initramfs-")
try:
# Podstawowa struktura
for d in ["bin", "sbin", "dev", "proc", "sys", "run", "new_root",
"usr/bin", "usr/sbin", "lib", "lib64", "etc"]:
os.makedirs(os.path.join(tmpdir, d), exist_ok=True)
# Skopiuj init
shutil.copy2(pag_init_script, os.path.join(tmpdir, "init"))
os.chmod(os.path.join(tmpdir, "init"), 0o755)
# Skopiuj niezbędne binaria (busybox lub podstawowe narzędzia)
busybox_paths = [
os.path.join(root, "usr/bin/busybox"),
os.path.join(root, "bin/busybox"),
"/usr/bin/busybox",
"/bin/busybox",
]
busybox = None
for bp in busybox_paths:
if os.path.exists(bp):
busybox = bp
break
if busybox:
shutil.copy2(busybox, os.path.join(tmpdir, "bin/busybox"))
# Utwórz symlinki dla podstawowych komend
for cmd in ["sh", "mount", "umount", "ls", "cat", "echo", "sleep",
"readlink", "mkdir", "switch_root", "cp", "rm"]:
link = os.path.join(tmpdir, "bin", cmd)
if not os.path.exists(link):
os.symlink("busybox", link)
# /bin/sh → busybox
if not os.path.exists(os.path.join(tmpdir, "bin/sh")):
os.symlink("busybox", os.path.join(tmpdir, "bin/sh"))
else:
# Bez busybox – kopiuj podstawowe narzędzia z deploymentu
for tool in ["bash", "mount", "umount", "readlink", "mkdir", "cat", "sleep", "cp", "rm"]:
src = os.path.join(root, "usr/bin", tool)
if not os.path.exists(src):
src = os.path.join(root, "bin", tool)
if os.path.exists(src):
dest = os.path.join(tmpdir, "bin", os.path.basename(tool))
shutil.copy2(src, dest)
# Kopiuj zależności .so
_copy_libs_for_binary(src, tmpdir, root)
# Dodaj moduły jądra (opcjonalnie – dla sterowników dyskowych)
modules_src = os.path.join(root, "lib/modules", kernel_ver)
if os.path.isdir(modules_src):
modules_dst = os.path.join(tmpdir, "lib/modules", kernel_ver)
# Kopiuj tylko niezbędne (fs, block, drivers/ata, drivers/nvme)
for sub in ["kernel/fs", "kernel/drivers/ata", "kernel/drivers/nvme",
"kernel/drivers/scsi", "kernel/drivers/virtio",
"modules.order", "modules.builtin"]:
src_sub = os.path.join(modules_src, sub)
if os.path.exists(src_sub):
dst_sub = os.path.join(modules_dst, sub)
os.makedirs(os.path.dirname(dst_sub), exist_ok=True)
if os.path.isdir(src_sub):
try:
shutil.copytree(src_sub, dst_sub, dirs_exist_ok=True, symlinks=True,
ignore_dangling_symlinks=True)
except (FileNotFoundError, PermissionError):
print(_(' ⚠ Skipping unavailable files: {arg1}', arg1=(sub)))
else:
try:
shutil.copy2(src_sub, dst_sub)
except (FileNotFoundError, PermissionError):
print(_(' ⚠ Skipping unavailable file: {arg1}', arg1=(sub)))
# Pakuj do initramfs.img
initramfs_path = os.path.join(boot_dir, "initramfs.img")
old_cwd = os.getcwd()
os.chdir(tmpdir)
try:
with open(initramfs_path + ".tmp", "wb") as out:
_run_cpio_pipeline(tmpdir, out)
os.rename(initramfs_path + ".tmp", initramfs_path)
finally:
os.chdir(old_cwd)
size_mb = os.path.getsize(initramfs_path) / 1048576
print(_(' ✅ initramfs.img ({arg1:.1f} MB) → {arg2}', arg1=(size_mb), arg2=(initramfs_path)))
return True
except Exception as e:
print(_(' ❌ initramfs build error: {arg1}', arg1=(e)))
return False
finally:
shutil.rmtree(tmpdir, ignore_errors=True)
def _run_cpio_pipeline(tmpdir: str, out):
"""find . -print0 | cpio --null -oH newc | gzip — bez shell=True.
Buduje pipeline przez subprocess.Popen, unikając pośrednika powłoki
(brak ryzyka injection i niepotrzebnego procesu sh). Wykonuje się w cwd=tmpdir.
Separatory NUL (\0): plik/katalog ze znakiem nowej linii w nazwie nie
rozjeżdża cpio (inaczej uszkodzone archiwum → kernel panic przy rozruchu).
"""
find = subprocess.Popen(["find", ".", "-print0"], cwd=tmpdir, stdout=subprocess.PIPE)
cpio = subprocess.Popen(["cpio", "--null", "-oH", "newc"], cwd=tmpdir,
stdin=find.stdout, stdout=subprocess.PIPE)
find.stdout.close() # zwolnij uchwyt – cpio dostanie SIGPIPE po zakończeniu find
gzip = subprocess.Popen(["gzip"], stdin=cpio.stdout, stdout=out)
cpio.stdout.close()
try:
gzip.wait(timeout=120)
if gzip.returncode != 0:
raise subprocess.CalledProcessError(gzip.returncode, ["gzip"])
cpio.wait(timeout=30)
find.wait(timeout=30)
except subprocess.TimeoutExpired:
for p in (gzip, cpio, find):
p.kill()
raise
finally:
for p in (find, cpio, gzip):
if p.poll() is None:
p.kill()
# Skontroluj też kody procesów pośrednich (cpio/find mogą zawieść, a gzip zwrócić 0)
if cpio.returncode != 0:
raise subprocess.CalledProcessError(cpio.returncode, ["cpio"])
if find.returncode != 0:
raise subprocess.CalledProcessError(find.returncode, ["find"])
def _copy_libs_for_binary(binary: str, dest_dir: str, root: str):
"""Kopiuje zależności .so dla binarki do initramfs (uproszczone ldd)."""
try:
result = subprocess.run(
["ldd", binary], capture_output=True, text=True, timeout=10
)
for line in result.stdout.split("\n"):
m = re.search(r'=>\s+(/\S+)', line)
if m:
lib_path = m.group(1)
lib_rel = lib_path.lstrip("/")
lib_dest = os.path.join(dest_dir, lib_rel)
if not os.path.exists(lib_dest):
os.makedirs(os.path.dirname(lib_dest), exist_ok=True)
# Szukaj w deployment root lub systemie
if os.path.exists(lib_path):
shutil.copy2(lib_path, lib_dest)
else:
alt = os.path.join(root, lib_rel)
if os.path.exists(alt):
shutil.copy2(alt, lib_dest)
except Exception:
pass
def cmd_initramfs_update():
"""Ręcznie przebudowuje initramfs dla bieżącego deploymentu."""
ensure_dirs()
deploy_dir = _get_deployment_root()
if deploy_dir != PAG_ROOT:
print(_('🏗️ Deployment: {arg1}', arg1=(os.path.basename(deploy_dir))))
ok = _rebuild_initramfs(deploy_dir)
if ok:
print(_('✅ Initramfs updated.'))
# Po initramfs – zaktualizuj też GRUB
_update_grub_config()
else:
print(_('❌ Initramfs update failed.'))
return 0 if ok else 1
def _boot_prefix() -> str:
"""Prefiks ścieżek jądra/initrd w grub.cfg.
Gdy /boot jest OSOBNYM punktem montowania, GRUB ma w `root` partycję
/boot (tam leży grub.cfg i jądra), więc ścieżki podajemy względem niej:
"/vmlinuz-…", "/initramfs.img" – BEZ przedrostka /boot. Gdy /boot leży
na roocie, wymagane jest "/boot/…". Zły przedrostek = "file not found".
"""
try:
if os.path.isdir("/boot") and os.path.ismount("/boot"):
return ""
except OSError:
pass
return "/boot"
def _strip_crlf(path: str) -> bool:
"""Usuwa CRLF/CR z pliku. True, jeśli coś zmieniono.
/etc/default/grub z końcówkami Windows wywala `grub-mkconfig`
(line 2: bad command), a wtedy menu GRUB nie jest odświeżane po
aktualizacji jądra — zostaje stary wpis startowy.
"""
try:
if not os.path.isfile(path):
return False
with open(path, "rb") as f:
data = f.read()
if b"\r" not in data:
return False
with open(path, "wb") as f:
f.write(data.replace(b"\r\n", b"\n").replace(b"\r", b"\n"))
return True
except Exception:
return False
def _repair_initramfs_links(boot: str = "/boot") -> bool:
"""Doprowadza aliasy initramfs do stanu, w którym GRUB ma co podać.
/etc/grub.d/10_linux dodaje linię `initrd` tylko jeśli istnieje
`initrd.img-<wersja>` lub `initramfs-<wersja>.img`. Dla wpisu z aliasu
`vmlinuz-linux` szuka `initrd.img-linux` / `initramfs-linux.img`.
Martwy łańcuch dowiązań = start BEZ initramfs, czyli panika
(VFS: Cannot open root device), gdy NVMe/LUKS są modułami.
"""
changed = False
try:
if not os.path.isdir(boot):
return False
imgs = []
for n in os.listdir(boot):
if not (n.startswith("initramfs-") and n.endswith(".img")):
continue
ver = n[len("initramfs-"):-len(".img")]
if not ver or not ver[0].isdigit():
continue # initramfs-linux.img to alias
fp = os.path.join(boot, n)
if os.path.isfile(fp) and not os.path.islink(fp):
imgs.append((os.path.getmtime(fp), n))
if not imgs:
return False
newest = max(imgs)[1]
def _link(alias: str, target: str, force: bool = False) -> None:
nonlocal changed
ap = os.path.join(boot, alias)
if os.path.islink(ap):
if os.readlink(ap) == target and os.path.exists(ap):
return
if os.path.exists(ap) and not force:
return # cel istnieje – nie ruszamy
os.remove(ap)
elif os.path.exists(ap):
return # prawdziwy plik – nie ruszamy
try:
os.symlink(target, ap)
changed = True
except OSError:
pass
_link("initramfs.img", newest, force=True)
if os.path.exists(os.path.join(boot, "vmlinuz-linux")):
_link("initramfs-linux.img", "initramfs.img")
_link("initrd.img-linux", "initramfs.img")
return changed
except Exception:
return changed
def _grub_entry_lacks_initrd(grub_cfg: str = "/boot/grub/grub.cfg") -> bool:
"""Czy pierwszy wpis menu nie ma linii `initrd` (start bez initramfs)."""
try:
with open(grub_cfg, encoding="utf-8", errors="replace") as f:
lines = f.read().splitlines()
except Exception:
return False
inside = False
for ln in lines:
st = ln.strip()
# Uwaga: `menuentry_id_option="..."` z nagłówka grub.cfg też zaczyna się
# od "menuentry" – wymagamy separatora, inaczej parser zgłasza fałszywy
# alarm „wpis startowy bez initramfs”.
if st.startswith("menuentry") and st[9:10] in (" ", "\t", "'", '"'):
if inside:
return True
inside = True
continue
if not inside:
continue
if st.startswith("initrd"):
return False
if st == "}":
return True
return False
def _refresh_bootloader():
"""Odświeża wpisy bootloadera po zmianie jądra.
Deploymenty (immutable OS): własny generator _update_grub_config().
Zwykła instalacja: standardowy `grub-mkconfig` – /etc/grub.d/10_linux
sam wygeneruje wpisy dla KAŻDEGO /boot/vmlinuz-* wraz z jego własnym
initrd. Bez tego `pag upgrade kernel` zostawiał w menu STARY wpis:
system startował ze starym jądrem, a nowe moduły leżały bezużyteczne
("moduły 7.2.8 na jądrze 7.2.5" → zawieszenie na starcie).
"""
try:
if _load_deployments():
_update_grub_config()
return
except Exception:
pass
grub_cfg = "/boot/grub/grub.cfg"
if not os.path.isdir("/boot/grub"):
return
# Zanim wygenerujemy menu: napraw dane wejściowe. Inaczej grub-mkconfig
# albo się wywali, albo wygeneruje wpis bez initramfs.
for _f in ("/etc/default/grub", "/boot/grub/grub.cfg.exemple"):
if _strip_crlf(_f):
print(" 🧹 " + _('crlf_fixed', _f))
if _repair_initramfs_links():
print(" 🔗 " + _('initramfs_links_fixed'))
for tool, cmd in ((
"grub-mkconfig", ["grub-mkconfig", "-o", grub_cfg]), (
"grub2-mkconfig", ["grub2-mkconfig", "-o", grub_cfg])):
if shutil.which(tool):
try:
print(_(' 📋 Regenerating GRUB (grub-mkconfig)...'))
r = subprocess.run(cmd, capture_output=True, text=True,
errors="replace", timeout=180)
if r.returncode != 0:
tail = [x for x in (r.stderr or r.stdout or "").splitlines() if x.strip()]
print(" ⚠ " + _('grub_failed', tail[-1] if tail else r.returncode))
elif _grub_entry_lacks_initrd(grub_cfg):
print(" ⚠ " + _('grub_no_initrd'))
else:
print(" ✅ " + _('grub_refreshed'))
except Exception:
pass
return
def _update_grub_config():
"""
Generuje wpisy GRUB dla wszystkich deploymentów.
Każdy deployment dostaje własny wpis – rollback możliwy z bootloadera.
"""
grub_cfg = "/boot/grub/grub.cfg"
if not os.path.exists(os.path.dirname(grub_cfg)):
return # brak GRUB
deployments = _load_deployments()
root_dev = _detect_root_device()
if not root_dev:
print(_(' ⚠ Could not detect the root partition – GRUB entries will have no root=.'),
file=sys.stderr)
print(_(' Set PAG_ROOT_DEVICE=/dev/... (or PAG_GRUB_ROOT) and retry.'),
file=sys.stderr)
root_arg = f" root={root_dev}" if root_dev else ""
lines = [
"# =====================================================================",
"# Pagan Linux – GRUB config (wygenerowane przez pag grub-update)",
f"# Data: {datetime.now().isoformat()}",
"# =====================================================================",
"",
]
# Domyślny – ostatni (najnowszy) deployment
if deployments:
latest = deployments[-1]["id"]
lines.append(f"set default=0")
lines.append(f"set timeout=5")
else:
lines.append("set default=0")
lines.append("set timeout=5")
lines.append("")
# Wpisy dla każdego deploymentu (od najnowszego)
entry_num = 0
for d in reversed(deployments):
deploy_dir = os.path.join(DEPLOYMENTS_DIR, d["id"])
boot_dir = os.path.join(deploy_dir, "boot")
kernels = sorted(
[f for f in os.listdir(boot_dir) if f.startswith("vmlinuz-")],
reverse=True
) if os.path.isdir(boot_dir) else []
kernel_path = f"/.deployments/{d['id']}/boot/{kernels[0]}" if kernels else ""
initrd_path = f"/.deployments/{d['id']}/boot/initramfs.img"
initrd_line = f"initrd {initrd_path}" if os.path.exists(os.path.join(boot_dir, "initramfs.img")) else ""
active_mark = f" [{_('active_deployment')}]" if d.get("active") else ""
pkg_list = ", ".join(d.get("packages", [])[:3])
label = f"Pagan Linux – {d['id']}{active_mark}"
lines.append(f"menuentry '{label}' {{")
if kernel_path:
lines.append(f" linux {kernel_path}{root_arg} rw quiet")
else:
lines.append(f" # Brak jądra w tym deploymencie")
if initrd_line:
lines.append(f" {initrd_line}")
lines.append("}")
lines.append("")
entry_num += 1
# Snapshoty systemu (btrfs) – każdy jako osobny wpis do uruchomienia.
_snap_lines = _grub_snapshot_entries()
if _snap_lines:
lines.append("# --- Snapshoty systemu (CoW) ---")
lines.extend(_snap_lines)
# Wpis fallback: zwykły root (gdyby wszystko padło).
# Uwaga: GRUB NIE rozwija globów – trzeba podać KONKRETNY plik jądra
# (wcześniejsze `linux /boot/vmlinuz-*` było niepoprawne).
fallback_kernels = sorted(
[f for f in os.listdir("/boot") if f.startswith("vmlinuz-")],
reverse=True
) if os.path.isdir("/boot") else []
# Osobna partycja /boot => GRUB ma ją w `root`, ścieżki BEZ /boot.
_bp = _boot_prefix()
lines.append(f"menuentry '{_('grub_fallback_label')}' {{")
if fallback_kernels:
lines.append(f" linux {_bp}/{fallback_kernels[0]}{root_arg} rw quiet")
_fi = _initrd_for_kernel("/boot", fallback_kernels[0])
if _fi:
lines.append(f" initrd {_bp}/{_fi}")
else:
lines.append(" # Brak jądra w /boot")
lines.append("}")
lines.append("")
# Zapisz
os.makedirs(os.path.dirname(grub_cfg), exist_ok=True)
with open(grub_cfg, "w") as f:
f.write("\n".join(lines))
print(_(' 📋 GRUB config updated – entries for each deployment'))
def _root_device_from_fstab(path: str = "/etc/fstab") -> str:
"""Zwraca DEVICE z wpisu dla '/' w fstab (pomija komentarze)."""
try:
with open(path, "r", encoding="utf-8", errors="replace") as fh:
for line in fh:
line = line.split("#", 1)[0].strip()
if not line:
continue
parts = line.split()
if len(parts) >= 2 and parts[1] == "/":
return parts[0]
except OSError:
pass
return ""
def _in_chroot() -> bool:
"""Heurystyka: czy działamy w chrocie (build ISO/IMG)?
W chrocie /proc/1/root to root HOSTA – inny system plików niż nasz '/'.
Na zwykłym systemie PID 1 ma root równy '/'. PAGAN_ROOT ustawiają skrypty
budujące i jest dziedziczony przez chroot (dodatkowa wskazówka).
"""
if os.environ.get("PAG_IN_CHROOT") == "1":
return True
if os.environ.get("PAGAN_ROOT"):
return True
try:
return os.stat("/").st_dev != os.stat("/proc/1/root").st_dev
except OSError:
return False
def _detect_root_device() -> str:
"""Wykrywa urządzenie/identyfikator partycji root dla GRUB (root=...).
Kolejność (od najbardziej wiarygodnego w danym kontekście):
1) PAG_ROOT_DEVICE / PAG_GRUB_ROOT – jawny override (build ISO/IMG,
instalator); najpewniejszy, bo nie zgadujemy.
2) /etc/fstab TARGETU – w chrocie findmnt '/' zwraca partycję HOSTA,
a fstab opisuje target (np. root=/dev/sda2 dla obrazu IMG).
3) findmnt '/' – na żywym systemie (obsługuje UUID/LUKS/subvol).
Zwraca "" gdy nie da się ustalić – wtedy GRUB nie dostaje błędnego root=.
"""
explicit = (os.environ.get("PAG_ROOT_DEVICE")
or os.environ.get("PAG_GRUB_ROOT") or "").strip()
if explicit:
return explicit
fstab_dev = _root_device_from_fstab()
if _in_chroot() and fstab_dev:
return fstab_dev
try:
result = subprocess.run(
["findmnt", "-n", "-o", "SOURCE", "/"],
capture_output=True, text=True, timeout=5
)
if result.returncode == 0 and result.stdout.strip():
return result.stdout.strip()
except Exception:
pass
# Ostatnia deska: fstab targetu (lepsze niż hardkodowane /dev/sda1,
# które na sprzęcie z NVMe dawało niebootowalny system).
return fstab_dev
def cmd_grub_update():
"""Ręcznie regeneruje konfigurację GRUB (deploymenty + snapshoty)."""
ensure_dirs()
print(_('📋 Updating GRUB configuration...'))
_ensure_snapshot_grub_script()
# Deploymenty mają własny generator; zwykły system – grub-mkconfig,
# który uruchomi /etc/grub.d/40_pagan_snapshots i zachowa pozostałe wpisy.
_refresh_bootloader()
print(_('✅ GRUB updated.'))
return 0
def cmd_deploy_list():
"""Wyświetla listę wszystkich deploymentów."""
deployments = _load_deployments()
if not deployments:
print(_("no_deployments")); return
print(_("deployments_list", len(deployments)))
active = os.readlink(ACTIVE_LINK) if os.path.islink(ACTIVE_LINK) else ""
for d in reversed(deployments):
marker = f" ◀ {_('active_deployment')}" if d.get("active") or d["id"] == os.path.basename(active) else ""
print(f" {d['id']}{marker}")
print(f" {_action_label(d['action'])}: {', '.join(d['packages'][:5])}")
if len(d.get('packages', [])) > 5:
print(_(' +{arg1} more...', arg1=(len(d['packages']) - 5)))
print(f" {d['timestamp']}")
def cmd_deploy_rollback():
"""Przełącza na poprzedni deployment."""
deployments = _load_deployments()
active_indices = [i for i, d in enumerate(deployments) if d.get("active")]
if len(deployments) < 2:
print(f"❌ {_('deploy_rollback_fail')}"); return 1
current_idx = active_indices[0] if active_indices else len(deployments) - 1
prev_idx = current_idx - 1 if current_idx > 0 else -1
if prev_idx < 0:
print(f"❌ {_('deploy_rollback_fail')}"); return 1
prev = deployments[prev_idx]
prev_dir = os.path.join(DEPLOYMENTS_DIR, prev["id"])
if not os.path.isdir(prev_dir):
print(_('❌ Deployment {arg1} does not exist on disk', arg1=(prev['id']))); return 1
print(_('⏪ Restoring deployment: {arg1}', arg1=(prev['id'])))
print(f" {prev['action']}: {', '.join(prev['packages'][:5])}")
if not _ask_confirm():
return 0
_switch_deployment(prev_dir)
for d in deployments:
d["active"] = (d["id"] == prev["id"])
_save_deployments(deployments)
_update_grub_config()
print(f"✅ {_('deploy_rollback_ok', prev['id'])}")
print(_(' 💡 Restart required to reload the system.'))
return 0
def cmd_deploy_cleanup(keep: int = 3):
"""Usuwa stare deploymenty, zachowując ostatnie `keep`."""
deployments = _load_deployments()
if len(deployments) <= keep:
print(f"✅ {_('deploy_cleanup_none', keep)}"); return 0
to_remove = deployments[:-keep]
removed = 0
for d in to_remove:
deploy_dir = os.path.join(DEPLOYMENTS_DIR, d["id"])
if os.path.isdir(deploy_dir):
shutil.rmtree(deploy_dir, ignore_errors=True)
removed += 1
remaining = deployments[-keep:]
_save_deployments(remaining)
print(f"✅ {_('deploy_cleanup_ok', removed)}")
return 0
# =============================================================================
# POMOCNICZE
# =============================================================================
# Pakiety dostarczane przez bazowy system (zawsze "zainstalowane"). Wchodzą do
# rootfs z ISO przez data.tar.xz, więc NIE ma ich w repo.json ani w bazie pag –
# każda zależność od nich (glibc, bash, python3…) wyglądałaby na "brakującą".
# Współdzielone przez rozwijanie i weryfikację zależności.
SYSTEM_BASE = {
"glibc", "libc", "gcc", "g++", "make", "binutils", "coreutils", "bash",
"linux-api-headers", "kernel-headers", "zlib", "pkg-config", "pkgconf",
"tar", "gzip", "xz", "bzip2", "findutils", "grep", "sed", "gawk", "awk",
"diffutils", "patch", "file", "m4", "perl", "python3", "sh",
}
def _resolve_deps(names, repo, installed):
resolved, visited = [], set()
missing = [] # zależności których nie ma ani w repo ani zainstalowane
def _is_base(dep):
"""True, gdy zależność dostarcza bazowy system (także przez provides)."""
return dep in SYSTEM_BASE \
or _resolve_provides(dep, repo, installed) in SYSTEM_BASE
def visit(name, explicit=False):
if name in visited: return
# Rozwijanie wirtualnych zależności przez provides
target = _resolve_provides(name, repo, installed)
# Zależność dostarczana przez bazowy system – nie ma jej w repo ani w
# bazie pag, więc nie "brakuje" jej i nie próbujemy jej instalować.
# Wyjątek: nazwa podana wprost przez użytkownika (explicit=True).
if not explicit and target in SYSTEM_BASE:
return
if target in visited: return
visited.add(target)
if target in repo:
for dep in repo[target].dependencies:
real_dep = _resolve_provides(dep, repo, installed)
real_target = real_dep if real_dep in repo else dep
if _is_base(dep):
continue
# Sprawdź czy zależność jest dostępna
if real_target not in installed and real_target not in repo:
if dep not in missing:
missing.append(dep)
if dep not in installed:
visit(real_target)
elif target not in installed:
# Pakiet nie istnieje ani w repo ani zainstalowany
if target not in missing:
missing.append(target)
if target not in installed and target not in resolved:
resolved.append(target)
for name in names:
visit(name, explicit=True)
# Zwróć brakujące (do sprawdzenia przez wywołującego)
return resolved, missing
def _verify_dependencies(to_install: list, repo: dict, installed: dict) -> int:
"""
Sprawdza czy wszystkie zależności pakietów do instalacji są spełnione.
Zwraca liczbę brakujących zależności.
"""
all_missing = []
all_warnings = []
for pkg_name in to_install:
pkg = repo.get(pkg_name)
if not pkg:
continue
for dep in pkg.dependencies:
if dep in SYSTEM_BASE:
continue # bazowy system dostarcza tę zależność
real_dep = _resolve_provides(dep, repo, installed)
# Sprawdź czy zależność jest dostępna (w repo lub już zainstalowana)
in_repo = real_dep in repo
in_installed = real_dep in installed
will_be_installed = real_dep in to_install
if not in_repo and not in_installed and not will_be_installed:
if dep not in all_missing:
all_missing.append((pkg_name, dep))
elif in_repo and not in_installed and not will_be_installed:
if dep not in [w[1] for w in all_warnings]:
all_warnings.append((pkg_name, dep, real_dep))
if all_missing:
print(_('\n❌ {arg1} – cannot install:', arg1=(_c('red', 'BRAKUJĄCE ZALEŻNOŚCI'))))
for pkg, dep in all_missing:
print(_(' {arg1} → needs {arg2} (missing from repositories)', arg1=(pkg), arg2=(_c('red', dep))))
print()
if all_warnings:
print(_('\n⚠ {arg1} – will be installed as dependencies:', arg1=(_c('yellow', 'NIESPEŁNIONE ZALEŻNOŚCI'))))
for pkg, dep, real in all_warnings:
print(_(' {arg1} → {arg2} ({arg3} – will be downloaded)', arg1=(pkg), arg2=(dep), arg3=(_c('green', real))))
print()
return len(all_missing)
# Biblioteki bazowe (glibc/gcc runtime) – zawsze dostępne, nie wymagają pakietu
BASE_SO = {
"libc.so.6", "libm.so.6", "libpthread.so.0", "libdl.so.2", "librt.so.1",
"libutil.so.1", "libresolv.so.2", "libnsl.so.1", "libcrypt.so.1",
"ld-linux.so.2", "ld-linux-x86-64.so.2", "ld-linux-aarch64.so.1",
"libgcc_s.so.1", "linux-vdso.so.1",
}
def _verify_so_deps(to_install: list, repo: dict, installed: dict) -> int:
"""Sprawdza wymagania ABI (provides_so / requires_so z metadata.json).
Fail-closed TYLKO gdy metadata jawnie deklaruje requires_so, a żaden pakiet
(bazowy, zainstalowany lub instalowany w tej transakcji) nie dostarcza
wymaganej wersji biblioteki. Stare pakiety bez tych pól są pomijane.
"""
provided = set(BASE_SO)
for n in to_install:
p = repo.get(n)
if p:
provided.update(p.provides_so or [])
for n, info in installed.items():
provided.update(info.get("provides_so", []) or [])
# NAPRAWA: soname faktycznie obecne w systemie (ldconfig -p). Metadane
# starych paczek (zbudowanych przed polem provides_so) ich nie deklaruja,
# a biblioteki sa na dysku - bez tego fail-closed check blokuje legalne
# aktualizacje (np. mesa -> libLLVM.so.22.1).
try:
import shutil as _sh, subprocess as _sp
_ld = _sh.which("ldconfig")
if _ld:
_o = _sp.run([_ld, "-p"], capture_output=True, text=True).stdout
for _ln in _o.splitlines():
_ln = _ln.strip()
if "=>" in _ln:
provided.add(_ln.split("=>")[0].strip().split()[0])
except Exception:
pass
missing = []
for n in sorted(to_install):
p = repo.get(n)
if not p:
continue
for so in (p.requires_so or []):
if so not in provided:
missing.append((n, so))
if missing:
print(f"\n❌ {_c('red', 'BRAK WYMAGANYCH BIBLIOTEK (ABI so-name)')}:")
for n, so in missing:
print(_(' {arg1} → requires {arg2} – no package provides this version', arg1=(n), arg2=(_c('red', so))))
print()
return len(missing)
def _download_pkg(pkg, attempts: int = 3, progress: bool = True,
on_progress=None, on_log=None):
"""Pobiera pakiet do cache.
`progress=False` wycisza pojedynczy pasek (np. gdy równoległy pobierający
pokazuje własny panel zbiorczy). `on_progress(downloaded, total)` pozwala
takiemu panelowi śledzić postęp bez wypisywania własnych linii, a
`on_log(text)` przekierowuje komunikaty (ponowienia, błędy) do panelu,
żeby nie rozbijały jego wielolinijkowego układu.
"""
def _log(msg: str) -> None:
if on_log is not None:
on_log(msg)
else:
print(msg, file=sys.stderr)
url = f"{pkg.repo_url}/{pkg.filename}"
dest = os.path.join(PAG_CACHE, pkg.filename)
if os.path.exists(dest) and (not pkg.sha256 or _sha256_file(dest) == pkg.sha256):
_download_pkg_sig(pkg, dest) # upewnij się, że sygnatura jest w cache
return dest
last_err = None
for attempt in range(1, attempts + 1):
try:
req = Request(url, headers={"User-Agent":"pag/3.0"})
with urlopen(req, timeout=600) as resp:
total = int(resp.headers.get("Content-Length", 0))
bar = DownloadBar(pkg.filename, total) if progress else None
done = 0
try:
with open(dest, "wb") as f:
while True:
chunk = resp.read(65536)
if not chunk:
break
f.write(chunk)
done += len(chunk)
if bar is not None:
bar.update(len(chunk))
if on_progress is not None:
on_progress(done, total)
finally:
if bar is not None:
bar.close()
if pkg.sha256 and _sha256_file(dest) != pkg.sha256:
last_err = _("sha256_mismatch")
try:
os.remove(dest)
except OSError:
pass
if attempt < attempts:
_log(_(' ↻ Retrying download of {arg1} ({arg2}/{arg3})...', arg1=(pkg.filename), arg2=(attempt), arg3=(attempts - 1)))
time.sleep(attempt)
continue
return None
_download_pkg_sig(pkg, dest)
return dest
except Exception as e:
last_err = e
# Usuń częściowy plik – bez tego mógłby zostać użyty jako „cache”
# (gdy pakiet nie ma sha256) albo mylić kolejną próbę.
try:
if os.path.exists(dest):
os.remove(dest)
except OSError:
pass
if attempt < attempts:
_log(_(' ↻ Retrying download of {arg1} ({arg2}/{arg3})...', arg1=(pkg.filename), arg2=(attempt), arg3=(attempts - 1)))
time.sleep(attempt)
continue
_log(_(' ⚠ Download error {arg1}: {arg2}', arg1=(pkg.filename), arg2=(last_err)))
return None
def _download_pkg_sig(pkg, dest):
"""Zapewnia AKTUALNY podpis pakietu (.asc, fallback .sig) w cache.
Istniejący podpis jest używany tylko wtedy, gdy faktycznie weryfikuje TĘ
paczkę. Inaczej po przebudowie tej samej wersji (ten sam plik, nowy sha256)
stary podpis zostawał obok nowej paczki i weryfikacja dawała fałszywe
„NIEPRAWIDŁOWY PODPIS GPG”.
"""
for ext in (".asc", ".sig"):
sig_dest = dest + ext
if os.path.exists(sig_dest):
ok, _fp = _gpg_verify_fp(sig_dest, dest)
if ok:
return
for ext in (".asc", ".sig"):
sig_dest = dest + ext
try:
req = Request(f"{pkg.repo_url}/{pkg.filename}{ext}", headers={"User-Agent":"pag/3.0"})
with urlopen(req, timeout=30) as resp:
data = resp.read()
except Exception:
continue
# nie mieszaj rozszerzeń – zostaje tylko ten wariant podpisu
for other in (".asc", ".sig"):
if other != ext:
try:
os.remove(dest + other)
except OSError:
pass
with open(sig_dest, "wb") as f:
f.write(data)
return
# Nie udało się pobrać podpisu – usuń nieaktualny z cache, żeby weryfikacja
# nie porównywała paczki z podpisem od innej wersji (czytelny „BRAK PODPISU”).
for other in (".asc", ".sig"):
try:
os.remove(dest + other)
except OSError:
pass
def _download_packages_parallel(pkgs: List[PackageInfo], max_workers: int = 4) -> Dict[str, Optional[str]]:
"""
Równoległe pobieranie wielu pakietów przez ThreadPoolExecutor.
Znacząco przyspiesza przy dużych aktualizacjach (50+ pakietów).
Każdy aktywny wątek ma własną linię w panelu: procent, nazwa pakietu,
pobrane/rozmiar i ETA (patrz `_ParallelDownloadDisplay`).
Zwraca słownik {nazwa_pakietu: ścieżka_lub_None}.
"""
results = {}
display = _ParallelDownloadDisplay(len(pkgs))
def _worker(pkg: PackageInfo):
sid = display.start(pkg.name, getattr(pkg, "size_bytes", 0) or 0)
path = None
try:
path = _download_pkg(
pkg, progress=False,
on_progress=lambda done, total: display.progress(sid, done, total),
on_log=display.log)
return path
finally:
display.finish(sid, ok=bool(path))
try:
with ThreadPoolExecutor(max_workers=max_workers) as executor:
future_to_pkg = {executor.submit(_worker, pkg): pkg for pkg in pkgs}
for future in as_completed(future_to_pkg):
pkg = future_to_pkg[future]
try:
results[pkg.name] = future.result()
except Exception:
results[pkg.name] = None
finally:
display.close()
return results
def load_world():
if not os.path.exists(WORLD_FILE): return set()
return {l.strip() for l in open(WORLD_FILE) if l.strip()}
def save_world(w):
with open(WORLD_FILE,"w") as f:
for n in sorted(w): f.write(f"{n}\n")
def _find_orphans(installed, world):
needed = set(world)
changed = True
while changed:
changed = False
for n in list(needed):
for dep in installed.get(n,{}).get("dependencies",[]):
if dep not in needed and dep in installed:
needed.add(dep); changed = True
return {n for n in installed if n not in needed}
# =============================================================================
# MAIN
# =============================================================================
def cmd_sbom(argv):
"""pag sbom export [spdx|cyclonedx] – manifest SBOM zainstalowanych pakietów.
Wypisuje na stdout JSON (SPDX 2.3 lub CycloneDX 1.5) z listą
zainstalowanych pakietów, wersji, licencji i sum SHA256.
"""
fmt = (argv[0] if argv else "spdx").lower()
if fmt not in ("spdx", "cyclonedx"):
print(_('❌ Format: spdx | cyclonedx'))
return 1
installed = load_json(INSTALLED_DB)
if not installed:
print("{}") if fmt == "cyclonedx" else print("{\"packages\": []}")
return 0
# metadata repo (licencje) – best-effort
try:
repo = fetch_all_packages()
except Exception:
repo = {}
names = sorted(installed)
created = datetime.now().astimezone().isoformat(timespec="seconds")
def _license_of(name):
p = repo.get(name)
lic = getattr(p, "license", None) or []
if isinstance(lic, list):
lic = ", ".join(x for x in lic if x)
return lic or "NOASSERTION"
if fmt == "spdx":
doc = {
"spdxVersion": "SPDX-2.3",
"dataLicense": "CC0-1.0",
"SPDXID": "SPDXRef-DOCUMENT",
"name": "PaganOS-installed",
"documentNamespace": f"https://repo.paganlinux.eu/sbom/installed-{int(time.time())}",
"creationInfo": {
"created": created,
"creators": [f"Tool: pag-{PAG_VERSION}"],
},
"packages": [],
}
for i, n in enumerate(names):
info = installed[n]
doc["packages"].append({
"SPDXID": f"SPDXRef-Package-{i+1}",
"name": n,
"versionInfo": info.get("version", ""),
"downloadLocation": info.get("repo", "NOASSERTION"),
"filesAnalyzed": False,
"licenseConcluded": _license_of(n),
"checksums": [{"algorithm": "SHA256", "checksumValue": info.get("sha256", "")}],
})
else: # cyclonedx
doc = {
"bomFormat": "CycloneDX",
"specVersion": "1.5",
"serialNumber": f"urn:uuid:{str(uuid.uuid4())}",
"version": 1,
"metadata": {
"timestamp": created,
"tools": [{"vendor": "PaganOS", "name": "pag", "version": PAG_VERSION}],
},
"components": [],
}
for n in names:
info = installed[n]
lic = _license_of(n)
comp = {
"type": "library",
"name": n,
"version": info.get("version", ""),
"hashes": [{"alg": "SHA-256", "content": info.get("sha256", "")}],
}
if lic != "NOASSERTION":
comp["licenses"] = [{"license": {"id": lic}}]
doc["components"].append(comp)
print(json.dumps(doc, indent=2, ensure_ascii=False))
return 0
USAGE_EN = """pag v3 – Pagan Linux Package Manager
BASIC:
pag install <pkg>... Install packages
pag remove <pkg>... Remove packages
pag update Update PACKAGES + system flatpaks (refreshes indexes)
pag sync Refresh indexes + show pending updates (changes nothing)
pag upgrade Update SYSTEM (packages + flatpaks + kernel/initramfs/GRUB)
pag list [--installed] List available / installed
pag search <query> Search packages
pag info <pkg> Package details
pag files <pkg> List package files
pag verify [--deep] Verify integrity (--deep = SHA256 per file)
pag clean Clear download cache
pag stats System statistics
pag download <pkg>... Download packages to cache (offline prep)
ROLLING (base baked into the image):
pag base [status] Image packages vs. repo (what pag manages)
pag base adopt [pkg...] Adopt base packages from the repo (--dry-run = preview)
SECURITY:
pag key-add <url|file> Import GPG key
pag key-list List trusted keys
pag key-remove <id> Remove key
pag key-trust <repo> Pin repo signing key fingerprint (no TOFU)
pag key-untrust <repo> Forget repo fingerprint (back to TOFU)
pag key-trusted List pinned repo fingerprints
ADVANCED:
pag why <pkg> Show why a package is installed
pag rdepends <pkg> Show which packages depend on a package
pag autoremove Auto-remove orphaned dependencies
pag pin <pkg> [ver] Pin package version
pag unpin <pkg> Unpin
pag pinned List pinned
pag history Transaction history
pag rollback Rollback last transaction
pag repair [--dry-run] Reinstall packages with missing files
pag remove-orphans Remove orphaned deps
pag repo-add <url> [name] Add repository (drop-in /etc/pag/repos/)
pag repo-list List repositories
pag sbom export [fmt] SBOM manifest (spdx|cyclonedx)
FLATPAK:
pag flatpak [<query>] Search & install (smart)
pag flatpak search <q> Search Flathub
pag flatpak install <id> Install flatpak
pag flatpak remove <id> Remove flatpak
pag flatpak list List installed flatpaks
pag flatpak update Update all flatpaks
pag flatpak info <id> Show flatpak details
pag update|upgrade --no-flatpak Skip Flatpak updates
SNAPSHOTS (btrfs CoW):
pag snapshot-list List system snapshots
pag snapshot-create [label] Create a snapshot now
pag snapshot-rollback [id] Start from snapshot at next boot (GRUB)
pag snapshot-delete <id> Delete a snapshot
IMMUTABLE OS (PAG_IMMUTABLE=1):
pag deploy-list List all deployments
pag deploy-rollback Switch to previous deployment
pag deploy-cleanup [N] Remove old deployments (keep last N, default 3)
pag initramfs-update Rebuild initramfs for current kernel/deployment
pag grub-update Regenerate GRUB entries for all deployments
"""
USAGE_PL = """pag v3 – Pagan Linux Package Manager
PODSTAWOWE:
pag install <pkg>... Instalacja pakietów
pag remove <pkg>... Usuwanie pakietów
pag update Pakiety + flatpaki systemowe (odświeża indeksy)
pag sync Odśwież indeksy + info o aktualizacjach (nic nie zmienia)
pag upgrade System: pakiety + flatpaki + kernel/initramfs/GRUB
pag list [--installed] Lista dostępnych / zainstalowanych
pag search <query> Szukaj pakietów
pag info <pkg> Szczegóły pakietu
pag files <pkg> Lista plików pakietu
pag verify [--deep] Weryfikacja integralności
pag clean Wyczyść cache pobierania
pag stats Statystyki systemu
pag download <pkg>... Pobierz do cache (offline)
ROLLING (baza wypalona w obrazie):
pag base [status] Pakiety z obrazu vs repo (czym pag zarządza)
pag base adopt [pkg...] Adoptuj pakiety bazy z repo (--dry-run = podgląd)
BEZPIECZEŃSTWO:
pag key-add <url|file> Importuj klucz GPG
pag key-list Lista zaufanych kluczy
pag key-remove <id> Usuń klucz
pag key-trust <repo> Przypnij fingerprint klucza repo (bez TOFU)
pag key-untrust <repo> Zapomnij fingerprint repo (powrót do TOFU)
pag key-trusted Lista przypiętych fingerprintów repo
ZAAWANSOWANE:
pag why <pkg> Dlaczego pakiet jest zainstalowany
pag rdepends <pkg> Które pakiety zależą od pakietu
pag autoremove Usuń osierocone zależności
pag pin <pkg> [ver] Przypnij wersję pakietu
pag unpin <pkg> Odepnij
pag pinned Lista przypiętych
pag history Historia transakcji
pag rollback Cofnij ostatnią transakcję
pag repair [--dry-run] Napraw brakujące pliki pakietów (reinstalacja)
pag remove-orphans Usuń osierocone zależności
pag repo-add <url> [nazwa] Dodaj repozytorium (drop-in w /etc/pag/repos/)
pag repo-list Lista repozytoriów
pag sbom export [fmt] Manifest SBOM (spdx|cyclonedx)
FLATPAK:
pag flatpak [<query>] Szukaj i instaluj
pag flatpak search <q> Szukaj na Flathub
pag flatpak install <id> Zainstaluj flatpak
pag flatpak remove <id> Usuń flatpak
pag flatpak list Lista zainstalowanych
pag flatpak update Aktualizuj wszystkie
pag flatpak info <id> Szczegóły flatpaka
pag update|upgrade --no-flatpak Pomiń aktualizację Flatpaków
SNAPSHOTY (btrfs CoW):
pag snapshot-list Lista snapshotów systemu
pag snapshot-create [opis] Utwórz snapshot teraz
pag snapshot-rollback [id] Uruchom snapshot przy następnym starcie (GRUB)
pag snapshot-delete <id> Usuń snapshot
IMMUTABLE OS (PAG_IMMUTABLE=1):
pag deploy-list Lista wdrożeń
pag deploy-rollback Przełącz na poprzednie wdrożenie
pag deploy-cleanup [N] Usuń stare wdrożenia (zachowaj N, domyślnie 3)
pag initramfs-update Przebuduj initramfs
pag grub-update Regeneruj wpisy GRUB"""
def _get_usage():
# Plik językowy może dostarczyć klucz "usage" – wtedy wygrywa z wbudowanym.
_u = T.get(LANG, {}).get("usage")
if _u:
return _u
if LANG == "pl":
return USAGE_PL
return USAGE_EN
# =============================================================================
# EASTER EGG: PAG WROOM – wyścigi ASCII w stylu Commodore
# -----------------------------------------------------------------------------
def cmd_wroom():
"""Ukryta gra: `pag wroom`.
Animowany top-down wyścig w ASCII: trzy pasy, ruszający się tor, przeciwnicy,
punkty, ETA niepotrzebne – liczy się rekord. Sterowanie strzałkami (lub
WSAD), P pauza, Q wyjście. Gra działa tylko na terminalu; poza TTY wypisuje
krótką podpowiedź, a po wyjściu przywraca ekran i ustawienia terminala.
"""
if not (sys.stdin.isatty() and sys.stdout.isatty()):
print(_('wroom_terminal'))
return 1
if os.environ.get("TERM", "") == "dumb":
print(_('wroom_terminal'))
return 1
try:
import random
import select
import termios
import tty
except ImportError:
print(_('wroom_terminal'))
return 1
ANSI_RE = re.compile(r"\x1b\[[0-9;?]*[A-Za-z]")
def _vlen(text):
return len(ANSI_RE.sub("", text))
def _vcut(text, width):
"""Przytnij linię do `width` WIDOCZNYCH kolumn (nie licząc ANSI)."""
if _vlen(text) <= width:
return text
out, vis, i = [], 0, 0
while i < len(text) and vis < width:
m = ANSI_RE.match(text, i)
if m:
out.append(m.group(0))
i = m.end()
continue
out.append(text[i])
vis += 1
i += 1
return "".join(out)
def _center(text, width):
v = _vlen(text)
if v >= width:
return _vcut(text, width)
pad = width - v
return " " * (pad // 2) + text + " " * (pad - pad // 2)
# --- geometria toru i sprite'y (każdy znak = 1 kolumna) -------------------
SPR_ROOF = " ▄█▄ "
SPR_BODY = "▐███▌"
LANE_W = 8
N_LANES = 3
ROAD_W = LANE_W * N_LANES + 2
MIN_W, MIN_H = 56, 16
GLYPHS = {
"P": ("████ ", "█ █", "████ ", "█ ", "█ "),
"A": (" ███ ", "█ █", "█████", "█ █", "█ █"),
"G": (" ████", "█ ", "█ ██", "█ █", " ████"),
"W": ("█ █", "█ █", "█ █ █", "██ ██", "█ █"),
"R": ("████ ", "█ █", "████ ", "█ █ ", "█ █ "),
"O": (" ███ ", "█ █", "█ █", "█ █", " ███ "),
"M": ("█ █", "██ ██", "█ █ █", "█ █", "█ █"),
}
def _logo():
rows = []
for r in range(5):
line = ""
for ch in "PAG WROOM":
if ch == " ":
line += " "
else:
line += GLYPHS[ch][r] + " "
rows.append(line.rstrip())
return rows
LOGO = _logo()
state = {
"phase": "title", "best": 0, "paused": False,
"lane": 1, "x": 1.0, "speed": 90.0, "boost": 0.0,
"distance": 0.0, "lives": 3, "opponents": [],
"spawn": 0.8, "invuln": 1.0, "flash": 0.0,
"scroll": 0.0, "time": 0.0, "road_h": 12,
}
def _new_game():
state.update(phase="play", paused=False, lane=1, x=1.0,
speed=90.0, boost=0.0, distance=0.0, lives=3,
opponents=[], spawn=0.8, invuln=1.0, flash=0.0,
scroll=0.0, time=0.0)
# --- wejście (bez blokowania) --------------------------------------------
ARROWS = {"\x1b[D": "LEFT", "\x1b[C": "RIGHT",
"\x1b[A": "UP", "\x1b[B": "DOWN",
"\x1bOD": "LEFT", "\x1bOC": "RIGHT",
"\x1bOA": "UP", "\x1bOB": "DOWN"}
fd = sys.stdin.fileno()
pending = ""
def _keys():
nonlocal pending
keys = []
try:
ready, _, _ = select.select([fd], [], [], 0)
if not ready:
return keys
data = pending + os.read(fd, 64).decode("utf-8", "ignore")
pending = ""
except (OSError, UnicodeDecodeError):
return keys
i = 0
while i < len(data):
if data[i] == "\x1b":
# Niekompletna sekwencja strzałki – dokończymy w następnej
# klatce. Sam ESC (bez reszty) nie wychodzi z gry: wyjściem
# jest Q, więc przypadkowy Alt/strzałka nie zabija wyścigu.
if i + 1 >= len(data):
pending = data[i:]
break
if data[i + 1] not in "[O":
i += 1
continue
if i + 2 >= len(data):
pending = data[i:]
break
seq = data[i:i + 3]
key = ARROWS.get(seq)
if key:
keys.append(key)
i += 3
continue
ch = data[i]
i += 1
if ch in "qQ":
keys.append("QUIT")
elif ch in "aA":
keys.append("LEFT")
elif ch in "dD":
keys.append("RIGHT")
elif ch in "wW":
keys.append("UP")
elif ch in "sS":
keys.append("DOWN")
elif ch in "pP":
keys.append("PAUSE")
elif ch in " \r\n rR":
keys.append("START")
return keys
# --- rysowanie toru -------------------------------------------------------
def _paint(row, start, text, color):
cells, cols = row
for i, ch in enumerate(text):
pos = start + i
if 0 <= pos < len(cells) and ch != " ":
cells[pos] = ch
cols[pos] = color
def _render_cells(row):
cells, cols = row
parts, i = [], 0
while i < len(cells):
j = i
while j + 1 < len(cells) and cols[j + 1] == cols[i]:
j += 1
seg = "".join(cells[i:j + 1])
parts.append(_c(cols[i], seg) if cols[i] else seg)
i = j + 1
return "".join(parts)
def _road_row(r, phase):
cells = [" "] * ROAD_W
cols = [None] * ROAD_W
cells[0] = "║"
cols[0] = "yellow"
cells[-1] = "║"
cols[-1] = "yellow"
for sep in (LANE_W, LANE_W * 2):
if (r + phase) % 4 < 2:
cells[1 + sep] = "│"
cols[1 + sep] = "dim"
return cells, cols
def _lane_start(pos, width):
return int(round(1 + pos * LANE_W + (LANE_W - width) / 2))
def _play_lines(W, H):
road_h = max(6, H - 4)
rows = [_center(_c("cyan", "PAG WROOM"), W)]
hud = _('wroom_hud', arg1=(int(state["distance"])),
arg2=(int(state["speed"])), arg3=(state["lives"]))
rows.append(_center(hud, W))
board = [_road_row(r, int(state["scroll"])) for r in range(road_h)]
for o in state["opponents"]:
base = int(round(o["y"]))
for dy, spr in ((0, SPR_ROOF), (1, SPR_BODY)):
rr = base + dy
if 0 <= rr < road_h:
_paint(board[rr], _lane_start(o["lane"], len(spr)),
spr, o["color"])
if not (state["invuln"] > 0 and int(state["time"] * 10) % 2):
for dy, spr in ((0, SPR_ROOF), (1, SPR_BODY)):
rr = road_h - 2 + dy
_paint(board[rr], _lane_start(state["x"], len(spr)),
spr, "cyan")
if state["flash"] > 0:
_paint(board[road_h - 2], ROAD_W // 2 - 2, "BUM!", "red")
left = max(0, (W - ROAD_W) // 2)
right = max(0, W - ROAD_W - left)
for r in range(road_h):
rows.append(" " * left + _render_cells(board[r]) + " " * right)
rows.append("")
rows.append(_center(_c("dim", _('wroom_controls')), W))
if state["paused"]:
rows[H // 2] = _center(_c("yellow", _('wroom_paused')), W)
return rows[:H]
def _menu_lines(W, H, blink):
block = []
if W >= len(LOGO[0]) + 2:
block.extend(_c("cyan", ln) for ln in LOGO)
else:
block.append(_c("cyan", "P A G W R O O M"))
block.append("")
block.append(_c("dim", _('wroom_tagline')))
if H >= 18:
block.append("")
block.append(" " + _c("cyan", "▄███▄") + " " +
_c("red", "▄███▄") + " " +
_c("yellow", "▄███▄"))
if H >= 22:
block.extend(["", _c("dim", 'LOAD "WROOM",8,1'),
_c("dim", "READY."), _c("dim", "RUN")])
block.append("")
if state["phase"] == "over":
block.append(_c("red", _('wroom_over')))
block.append("")
block.append(_('wroom_score', arg1=(int(state["distance"]))))
block.append(_('wroom_best', arg1=(state["best"])))
block.append("")
block.append(_('wroom_restart'))
else:
block.append(_('wroom_controls'))
block.append("")
block.append(_c("yellow", _('wroom_press')) if blink else "")
top = max(0, (H - len(block)) // 2)
rows = [""] * H
for i, line in enumerate(block):
if top + i < H:
rows[top + i] = _center(line, W)
return rows
# --- fizyka i kolizje -----------------------------------------------------
def _spawn():
free = [lane for lane in range(N_LANES)
if not any(o["lane"] == lane and o["y"] < 4
for o in state["opponents"])]
if not free:
return
state["opponents"].append({
"lane": random.choice(free),
"y": -2.0,
"speed": state["speed"] * random.uniform(0.45, 0.78),
"color": random.choice(("red", "yellow", "green")),
})
def _update(dt):
state["time"] += dt
if state["phase"] != "play" or state["paused"]:
return
state["boost"] *= max(0.0, 1.0 - dt * 3.0)
base = 90.0 + min(120.0, state["distance"] * 0.02)
target = max(45.0, base + state["boost"])
state["speed"] += (target - state["speed"]) * min(1.0, dt * 2.0)
state["distance"] += state["speed"] * dt * 0.45
state["scroll"] += state["speed"] * dt * 0.09
state["x"] += (state["lane"] - state["x"]) * min(1.0, dt * 9.0)
if state["invuln"] > 0:
state["invuln"] = max(0.0, state["invuln"] - dt)
if state["flash"] > 0:
state["flash"] = max(0.0, state["flash"] - dt)
state["spawn"] -= dt
if state["spawn"] <= 0:
_spawn()
state["spawn"] = max(0.45, 1.35 - state["speed"] / 320.0)
for o in list(state["opponents"]):
o["y"] += (state["speed"] - o["speed"]) * dt * 0.06
if o["y"] > state["road_h"] + 2 or o["y"] < -4:
state["opponents"].remove(o)
if state["invuln"] > 0:
return
player_cy = state["road_h"] - 1.0
for o in list(state["opponents"]):
if (abs((o["y"] + 1.0) - player_cy) < 1.25
and abs(o["lane"] - state["x"]) < 0.55):
state["lives"] -= 1
state["flash"] = 0.6
state["invuln"] = 1.8
state["speed"] = max(45.0, state["speed"] * 0.5)
state["boost"] = 0.0
state["opponents"].remove(o)
state["opponents"] = [x for x in state["opponents"]
if x["y"] < state["road_h"] - 5]
try:
out.write("\a")
out.flush()
except OSError:
pass
if state["lives"] <= 0:
state["phase"] = "over"
state["best"] = max(state["best"],
int(state["distance"]))
break
# --- pętla gry ------------------------------------------------------------
old_attrs = termios.tcgetattr(fd)
out = sys.stdout
try:
tty.setcbreak(fd)
out.write("\x1b[?1049h\x1b[?25l\x1b[2J")
out.flush()
running = True
last = time.monotonic()
last_size = None
while running:
for key in _keys():
if key == "QUIT":
running = False
break
if state["phase"] in ("title", "over"):
if key == "START":
_new_game()
elif key == "PAUSE":
state["paused"] = not state["paused"]
elif state["paused"]:
continue
elif key == "LEFT":
state["lane"] = max(0, state["lane"] - 1)
elif key == "RIGHT":
state["lane"] = min(N_LANES - 1, state["lane"] + 1)
elif key == "UP":
state["boost"] = min(55.0, state["boost"] + 14.0)
elif key == "DOWN":
state["boost"] = max(-45.0, state["boost"] - 14.0)
if not running:
break
size = shutil.get_terminal_size((80, 24))
W, H = size.columns, size.lines
if last_size != (W, H):
last_size = (W, H)
out.write("\x1b[2J")
state["road_h"] = max(6, H - 4)
now = time.monotonic()
dt = min(0.1, max(0.0, now - last))
last = now
if W >= MIN_W and H >= MIN_H:
_update(dt)
if W < MIN_W or H < MIN_H:
lines = [""] * H
msg = _('wroom_too_small', arg1=(MIN_W), arg2=(MIN_H))
lines[H // 2] = _center(_c("yellow", msg), W)
elif state["phase"] == "play":
lines = _play_lines(W, H)
else:
blink = int(time.monotonic() * 2) % 2 == 0
lines = _menu_lines(W, H, blink)
buf = ["\x1b[H"]
for i, line in enumerate(lines):
buf.append(_vcut(line, W))
buf.append("\x1b[K")
if i != len(lines) - 1:
buf.append("\n")
out.write("".join(buf))
out.flush()
spent = time.monotonic() - now
if spent < 1.0 / 20.0:
time.sleep(1.0 / 20.0 - spent)
finally:
try:
out.write("\x1b[0m\x1b[?25h\x1b[?1049l")
out.flush()
except OSError:
pass
termios.tcsetattr(fd, termios.TCSADRAIN, old_attrs)
return 0
def _extract_lang(outdir: str) -> int:
"""Eksport wbudowanych tłumaczeń do outdir/{pl,en}.json (+ klucz "usage").
Używane przez recepturę pakietu (pag.pag), żeby tłumaczenia jechały RAZEM
z wersją paga – po `pag install/upgrade pag` i self-update są zawsze zgodne.
"""
os.makedirs(outdir, exist_ok=True)
for _code in ("pl", "en"):
_d = dict(T.get(_code, {}))
_u = globals().get(f"USAGE_{_code.upper()}", "")
if _u:
_d["usage"] = _u
_p = os.path.join(outdir, f"{_code}.json")
with open(_p, "w", encoding="utf-8") as _fh:
json.dump(_d, _fh, ensure_ascii=False, indent=2, sort_keys=True)
print(_(' ✓ {arg1} ({arg2} keys)', arg1=(_p), arg2=(len(_d))))
return 0
def main():
# Ukryte (używane przy budowie pakietu): eksport tłumaczeń do plików
if len(sys.argv) >= 3 and sys.argv[1] == "--lang-extract":
sys.exit(_extract_lang(sys.argv[2]))
if len(sys.argv) >= 2 and sys.argv[1] in ("--version", "-V", "version"):
print(f"pag {PAG_VERSION}")
sys.exit(0)
if len(sys.argv) == 2 and sys.argv[1] in ("--help", "-h", "help"):
print(_get_usage()); sys.exit(0)
if len(sys.argv) < 2:
print(_get_usage()); sys.exit(0)
cmd = sys.argv[1]
args = sys.argv[2:]
# Python bez modułu ssl = brak HTTPS w urllib. Powiedz to wprost, zamiast
# pokazywać mylące „unknown url type: https” przy każdej operacji sieciowej.
if not _ssl_ok():
print(f" ⚠ {_('ssl_broken')}", file=sys.stderr)
# `pag repair --dry-run`: diagnostyka bez roota (nic nie zmienia).
if cmd == "repair" and "--dry-run" in args and os.geteuid() != 0:
sys.exit(cmd_repair(dry_run=True) or 0)
# --- Komendy TYLKO DO ODCZYTU (nie wymagają roota) ---
READ_ONLY = {
"list": lambda: cmd_list("--installed" in args),
"search": lambda: cmd_search(args[0]) if args else print(_('Usage: pag search <query>')),
"info": lambda: cmd_info(args[0]) if args else print(_('Usage: pag info <pkg>')),
"files": lambda: cmd_files(args[0]) if args else print(_('Usage: pag files <pkg>')),
"verify": lambda: cmd_verify("--deep" in args),
"why": lambda: cmd_why(args[0]) if args else print(_('Usage: pag why <pkg>')),
"rdepends": lambda: cmd_rdepends(args[0]) if args else print(_('Usage: pag rdepends <pkg>')),
"stats": cmd_stats,
"pinned": cmd_pinned,
"history": cmd_history,
"repo-list": cmd_repo_list,
"key-list": cmd_key_list,
"key-trusted": cmd_key_trusted,
"flatpak": lambda: cmd_flatpak(args),
"flatpak-search": lambda: cmd_flatpak_search(args[0]) if args else print(_('Usage: pag flatpak-search <query>')),
"flatpak-list": cmd_flatpak_list,
"flatpak-info": lambda: cmd_flatpak_info(args[0]) if args else print(_('Usage: pag flatpak-info <id>')),
"deploy-list": cmd_deploy_list,
"deploy": cmd_deploy_list,
"snapshot-list": cmd_snapshot_list,
"snapshots": cmd_snapshot_list,
"snapshot-grub": cmd_snapshot_grub,
"sbom": lambda: cmd_sbom(args),
"wroom": cmd_wroom, # easter egg – działa bez roota
}
if cmd in READ_ONLY:
sys.exit(READ_ONLY[cmd]() or 0)
# --- `pag base` / `pag base status`: tylko odczyt (bez roota i bez locka) ---
# `pag base adopt` NIE wpada tutaj – idzie ścieżką komend zapisu (roota + lock
# pilnuje wspólna obsługa niżej), żeby transakcja była bezpieczna.
if cmd in ("base", "base-status") and not (args and args[0] in ("adopt", "register")):
sys.exit(cmd_base_status() or 0)
# --- Smart search: `pag <nazwa-pakietu>` → repo + Flathub + sugestie ---
WRITE_CMDS = {
"install", "remove", "update", "sync", "upgrade", "clean", "download",
"autoremove", "remove-orphans", "pin", "unpin", "rollback",
"repo-add", "key-add", "key-remove", "key-trust", "key-untrust",
"self-update",
"flatpak", "flatpak-install", "flatpak-remove", "flatpak-update",
"deploy-rollback", "deploy-cleanup", "initramfs-update", "grub-update",
"snapshot-create", "snapshot-delete", "snapshot-rollback",
"base", "base-adopt", "base-register",
"repair",
}
if cmd not in WRITE_CMDS:
# Literówka komendy? (np. `pag instal steam` zamiast `pag install`) –
# zasugeruj poprawną komendę ZAMIAST wpadać w smart search (który
# potrafi wisieć na `flatpak search` aż do Ctrl-C).
_known = set(READ_ONLY) | set(WRITE_CMDS)
_known.discard("wroom") # easter egg – nie podpowiadaj go w literówkach
_close = difflib.get_close_matches(cmd, _known, n=1, cutoff=0.75)
if _close:
print(_("❌ Unknown command: '{arg1}'. Did you mean '{arg2}'?", arg1=(cmd), arg2=(_close[0])))
print(_(" Run 'pag' without arguments to see the command list."))
sys.exit(1)
sys.exit(_smart_search(" ".join([cmd] + args)) or 0)
# Obsługa flag globalnych (-y/--yes oraz transakcji/snapshotów)
global_args = []
for a in args:
if a in ("-y", "--yes"):
os.environ["PAG_YES"] = "1"
elif a == "--dry-run":
os.environ["PAG_DRY_RUN"] = "1"
global_args.append(a) # `repair`/`base adopt` czytają flagę
elif a == "--snapshot":
os.environ["PAG_SNAPSHOT"] = "always"
elif a == "--no-snapshot":
os.environ["PAG_SNAPSHOT"] = "never"
elif a == "--atomic":
os.environ["PAG_ATOMIC"] = "1"
elif a == "--no-atomic":
os.environ["PAG_ATOMIC"] = "0"
elif a == "--no-flatpak":
os.environ["PAG_FLATPAK"] = "0"
elif a == "--flatpak":
os.environ["PAG_FLATPAK"] = "1"
else:
global_args.append(a)
args = global_args
# --- Komendy ZAPISU (wymagają roota) ---
if os.geteuid() != 0:
print(f"❌ {_('root_required')}", file=sys.stderr); sys.exit(1)
ensure_dirs()
with DatabaseLock():
# Auto-naprawa: backup z przerwanej transakcji (bez wpisu „success")
# -> przywróć brakujące pliki, zanim cokolwiek innego zrobimy.
_recover_interrupted_transactions()
WRITE_COMMANDS = {
"install": lambda: cmd_install(
[a for a in args if a not in (
"-f", "--force", "--dry-run", "--snapshot", "--no-snapshot",
"--atomic", "--no-atomic", "--")],
upgrade=("-f" in args or "--force" in args)),
"remove": lambda: cmd_remove(args),
"update": lambda: cmd_update(do_upgrade=True),
"sync": lambda: cmd_update(do_upgrade=False),
"upgrade": cmd_upgrade,
"clean": cmd_clean,
"download": lambda: cmd_download(args),
"autoremove": cmd_autoremove,
"remove-orphans": cmd_remove_orphans,
"pin": lambda: cmd_pin(args[0], args[1] if len(args)>1 else ""),
"unpin": lambda: cmd_unpin(args[0]) if args else print(_('Usage: pag unpin <pkg>')),
"rollback": cmd_rollback,
"repair": lambda: cmd_repair(dry_run="--dry-run" in args),
"repo-add": lambda: cmd_repo_add(args[0], args[1] if len(args) > 1 else "") if args else print(_('Usage: pag repo-add <url> [name]')),
"key-add": lambda: cmd_key_add(args[0]) if args else print(_('Usage: pag key-add <url|file>')),
"key-remove": lambda: cmd_key_remove(args[0]) if args else print(_('Usage: pag key-remove <id>')),
"key-trust": lambda: cmd_key_trust(args[0]) if args else print(_('Usage: pag key-trust <repo_url>')),
"key-untrust": lambda: cmd_key_untrust(args[0]) if args else print(_('Usage: pag key-untrust <repo_url>')),
"self-update": cmd_self_update,
"flatpak": lambda: cmd_flatpak(args),
"flatpak-install": lambda: _flatpak_smart_install(args) if args else print(_('Usage: pag flatpak-install <app>')),
"flatpak-remove": lambda: _flatpak_smart_remove(args) if args else print(_('Usage: pag flatpak-remove <app>')),
"flatpak-update": cmd_flatpak_update,
"deploy-rollback": cmd_deploy_rollback,
"deploy-cleanup": lambda: cmd_deploy_cleanup(int(args[0]) if args else 3),
"snapshot-create": lambda: cmd_snapshot_create(" ".join(
a for a in args if not a.startswith("-"))),
"snapshot-delete": lambda: cmd_snapshot_delete(args[0]) if args else print(
_('Usage: pag snapshot-delete <id>')),
"snapshot-rollback": lambda: cmd_snapshot_rollback(
args[0] if args else ""),
"initramfs-update": cmd_initramfs_update,
"grub-update": cmd_grub_update,
"base": lambda: cmd_base_register(args) if (args and args[0] == "register") else cmd_base_adopt(args),
"base-adopt": lambda: cmd_base_adopt(args),
"base-register": lambda: cmd_base_register(args),
}
fn = WRITE_COMMANDS.get(cmd)
if fn:
sys.exit(fn() or 0)
# Should never reach here – _smart_search handles unknowns
sys.exit(_smart_search(" ".join([cmd] + args)) or 0)
if __name__ == "__main__":
try:
main()
except KeyboardInterrupt:
# Ctrl-C (np. podczas flatpak search / pobierania) – bez tracebacka
print(_('\n ⚠ Interrupted (Ctrl-C).'))
sys.exit(130)