anon-pi 0.12.0 → 0.14.0

package/src/cli.ts

@@ -79,6 +79,7 @@ import {
 	resolveRunPlan,
 	resolveRunVsStart,
 	serializeMachineJson,
+	snapshotImageRef,
 	serializeConfigJson,
 	setImageWarning,
 	keptContainerKey,
@@ -680,6 +681,8 @@ function runMachine(machineArgs: string[]): number {
 				return machineSetImage(env, cmd.name, cmd.image);
 			case 'rm':
 				return machineRm(env, cmd.name, cmd.yes);
+			case 'snapshot':
+				return machineSnapshot(env, cmd.name, cmd.machine, cmd.imageTag);
 		}
 	} catch (e) {
 		return reportAnonPiError(e);
@@ -827,6 +830,72 @@ function machineRm(env: AnonPiEnv, name: string, yes: boolean): number {
 	return 0;
 }
 
+/**
+ * `machine snapshot <new-name> [-m <machine>] [--image-tag <ref>]`: commit a
+ * RUNNING jailed container into a new image and create <new-name> pinned to it.
+ * The user does interactive system work in a session (e.g. `sudo apt install`),
+ * then, WITHOUT having exited (the default `--rm` would have destroyed the
+ * container), preserves that exact environment as a new machine. The container
+ * to commit is AUTO-DETECTED from the running anon-pi containers (a picker when
+ * several are up); `-m <machine>` is an OPTIONAL filter, not a required source.
+ * podman pauses the container during commit and unpauses, so the live session
+ * survives. The new machine gets a FRESH home (image and home are orthogonal;
+ * snapshot keeps the SOFTWARE, not the conversations). Forced egress is
+ * untouched: commit is a local podman op, and the snapshot machine relaunches
+ * through the same forced-egress jail.
+ */
+function machineSnapshot(
+	env: AnonPiEnv,
+	name: string,
+	machine: string | undefined,
+	imageTag: string | undefined,
+): number {
+	// Refuse to clobber an existing target machine FIRST (before netcage / any
+	// commit), so a name clash fails fast and never leaves an orphan image.
+	// Mirrors machine create.
+	const targetDir = machineDir(env, name);
+	if (existsSync(targetDir)) {
+		process.stderr.write(
+			`anon-pi: machine ${JSON.stringify(name)} already exists (${targetDir}). ` +
+				'Pick a different <new-name> or `anon-pi machine rm` it first.\n',
+		);
+		return 1;
+	}
+
+	if (!hasNetcage()) return netcageMissing();
+
+	// Auto-detect the running anon-pi container to commit (optionally filtered by
+	// -m <machine>); reuses the forward/ports running-container resolution.
+	const target = resolveRunningContainer(machine, 'snapshot');
+	if (target === undefined) return 1;
+
+	const imageRef = imageTag ?? snapshotImageRef(name, new Date());
+	process.stderr.write(
+		`anon-pi: committing ${target.name} -> image ${imageRef} (pausing the container briefly)\u2026\n`,
+	);
+	const committed = spawnNetcage(['commit', target.ref, imageRef]);
+	if (committed !== 0) {
+		process.stderr.write(
+			`anon-pi: netcage commit failed; machine ${JSON.stringify(name)} NOT created.\n`,
+		);
+		return committed;
+	}
+
+	// Create the machine pinned to the committed image (its home seeds on first
+	// launch, exactly like `machine create`).
+	mkdirSync(machineHomeDir(env, name), {recursive: true});
+	writeFileSync(
+		machineJsonPath(env, name),
+		serializeMachineJson({image: imageRef}),
+	);
+	process.stdout.write(
+		`anon-pi: snapshotted ${target.name} into machine ${JSON.stringify(name)} ` +
+			`(image ${imageRef}) at ${targetDir}.\n` +
+			`Its home seeds fresh on first launch, e.g. \`anon-pi -m ${name} --shell\`.\n`,
+	);
+	return 0;
+}
+
 // --- the destructive cleanup verbs (thin I/O over the pure resolvers) --------
 //
 // `--delete-home [<machine>]` and `--delete-project <project>` REPLACE the old
@@ -2047,11 +2116,24 @@ USAGE
   anon-pi machine list                            list machines and their images
   anon-pi machine set-image <name> <ref>          re-pin the image (WARNS; no reseed)
   anon-pi machine rm <name> [--yes]               delete the machine + its home
+  anon-pi machine snapshot <new-name> [-m <machine>] [--image-tag <ref>]
+                                                  commit a RUNNING container into a
+                                                  new image + create <new-name>
 
 A machine is an image + a persistent host home (machines/<name>/{machine.json,home/}).
 The home is seeded on FIRST LAUNCH, not at create. \`set-image\` re-pins only and
 warns (the home was built for the old image); \`rm\` confirms on a TTY, skips with
 \`--yes\`, and aborts non-interactively without it.
+
+\`snapshot\` captures the CURRENT filesystem of a RUNNING jailed container (e.g.
+after \`sudo apt install\`) into a new image and creates <new-name> pinned to it,
+so you can preserve an environment you built interactively WITHOUT having
+pre-decided \`--keep\`. The container is auto-detected from the running anon-pi
+containers (a picker when several are up); \`-m <machine>\` is an OPTIONAL filter,
+not a required source. The container must still be RUNNING (do not exit the
+session); podman pauses it briefly during the commit. The new machine gets a
+FRESH home (the image is the software, the home is separate). Same forced-egress
+jail on relaunch.
 `;
 
 // --- impure helpers ---------------------------------------------------------
@@ -2224,6 +2306,63 @@ function resolveForwardTarget(
 	return matches.find((c) => c.ref === picked.project);
 }
 
+/**
+ * Resolve the ONE running anon-pi container to act on, for `machine snapshot`.
+ * The container is what matters; `machine` is an OPTIONAL narrowing filter
+ * (undefined = every running anon-pi container qualifies). 0 => error (start a
+ * session first), 1 => it, many => an arrow-key picker labelled by each
+ * container's machine + project + name (so a cross-machine list is
+ * distinguishable). Returns undefined on no-match or a cancelled pick (reason
+ * printed). TTY needed only for the picker.
+ */
+function resolveRunningContainer(
+	machine: string | undefined,
+	verb: string,
+): ManagedContainer | undefined {
+	const matches = resolveManagedMatches({
+		containers: queryRunningContainers(),
+		machine,
+		project: undefined,
+	});
+	const scope =
+		machine !== undefined ? ` for machine ${JSON.stringify(machine)}` : '';
+	if (matches.length === 0) {
+		process.stderr.write(
+			`anon-pi: no running anon-pi container${scope}. ` +
+				'Start a session (e.g. `anon-pi <project>`), do your work, and ' +
+				`WITHOUT exiting run \`anon-pi machine ${verb}\` from another terminal.\n`,
+		);
+		return undefined;
+	}
+	if (matches.length === 1) return matches[0];
+
+	if (!process.stdin.isTTY) {
+		process.stderr.write(
+			`anon-pi: ${matches.length} running containers${scope}; a terminal is needed ` +
+				'to pick one (or narrow with `-m <machine>`).\n',
+		);
+		return undefined;
+	}
+	const entries: MenuEntry[] = matches.map((c) => {
+		const f = parseKeptKey(c.key);
+		const proj = keyProject(f);
+		const label = proj === '' ? '(shell)' : proj;
+		return {
+			kind: 'project',
+			project: c.ref,
+			label: `${f.machine ?? '?'} / ${label} [${c.name}]`,
+		};
+	});
+	const picked = select(entries, {
+		header: `anon-pi: pick a container to ${verb} (\u2191/\u2193 move, Enter select, Ctrl-C quit)`,
+	});
+	if (picked === undefined) {
+		process.stderr.write('anon-pi: cancelled; nothing snapshotted.\n');
+		return undefined;
+	}
+	return matches.find((c) => c.ref === picked.project);
+}
+
 /**
  * `anon-pi forward [<project>] [--port <[hostPort:]jailPort>] [--bind <addr>]
  * [-m <machine>]`: open a host->jail port on a running anon-pi container. Wraps