@calamity-inc/slave 0.1.1 → 0.3.0

package/README.md

@@ -2,17 +2,16 @@
 
 Vibe coding without the kaboom factor.
 
-## Installation
+## Setup
 
-```
-npm i -g @calamity-inc/slave
-```
+1. Install slave: `npm i -g @calamity-inc/slave`
+2. Create a default profile, e.g. `slave --create-profile default openai gpt-6-luna` or `slave --create-profile default anthropic claude-haiku-5-5`
 
 ## Usage
 
 In any directory:
 ```
-slave [flags] [--] How do I use the 'slave' command?
+slave [options] [--] How do I use the 'slave' command?
 ```
 
 You can also pipe text in:
@@ -20,19 +19,29 @@ You can also pipe text in:
 cat yap.txt | slave Summarize this text
 ```
 
-Flags:
+Options:
 - `-c`, `--cont`, `--continue` — add your previous invocation to the context of this one
+- `-a`, `--amend` — retry the previous invocation, using the context from before it
 - `-w`, `--web` — allow the model to search the web
-- `-n`, `--no-fs`, `--nofs` — disables filesystem access so you can just have a non-binding chat with the model
+- `-n`, `--no-fs`, `--nofs` — disable filesystem access
+- `-s`, `--sandbox` — allow the model to use a docker container
+- `-p`, `--profile` `<name>` — use the specified profile
 
 Single-character flags can be combined, so `slave -cw prompt` is equivalent to `slave -c -w prompt`.
 
-## Sandboxing / Security
+Subcommands:
+- `--create-profile <name> <provider> <model>` — creates a profile
+	- `provider` can be `openai`, `anthropic`, or an OpenAI-compatible base URL like `http://127.0.0.1:1234/v1` for [LM Studio](https://lmstudio.ai/developers).
+- `--delete-profile <name>` — deletes a profile
+- `--update-api-key <provider>` — updates an API Key
+
+## Security
 
-The model gets no command prompt access and limited access to your filesystem:
-- Only within the working directory and subdirectories.
+The model can't run commands on your system; it only gets limited access to your filesystem:
+- Within the working directory and subdirectories.
 - `.git` folder and `.env` file can't be accessed by the model, tho it knows they exist, if they do.
 - Files that are `.gitignore`d can't be written to.
+- You can provide a `.slaveignore` for files that the model should not be allowed to read or write. It will still be able to know of their existence.
 
 However, these restrictions are only as good as your practices; you should:
 - Only run `slave` in Git-tracked folders and be sure that anything you don't want to lose is committed or at least staged so you can always revert any changes made by the model.

package/index.js

@@ -1,48 +1,48 @@
 #!/usr/bin/env node
