anon-pi 0.1.1 → 0.3.0

package/src/cli.ts

@@ -1,12 +1,27 @@
 #!/usr/bin/env node
-// anon-pi CLI: resolve the run plan (pure), do the one filesystem side-effect
-// (seed the session config if absent), then exec `netcage run ...` with inherited
-// stdio so the interactive pi session (-it) passes through the terminal cleanly.
+// anon-pi CLI. Two commands:
+//   anon-pi [WORKDIR]   resolve the run plan (pure) and exec `netcage run ...`
+//                       with inherited stdio (so -it is a real interactive TTY).
+//                       The seed models.json is mounted read-only and copied
+//                       into the container's ~/.pi/agent by the run command, so
+//                       it layers onto the image's config (extensions survive).
+//   anon-pi import      generate the seed models.json from the host models.json,
+//                       carrying only the provider that serves ANON_PI_LLM.
 
-import {cpSync, existsSync, mkdirSync} from 'node:fs';
+import {existsSync, mkdirSync, readFileSync, writeFileSync} from 'node:fs';
 import {spawnSync} from 'node:child_process';
-import {dirname} from 'node:path';
-import {AnonPiError, buildRunPlan, envFromProcess, HELP} from './anon-pi.js';
+import {join} from 'node:path';
+import {
+	AnonPiError,
+	buildRunPlan,
+	envFromProcess,
+	HELP,
+	MODELS_FILE,
+	pickProviderForLlm,
+	resolveConfigSeed,
+	resolveSourceModelsPath,
+	type PiModelsFile,
+} from './anon-pi.js';
 
 function main(argv: string[]): number {
 	const args = argv.slice(2);
@@ -16,11 +31,23 @@ function main(argv: string[]): number {
 		return 0;
 	}
 
-	// The only positional is the optional workdir. Reject stray flags so a typo
-	// (e.g. --allow-direct) is not silently swallowed: anon-pi owns the netcage
-	// argv, extra flags are not passed through.
+	// Subcommand dispatch: the first bare token may be `import`.
+	if (args[0] === 'import') {
+		return runImport(args.slice(1));
+	}
+
+	return runLaunch(args);
+}
+
+// --- anon-pi [WORKDIR] : launch pi jailed -----------------------------------
+function runLaunch(args: string[]): number {
+	// One optional positional (the workdir) + the --ephemeral flag. Reject other
+	// flags so a typo is not silently swallowed: anon-pi owns the netcage argv.
+	const ephemeralFlag = args.includes('--ephemeral') || args.includes('--eph');
 	const positionals = args.filter((a) => !a.startsWith('-'));
-	const flags = args.filter((a) => a.startsWith('-'));
+	const flags = args.filter(
+		(a) => a.startsWith('-') && a !== '--ephemeral' && a !== '--eph',
+	);
 	if (flags.length > 0) {
 		process.stderr.write(
 			`anon-pi: unknown option(s): ${flags.join(' ')}\nRun \`anon-pi --help\`.\n`,
@@ -35,6 +62,7 @@ function main(argv: string[]): number {
 	}
 
 	const env = envFromProcess(process.env);
+	if (ephemeralFlag) env.ephemeral = true;
 
 	let plan;
 	try {
@@ -56,19 +84,23 @@ function main(argv: string[]): number {
 		return 1;
 	}
 
-	// The one side-effect: seed the per-session config from the canonical seed the
-	// FIRST time this workdir is used. Reuse-if-present, seed-if-absent.
-	if (plan.needsSeed) {
-		mkdirSync(dirname(plan.sessionAgentDir), {recursive: true});
-		cpSync(plan.configSeed, plan.sessionAgentDir, {recursive: true});
+	mkdirSync(plan.workdir, {recursive: true});
+	if (env.ephemeral) {
+		// No host state dir: pi writes to the container's own --rm layer, so the
+		// session leaves NO trace on the host and there is nothing to clean up.
 		process.stderr.write(
-			`anon-pi: seeded session config -> ${plan.sessionAgentDir}\n`,
+			'anon-pi: ephemeral session (nothing persisted; no host state)\n',
 		);
+	} else {
+		// Persistent mode: create the per-workdir state home to mount.
+		mkdirSync(plan.stateDir, {recursive: true});
+		if (plan.fresh) {
+			process.stderr.write(
+				`anon-pi: new session home ${plan.stateDir} (seeding on first launch)\n`,
+			);
+		}
 	}
 
-	// Ensure the workdir exists (a fresh named folder is fine).
-	mkdirSync(plan.workdir, {recursive: true});
-
 	// Hand off to netcage with inherited stdio so -it is a real interactive TTY.
 	const res = spawnSync('netcage', plan.netcageArgs, {stdio: 'inherit'});
 	if (res.error) {
@@ -81,6 +113,84 @@ function main(argv: string[]): number {
 	return res.status ?? 1;
 }
 
+// --- anon-pi import : write the seed models.json ----------------------------
+function runImport(args: string[]): number {
+	const force = args.includes('--force') || args.includes('-f');
+	const stray = args.filter(
+		(a) => a.startsWith('-') && a !== '--force' && a !== '-f',
+	);
+	if (stray.length > 0) {
+		process.stderr.write(
+			`anon-pi import: unknown option(s): ${stray.join(' ')}\nRun \`anon-pi --help\`.\n`,
+		);
+		return 2;
+	}
+
+	const env = envFromProcess(process.env);
+
+	if (!env.llmDirect || env.llmDirect.trim() === '') {
+		process.stderr.write(
+			'anon-pi import: set ANON_PI_LLM to the RFC1918/link-local IP[:port] of the local\n' +
+				'model whose provider should be imported (e.g. ANON_PI_LLM=192.168.1.150:8080).\n',
+		);
+		return 1;
+	}
+
+	const source = resolveSourceModelsPath(env);
+	if (!existsSync(source)) {
+		process.stderr.write(
+			`anon-pi import: host models.json not found at ${source}.\n` +
+				'Set ANON_PI_SOURCE_MODELS to your pi models.json, or run pi once to create it.\n',
+		);
+		return 1;
+	}
+
+	let hostModels: PiModelsFile;
+	try {
+		hostModels = JSON.parse(readFileSync(source, 'utf8')) as PiModelsFile;
+	} catch (e) {
+		process.stderr.write(
+			`anon-pi import: could not parse ${source}: ${(e as Error).message}\n`,
+		);
+		return 1;
+	}
+
+	let result;
+	try {
+		result = pickProviderForLlm(hostModels, env.llmDirect);
+	} catch (e) {
+		if (e instanceof AnonPiError) {
+			process.stderr.write(e.message + '\n');
+			return 1;
+		}
+		throw e;
+	}
+
+	const seedDir = resolveConfigSeed(env);
+	const dest = join(seedDir, MODELS_FILE);
+	if (existsSync(dest) && !force) {
+		process.stderr.write(
+			`anon-pi import: ${dest} already exists. Re-run with --force to overwrite.\n`,
+		);
+		return 1;
+	}
+
+	if (result.apiKeyLooksReal) {
+		process.stderr.write(
+			`anon-pi import: WARNING: provider "${result.name}" carries a real-looking apiKey; it\n` +
+				'will be written into the seed. For a local model this is usually fine, but review\n' +
+				`${dest} if that key identifies you.\n`,
+		);
+	}
+
+	mkdirSync(seedDir, {recursive: true});
+	writeFileSync(dest, JSON.stringify(result.models, null, 2) + '\n');
+	process.stderr.write(
+		`anon-pi import: wrote ${dest} (provider "${result.name}"). Run \`anon-pi\` to launch.\n`,
+	);
+	return 0;
+}
+
 function hasNetcage(): boolean {
 	const which = spawnSync(
 		process.platform === 'win32' ? 'where' : 'command',