@calamity-inc/slave 0.2.0 → 0.3.0

package/README.md

@@ -5,7 +5,7 @@ Vibe coding without the kaboom factor.
 ## Setup
 
 1. Install slave: `npm i -g @calamity-inc/slave`
-2. Create a default profile, e.g. `slave --create-profile default openai gpt-6-luna`
+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
 
@@ -21,23 +21,24 @@ cat yap.txt | slave Summarize this text
 
 Options:
 - `-c`, `--cont`, `--continue` — add your previous invocation to the context of this one
-- `--amend` — retry the previous invocation, using the context from before it
+- `-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` — disable filesystem access
-- `-p, --profile <name>` — use the specified profile
+- `-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`.
 
 Subcommands:
 - `--create-profile <name> <provider> <model>` — creates a profile
-	- `provider` can be `openai` or an OpenAI-compatible base URL, e.g. `http://127.0.0.1:1234/v1` for [LM Studio](https://lmstudio.ai/developers).
+	- `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
 
-## Sandboxing / Security
+## 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.

package/index.js

@@ -1,25 +1,24 @@
 #!/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 ignore from "ignore";
+
+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 state = fs.existsSync(path.join(configDir, ".state.json")) ? JSON.parse(fs.readFileSync(path.join(configDir, ".state.json"), "utf8")) : {};
+
+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 ??= {};
-if (!state.apiKeys.openai && fs.existsSync(path.join(configDir, ".env"))) {
-	const env = parseEnv(fs.readFileSync(path.join(configDir, ".env"), "utf8"));
-	if (env.OPENAI_API_KEY) {
-		state.apiKeys.openai = env.OPENAI_API_KEY;
-	}
-}
+state.providerStates ??= {};
 const promptForApiKey = async (provider) => {
 	const readline = createInterface({ input: process.stdin, output: process.stdout });
 	try {
@@ -30,8 +29,9 @@ const promptForApiKey = async (provider) => {
 	}
 };
 const saveState = () => {
-	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.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);
 };
 
 const slaveignore = ignore();
@@ -42,7 +42,7 @@ 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,12 +51,20 @@ const isOutOfReach = (p, type) => {
 	if (segs.includes(".env") || segs.includes(".git")) {
 		return true;
 	}
-	if (rel && (slaveignore.ignores(rel) || (type == "write" && 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 (fs.existsSync(filePath)) {
@@ -71,10 +79,25 @@ const writeFileFromModel = (filePath, data, usesCRLF) => {
 	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;
@@ -88,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;
@@ -116,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");
@@ -142,128 +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 (client, model, input, previous_response_id) => {
+			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)
 			};
 		});
 
@@ -276,8 +413,59 @@ const generateResponseOptionallyUsingTools = async (client, model, input, previo
 		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());
@@ -297,9 +485,10 @@ program
 	.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("--amend", "retry the previous invocation, using the context from before it")
+	.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
@@ -314,7 +503,7 @@ if (options.createProfile) {
 		process.exit(1);
 	}
 	const provider = program.args[0];
-	if (provider != "openai" && !provider.startsWith("http://") && !provider.startsWith("https://")) {
+	if (provider != "openai" && provider != "anthropic" && !provider.startsWith("http://") && !provider.startsWith("https://")) {
 		console.log(`Invalid provider: ${provider}`);
 		process.exit(1);
 	}
@@ -352,22 +541,26 @@ if (!profile) {
 }
 
 let prompt = program.args.join(" ").trim();
-let previous_response_id;
+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_response_id = state.previous_response_id;
+	previous_provider_state = state.providerStates[profile.provider].previous;
 }
 else if (options.amend) {
-	previous_response_id = state.previous_previous_response_id;
+	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) {
-	tools.push({ type: "web_search" });
 	overrides.push("web search enabled");
 }
-if (options.fs == false || options.nofs) {
-	tools = tools.filter(tool => tool.type != "function");
+if (!filesystemEnabled) {
 	overrides.push("no filesystem access");
 }
+if (options.sandbox) {
+	overrides.push("sandbox enabled");
+}
 let stdinText = "";
 if (!process.stdin.isTTY) {
 	const chunks = [];
@@ -381,28 +574,38 @@ if (!prompt) {
 	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}`;
 }
 console.log(`(${overrides.join(", ")})\n`);
 
-//console.log({ model: profile.model, prompt, previous_response_id });
+//console.log({ model: profile.model, prompt, previous_provider_state });
 
 const clientOpts = {
 	apiKey: state.apiKeys[profile.provider],
 };
-if (profile.provider != "openai") {
-	clientOpts.baseURL = profile.provider;
-	clientOpts.apiKey ||= "dummy";
+let response;
+if (profile.provider == "anthropic") {
+	const client = new Anthropic(clientOpts);
+	response = await anthropic_generateResponseOptionallyUsingTools(client, profile.model, prompt, previous_provider_state);
+}
+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);
 }
-const client = new OpenAI(clientOpts);
-const response = await generateResponseOptionallyUsingTools(client, profile.model, prompt, previous_response_id);
-state.previous_previous_response_id = previous_response_id;
-state.previous_response_id = response.id;
+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) + "\n");

package/package.json

@@ -4,13 +4,15 @@
 		"type": "git",
 		"url": "git+https://github.com/calamity-inc/slave.git"
 	},
-	"version": "0.2.0",
+	"version": "0.3.0",
 	"type": "module",
 	"bin": {
 		"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",

package/.slaveignore

@@ -1 +0,0 @@
-.state.json