anon-pi 0.9.0 → 0.10.0

package/src/cli.ts

@@ -56,6 +56,8 @@ import {
 	parseConfigJson,
 	parseLaunchArgs,
 	isHeadlessPiArgs,
+	resumeSessionId,
+	sessionHeaderCwd,
 	anonPiVersion,
 	parseMachineArgs,
 	parseMachineJson,
@@ -294,6 +296,15 @@ function runLaunch(parsed: ParsedLaunch): number {
 			modelsSeed,
 			settingsSeed,
 		};
+
+		// RESUME family with NO project: resolve the session's recorded cwd from the
+		// host store and cd there, so pi resumes in place (no fork prompt). A given
+		// project is trusted verbatim (pi guards a mismatch); an unresolvable id
+		// leaves the cwd at the projects root (pi decides), so this is pure upside.
+		if (parsed.mode === 'pi' && parsed.project === undefined) {
+			const sessionCwd = resolveSessionCwd(env, machineName, parsed.piArgs);
+			if (sessionCwd !== undefined) intent.sessionCwd = sessionCwd;
+		}
 	} catch (e) {
 		return reportAnonPiError(e);
 	}
@@ -1848,11 +1859,11 @@ function detectProxyViaNetcage(): NetcageDetectProxy | undefined {
  * (`--root <graphroot>`), NOT the operator's default rootless store, so a plain
  * `podman build` would put the image where `netcage run` cannot see it (it would
  * try to pull the `localhost/…` ref and fail). We therefore:
- *   1. PREFER `netcage build` when netcage exposes it (future-proof: netcage owns
- *      its store + graphroot, no path hardcoded here); else
+ *   1. PREFER `netcage build` when netcage exposes it (netcage >= 0.7.1; netcage
+ *      owns its store + graphroot, no path hardcoded here); else
  *   2. `podman build` into the default store, then `podman save | podman --root
- *      <graphroot> load` to copy it into netcage's store (the interim workaround
- *      until netcage ships a build/load verb).
+ *      <graphroot> load` to copy it into netcage's store (the fallback for an
+ *      older netcage without the build/load verbs).
  * Streams output (inherited stdio) so the user sees the build. Returns true on
  * success. The build CONTEXT is the Dockerfile's own directory.
  */
@@ -1901,8 +1912,8 @@ function buildImage(dockerfile: string, tag: string): boolean {
  * Copy a locally-built image (in the default podman store) INTO netcage's
  * private graphroot store, so `netcage run <tag>` finds it without a pull. Uses
  * `podman save <tag> | podman --root <graphroot> load`. Best-effort: on failure
- * it warns (the image still exists in the default store; a future `netcage
- * build`/`load` verb removes this dance). Returns true on success.
+ * it warns (the image still exists in the default store; on netcage >= 0.7.1 the
+ * `netcage build`/`load` verbs remove this dance). Returns true on success.
  */
 function loadImageIntoNetcageStore(tag: string): boolean {
 	const graphroot = resolveNetcageGraphroot(process.env);
@@ -2093,8 +2104,65 @@ function withKeyLabel(netcageArgs: string[], key: string): string[] {
 	return out;
 }
 
+/**
+ * Best-effort: resolve a RESUME-family launch's session cwd from the host
+ * session store, so the CLI can cd there (intent.sessionCwd) and pi resumes in
+ * place instead of prompting to fork. Globs the machine's sessions dir for a
+ * file whose name carries `<id>` (pi names them `<ts>_<id>.jsonl`), reads the
+ * HEADER line, and returns its recorded cwd (pure sessionHeaderCwd). Returns
+ * undefined on any miss (no id, id not found, unreadable, no cwd): the caller
+ * then leaves the cwd at the projects root and lets pi decide, as before. NEVER
+ * throws (a resume must not fail on a store-read hiccup).
+ */
+function resolveSessionCwd(
+	env: AnonPiEnv,
+	machine: string,
+	piArgs: readonly string[] | undefined,
+): string | undefined {
+	const id = resumeSessionId(piArgs);
+	if (id === undefined) return undefined;
+	const sessionsRoot = machineSessionsDir(env, machine);
+	if (!existsSync(sessionsRoot)) return undefined;
+	try {
+		// sessions/<slug>/<ts>_<id>.jsonl: scan each slug dir for a file whose name
+		// contains the id. The id is a UUID (no path/glob metachars), so a substring
+		// match is safe and cheap for the short session lists here.
+		for (const slug of readdirSync(sessionsRoot, {withFileTypes: true})) {
+			if (!slug.isDirectory()) continue;
+			const slugDir = join(sessionsRoot, slug.name);
+			for (const f of readdirSync(slugDir)) {
+				if (!f.endsWith('.jsonl') || !f.includes(id)) continue;
+				const header = firstLine(join(slugDir, f));
+				if (header === undefined) return undefined;
+				return sessionHeaderCwd(header);
+			}
+		}
+	} catch {
+		return undefined;
+	}
+	return undefined;
+}
+
+/** Read a file's FIRST line (up to a newline), or undefined if unreadable. */
+function firstLine(path: string): string | undefined {
+	try {
+		const text = readFileSync(path, 'utf8');
+		const nl = text.indexOf('\n');
+		return nl === -1 ? text : text.slice(0, nl);
+	} catch {
+		return undefined;
+	}
+}
+
 /** Spawn netcage with inherited stdio; propagate its exit code. */
 function spawnNetcage(netcageArgs: string[]): number {
+	// Explain the pause: netcage sets up the jail (netns, firewall, DNS, container
+	// start) BEFORE pi paints, so without this line the user sees only a blinking
+	// cursor. Goes to stderr so it never pollutes any piped stdout, and is
+	// transient (pi typically clears the screen when its TUI comes up).
+	process.stderr.write(
+		'anon-pi: entering the netcage jail (setting up forced-egress)\u2026\n',
+	);
 	const res = spawnSync('netcage', netcageArgs, {stdio: 'inherit'});
 	if (res.error) {
 		process.stderr.write(