b1aa805..master · nix-container

git.iko.soy/nix-container

on master help sign in

.gitignore−1

since splitsnapshots

unifiedsplit

@@ -1,2 +1 @@

1−image.tar.gz

2result

1result

LICENSEnew file+21

@@ -0,0 +1,21 @@

1+MIT License

5+Permission is hereby granted, free of charge, to any person obtaining a copy

6+of this software and associated documentation files (the "Software"), to deal

7+in the Software without restriction, including without limitation the rights

8+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

9+copies of the Software, and to permit persons to whom the Software is

10+furnished to do so, subject to the following conditions:

11+

12+The above copyright notice and this permission notice shall be included in all

13+copies or substantial portions of the Software.

14+

15+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

16+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

17+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

18+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

19+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

20+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

21+SOFTWARE.

README.md+92−53

@@ -1,85 +1,117 @@

1−# container-nix

1+# nix-container

3A Nix flake that builds an **OCI image** (via

4[`nix2container`](https://github.com/nlewo/nix2container)) for running with

5Apple's [`container`](https://github.com/apple/container) CLI on macOS.

7It's a plain, single-process image — no NixOS, no systemd — defined in

8−[`flake.nix`](./flake.nix). The default command is `fish` (with a configured

8+[`flake.nix`](./flake.nix). `c start` drops you into a

9−prompt), and the image ships a handful of dev/LLM tools: `git`, `jujutsu`,

9+[`herdr`](https://herdr.dev) session whose panes use your host login shell

10−`ripgrep`, `fd`, `jq`, `nodejs`, `python3`, a Rust + C toolchain,

10+(detected and bundled by `c init`). You choose what else it ships via a

11−`charmbracelet.crush`, `openssh`, and more.

11+per-project `container.nix`.

13## Prerequisites

15+- [Nix](https://nixos.org/download/) with flakes enabled.

15−- Apple's `container` CLI installed, with services started:

16+- Apple's [`container`](https://github.com/apple/container) CLI installed, with

16− `container system start` (first run downloads a Linux kernel).

17+ services started: `container system start` (first run downloads a Linux

17−- A **Linux builder** — the image *contents* are Linux binaries and can't be

18+ kernel).

18− built on macOS. `internal.iko.soy` (aarch64-linux) is already configured, so

19+- A **Linux builder** *only if you use packages that aren't in the binary

19− `nix` dispatches to it automatically.

20+ cache*. The image is assembled entirely on macOS — the root filesystem is just

20−

21+ a host-built symlink tree over the **substituted** Linux store paths — so a

21−## Steps

22+ fully-cached package set needs no builder. Compiling a Linux package that

23+ `cache.nixos.org` doesn't have does, though: use a [remote builder][builders]

24+ or, on Apple Silicon, the `nix-darwin` `linux-builder`.

25+

26+[builders]: https://nix.dev/manual/nix/latest/advanced-topics/distributed-builds

27+

28+## Packages

29+

30+`init` builds the image from a **`container.nix`** in the current directory — an

31+attrset with a `packages` function (`{ pkgs, nur }` returning the package list;

32+`nur` is [NUR](https://github.com/nix-community/NUR), for packages outside

33+nixpkgs) and an optional `mounts` list. It is **required**; there is no default.

34+

35+```nix

36+# ./container.nix

37+{

38+ packages = { pkgs, nur }: with pkgs; [

39+ git

40+ go

41+ nur.repos.charmbracelet.crush

42+ ];

43+ # Extra "host:container" bind mounts, on top of $PWD → /workspace. A leading

44+ # ~/ in the host path expands to $HOME. Optional.

45+ mounts = [

46+ "~/data:/data"

47+ ];

48+}

49+```

23−### 1. Build the image archive

51+Your **host login shell** (detected by `c init`, bash fallback), **coreutils**,

52+[**herdr**](https://herdr.dev) (the session `c start` launches), **Nix** itself

53+(with CA certs and `nix-command`/`flakes` enabled, single-user), and the ncurses

54+**terminfo** database are always included — no need to list them.

25−`nix run` builds the Linux contents (on the remote builder) and writes a tagged

56+Point at a different file with `-c`/`--config`:

26−OCI archive locally via `skopeo`. Pass the output path; the image is tagged

27−`nixos-container:latest`.

29```sh

58```sh

30−nix run . -- image.tar.gz

59+nix run github:ilyakooo0/nix-container -- init --config envs/ci.nix

31```

60```

33−### 2. Load it into `container`

62+## Quick start

35−```sh

64+No clone needed — `nix run` drives everything. Run it from a project directory

36−container image load --input image.tar.gz

65+that holds a `container.nix`; the container is named after that directory.

37−```

38−

39−### 3. Create and start the container

41```sh

67```sh

42−container create --name nixos --ssh -it nixos-container:latest

68+# build the image, load it, and create the container (named after $PWD):

43−container start -ai nixos

69+nix run github:ilyakooo0/nix-container -- init

70+

71+# start it and attach — drops you into a herdr session:

72+nix run github:ilyakooo0/nix-container -- start

44```

73```

75+- `init` builds the OCI archive in a temp dir, loads it into `container`,

76+ deletes the temp file, then (re)creates the container. It mounts the current

77+ directory at `/workspace` (the container's working directory).

46- `--ssh` forwards your host SSH agent socket into the container (so `git` over

78- `--ssh` forwards your host SSH agent socket into the container (so `git` over

47− SSH etc. works with your keys).

79+ SSH works with your keys).

48−- `-it` / `-ai` give an interactive TTY; `start -ai` attaches to it.

80+- Add more mounts persistently via `mounts` in `container.nix` (above), or

81+ ad-hoc by passing them through to `create` (mounts can only be set at creation):

82+

83+ ```sh

84+ nix run github:ilyakooo0/nix-container -- init -v $HOME/data:/data

85+ ```

50−You land in `fish`. Exit the shell to stop the container.

87+Working from a checkout, [`./c init`](./c) / `./c start` are equivalent — and

88+`c` can be symlinked onto your `$PATH` and run from any project.

52## Re-running after a rebuild

90## Re-running after a rebuild

54−`container` keeps the loaded image and the created container, so to pick up a

92+Just run `init` again — it reloads the image and replaces the existing container

55−new build, remove the old ones first:

93+(removing the old one first), so there's nothing to clean up:

57```sh

95```sh

58−nix run . -- image.tar.gz # rebuild the archive

96+nix run github:ilyakooo0/nix-container -- init

59−container rm nixos # remove the old container (stop it first if running)

60−container image rm nixos-container:latest

61−container image load --input image.tar.gz

62−container create --name nixos --ssh -it nixos-container:latest

63−container start -ai nixos

64```

97```

66−## Other image destinations

99+## Customize further

100

68−`nix run .#copyTo` is nix2container's generic skopeo wrapper

101+Fork or clone to change what isn't per-project — `config.cmd`/`env` or the image

69−(`skopeo copy nix:<image> "$@"`) — the argument is any skopeo destination:

102+name — in [`flake.nix`](./flake.nix). The flake also exposes build helpers:

103

71−```sh

104+- `lib.<system>.copyWith` → a skopeo copy app for a `{ pkgs, nur }: [ ... ]`

72−nix run .#copyTo -- docker://ghcr.io/me/nixos:latest # push to a registry

105+ function, for building/pushing the image anywhere skopeo can write (e.g. a

73−nix run .#copyTo -- docker-daemon:nixos-container:latest # local Docker daemon

106+ registry):

74−```

75−

76−## Customize

107

78−Edit the `buildImage` call in [`flake.nix`](./flake.nix):

108+ ```sh

79−

109+ drv=$(nix build --no-link --print-out-paths --impure --expr \

80−- Add packages to `copyToRoot.paths`.

110+ '(builtins.getFlake "github:ilyakooo0/nix-container").lib.${builtins.currentSystem}.copyWith (import ./container.nix).packages')

81−- Change the default process via `config.cmd`.

111+ $drv/bin/copy-to docker://ghcr.io/me/img:latest

82−- Add env vars via `config.env`.

112+ ```

113+- `lib.<system>.mkImage <name> <shell>` → the underlying OCI image (`copyWith`

114+ defaults these to `nix-container` / `bash`).

115

84The flake uses `flake-utils` over `{aarch64,x86_64}-{darwin,linux}`; the host

116The flake uses `flake-utils` over `{aarch64,x86_64}-{darwin,linux}`; the host

85system maps to the matching Linux target automatically (an Intel Mac builds an

117system maps to the matching Linux target automatically (an Intel Mac builds an

@@ -87,8 +119,15 @@ system maps to the matching Linux target automatically (an Intel Mac builds an

119

88## How it works

120## How it works

121

90−- **Contents** (`copyToRoot`) are built from `pkgsLinux` → the Linux builder.

122+- **Contents** are Linux store paths — downloaded prebuilt from the binary cache

123+ (only built on a Linux builder if not cached).

124+- **Assembly** runs entirely on your Mac: `copyToRoot` is a *host-arch* `buildEnv`

125+ symlink tree over those Linux paths (symlinks are arch-neutral), and

91−- **Assembly** (`nix2container` + the `skopeo` copy) runs on your Mac, so a

126+ `nix2container` + `skopeo` package it — so for a cached set, `init` produces a

92− single `nix run` produces a loadable archive.

127+ loadable Linux image with no Linux build at all.

93- Apple's `container` runs each container in its own lightweight Linux VM and

128- Apple's `container` runs each container in its own lightweight Linux VM and

94 consumes standard OCI images — no `--privileged` or systemd needed.

129 consumes standard OCI images — no `--privileged` or systemd needed.

130+

131+## License

132+

133+[MIT](./LICENSE).

c+82−4

@@ -1,16 +1,94 @@

1#!/usr/bin/env fish

2# Manage a container named after the current directory.

3−# c init [extra create args] create it (e.g. c init -v $PWD:/work)

3+# c init [-c FILE] [extra create args] build + load the image, then (re)create it

4+# (config from FILE, default ./container.nix)

4−# c start start it and attach

5+# c start start it and attach

6set -l name (path basename $PWD)

7set -l name (path basename $PWD)

8+# The flake lives next to this script (resolve symlinks so it works from $PATH too).

9+set -l flake (path dirname (path resolve (status filename)))

10+# Per-directory image ref this script loads and runs (archive tag + `create`).

11+set -l image "nix-container-$name:latest"

8switch $argv[1]

13switch $argv[1]

9 case init

14 case init

15+ # -c/--config overrides the default ./container.nix; leftover args (e.g.

16+ # mounts) are forwarded to `container create`.

17+ argparse --ignore-unknown 'c/config=' -- $argv[2..-1]

18+ or exit 1

19+ set -l config container.nix

20+ if set -q _flag_config

21+ set config $_flag_config

22+ end

23+

24+ if not test -e $config

25+ echo "c: config file not found: $config" >&2

26+ echo " create one ('{ packages = { pkgs, nur }: [ ... ]; mounts = [ ]; }') or pass -c FILE" >&2

27+ exit 1

28+ end

29+

30+ # Host login shell (by name): added to the image automatically and baked

31+ # in as the cmd + default $SHELL (what herdr panes etc. spawn), so it

32+ # needn't be listed in container.nix. Falls back to bash.

33+ set -l shell bash

34+ test -n "$SHELL"; and set shell (path basename $SHELL)

35+

36+ # Build an image with the config's `packages` (plus the shell) into a

37+ # temp dir, load it, then clean up.

38+ set -l tmp (mktemp -d)

39+ set -l archive $tmp/image.tar.gz

40+ set -lx NIX_CONTAINER_CONFIG (path resolve $config)

41+ set -l expr "(builtins.getFlake \"$flake\").lib.\${builtins.currentSystem}.copyWithShell \"nix-container-$name\" \"$shell\" (import (/. + builtins.getEnv \"NIX_CONTAINER_CONFIG\")).packages"

42+ set -l copyer (nix build --impure --no-link --print-out-paths --expr "$expr")

43+ set -l rc $status

44+ if test $rc -eq 0

45+ $copyer/bin/copy-to "oci-archive:$archive:$image"

46+ set rc $status

47+ end

48+ if test $rc -eq 0

49+ container image load --input $archive

50+ set rc $status

51+ end

52+

53+ rm -rf $tmp

54+ test $rc -eq 0; or exit $rc

55+

56+ # Mount the project at /workspace (the default cwd), plus any extra

57+ # mounts from the config (`mounts = [ "host:container" … ]`). A leading

58+ # ~/ in the host path expands to $HOME (nix leaves it literal).

59+ set -l mounts -v "$PWD:/workspace"

60+ for m in (nix eval --impure --raw --expr "builtins.concatStringsSep \"\n\" ((import (/. + builtins.getEnv \"NIX_CONTAINER_CONFIG\")).mounts or [])")

61+ set -a mounts -v (string replace -r '^~/' "$HOME/" -- $m)

62+ end

63+

64+ # TERM to bake into the container env (`-e TERM`): the runtime hands the

65+ # `start -ai` session a bare "xterm", so set the host's real terminal,

66+ # mapped to an entry the bundled ncurses ships — Ghostty reports

67+ # "xterm-ghostty", which ncurses ships as "ghostty" — falling back to

68+ # xterm-256color for an empty or bare-"xterm" value.

69+ set -l term xterm-256color

70+ if test "$TERM" = xterm-ghostty

71+ set term ghostty

72+ else if test -n "$TERM"; and test "$TERM" != xterm

73+ set term $TERM

74+ end

75+

76+ # Replace any existing container of the same name, then create it running

77+ # herdr in a session named after the project (`<dir>-container`). This

78+ # overrides the image's default plain-herdr cmd; `c start` attaches to it.

79+ container rm --force $name 2>/dev/null

80+ # The image only lays down /bin and /etc, so /tmp and /run don't exist;

81+ # without them anything that writes temp files (herdr, build tools, …)

82+ # fails with ENOENT. Mount writable tmpfs at both.

10− container create --name $name --ssh -it $argv[2..-1] nixos-container:latest

83+ container create --name $name --ssh -it -e "TERM=$term" \

84+ --tmpfs /tmp --tmpfs /run --memory 8g --cwd /workspace $mounts $argv \

85+ $image /bin/herdr session attach "$name-container"

11 case start

86 case start

87+ # Start the container and attach to its cmd (herdr). TERM was baked into

88+ # the container env at create time (`-e TERM`), which survives this path.

89+ # Exiting herdr (PID1) stops the container; `c start` boots it again.

12 container start -ai $name

90 container start -ai $name

13 case '*'

91 case '*'

14− echo "usage: c init|start" >&2

92+ echo "usage: c init [-c FILE] [create args] | start" >&2

15 exit 1

93 exit 1

16end

94end

flake.nix+113−125

@@ -72,139 +72,127 @@

72 # Host package set, for the wrapper app below.

73 pkgsHost = nixpkgs.legacyPackages.${system};

75− # skopeo writes the OCI archive's ref.name from the *destination*

75+ # Default image name (for `copyWith`); `c init` passes a per-directory

76− # string, not from the image config — so the wrapper app must spell

76+ # name (`nix-container-<dir>`) to `copyWithShell` instead.

77− # these out, else the archive loads as `untagged`.

78− imageName = "nixos-container";

77+ imageName = "nix-container";

79 imageTag = "latest";

78 imageTag = "latest";

81− # Fish prompt config, copied from smol-nix's mkSmol.nix. Installed at

80+ # Build the OCI image (named `name`) from a `{ pkgs, nur }: [ ... ]`

82− # /root/.config/fish/config.fish (fish reads $HOME/.config/fish).

81+ # package function, for the named shell. The image's `cmd` is herdr

83− fishConfig = pkgsLinux.writeText "config.fish" ''

82+ # (the session `c start` attaches to); the shell is the default `$SHELL`

84− # No welcome banner.

83+ # (what herdr panes spawn) and is added automatically, so `container.nix`

85− set -g fish_greeting

84+ # lists only your extras. Nix (+ CA certs) and the ncurses terminfo

86−

85+ # database are always shipped too. Nothing here is fish-specific: the

87− # Define the prompt as a function so fish renders it before every

86+ # TERM fixup happens host-side in `c` (passed via `-e TERM` at create).

88− # command; at top level it would run once at startup and be ignored.

87+ mkImage =

89− function fish_prompt

88+ name: shell: packages:

90− set -l nix_shell_info

91− if set -q IN_NIX_SHELL; or set -q IN_NIX_RUN

92− set nix_shell_info ' ❄️'

93− end

94−

95− set -l cwd (prompt_pwd)

96−

97− set -l bookmark_info

98− if jj root 2>/dev/null >/dev/null

99− set -l jj_bookmark (jj log -r 'heads(::@ & bookmarks())' -T 'local_bookmarks ++ "\n"' --no-graph 2>/dev/null | tail -1)

100− if test -n "$jj_bookmark"

101− set bookmark_info ' ' (set_color brmagenta) $jj_bookmark (set_color normal)

102− end

103− end

104−

105− echo -n -s (set_color $fish_color_cwd) $cwd (set_color normal) $bookmark_info ' 🏗️' $nix_shell_info '> '

106− end

107− '';

108−

109− # Lay the config out at the path fish reads.

110− fishRoot = pkgsLinux.runCommand "fish-config-root" { } ''

111− mkdir -p "$out/root/.config/fish"

112− cp ${fishConfig} "$out/root/.config/fish/config.fish"

113− '';

114−

115− image = n2c.buildImage {

89+ n2c.buildImage {

116− name = imageName;

90+ inherit name;

117− tag = imageTag;

91+ tag = imageTag;

118− inherit arch;

92+ inherit arch;

119−

93+

120− # A plain, single-process root filesystem. No NixOS, no systemd.

94+ # A plain, single-process root filesystem. No NixOS, no systemd.

95+ # buildEnv only *symlinks* paths (never runs them), so build it on

96+ # the host arch — the tree is arch-neutral and links the

97+ # (substituted) Linux store paths, sparing the Linux builder.

121− copyToRoot = pkgsLinux.buildEnv {

98+ copyToRoot = pkgsHost.buildEnv {

122− name = "root";

99+ name = "root";

100+ paths =

101+ packages {

123− paths = with pkgsLinux; [

102+ pkgs = pkgsLinux;

124− bashInteractive

103+ nur = nurPkgs;

125− fish

104+ }

126− fishRoot

105+ # The shell (cmd + $SHELL), when it exists in nixpkgs.

127− openssh

106+ ++ pkgsLinux.lib.optional (pkgsLinux ? ${shell}) pkgsLinux.${shell}

107+ ++ [

108+ pkgsLinux.nix

109+ pkgsLinux.cacert

110+ # Basic userland (ls, cat, cp, sleep, …) so the container is

111+ # usable out of the box and tools that shell out don't fail.

128− coreutils-full

112+ pkgsLinux.coreutils-full

129− btop

113+ # Networking glue glibc needs: /etc/nsswitch.conf (+passwd,

130− jujutsu

114+ # group) so DNS/host lookups resolve, and /etc/protocols,

131− zellij

115+ # /etc/services. Without these, hostname resolution fails.

132− micro

116+ pkgsLinux.fakeNss

133− helix

117+ pkgsLinux.iana-etc

134− nurPkgs.repos.charmbracelet.crush

118+ # The terminfo database (+ tput/clear/reset) so TUIs find the

135−

119+ # entry for whatever TERM `c` passes in and render correctly.

136− # LLM tools

120+ pkgsLinux.ncurses

137− git

121+ # The session `c start` always launches.

138− ripgrep

122+ pkgsLinux.herdr

139− fd

123+ ];

140− jq

124+ # Link all of /etc so the above files (nsswitch.conf, protocols,

141− curl

125+ # services, passwd, group, ssl certs) are present.

142− wget

126+ pathsToLink = [

143− gnused

127+ "/bin"

144− gnugrep

128+ "/etc"

145− gawk

129+ ];

146− findutils

130+ };

147− gnutar

131+

148− gzip

132+ initializeNixDatabase = true;

149− unzip

133+

150− less

134+ config = {

151− which

135+ # `cmd` (not `entrypoint`): the default command, *replaced* by any

152− tree

136+ # command passed to `container run/create`. Plain herdr here;

153− nodejs

137+ # `c init` overrides it with `herdr session attach <dir>-container` so

154− python3

138+ # the session is named per project. `c start` attaches via

155−

139+ # `container start -ai`; exiting herdr (PID1) stops the container.

156− # rust

140+ cmd = [ "/bin/herdr" ];

157− rustc

141+ env = [

158− cargo

142+ "PATH=/bin"

159− rustfmt

143+ "HOME=/root"

160− clippy

144+ # Default shell for tools that spawn one (herdr panes, etc.).

161−

145+ "SHELL=/bin/${shell}"

162− # C toolchain — rustc links final binaries through `cc`/`ld`.

146+ # Marker so shells/scripts can detect they're in here.

163− gcc # provides cc/gcc; pulls in binutils (ld) via its closure

147+ "NIX_CONTAINER=1"

164− ];

148+ # Advertise truecolor for 24-bit-aware tools; `c` passes the

165− pathsToLink = [

149+ # resolved TERM via -e (the runtime would otherwise force xterm).

166− "/bin"

150+ "COLORTERM=truecolor"

167− "/root"

151+ # A UTF-8 locale so tools handle multibyte/wide characters

152+ # correctly. glibc ships C.UTF-8 built in, so this needs no

153+ # locale-archive.

154+ "LANG=C.UTF-8"

155+ # CA trust for every TLS client (curl/git/…) and Nix.

156+ "SSL_CERT_FILE=/etc/ssl/certs/ca-bundle.crt"

157+ "NIX_SSL_CERT_FILE=/etc/ssl/certs/ca-bundle.crt"

158+ # Make the bundled Nix usable: flake commands on, and

159+ # single-user (no daemon/nixbld).

160+ "NIX_CONFIG=experimental-features = nix-command flakes\nbuild-users-group =\nsandbox = false"

161+ ];

168− ];

162+ };

169 };

163 };

170

164

171− initializeNixDatabase = true;

165+ # `nix run . -- init|start` runs the bundled `c` manager script. Its

172−

166+ # `init` builds the image from the project's `container.nix` (via

173− config = {

167+ # `lib.copyWithShell`); the script finds the flake from its own (store)

174− # `cmd` (not `entrypoint`): it's the default command and is

168+ # location, so this works from a checkout or straight from

175− # *replaced* by `container run … -- <cmd>`. An entrypoint would be

169+ # `nix run github:…/nix-container`.

176− # prepended instead, so `run … -- /bin/sh` would become

170+ cApp = pkgsHost.writeShellScriptBin "c" ''

177− # `/bin/bash /bin/sh` and fail with "cannot execute binary file".

171+ exec ${pkgsHost.fish}/bin/fish ${self}/c "$@"

178− cmd = [ "/bin/fish" ];

179− env = [

180− "PATH=/bin"

181− # fish reads its prompt from $HOME/.config/fish/config.fish.

182− "HOME=/root"

183− ];

184− };

185− };

186−

187− # `nix run . -- <path>` writes an OCI archive tagged

188− # <imageName>:<imageTag>. The raw `image.copyTo` is a passthrough

189− # (`skopeo copy nix:<image> "$@"`), so an `oci-archive:<path>` with no

190− # ref loads as `untagged`; this bakes the ref into the destination.

191− copyToOCI = pkgsHost.writeShellApplication {

192− name = "copy-to-oci";

193− text = ''

194− out="''${1:-image.tar}"

195− exec ${image.copyTo}/bin/copy-to "oci-archive:$out:${imageName}:${imageTag}"

196− '';

172+ '';

197− };

198 in

173 in

199 {

174 {

200 apps = {

175 apps = {

201− # nix run . -- <path> → OCI archive tagged <name>:<tag>,

176+ # nix run . -- init|start → build+load+create / start a container

202− # loadable with `container image load -i <path>`.

203− default = flake-utils.lib.mkApp { drv = copyToOCI; };

177+ default = flake-utils.lib.mkApp { drv = cApp; };

178+ };

204

179

205− # Generic skopeo passthrough for any other destination, e.g.

180+ # Build helpers take a `{ pkgs, nur }: [ ... ]` packages function (the

206− # nix run .#copyTo -- docker://ghcr.io/me/img:latest

181+ # `packages` attr of a project's `container.nix`). `c init` uses

207− copyTo = flake-utils.lib.mkApp { drv = image.copyTo; };

182+ # `copyWithShell` (host shell baked in); `copyWith` is the generic form:

183+ # (builtins.getFlake "github:…/nix-container")

184+ # .lib.<system>.copyWith (import ./container.nix).packages

185+ lib = {

186+ inherit mkImage;

187+ # Build the image's `copyTo` script (a skopeo-copy wrapper) from a

188+ # `{ pkgs, nur }: [ ... ]` function, named `imageName`. Defaults the

189+ # shell (cmd + $SHELL) to bash; use `copyWithShell` to pick another.

190+ copyWith = packages: (mkImage imageName "bash" packages).copyTo;

191+ # Like `copyWith`, but for the given image `name` and shell — `c init`

192+ # passes `nix-container-<dir>` and the host login shell, which is added

193+ # to the image and used as cmd + $SHELL without being listed in

194+ # `container.nix`.

195+ copyWithShell = name: shell: packages: (mkImage name shell packages).copyTo;

208 };

196 };

209 }

197 }

210 );

198 );

resultdeleted−1

@@ -1 +0,0 @@

1−/nix/store/04m5crcxpbg3fhyzsf8152xl8693qyyi-image-nixos-container.json