+
+import { execFileSync, spawnSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { parseEnv } from "node:util";
 import { createInterface } from "node:readline/promises";
+
+import Anthropic from "@anthropic-ai/sdk";
+import { Command } from "commander";
+import envPaths from "env-paths";
 import ignore from "ignore";
 import { marked } from "marked";
 import { markedTerminal } from "marked-terminal";
 import OpenAI from "openai";
 
-const configDir = path.dirname(fileURLToPath(import.meta.url));
-const env = fs.existsSync(path.join(configDir, ".env")) ? parseEnv(fs.readFileSync(path.join(configDir, ".env"), "utf8")) : {};
-if (!env.OPENAI_API_KEY) {
-	if (!process.stdin.isTTY) {
-		console.error(`No OPENAI_API_KEY found. Run this command in a terminal to enter your key, or add it to ${path.join(configDir, ".env")}.`);
-		process.exit(1);
-	}
 
+const configDir = envPaths("slave").data;
+const state = fs.existsSync(path.join(configDir, "state.json")) ? JSON.parse(fs.readFileSync(path.join(configDir, "state.json"), "utf8")) : {};
+state.profiles ??= {};
+state.apiKeys ??= {};
+state.providerStates ??= {};
+const promptForApiKey = async (provider) => {
 	const readline = createInterface({ input: process.stdin, output: process.stdout });
 	try {
-		env.OPENAI_API_KEY = (await readline.question("Enter your OpenAI API key: ")).trim();
+		state.apiKeys[provider] = (await readline.question("Enter your API key: ")).trim();
 	}
 	finally {
 		readline.close();
 	}
-	if (!env.OPENAI_API_KEY) {
-		console.error("An API key is required.");
-		process.exit(1);
-	}
-	console.log();
+};
+const saveState = () => {
+	fs.mkdirSync(configDir, { recursive: true });
+	fs.writeFileSync(path.join(configDir, "state.json"), JSON.stringify(state, null, 2), { encoding: "utf8", mode: 0o600 });
+	fs.chmodSync(path.join(configDir, "state.json"), 0o600);
+};
 
-	fs.writeFileSync(path.join(configDir, ".env"), `OPENAI_API_KEY=${env.OPENAI_API_KEY}`, { encoding: "utf8", mode: 0o600 });
-	fs.chmodSync(path.join(configDir, ".env"), 0o600);
+const slaveignore = ignore();
+if (fs.existsSync(".slaveignore")) {
+	slaveignore.add(fs.readFileSync(".slaveignore", "utf8").replaceAll("/\n", "\n"));
 }
-const client = new OpenAI({
-	apiKey: env.OPENAI_API_KEY,
-});
-
 const gitignore = ignore();
 if (fs.existsSync(".gitignore")) {
 	gitignore.add(fs.readFileSync(".gitignore", "utf8").replaceAll("/\n", "\n"));
 }
-
-const isOutOfReach = (p, type) => {
+const isOutOfReach = (p, accessType) => {
 	const rel = path.relative(".", p);
 	if (rel.startsWith("..") || path.isAbsolute(rel)) {
 		return true;
@@ -51,25 +51,53 @@ const isOutOfReach = (p, type) => {
 	if (segs.includes(".env") || segs.includes(".git")) {
 		return true;
 	}
-	if (type == "write" && rel && gitignore.ignores(rel)) {
+	if (rel && (slaveignore.ignores(rel) || (accessType == "write" && gitignore.ignores(rel)))) {
 		return true;
 	}
 	return false;
 };
 
+const fixPath = (path, accessType) => {
+	if (path.startsWith("/")) {
+		path = path.substring(1);
+		path ||= ".";
+	}
+	return isOutOfReach(path, accessType) ? "" : path;
+};
+
 const readFileForModel = (filePath) => fs.readFileSync(filePath, "utf8").replaceAll("\r\n", "\n");
 const writeFileFromModel = (filePath, data, usesCRLF) => {
-	if (usesCRLF === undefined) {
-		usesCRLF = fs.existsSync(filePath) && fs.readFileSync(filePath, "utf8").includes("\r\n");
+	if (fs.existsSync(filePath)) {
+		if (usesCRLF === undefined) {
+			usesCRLF = fs.readFileSync(filePath, "utf8").includes("\r\n");
+		}
+	}
+	else {
+		fs.mkdirSync(path.dirname(filePath), { recursive: true });
 	}
 	const normalized = data.replaceAll("\r\n", "\n");
 	fs.writeFileSync(filePath, usesCRLF ? normalized.replaceAll("\n", "\r\n") : normalized, "utf8");
 };
 
+let used_docker;
+const ensureSandbox = () => {
+	if (!used_docker) {
+		try {
+			// `docker pull ghcr.io/calamity-inc/slave-sandbox` is not needed to get the image, but would be needed to update it.
+			execFileSync("docker", ["run", "-d", "--name", "slave-sandbox", "ghcr.io/calamity-inc/slave-sandbox", "sleep", "infinity"], { encoding: "utf8" });
+		}
+		catch (e) {
+			// container may already exist if it was not cleaned up previously. this is okay-ish.
+		}
+		used_docker = true;
+	}
+};
+
 const functions = {
 	ls: ({ path }) => {
 		path ??= ".";
-		if (isOutOfReach(path)) {
+		path = fixPath(path);
+		if (!path) {
 			return "Out of your reach";
 		}
 		let files;
@@ -83,7 +111,8 @@ const functions = {
 	},
 	findFiles: ({ path, substring, recursive }) => {
 		path ??= ".";
-		if (isOutOfReach(path)) {
+		path = fixPath(path);
+		if (!path) {
 			return "Out of your reach";
 		}
 		let files;
@@ -111,21 +140,27 @@ const functions = {
 		return res.join("\n");
 	},
 	readFile: ({ path }) => {
-		if (isOutOfReach(path)) {
-			return "Out of your reach";
+		path = fixPath(path);
+		if (!path) {
+			return "You don't have read access to this file";
+		}
+		if (!fs.existsSync(path) || !fs.statSync(path).isFile()) {
+			return "No such file";
 		}
 		return readFileForModel(path);
 	},
 	writeFile: ({ path, data }) => {
-		if (isOutOfReach(path, "write")) {
-			return "Out of your reach";
+		path = fixPath(path, "write");
+		if (!path) {
+			return "You don't have write access to this file";
 		}
 		writeFileFromModel(path, data);
 		return "OK";
 	},
 	fileFindAndReplace: ({ path, substring, replacement, expectedMatches }) => {
-		if (isOutOfReach(path, "write")) {
-			return "Out of your reach";
+		path = fixPath(path, "write");
+		if (!path) {
+			return "You don't have write access to this file";
 		}
 		const fileContent = fs.readFileSync(path, "utf8");
 		const usesCRLF = fileContent.includes("\r\n");
@@ -137,129 +172,235 @@ const functions = {
 		writeFileFromModel(path, arr.join(replacement), usesCRLF);
 		return "OK";
 	},
-	system: ({ command }) => {
+	sandboxExec: ({ command, args }) => {
+		ensureSandbox();
+		const result = spawnSync("docker", [ "exec", "slave-sandbox", command, ...args ], { encoding: "utf8" });
+		const output = (result.stdout ?? "") + (result.stderr ?? "");
+		if (result.error) {
+			return (output || result.error.message).trimEnd();
+		}
+		if (result.status !== 0 && !output) {
+			return `Command exited with status ${result.status}`;
+		}
+		return output;
+	},
+	sandboxCopyIn: ({ hostPath, sbxPath }) => {
+		hostPath = fixPath(hostPath);
+		if (!hostPath) {
+			return "You don't have read access to this file";
+		}
+		if (!fs.existsSync(hostPath) || !fs.statSync(hostPath).isFile()) {
+			return "Host path must point to a file";
+		}
+		ensureSandbox();
+		try {
+			execFileSync("docker", ["cp", "-L", hostPath, `slave-sandbox:${sbxPath}`], { encoding: "utf8" });
+			return "OK";
+		}
+		catch (e) {
+			return (e.stdout ?? e.message).trimEnd();
+		}
+	},
+	sandboxCopyOut: ({ sbxPath, hostPath }) => {
+		hostPath = fixPath(hostPath, "write");
+		if (!hostPath) {
+			return "You don't have write access to this file";
+		}
+		if (fs.existsSync(hostPath) && !fs.statSync(hostPath).isFile()) {
+			return "Host path must point to a file";
+		}
+		ensureSandbox();
+		execFileSync("docker", ["cp", "-L", `slave-sandbox:${sbxPath}`, hostPath], { encoding: "utf8" });
+		return "OK";
+	},
+	/*system: ({ command }) => {
 		//process.exit(1);
 		return "It's interesting that you called this tool! Unfortunately for you, it does nothing.";
-	},
+	}*/
 };
 
-let tools = [
-	{
-		type: "function",
-		name: "ls",
-		description: "Lists files",
-		parameters: {
-			type: "object",
-			properties: {
-				path: { type: ["string", "null"] },
+const tools = [];
+const initTools = (fs, sandbox, web_search) => {
+	if (fs) {
+		tools.push(
+			{
+				type: "function",
+				name: "ls",
+				description: "Lists files",
+				parameters: {
+					type: "object",
+					properties: {
+						path: { type: ["string", "null"] },
+					},
+					required: [ "path" ],
+					additionalProperties: false,
+				},
+				strict: true,
 			},
-			required: [ "path" ],
-			additionalProperties: false,
-		},
-		strict: true,
-	},
-	{
-		type: "function",
-		name: "findFiles",
-		parameters: {
-			type: "object",
-			properties: {
-				path: { type: ["string", "null"] },
-				substring: { type: "string" },
-				recursive: { type: ["boolean", "null"] },
+			{
+				type: "function",
+				name: "findFiles",
+				parameters: {
+					type: "object",
+					properties: {
+						path: { type: ["string", "null"] },
+						substring: { type: "string" },
+						recursive: { type: ["boolean", "null"] },
+					},
+					required: [ "path", "substring", "recursive" ],
+					additionalProperties: false,
+				},
+				strict: true,
 			},
-			required: [ "path", "substring", "recursive" ],
-			additionalProperties: false,
-		},
-		strict: true,
-	},
-	{
-		type: "function",
-		name: "readFile",
-		parameters: {
-			type: "object",
-			properties: {
-				path: { type: "string" },
+			{
+				type: "function",
+				name: "readFile",
+				parameters: {
+					type: "object",
+					properties: {
+						path: { type: "string" },
+					},
+					required: [ "path" ],
+					additionalProperties: false,
+				},
+				strict: true,
 			},
-			required: [ "path" ],
-			additionalProperties: false,
-		},
-		strict: true,
-	},
-	{
-		type: "function",
-		name: "writeFile",
-		parameters: {
-			type: "object",
-			properties: {
-				path: { type: "string" },
-				data: { type: "string" },
+			{
+				type: "function",
+				name: "writeFile",
+				parameters: {
+					type: "object",
+					properties: {
+						path: { type: "string" },
+						data: { type: "string" },
+					},
+					required: [ "path", "data" ],
+					additionalProperties: false,
+				},
+				strict: true,
 			},
-			required: [ "path", "data" ],
-			additionalProperties: false,
-		},
-		strict: true,
-	},
-	{
-		type: "function",
-		name: "fileFindAndReplace",
-		parameters: {
-			type: "object",
-			properties: {
-				path: { type: "string" },
-				substring: { type: "string" },
-				replacement: { type: "string" },
-				expectedMatches: { type: ["number", "null"] },
+			{
+				type: "function",
+				name: "fileFindAndReplace",
+				parameters: {
+					type: "object",
+					properties: {
+						path: { type: "string" },
+						substring: { type: "string" },
+						replacement: { type: "string" },
+						expectedMatches: { type: ["number", "null"] },
+					},
+					required: [ "path", "substring", "replacement", "expectedMatches" ],
+					additionalProperties: false,
+				},
+				strict: true,
 			},
-			required: [ "path", "substring", "replacement", "expectedMatches" ],
-			additionalProperties: false,
-		},
-		strict: true,
-	},
-	// This is useful to see where the model maybe expects a better tool:
-	/*{
-		type: "function",
-		name: "system",
-		parameters: {
-			type: "object",
-			properties: {
-				command: { type: "string" },
+		);
+	}
+	if (sandbox) {
+		tools.push({
+			type: "function",
+			name: "sandboxExec",
+			description: "Runs a command without Bash in an isolated sandbox.",
+			parameters: {
+				type: "object",
+				properties: {
+					command: { type: "string" },
+					args: { type: "array", items: { type: "string" } },
+				},
+				required: [ "command", "args" ],
+				additionalProperties: false,
 			},
-			required: [ "command" ],
-			additionalProperties: false,
-		},
-		strict: true,
-	},*/
-];
-
-const generateResponseOptionallyUsingTools = async (input, previous_response_id) => {
-	const model = "gpt-6-luna";
+			strict: true,
+		});
+		if (fs) {
+			tools.push(
+				{
+					type: "function",
+					name: "sandboxCopyIn",
+					parameters: {
+						type: "object",
+						properties: {
+							hostPath: { type: "string" },
+							sbxPath: { type: "string" },
+						},
+						required: [ "hostPath", "sbxPath" ],
+						additionalProperties: false,
+					},
+					strict: true,
+				},
+				{
+					type: "function",
+					name: "sandboxCopyOut",
+					parameters: {
+						type: "object",
+						properties: {
+							sbxPath: { type: "string" },
+							hostPath: { type: "string" },
+						},
+						required: [ "sbxPath", "hostPath" ],
+						additionalProperties: false,
+					},
+					strict: true,
+				},
+			);
+		}
+	}
+	if (web_search) {
+		tools.push({ type: "web_search" });
+	}
+};
+
+const toolToAnthropic = (t) => {
+	if (t.type == "function") {
+		return {
+			name: t.name,
+			description: t.description,
+			input_schema: {
+				type: t.parameters.type,
+				properties: t.parameters.properties,
+			}
+		};
+	}
+	else if (t.type == "web_search") {
+		return {
+			type: "web_search_20260318",
+			name: "web_search"
+		};
+	}
+};
+
+const useTool = (name, args, argsStr) => {
+	console.log("$ " + name + argsStr);
+	const output = String(functions[name](args));
+	let consoleOutput = output.replaceAll("\r", "<CR>").replaceAll("\n", "<NL>");
+	if (name == "readFile" && consoleOutput.length > 80) {
+		consoleOutput = consoleOutput.substring(0, 77) + "...";
+	}
+	console.log(consoleOutput);
+	return output;
+};
+
+const openai_generateResponseOptionallyUsingTools = async (client, model, input, state) => {
 	let response = await client.responses.create({
 		model,
-		previous_response_id,
+		previous_response_id: state,
 		input,
 		tools,
 	});
 	let used_tools = false;
 
 	while (true) {
-		const toolCalls = response.output.filter((item) => item.type === "function_call");
+		const toolCalls = response.output.filter((item) => item.type == "function_call");
 		if (toolCalls.length == 0) {
 			break;
 		}
 
 		const outputs = toolCalls.map((call) => {
-			console.log("$ " + call.name + call.arguments);
-			const output = String(functions[call.name](JSON.parse(call.arguments)));
-			let consoleOutput = output.replaceAll("\r", "<CR>").replaceAll("\n", "<NL>");
-			if (call.name == "readFile" && consoleOutput.length > 80) {
-				consoleOutput = consoleOutput.substring(0, 77) + "...";
-			}
-			console.log(consoleOutput);
 			return {
 				type: "function_call_output",
 				call_id: call.call_id,
-				output,
+				output: useTool(call.name, JSON.parse(call.arguments), call.arguments)
 			};
 		});
 
@@ -272,62 +413,154 @@ const generateResponseOptionallyUsingTools = async (input, previous_response_id)
 		used_tools = true;
 	}
 
-	response.used_tools = used_tools;
-	return response;
+	return {
+		output_text: response.output_text,
+		state: response.id,
+		used_tools,
+	};
+};
+
+const anthropic_generateResponseOptionallyUsingTools = async (client, model, input, state) => {
+	state = JSON.parse(state || "[]");
+	state.push({ role: "user", content: input });
+	let used_tools = false;
+
+	const anthropicTools = tools.map(t => toolToAnthropic(t));
+
+	let message = await client.messages.create({
+		model,
+		max_tokens: 4096,
+		cache_control: { type: "ephemeral" },
+		messages: state,
+		tools: anthropicTools,
+	});
+	state.push({ role: message.role, content: message.content });
+
+	while (message.stop_reason == "tool_use" || message.stop_reason == "max_tokens" || message.stop_reason == "pause_turn") {
+		const toolCalls = message.content.filter((item) => item.type == "tool_use");
+		if (toolCalls.length) {
+			const outputs = toolCalls.map((call) => {
+				return {
+					type: "tool_result",
+					tool_use_id: call.id,
+					content: useTool(call.name, call.input, JSON.stringify(call.input))
+				};
+			});
+			state.push({ role: "user", content: outputs });
+			used_tools = true;
+		}
+
+		message = await client.messages.create({
+			model,
+			max_tokens: 4096,
+			cache_control: { type: "ephemeral" },
+			messages: state,
+			tools: anthropicTools,
+		});
+		state.push({ role: message.role, content: message.content });
+	}
+
+	//console.log(message);
+	return {
+		output_text: message.content.find((item) => item.type == "text").text,
+		state: JSON.stringify(state),
+		used_tools,
+	};
 };
 
 marked.use(markedTerminal());
 const markdownToConsoleText = (md) => {
 	const _console_error = console.error; // prevent unintended output about unknown languages, e.g. "```env\ndeez\n```\n"
 	console.error = undefined;
-	const text = marked.parse(md);
+	const text = marked.parse(md).trimEnd() + "\n";
 	console.error = _console_error;
 	return text;
 };
 
-let i = 2;
-let previous_response_id;
-const overrides = [];
-const processFlag = (flag) => {
-	if (flag == "-c" || flag == "--cont" || flag == "--continue") {
-		if (fs.existsSync(path.join(configDir, ".state.json"))) {
-			previous_response_id = JSON.parse(fs.readFileSync(path.join(configDir, ".state.json"), "utf8")).previous_response_id;
-		}
-	}
-	else if (flag == "-w" || flag == "--web") {
-		if (!overrides.includes("web search enabled")) {
-			tools.push({ type: "web_search" });
-			overrides.push("web search enabled");
-		}
+
+const program = new Command();
+program
+	.name("slave")
+	.usage("[options] [--] [prompt...]")
+	.description("Vibe coding without the kaboom factor.")
+	.argument("[prompt...]")
+	.option("-c, --continue", "add your previous invocation to the context of this one").option("--cont")
+	.option("-a, --amend", "retry the previous invocation, using the context from before it")
+	.option("-w, --web", "allow the model to search the web")
+	.option("-n, --no-fs", "disable filesystem access").option("--nofs")
+	.option("-s, --sandbox", "allow the model to use a docker container")
+	.option("-p, --profile <name>", "profile name", "default")
+	.option("--create-profile <name> <provider> <model>", "create a profile")
+	.option("--delete-profile <name>", "delete a profile") // TODO
+	.option("--update-api-key <provider>", "update an API key") // TODO
+	.helpOption("-?, --help", "display help")
+	.parse();
+const options = program.opts();
+
+if (options.createProfile) {
+	if (!program.args[0] || !program.args[1]) {
+		console.log("Syntax: slave --create-profile <name> <provider> <model>");
+		process.exit(1);
 	}
-	else if (flag == "-n" || flag == "--no-fs" || flag == "--nofs") {
-		if (!overrides.includes("no filesystem access")) {
-			tools = tools.filter(tool => tool.type != "function");
-			overrides.push("no filesystem access");
-		}
+	const provider = program.args[0];
+	if (provider != "openai" && provider != "anthropic" && !provider.startsWith("http://") && !provider.startsWith("https://")) {
+		console.log(`Invalid provider: ${provider}`);
+		process.exit(1);
 	}
-	else {
-		console.log(`Unknown flag: ${flag}`);
+	const isCreate = !(options.createProfile in state.profiles);
+	state.profiles[options.createProfile] = { provider, model: program.args[1] };
+	if (!state.apiKeys[provider]) {
+		await promptForApiKey(provider);
 	}
-};
-for (; i != process.argv.length; ++i) {
-	const argument = process.argv[i];
-	if (!argument.startsWith("-")) {
-		break;
-	}
-	if (argument == "--") {
-		++i;
-		break;
+	saveState();
+	console.log(`${isCreate ? "Created" : "Updated"} ${options.createProfile} profile.`);
+	process.exit(0);
+}
+if (options.deleteProfile) {
+	delete state.profiles[options.deleteProfile];
+	saveState();
+	console.log(`Deleted ${options.deleteProfile} profile.`);
+	process.exit(0);
+}
+if (options.updateApiKey) {
+	await promptForApiKey(options.updateApiKey);
+	saveState();
+	console.log("Saved.");
+	process.exit(0);
+}
+
+const profile = state.profiles[options.profile];
+if (!profile) {
+	if (options.profile == "default") {
+		console.log(markdownToConsoleText("You did not specify a profile, but a default profile does not exist. Use e.g. `slave --create-profile default openai gpt-6-luna` to create one."));
 	}
-	// Short flags can be combined (for example, -cw is equivalent to -c -w).
-	const flags = argument.startsWith("--") || argument.length <= 2
-		? [argument]
-		: [...argument.slice(1)].map((flag) => `-${flag}`);
-	for (const flag of flags) {
-		processFlag(flag);
+	else {
+		console.log(markdownToConsoleText(`No such profile. Use e.g. \`slave --create-profile ${options.profile} openai gpt-6-luna\` to create it.`));
 	}
+	process.exit(1);
+}
+
+let prompt = program.args.join(" ").trim();
+let previous_provider_state;
+const overrides = [profile.provider.startsWith("http") ? `${profile.model} via ${profile.provider}` : `${profile.provider}/${profile.model}`];
+state.providerStates[profile.provider] ??= {};
+if (options.continue || options.cont) {
+	previous_provider_state = state.providerStates[profile.provider].previous;
+}
+else if (options.amend) {
+	previous_provider_state = state.providerStates[profile.provider].previous_previous;
+}
+const filesystemEnabled = options.fs !== false && !options.nofs;
+initTools(filesystemEnabled, options.sandbox, options.web);
+if (options.web) {
+	overrides.push("web search enabled");
+}
+if (!filesystemEnabled) {
+	overrides.push("no filesystem access");
+}
+if (options.sandbox) {
+	overrides.push("sandbox enabled");
 }
-let prompt = process.argv.slice(i).join(" ").trim();
 let stdinText = "";
 if (!process.stdin.isTTY) {
 	const chunks = [];
@@ -337,22 +570,42 @@ if (!process.stdin.isTTY) {
 	stdinText = Buffer.concat(chunks).toString("utf8");
 }
 if (!prompt) {
-	console.log("Syntax: slave [flags] [--] <prompt>");
+	console.log("No prompt given.");
 	process.exit(1);
 }
 
-console.log((previous_response_id ? "FOLLOW-UP" : "PROMPT") + ": " + prompt);
+console.log((previous_provider_state ? "FOLLOW-UP" : "PROMPT") + ": " + prompt);
 if (stdinText) {
 	overrides.push("stdin provided");
 	prompt = `${stdinText}\n\n${prompt}`;
 }
-if (overrides.length) {
-	console.log(`(${overrides.join(", ")})`);
+console.log(`(${overrides.join(", ")})\n`);
+
+//console.log({ model: profile.model, prompt, previous_provider_state });
+
+const clientOpts = {
+	apiKey: state.apiKeys[profile.provider],
+};
+let response;
+if (profile.provider == "anthropic") {
+	const client = new Anthropic(clientOpts);
+	response = await anthropic_generateResponseOptionallyUsingTools(client, profile.model, prompt, previous_provider_state);
 }
-console.log();
-const response = await generateResponseOptionallyUsingTools(prompt, previous_response_id);
-fs.writeFileSync(path.join(configDir, ".state.json"), JSON.stringify({ previous_response_id: response.id }), "utf8");
+else {
+	if (profile.provider != "openai") {
+		clientOpts.baseURL = profile.provider;
+		clientOpts.apiKey ||= "dummy";
+	}
+	const client = new OpenAI(clientOpts);
+	response = await openai_generateResponseOptionallyUsingTools(client, profile.model, prompt, previous_provider_state);
+}
+state.providerStates[profile.provider].previous_previous = previous_provider_state;
+state.providerStates[profile.provider].previous = response.state;
+saveState();
 if (response.used_tools) {
+	if (used_docker) {
+		execFileSync("docker", ["rm", "-f", "slave-sandbox"], { encoding: "utf8" });
+	}
 	console.log();
 }
-console.log(markdownToConsoleText(response.output_text).trimEnd() + "\n");
+console.log(markdownToConsoleText(response.output_text) + "\n");

package/package.json

@@ -4,12 +4,15 @@
 		"type": "git",
 		"url": "git+https://github.com/calamity-inc/slave.git"
 	},
-	"version": "0.1.1",
+	"version": "0.3.0",
 	"type": "module",
 	"bin": {
-		"slave": "./index.js"
+		"slave": "index.js"
 	},
 	"dependencies": {
+		"@anthropic-ai/sdk": "^1.3.0",
+		"commander": "^15.0.0",
+		"env-paths": "^4.0.0",
 		"ignore": "^7.0.13",
 		"marked": "^12",
 		"marked-terminal": "7.0.0",