From 7e1792f61b10905baacc408c243a9909bf010901 Mon Sep 17 00:00:00 2001 From: Caio Barbieri Date: Fri, 2 Oct 2026 21:27:59 -0300 Subject: [PATCH 1/3] Add standalone Nix Home Manager rehearsal and isolated CI validation --- .github/workflows/nix-rehearsal.yml | 51 +++++++++++++ portable-linux/README.md | 2 +- portable-linux/flake.nix | 29 +++++++ portable-linux/nix/README.md | 113 ++++++++++++++++++++++++++-- portable-linux/nix/rehearsal.nix | 7 ++ portable-linux/nix/validate.py | 113 ++++++++++++++++++++++++++++ 6 files changed, 307 insertions(+), 8 deletions(-) create mode 100644 .github/workflows/nix-rehearsal.yml create mode 100644 portable-linux/flake.nix create mode 100644 portable-linux/nix/rehearsal.nix create mode 100644 portable-linux/nix/validate.py diff --git a/.github/workflows/nix-rehearsal.yml b/.github/workflows/nix-rehearsal.yml new file mode 100644 index 0000000..671ace6 --- /dev/null +++ b/.github/workflows/nix-rehearsal.yml @@ -0,0 +1,51 @@ +# Local proposal: publish/run only after explicit approval of Nix installation in CI. +name: Nix standalone build only +on: + push: + paths: ['portable-linux/flake.nix', 'portable-linux/nix/**', 'portable-linux/files/**', '.github/workflows/nix-rehearsal.yml'] + pull_request: + paths: ['portable-linux/flake.nix', 'portable-linux/nix/**', 'portable-linux/files/**', '.github/workflows/nix-rehearsal.yml'] + workflow_dispatch: +permissions: + contents: read +jobs: + standalone: + runs-on: ubuntu-24.04 + timeout-minutes: 35 + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + with: + persist-credentials: false + - name: Official pinned Nix distribution in disposable runner only + shell: bash + run: | + set -euo pipefail + runtime_home=$(mktemp -d /tmp/nix-ci-home-XXXXXX) + dist=$(mktemp -d /tmp/nix-ci-dist-XXXXXX) + release=https://releases.nixos.org/nix/nix-2.35.2 + archive=nix-2.35.2-x86_64-linux.tar.xz + curl --fail --location --proto '=https' --tlsv1.2 "$release/$archive" -o "$dist/$archive" + curl --fail --location --proto '=https' --tlsv1.2 "$release/$archive.sha256" -o "$dist/checksum" + checksum=$(tr -d '\r\n' < "$dist/checksum") + [[ "$checksum" =~ ^[0-9a-f]{64}$ ]] + (cd "$dist" && printf '%s %s\n' "$checksum" "$archive" | sha256sum --check -) + tar -xJf "$dist/$archive" -C "$dist" + HOME="$runtime_home" "$dist/nix-2.35.2-x86_64-linux/install" --no-daemon --no-channel-add --no-modify-profile + printf '%s\n' "$runtime_home/.nix-profile/bin" >> "$GITHUB_PATH" + - name: Generate real lock, evaluate Linux targets, build x86_64 without activation + shell: bash + env: + PYTHONDONTWRITEBYTECODE: '1' + run: | + set -euo pipefail + python3 portable-linux/nix/validate.py --build > "$RUNNER_TEMP/nix-result.json" + stage=$(python3 -c 'import json,sys; print(json.load(open(sys.argv[1]))["stage"])' "$RUNNER_TEMP/nix-result.json") + mkdir "$RUNNER_TEMP/nix-evidence" + cp "$stage/source/flake.lock" "$stage/sources.json" "$stage/validation.json" "$RUNNER_TEMP/nix-evidence/" + - name: Preserve generated lock and successful build evidence for review + uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2 + with: + name: nix-lock-and-validation + path: ${{ runner.temp }}/nix-evidence/ + if-no-files-found: error + retention-days: 7 diff --git a/portable-linux/README.md b/portable-linux/README.md index 1946d60..38b41e2 100644 --- a/portable-linux/README.md +++ b/portable-linux/README.md @@ -42,7 +42,7 @@ Projetos/WIP precisam de plano independente: selecionar apenas código pessoal a ## Nix opcional -O módulo em `nix/home.nix` declara sete CLIs e os três dotfiles comuns. Não é configuração standalone completa ou ativada: requer home.username, home.homeDirectory, home.stateVersion e inputs compatíveis definidos na configuração aprovada do host. Sem flake.lock inventado. Nix estava ausente durante a preparação: checagem lexical/referências passou, mas parser/eval/build não foi executado. Ver `nix/README.md`. +O módulo em `nix/home.nix` declara sete CLIs e os três dotfiles comuns. `flake.nix` e `nix/rehearsal.nix` acrescentam entrada standalone com inputs oficiais fixados e identidade sintética Linux, sem ativação. `nix/validate.py` exporta somente seis fontes para ensaio e pode gerar lock/eval/build em ambiente Nix autorizado. Nix está ausente localmente; não há flake.lock nem parser/eval/build executado. O novo workflow Nix é proposta local, exige aprovação de publicação/instalação no runner. Ver [nix/README.md](nix/README.md). Nix pode precisar admin para /nix, inclusive single-user; não contornar TI. Se Nix não for autorizado, manter os arquivos comuns e ferramentas instaladas pelo mecanismo aprovado. Drivers/GPU/audio, VPN, login, agentes de segurança e GUI ficam fora da primeira camada. diff --git a/portable-linux/flake.nix b/portable-linux/flake.nix new file mode 100644 index 0000000..3195f4e --- /dev/null +++ b/portable-linux/flake.nix @@ -0,0 +1,29 @@ +{ + description = "Personal Linux Home Manager rehearsal; build only, never activate"; + + inputs = { + # Official release branches inspected on 2026-10-03. A real Nix-generated + # flake.lock is still required; these revision pins are not a substitute. + nixpkgs.url = "github:NixOS/nixpkgs/774debe7a0d1b496e35677ad955a1011c6ff74f3"; + home-manager.url = "github:nix-community/home-manager/e5fcd298a00f08b6e8390baf04aa8edb62203070"; + home-manager.inputs.nixpkgs.follows = "nixpkgs"; + }; + + outputs = { nixpkgs, home-manager, ... }: + let + systems = [ "x86_64-linux" "aarch64-linux" ]; + mkHome = system: home-manager.lib.homeManagerConfiguration { + pkgs = import nixpkgs { inherit system; config.allowUnfree = false; }; + modules = [ ./nix/home.nix ./nix/rehearsal.nix ]; + }; + in { + homeConfigurations = builtins.listToAttrs (map (system: { + name = "rehearsal-${system}"; + value = mkHome system; + }) systems); + packages = builtins.listToAttrs (map (system: { + name = system; + value = { default = (mkHome system).activationPackage; }; + }) systems); + }; +} diff --git a/portable-linux/nix/README.md b/portable-linux/nix/README.md index b7d0a92..8f0ac29 100644 --- a/portable-linux/nix/README.md +++ b/portable-linux/nix/README.md @@ -1,13 +1,112 @@ -# Nix opcional — módulo rascunho +# Nix/Home Manager standalone — ensaio sem ativação -`home.nix` é um módulo Home Manager mínimo implementado em fonte, não uma instalação standalone completa nem uma configuração ativável já validada. Reutiliza exatamente os três arquivos comuns e declara sete CLIs. Não instala Nix, altera login shell, habilita serviços, ativa contas ou copia configuração corporativa. +Configuração standalone Linux preparada em fonte, ainda **sem parse/eval/build Nix**. +O módulo `home.nix` existente era válido como módulo mínimo, mas faltavam inputs, +identidade de ensaio e ponto de entrada. Ele foi preservado; `../flake.nix` fornece +Nixpkgs/Home Manager e `rehearsal.nix` fornece somente uma identidade sintética. +Nenhuma configuração do notebook ou identidade corporativa foi importada. -Alvo provisório: Linux genérico. A configuração standalone do host, criada somente depois de aprovação de TI, deve importar este módulo e definir `home.username`, `home.homeDirectory` e `home.stateVersion` com dados/versão confirmados. Não inferir nome de conta ou diretório a partir do notebook de origem; não atualizar stateVersion automaticamente. Selecionar release compatível de Nixpkgs/Home Manager e guardar a seleção revisada. Não há flake.lock gerado: sem Nix/rede nesta fase, não inventamos um lock ou pin alegadamente validado. +## Inputs e alvo -Verificação atual: checagem local de delimitadores, referências existentes, allowlist de pacotes/arquivos e ausência de imports externos/secrets. Isso **não substitui** parser/eval/build Nix. Nix não está instalado neste equipamento; parse e avaliação completos são pendências explícitas. Depois de TI aprovar ambiente de ensaio apropriado, usar parser/eval e build, inspecionar outputs e diff da ativação antes de qualquer switch. Não executar switch nesta preparação. +Releases compatíveis: Nixpkgs `nixos-26.05` e Home Manager `release-26.05`, conforme +[orientação oficial standalone](https://raw.githubusercontent.com/nix-community/home-manager/release-26.05/docs/manual/installation/standalone.md). +Refs consultadas em 2026-10-03 e fixadas por revisões reais: -Nix pode precisar admin para `/nix`, mesmo single-user; não contornar a política de TI. Cache/downloads dependem de rede/proxy permitido; não adicionar caches ou desligar TLS. Nix store é legível por outros usuários: nenhum segredo literal, nem mesmo de repo privado. Dados mutáveis e WIP precisam de backup separado. Rollback depende de gerações preservadas; garbage collection pode remover esse caminho. +- Nixpkgs: `774debe7a0d1b496e35677ad955a1011c6ff74f3`. +- Home Manager: `e5fcd298a00f08b6e8390baf04aa8edb62203070`; nixpkgs segue o mesmo input. -Fallback permanece `restore.py` e instalação das ferramentas pelo método aprovado. Preferências Code opcionais não entram neste módulo nem no restore inicial; revisar/mesclar separadamente com configuração existente se Code estiver aprovado. +Os pins de revisão são seleção de fonte, não lock nem evidência de avaliação. +`flake.lock` ainda não existe: somente `nix flake lock` autorizado poderá gerar seus +narHashes e metadados reais. Não inventar hash, timestamp ou lock à mão. +Alvos: avaliação `x86_64-linux` e `aarch64-linux`; build somente x86_64 no CI proposto. +O fixture novo usa username `personal-rehearsal`, HOME `/tmp/personal-home-manager-rehearsal` +e stateVersion `26.05`; não identifica pessoa/host e jamais deve ser ativado. +Num host futuro, stateVersion é a versão inicial escolhida conscientemente, não +campo para acompanhar upgrades automaticamente. -Fontes oficiais: [instalação Home Manager](https://nix-community.github.io/home-manager/installation.html), [configuração](https://nix-community.github.io/home-manager/usage/configuration.html), [instalação Nix](https://nix.dev/manual/nix/stable/installation/installing-binary.html), [arquivos locais e store](https://nix.dev/tutorials/working-with-local-files.html), [garbage collection](https://nix.dev/manual/nix/stable/package-management/garbage-collection.html). +## Exportação mínima e comandos reais + +A partir de `portable-linux/`, o comando local de exportação não precisa Nix: + +```sh +PYTHONDONTWRITEBYTECODE=1 python3 nix/validate.py +``` + +Ele preserva scratch e copia somente seis fontes públicas fixas: flake, módulo, +fixture e os três dotfiles. Não exporta o repo inteiro, configs locais, journals, +skills, inventários ou WIP. Nenhum arquivo de HOME é lido. Conferir o diff dessas +seis fontes antes do ensaio; a allowlist sozinha não torna uma fonte modificada segura. +O caminho `source` retornado é o único que deve entrar no Nix store. + +Em ambiente descartável **já autorizado com Nix instalado**, após revisão: + +```sh +PYTHONDONTWRITEBYTECODE=1 python3 nix/validate.py --build +``` + +O comando usa HOME temporário, não herda tokens/credenciais, não aceita nixConfig +de flakes, gera lock real, confere revisões, avalia os dois alvos, constrói a geração +x86_64 e compara os três arquivos gerados byte a byte. Nunca executa `activate`, +`home-manager switch`, `nix profile install`, serviços ou garbage collection. +Usa o cache oficial padrão; não adiciona cache/credencial nem desativa TLS/sandbox. +Exit 0 com `validation.json` só ocorre após todas essas verificações; falta de Nix +retorna 2 antes de exportar. Outras falhas retornam não zero e preservam o scratch. + +Equivalentes manuais, depois de entrar no diretório `source` exportado: + +```sh +nix --extra-experimental-features 'nix-command flakes' flake lock +nix --extra-experimental-features 'nix-command flakes' eval --no-update-lock-file --raw '.#homeConfigurations.rehearsal-x86_64-linux.activationPackage.drvPath' +nix --extra-experimental-features 'nix-command flakes' eval --no-update-lock-file --raw '.#homeConfigurations.rehearsal-aarch64-linux.activationPackage.drvPath' +nix --extra-experimental-features 'nix-command flakes' build --no-update-lock-file --no-link --print-out-paths '.#packages.x86_64-linux.default' +``` + +Esses comandos escrevem store/downloads no ambiente isolado; não são comandos para +executar no notebook de origem. Um build não ativa configuração e não testa rollback +Home Manager real. Rollback do bootstrap foi testado separadamente; gerações Home +Manager dependem de retenção e podem sumir após GC. Nunca misturar HM e bootstrap +sobre os mesmos destinos (o bootstrap recusa symlinks). + +## Plano de CI — depende de aprovação específica + +Workflow proposto: `.github/workflows/nix-rehearsal.yml`, Ubuntu 24.04 descartável. +Publicar esse workflow em branch nova dispara push/PR e instala software no runner; +é uma nova execução externa, exige aprovação específica antes de publicar. +Não houve publicação ou execução nesta fase. + +1. Checkout oficial pinado, contents:read, credenciais não persistidas. +2. Baixar distribuição oficial Nix **2.35.2** e checksum via HTTPS; verificar checksum. +3. Executar instalador oficial single-user só no runner, sem daemon/canais/alterar + profile shell. O instalador pode usar sudo para `/nix` **do runner**, nunca do host. +4. Executar `validate.py --build`; nenhuma ativação, nenhum volume/home do notebook. +5. Preservar só lock gerado e relatórios de hashes/build em artifact por sete dias. + Não fazer commit automático, upload de HOME, pacote result ou logs privados. + +Download/checksum do mesmo distribuidor verifica integridade, não é assinatura +independente. A disponibilidade do tarball/checksum e as opções do instalador serão +conferidas na execução; qualquer falha deve parar, sem trocar fonte/desligar checks. +Nix 2.35.2 foi confirmado na [página oficial](https://nixos.org/download/) e +[tag oficial](https://github.com/NixOS/nix/tree/2.35.2). +[Upload artifact v4.6.2](https://github.com/actions/upload-artifact/tree/ea165f8d65b6e75b540449e92b4886f43607fa02) +está pinado por SHA verificado. Sem caches adicionais, self-hosted runner ou secrets. +Após sucesso real, revisar artifact, lock/input graph e outputs antes de incorporar +lock ao repo; a aprovação de CI não autoriza merge ou ativação de host. + +## Limites atuais e recuperação futura + +Nix ausente localmente; Docker socket e namespaces já bloqueados. Não contornar +permissões/kernel, instalar runtime no notebook ou dizer que a checagem de fontes +é parse/build. O incremento local é preparado, não validado pelo Nix ainda. +Perfis dev/machine/AI e identidade por pasta do bootstrap não foram reimplementados +nesta camada: Home Manager contém somente base e sete CLIs. Não copiar includeIf, +providers/MCP, tokens ou identidade real para obter paridade automática. + +Para notebook futuro: confirmar SO/arquitetura/TI, definir módulo de host com +username/HOME/stateVersion explícitos, revisar destinos e backup antes de ativar. +Secrets nunca entram em Git/flake/store, mesmo com repo privado. Reauth é manual. +Nix opcional não substitui o sistema; fallback `setup.py` continua disponível. +Backup/arquivamento dos 13 arquivos excluídos permanece suspenso e independente. + +Fontes oficiais: [instalador Nix](https://nix.dev/manual/nix/stable/installation/installing-binary.html), +[geração de lock](https://nix.dev/manual/nix/2.34/command-ref/new-cli/nix3-flake-lock.html), +[store e arquivos locais](https://nix.dev/tutorials/working-with-local-files.html). diff --git a/portable-linux/nix/rehearsal.nix b/portable-linux/nix/rehearsal.nix new file mode 100644 index 0000000..3ec5412 --- /dev/null +++ b/portable-linux/nix/rehearsal.nix @@ -0,0 +1,7 @@ +# Synthetic standalone identity. Never activate this fixture or infer a host user. +{ ... }: +{ + home.username = "personal-rehearsal"; + home.homeDirectory = "/tmp/personal-home-manager-rehearsal"; + home.stateVersion = "26.05"; +} diff --git a/portable-linux/nix/validate.py b/portable-linux/nix/validate.py new file mode 100644 index 0000000..d908544 --- /dev/null +++ b/portable-linux/nix/validate.py @@ -0,0 +1,113 @@ +#!/usr/bin/env python3 +"""Export fixed public sources, then optionally lock/evaluate/build. No activation.""" +import argparse +import hashlib +import json +import os +from pathlib import Path +import shutil +import subprocess +import tempfile + +ROOT = Path(__file__).resolve().parents[1] +SOURCES = ("flake.nix", "nix/home.nix", "nix/rehearsal.nix", + "files/vimrc", "files/zshrc", "files/gitconfig") +REVISIONS = {"nixpkgs": "774debe7a0d1b496e35677ad955a1011c6ff74f3", + "home-manager": "e5fcd298a00f08b6e8390baf04aa8edb62203070"} + + +def stage(): + # No arbitrary path/config/identity arguments; no HOME/repo-wide source copy. + folder = Path(tempfile.mkdtemp(prefix="personal-nix-", dir="/tmp")) + source = folder / "source" + source.mkdir() + hashes = {} + for name in SOURCES: + p = ROOT / name + if any(x.is_symlink() for x in [p, *p.parents]) or not p.is_file(): + raise ValueError("Nonordinary or symlink source") + data = p.read_bytes() + q = source / name + q.parent.mkdir(parents=True, exist_ok=True) + q.write_bytes(data) + hashes[name] = hashlib.sha256(data).hexdigest() + (folder / "sources.json").write_text(json.dumps(hashes, indent=2) + "\n") + return folder, source + + +def run(nix, source, args, env): + return subprocess.check_output( + [nix, *args], cwd=source, env=env, text=True).strip() + + +def validate(folder, source): + nix = shutil.which("nix") + if nix is None: + raise ValueError("Nix unavailable; export is not parse/eval/build") + private_home = folder / "runtime-home" + private_home.mkdir() + env = {"PATH": os.environ.get("PATH", "/usr/bin:/bin"), + "HOME": str(private_home), "LANG": "C.UTF-8", + "NIX_USER_CONF_FILES": "/dev/null", + "NIX_CONFIG": "experimental-features = nix-command flakes\naccept-flake-config = false\n"} + version = run(nix, source, ["--version"], env) + run(nix, source, ["flake", "lock", "path:" + str(source)], env) + lock = json.loads((source / "flake.lock").read_text()) + inputs = lock["nodes"][lock["root"]]["inputs"] + for name, revision in REVISIONS.items(): + node = lock["nodes"][inputs[name]]["locked"] + if node["rev"] != revision or "narHash" not in node: + raise ValueError("Unexpected generated input lock") + if lock["nodes"][inputs["home-manager"]]["inputs"]["nixpkgs"] != ["nixpkgs"]: + raise ValueError("Home Manager must follow the selected Nixpkgs") + evaluations = {} + for system in ("x86_64-linux", "aarch64-linux"): + attr = ".#homeConfigurations.rehearsal-" + system + evaluations[system] = run(nix, source, + ["eval", "--no-update-lock-file", "--raw", attr + ".activationPackage.drvPath"], env) + for option, expected in (("username", "personal-rehearsal"), + ("homeDirectory", "/tmp/personal-home-manager-rehearsal"), + ("stateVersion", "26.05")): + actual = json.loads(run(nix, source, + ["eval", "--no-update-lock-file", "--json", attr + ".config.home." + option], env)) + if actual != expected: + raise ValueError("Synthetic host configuration drift") + # CI is x86_64; no cross-build or ARM runtime claim. + output = run(nix, source, ["build", "--no-update-lock-file", "--no-link", + "--print-out-paths", ".#packages.x86_64-linux.default"], env) + outputs = output.splitlines() + if len(outputs) != 1 or not outputs[0].startswith("/nix/store/"): + raise ValueError("Unexpected build outputs") + generation = Path(outputs[0]) + if not (generation / "activate").is_file(): + raise ValueError("Missing activation artifact (must not execute it)") + for source_name, target in (("files/vimrc", ".vimrc"), ("files/zshrc", ".zshrc"), + ("files/gitconfig", ".gitconfig")): + if (generation / "home-files" / target).read_bytes() != (source / source_name).read_bytes(): + raise ValueError("Built dotfile differs from reviewed source") + report = {"nix": version, "evaluated": evaluations, "built": outputs, + "source_bytes_verified": True, "activation_executed": False, + "arm_build": False, "lock": "generated by nix flake lock"} + (folder / "validation.json").write_text(json.dumps(report, indent=2) + "\n") + # Deliberately preserve scratch sources, lock and build evidence. + return report + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--build", action="store_true", + help="Use only in an explicitly authorized disposable Nix environment") + args = parser.parse_args() + if args.build and shutil.which("nix") is None: + parser.exit(2, "Nix unavailable: no evaluation/build or lock generated.\n") + folder, source = stage() + result = {"stage": str(folder), "source": str(source), "exported_sources": list(SOURCES), + "evaluated_or_built": False} + if args.build: + result["validation"] = validate(folder, source) + result["evaluated_or_built"] = True + print(json.dumps(result, indent=2)) + + +if __name__ == "__main__": + main() From 78c68d77a4a3333a8e1e9b826b111956567e7fc0 Mon Sep 17 00:00:00 2001 From: Caio Barbieri Date: Fri, 2 Oct 2026 21:31:47 -0300 Subject: [PATCH 2/3] Preserve Nix-generated lock and validate reuse without activation --- .github/workflows/nix-rehearsal.yml | 2 +- portable-linux/README.md | 2 +- portable-linux/flake.lock | 49 +++++++++++++++++++++++++++++ portable-linux/nix/README.md | 42 ++++++++++++++----------- portable-linux/nix/validate.py | 20 ++++++++++-- 5 files changed, 92 insertions(+), 23 deletions(-) create mode 100644 portable-linux/flake.lock diff --git a/.github/workflows/nix-rehearsal.yml b/.github/workflows/nix-rehearsal.yml index 671ace6..2c9cc59 100644 --- a/.github/workflows/nix-rehearsal.yml +++ b/.github/workflows/nix-rehearsal.yml @@ -1,4 +1,4 @@ -# Local proposal: publish/run only after explicit approval of Nix installation in CI. +# Explicitly approved Nix installation in disposable GitHub runners only. name: Nix standalone build only on: push: diff --git a/portable-linux/README.md b/portable-linux/README.md index 38b41e2..47b8072 100644 --- a/portable-linux/README.md +++ b/portable-linux/README.md @@ -42,7 +42,7 @@ Projetos/WIP precisam de plano independente: selecionar apenas código pessoal a ## Nix opcional -O módulo em `nix/home.nix` declara sete CLIs e os três dotfiles comuns. `flake.nix` e `nix/rehearsal.nix` acrescentam entrada standalone com inputs oficiais fixados e identidade sintética Linux, sem ativação. `nix/validate.py` exporta somente seis fontes para ensaio e pode gerar lock/eval/build em ambiente Nix autorizado. Nix está ausente localmente; não há flake.lock nem parser/eval/build executado. O novo workflow Nix é proposta local, exige aprovação de publicação/instalação no runner. Ver [nix/README.md](nix/README.md). +O módulo em `nix/home.nix` declara sete CLIs e os três dotfiles comuns. `flake.nix` e `nix/rehearsal.nix` acrescentam entrada standalone com inputs oficiais fixados e identidade sintética Linux, sem ativação. `nix/validate.py` exporta somente seis fontes para ensaio e pode gerar lock/eval/build em ambiente Nix autorizado. Nix continua ausente localmente. O CI autorizado com Nix 2.35.2 gerou o flake.lock real, avaliou x86_64/ARM64 e construiu x86_64, sem ativação. O lock foi revisado e incorporado à branch; reutilização e checks do commit atual devem passar antes de merge. Ver [nix/README.md](nix/README.md). Nix pode precisar admin para /nix, inclusive single-user; não contornar TI. Se Nix não for autorizado, manter os arquivos comuns e ferramentas instaladas pelo mecanismo aprovado. Drivers/GPU/audio, VPN, login, agentes de segurança e GUI ficam fora da primeira camada. diff --git a/portable-linux/flake.lock b/portable-linux/flake.lock new file mode 100644 index 0000000..8ac315b --- /dev/null +++ b/portable-linux/flake.lock @@ -0,0 +1,49 @@ +{ + "nodes": { + "home-manager": { + "inputs": { + "nixpkgs": [ + "nixpkgs" + ] + }, + "locked": { + "lastModified": 1790742243, + "narHash": "sha256-kaNo6xHiL31AbNNEreG0OTKf4j6Cxlo5bPawjX7lnbQ=", + "owner": "nix-community", + "repo": "home-manager", + "rev": "e5fcd298a00f08b6e8390baf04aa8edb62203070", + "type": "github" + }, + "original": { + "owner": "nix-community", + "repo": "home-manager", + "rev": "e5fcd298a00f08b6e8390baf04aa8edb62203070", + "type": "github" + } + }, + "nixpkgs": { + "locked": { + "lastModified": 1790920529, + "narHash": "sha256-nQyFkMR78WP6PiXKkDW2SjqzLf/spQqjRuxRGSbcV8k=", + "owner": "NixOS", + "repo": "nixpkgs", + "rev": "774debe7a0d1b496e35677ad955a1011c6ff74f3", + "type": "github" + }, + "original": { + "owner": "NixOS", + "repo": "nixpkgs", + "rev": "774debe7a0d1b496e35677ad955a1011c6ff74f3", + "type": "github" + } + }, + "root": { + "inputs": { + "home-manager": "home-manager", + "nixpkgs": "nixpkgs" + } + } + }, + "root": "root", + "version": 7 +} diff --git a/portable-linux/nix/README.md b/portable-linux/nix/README.md index 8f0ac29..94815c4 100644 --- a/portable-linux/nix/README.md +++ b/portable-linux/nix/README.md @@ -1,6 +1,6 @@ # Nix/Home Manager standalone — ensaio sem ativação -Configuração standalone Linux preparada em fonte, ainda **sem parse/eval/build Nix**. +Configuração standalone Linux com avaliação/build reais no CI Nix 2.35.2. O módulo `home.nix` existente era válido como módulo mínimo, mas faltavam inputs, identidade de ensaio e ponto de entrada. Ele foi preservado; `../flake.nix` fornece Nixpkgs/Home Manager e `rehearsal.nix` fornece somente uma identidade sintética. @@ -15,9 +15,10 @@ Refs consultadas em 2026-10-03 e fixadas por revisões reais: - Nixpkgs: `774debe7a0d1b496e35677ad955a1011c6ff74f3`. - Home Manager: `e5fcd298a00f08b6e8390baf04aa8edb62203070`; nixpkgs segue o mesmo input. -Os pins de revisão são seleção de fonte, não lock nem evidência de avaliação. -`flake.lock` ainda não existe: somente `nix flake lock` autorizado poderá gerar seus -narHashes e metadados reais. Não inventar hash, timestamp ou lock à mão. +Os pins de revisão são seleção de fonte; o `flake.lock` incluído foi gerado por +`nix flake lock` no [runner autorizado](https://github.com/caiolombello/dotfiles/actions/runs/37082208570) +e seu artifact foi conferido por digest e hashes das seis fontes. NarHashes e +metadados foram produzidos pela ferramenta, sem edição manual. Alvos: avaliação `x86_64-linux` e `aarch64-linux`; build somente x86_64 no CI proposto. O fixture novo usa username `personal-rehearsal`, HOME `/tmp/personal-home-manager-rehearsal` e stateVersion `26.05`; não identifica pessoa/host e jamais deve ser ativado. @@ -33,10 +34,11 @@ PYTHONDONTWRITEBYTECODE=1 python3 nix/validate.py ``` Ele preserva scratch e copia somente seis fontes públicas fixas: flake, módulo, -fixture e os três dotfiles. Não exporta o repo inteiro, configs locais, journals, +fixture e os três dotfiles, mais o lock revisado quando presente. Não exporta o repo inteiro, configs locais, journals, skills, inventários ou WIP. Nenhum arquivo de HOME é lido. Conferir o diff dessas seis fontes antes do ensaio; a allowlist sozinha não torna uma fonte modificada segura. -O caminho `source` retornado é o único que deve entrar no Nix store. +O caminho `source` retornado é o único que deve entrar no Nix store. O lock existente +é reutilizado byte a byte; eval/build usam `--no-update-lock-file`. Em ambiente descartável **já autorizado com Nix instalado**, após revisão: @@ -45,7 +47,7 @@ PYTHONDONTWRITEBYTECODE=1 python3 nix/validate.py --build ``` O comando usa HOME temporário, não herda tokens/credenciais, não aceita nixConfig -de flakes, gera lock real, confere revisões, avalia os dois alvos, constrói a geração +de flakes, gera lock real somente se ausente, reutiliza o lock existente e confere revisões, avalia os dois alvos, constrói a geração x86_64 e compara os três arquivos gerados byte a byte. Nunca executa `activate`, `home-manager switch`, `nix profile install`, serviços ou garbage collection. Usa o cache oficial padrão; não adiciona cache/credencial nem desativa TLS/sandbox. @@ -67,12 +69,14 @@ Home Manager real. Rollback do bootstrap foi testado separadamente; gerações H Manager dependem de retenção e podem sumir após GC. Nunca misturar HM e bootstrap sobre os mesmos destinos (o bootstrap recusa symlinks). -## Plano de CI — depende de aprovação específica +## CI aprovado e executado Workflow proposto: `.github/workflows/nix-rehearsal.yml`, Ubuntu 24.04 descartável. -Publicar esse workflow em branch nova dispara push/PR e instala software no runner; -é uma nova execução externa, exige aprovação específica antes de publicar. -Não houve publicação ou execução nesta fase. +Publicar esse workflow em branch nova dispara push/PR e instala software no runner. +Esse escopo recebeu aprovação específica: [PR draft 3](https://github.com/caiolombello/dotfiles/pull/3). +A primeira execução teve sucesso com avaliação nos dois alvos e build x86_64, +comparação byte a byte dos três dotfiles e nenhuma ativação. A incorporação do lock +e sua reutilização são verificadas pelos checks do commit atual, antes de merge. 1. Checkout oficial pinado, contents:read, credenciais não persistidas. 2. Baixar distribuição oficial Nix **2.35.2** e checksum via HTTPS; verificar checksum. @@ -83,20 +87,22 @@ Não houve publicação ou execução nesta fase. Não fazer commit automático, upload de HOME, pacote result ou logs privados. Download/checksum do mesmo distribuidor verifica integridade, não é assinatura -independente. A disponibilidade do tarball/checksum e as opções do instalador serão -conferidas na execução; qualquer falha deve parar, sem trocar fonte/desligar checks. +independente. Tarball, checksum e opções do instalador foram usados com sucesso na primeira +execução; futuras falhas devem parar, sem trocar fonte/desligar checks. Nix 2.35.2 foi confirmado na [página oficial](https://nixos.org/download/) e [tag oficial](https://github.com/NixOS/nix/tree/2.35.2). [Upload artifact v4.6.2](https://github.com/actions/upload-artifact/tree/ea165f8d65b6e75b540449e92b4886f43607fa02) está pinado por SHA verificado. Sem caches adicionais, self-hosted runner ou secrets. -Após sucesso real, revisar artifact, lock/input graph e outputs antes de incorporar -lock ao repo; a aprovação de CI não autoriza merge ou ativação de host. +Artifact, lock/input graph e outputs foram revisados antes de incorporar o lock +à branch. A aprovação de CI não autoriza merge ou ativação de host. ## Limites atuais e recuperação futura -Nix ausente localmente; Docker socket e namespaces já bloqueados. Não contornar -permissões/kernel, instalar runtime no notebook ou dizer que a checagem de fontes -é parse/build. O incremento local é preparado, não validado pelo Nix ainda. +Nix continua ausente localmente; Docker socket e namespaces já bloqueados. Não +contornar permissões/kernel nem instalar runtime no notebook. A validação real +foi feita no CI Ubuntu descartável; não é container local nem setup do host. +ARM64 foi avaliado, sem build/runtime ARM64. Ativação e rollback Home Manager +não foram executados. Build/eval não certificam o futuro SO ou política de TI. Perfis dev/machine/AI e identidade por pasta do bootstrap não foram reimplementados nesta camada: Home Manager contém somente base e sete CLIs. Não copiar includeIf, providers/MCP, tokens ou identidade real para obter paridade automática. diff --git a/portable-linux/nix/validate.py b/portable-linux/nix/validate.py index d908544..299a02e 100644 --- a/portable-linux/nix/validate.py +++ b/portable-linux/nix/validate.py @@ -31,6 +31,16 @@ def stage(): q.parent.mkdir(parents=True, exist_ok=True) q.write_bytes(data) hashes[name] = hashlib.sha256(data).hexdigest() + # Once the reviewed, tool-generated lock is committed, reuse it verbatim. + # Never copy arbitrary local configs or regenerate an existing lock silently. + lock = ROOT / "flake.lock" + if lock.exists() or lock.is_symlink(): + if lock.is_symlink() or not lock.is_file(): + raise ValueError("Nonordinary lock source") + data = lock.read_bytes() + json.loads(data) + (source / "flake.lock").write_bytes(data) + hashes["flake.lock"] = hashlib.sha256(data).hexdigest() (folder / "sources.json").write_text(json.dumps(hashes, indent=2) + "\n") return folder, source @@ -51,7 +61,9 @@ def validate(folder, source): "NIX_USER_CONF_FILES": "/dev/null", "NIX_CONFIG": "experimental-features = nix-command flakes\naccept-flake-config = false\n"} version = run(nix, source, ["--version"], env) - run(nix, source, ["flake", "lock", "path:" + str(source)], env) + reused_lock = (source / "flake.lock").exists() + if not reused_lock: + run(nix, source, ["flake", "lock", "path:" + str(source)], env) lock = json.loads((source / "flake.lock").read_text()) inputs = lock["nodes"][lock["root"]]["inputs"] for name, revision in REVISIONS.items(): @@ -87,7 +99,9 @@ def validate(folder, source): raise ValueError("Built dotfile differs from reviewed source") report = {"nix": version, "evaluated": evaluations, "built": outputs, "source_bytes_verified": True, "activation_executed": False, - "arm_build": False, "lock": "generated by nix flake lock"} + "arm_build": False, + "lock_sha256": hashlib.sha256((source / "flake.lock").read_bytes()).hexdigest(), + "lock": "reused reviewed tool-generated lock" if reused_lock else "generated by nix flake lock"} (folder / "validation.json").write_text(json.dumps(report, indent=2) + "\n") # Deliberately preserve scratch sources, lock and build evidence. return report @@ -101,7 +115,7 @@ def main(): if args.build and shutil.which("nix") is None: parser.exit(2, "Nix unavailable: no evaluation/build or lock generated.\n") folder, source = stage() - result = {"stage": str(folder), "source": str(source), "exported_sources": list(SOURCES), + result = {"stage": str(folder), "source": str(source), "exported_sources": list(json.loads((folder / "sources.json").read_text())), "evaluated_or_built": False} if args.build: result["validation"] = validate(folder, source) From 6c4d9882847aa2981c4c063598bac03c0d590b40 Mon Sep 17 00:00:00 2001 From: Caio Barbieri Date: Fri, 2 Oct 2026 21:32:45 -0300 Subject: [PATCH 3/3] Align agent guide with verified standalone Nix rehearsal --- portable-linux/AGENT-SETUP.md | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/portable-linux/AGENT-SETUP.md b/portable-linux/AGENT-SETUP.md index 7fde24e..824ce3a 100644 --- a/portable-linux/AGENT-SETUP.md +++ b/portable-linux/AGENT-SETUP.md @@ -161,12 +161,14 @@ Pin do checkout obtido no [commit oficial de v7.0.1](https://github.com/actions/ ## Nix e limites -Home Manager permanece opcional e não instalado/avaliado. Reaproveita os arquivos +Home Manager permanece opcional e não instalado no notebook. O ensaio standalone +foi avaliado nos dois alvos Linux e construído em x86_64 no runner Nix autorizado, +sem ativação; ver `nix/README.md` para lock, CI e limites. Reaproveita os arquivos base, incluindo Git explícito, mas perfis dinâmicos/identidade não têm integração Home Manager completa. Não misturar dois gerenciadores sobre os mesmos destinos: -symlinks Home Manager são recusados por este bootstrap. Sem lock inventado ou -alegação de reprodutibilidade Nix. SO/TI, identidade, stateVersion e inputs/pins -exigem configuração e avaliação/build posteriores em ambiente autorizado. +symlinks Home Manager são recusados por este bootstrap. O lock incluído foi gerado pela ferramenta no runner e revisado. SO/TI, identidade +e stateVersion do host futuro exigem configuração explícita e avaliação/build +posteriores; o fixture não autoriza ativação real. O módulo AI é somente orientação, sem provider, endpoint, token, MCP, skills massivas, históricos, sessões ou mudança de permissões. Backup dos 13 arquivos pendentes e