anon-pi 0.11.1 → 0.13.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.source, cmd.name, cmd.imageTag);
 		}
 	} catch (e) {
 		return reportAnonPiError(e);
@@ -827,6 +830,70 @@ function machineRm(env: AnonPiEnv, name: string, yes: boolean): number {
 	return 0;
 }
 
+/**
+ * `machine snapshot <source> <new-name> [--image-tag <ref>]`: commit the source
+ * machine's 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. 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,
+	source: string,
+	name: string,
+	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();
+
+	// Resolve the ONE running anon-pi container for the SOURCE machine (reuse the
+	// forward/ports running-container resolution, scoped by machine).
+	const target = resolveRunningContainer(source, '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 machine ${JSON.stringify(source)} into ${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 +2114,22 @@ 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 <machine> <new-name> [--image-tag <ref>]
+                                                  commit <machine>'s 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 <machine>'s 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 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 +2302,54 @@ function resolveForwardTarget(
 	return matches.find((c) => c.ref === picked.project);
 }
 
+/**
+ * Resolve the ONE running anon-pi container for a MACHINE (no project scope, no
+ * port hints), for `machine snapshot`. Filters the running managed containers by
+ * machine: 0 => error (start a session first), 1 => it, many => an arrow-key
+ * picker labelled by each container's project + name. Returns undefined on
+ * no-match or a cancelled pick (reason printed). TTY needed only for the picker.
+ */
+function resolveRunningContainer(
+	machine: string,
+	verb: string,
+): ManagedContainer | undefined {
+	const matches = resolveManagedMatches({
+		containers: queryRunningContainers(),
+		machine,
+		project: undefined,
+	});
+	if (matches.length === 0) {
+		process.stderr.write(
+			`anon-pi: no running anon-pi container for machine ${JSON.stringify(machine)}. ` +
+				`Start a session (e.g. \`anon-pi -m ${machine} --shell\`), 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 on machine ${JSON.stringify(machine)}; ` +
+				'a terminal is needed to pick one.\n',
+		);
+		return undefined;
+	}
+	const entries: MenuEntry[] = matches.map((c) => {
+		const proj = keyProject(parseKeptKey(c.key));
+		const label = proj === '' ? '(shell)' : proj;
+		return {kind: 'project', project: c.ref, label: `${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