piclaw 0.0.19 → 0.0.21

package/.output/server/_chunks/terminal.mjs

@@ -1,6 +1,8 @@
+import { s as config } from "./config.mjs";
 import { t as createLogger } from "./logger.mjs";
+import { t as deviceBus } from "./device-bus.mjs";
+import { accessSync, constants } from "node:fs";
 import crypto from "node:crypto";
-import os from "node:os";
 var _isBun = typeof globalThis.Bun !== "undefined";
 var _isWebContainer = process.env.SHELL === "/bin/jsh" || !!process.versions?.webcontainer;
 async function spawnPty(opts) {
@@ -26,6 +28,7 @@ async function spawnVirtualPty(...args) {
 }
 var logger = createLogger("terminal");
 var MAX_SESSIONS = 20;
+var _ttyId = 0;
 var SESSION_TIMEOUT = 1800 * 1e3;
 var TerminalManager = class {
 	sessions = /* @__PURE__ */ new Map();
@@ -34,21 +37,44 @@ var TerminalManager = class {
 		const id = crypto.randomUUID();
 		const cols = opts?.cols ?? 80;
 		const rows = opts?.rows ?? 24;
-		const cwd = opts?.cwd?.startsWith("~") ? os.homedir() + opts.cwd.slice(1) : opts?.cwd ?? process.cwd();
+		const sandboxMode = config.get("sandbox");
+		const forceSandbox = sandboxMode === "enforced" || sandboxMode === "true";
 		let handle;
-		if (opts?.virtual) handle = await spawnVirtualPty({ cwd });
-		else {
-			const shell = process.env.SHELL || "/bin/bash";
+		let cwd;
+		if (opts?.sandboxId) {
+			handle = await spawnVirtualPty({ sandboxId: opts.sandboxId });
+			const { sandboxManager } = await import("../_libs/_89.mjs");
+			const sb = sandboxManager.get(opts.sandboxId);
+			cwd = sb.env.HOME || sb.cwd;
+		} else if (opts?.sandbox || forceSandbox) {
+			const sbId = `tty${++_ttyId}`;
+			cwd = `/home/${sbId}`;
+			handle = await spawnVirtualPty({ sandboxId: sbId });
+		} else {
+			cwd = opts?.cwd ?? process.cwd();
+			const shell = resolveShell();
 			const env = { TERM: "xterm-256color" };
 			for (const [k, v] of Object.entries(process.env)) if (v !== void 0) env[k] = v;
 			env.TERM = "xterm-256color";
-			handle = await spawnPty({
+			const spawnOpts = {
 				shell,
 				cols,
 				rows,
 				cwd,
 				env
-			});
+			};
+			try {
+				handle = await spawnPty(spawnOpts);
+			} catch (err) {
+				if (err?.code === "ENOENT") {
+					logger.warn({
+						shell,
+						err: err.message
+					}, "PTY spawn ENOENT, retrying");
+					await new Promise((r) => setTimeout(r, 500));
+					handle = await spawnPty(spawnOpts);
+				} else throw err;
+			}
 		}
 		const session = {
 			id,
@@ -58,7 +84,7 @@ var TerminalManager = class {
 			cols,
 			rows,
 			cwd,
-			label: opts?.label ?? "shell",
+			label: opts?.label ?? (opts?.sandbox || opts?.sandboxId || forceSandbox ? "shell (Sandbox)" : "shell"),
 			listeners: /* @__PURE__ */ new Set(),
 			exitListeners: /* @__PURE__ */ new Set(),
 			timeoutTimer: setTimeout(() => this.kill(id), SESSION_TIMEOUT)
@@ -77,6 +103,17 @@ var TerminalManager = class {
 			rows,
 			cwd
 		}, "Terminal session created");
+		deviceBus.emitDeviceEvent("terminal", {
+			action: "created",
+			session: {
+				id,
+				cols,
+				rows,
+				cwd,
+				label: session.label,
+				createdAt: session.createdAt
+			}
+		});
 		return session;
 	}
 	get(id) {
@@ -147,6 +184,10 @@ var TerminalManager = class {
 		session.listeners.clear();
 		this.sessions.delete(id);
 		logger.info({ id }, "Terminal session destroyed");
+		deviceBus.emitDeviceEvent("terminal", {
+			action: "destroyed",
+			sessionId: id
+		});
 	}
 	resetTimeout(session) {
 		clearTimeout(session.timeoutTimer);
@@ -154,4 +195,18 @@ var TerminalManager = class {
 	}
 };
 const terminalManager = new TerminalManager();
+/** Resolve a valid shell path with fallback chain. */
+function resolveShell() {
+	const candidates = [
+		process.env.SHELL,
+		"/bin/zsh",
+		"/bin/bash",
+		"/bin/sh"
+	];
+	for (const sh of candidates) if (sh) try {
+		accessSync(sh, constants.X_OK);
+		return sh;
+	} catch {}
+	return "/bin/sh";
+}
 export { terminalManager as t };

package/.output/server/_chunks/uploads.mjs

@@ -0,0 +1,60 @@
+import { n as GROUPS_DIR } from "./config.mjs";
+import { n as src_default } from "../_libs/mime.mjs";
+import fs from "node:fs";
+import path from "node:path";
+function isImageMimeType(mimeType) {
+	return mimeType.startsWith("image/");
+}
+function getMimeType(filename) {
+	return src_default.getType(filename) || "application/octet-stream";
+}
+/** Resolve the downloads directory for a group */
+function downloadsDir(groupFolder) {
+	return path.join(GROUPS_DIR, groupFolder, "downloads");
+}
+/** Assert that `resolved` is within `parent` to defeat `..` traversal */
+function assertWithinDir(resolved, parent) {
+	fs.mkdirSync(parent, { recursive: true });
+	const realParent = fs.realpathSync(parent);
+	const real = fs.existsSync(resolved) ? fs.realpathSync(resolved) : path.resolve(resolved);
+	if (!real.startsWith(realParent + path.sep) && real !== realParent) throw new Error("Path traversal denied");
+	return real;
+}
+/** Save an attachment to disk under `<group_dir>/downloads/<msgId>/<name>` */
+function saveAttachment(groupFolder, messageId, attachment) {
+	const groupDir = downloadsDir(groupFolder);
+	const dir = path.join(groupDir, messageId);
+	fs.mkdirSync(dir, { recursive: true });
+	const filePath = path.join(dir, path.basename(attachment.name));
+	assertWithinDir(filePath, groupDir);
+	fs.writeFileSync(filePath, Buffer.from(attachment.data, "base64"));
+	return {
+		path: `${groupFolder}/${messageId}/${path.basename(attachment.name)}`,
+		mimeType: attachment.mimeType,
+		name: path.basename(attachment.name)
+	};
+}
+/** Read an attachment file as base64 */
+function readAttachmentBase64(groupFolder, attachment) {
+	const groupDir = downloadsDir(groupFolder);
+	const filePath = path.join(groupDir, attachment.path.slice(groupFolder.length + 1));
+	assertWithinDir(filePath, groupDir);
+	if (!fs.existsSync(filePath)) throw new Error(`Attachment not found: ${attachment.path}`);
+	return fs.readFileSync(filePath).toString("base64");
+}
+/** Get the absolute path for an attachment (for serving) */
+function getAttachmentPath(relPath) {
+	const parts = relPath.split("/");
+	if (parts.length < 3) return void 0;
+	const groupFolder = parts[0];
+	const groupDir = path.join(GROUPS_DIR, groupFolder, "downloads");
+	const filePath = path.join(groupDir, parts.slice(1).join("/"));
+	if (!fs.existsSync(filePath)) return void 0;
+	try {
+		assertWithinDir(filePath, groupDir);
+	} catch {
+		return;
+	}
+	return filePath;
+}
+export { saveAttachment as a, readAttachmentBase64 as i, getMimeType as n, isImageMimeType as r, getAttachmentPath as t };

package/.output/server/_chunks/virtual.mjs

@@ -1,43 +1,123 @@
 async function spawnVirtualPty(opts) {
-	const { Bash } = await import("../_libs/_99.mjs");
+	const { sandboxManager } = await import("../_libs/_89.mjs");
 	const dataListeners = /* @__PURE__ */ new Set();
 	const exitListeners = /* @__PURE__ */ new Set();
-	let cwd = opts.cwd || "/";
-	let env = {
-		HOME: "/home/user",
-		PATH: "/usr/bin:/bin",
-		...opts.env
-	};
+	let sandbox;
+	if (opts.sandboxId) sandbox = sandboxManager.get(opts.sandboxId);
+	else {
+		const standaloneId = `tty${Date.now()}`;
+		sandbox = sandboxManager.get(standaloneId, {
+			cwd: opts.cwd || "/",
+			files: opts.files
+		});
+		if (opts.env) Object.assign(sandbox.env, opts.env);
+	}
 	let line = "";
+	let cursor = 0;
 	let alive = true;
 	let busy = false;
 	let pending = "";
-	const bash = new Bash({
-		cwd,
-		env,
-		files: opts.files
-	});
 	function emit(data) {
 		for (const cb of dataListeners) cb(data);
 	}
 	function prompt() {
-		const home = env.HOME || "";
+		const home = sandbox.env.HOME || "";
+		const cwd = sandbox.cwd;
 		emit(`\x1b[1;32m${home && cwd.startsWith(home) ? "~" + cwd.slice(home.length) : cwd}\x1b[0m $ `);
 	}
+	/** Redraw the line from the current cursor position (used after insertions/deletions). */
+	function redrawLine() {
+		const after = line.slice(cursor);
+		emit("\x1B[K" + after);
+		if (after.length > 0) emit(`\x1b[${after.length}D`);
+	}
+	/** Erase entire input line from terminal, reset cursor to prompt end. */
+	function clearLine() {
+		if (cursor < line.length) emit(`\x1b[${line.length - cursor}C`);
+		if (line.length > 0) emit("\b \b".repeat(line.length));
+	}
+	async function handleTab() {
+		const before = line.slice(0, cursor);
+		const wordStart = Math.max(before.lastIndexOf(" ") + 1, 0);
+		const word = before.slice(wordStart);
+		const cwd = sandbox.env.PWD || sandbox.cwd;
+		let dir;
+		let prefix;
+		if (word.includes("/")) {
+			const lastSlash = word.lastIndexOf("/");
+			const dirPart = word.slice(0, lastSlash) || "/";
+			dir = dirPart.startsWith("/") ? dirPart : sandbox.fs.resolvePath(cwd, dirPart);
+			prefix = word.slice(lastSlash + 1);
+		} else {
+			dir = cwd;
+			prefix = word;
+		}
+		let entries;
+		try {
+			if (sandbox.fs.readdirWithFileTypes) entries = await sandbox.fs.readdirWithFileTypes(dir);
+			else {
+				const names = await sandbox.fs.readdir(dir);
+				entries = await Promise.all(names.map(async (n) => {
+					return {
+						name: n,
+						isDirectory: (await sandbox.fs.stat(sandbox.fs.resolvePath(dir, n))).isDirectory
+					};
+				}));
+			}
+		} catch {
+			emit("\x07");
+			return;
+		}
+		const matches = entries.filter((e) => e.name.startsWith(prefix));
+		if (matches.length === 0) {
+			emit("\x07");
+			return;
+		}
+		if (matches.length === 1) {
+			const m = matches[0];
+			const suffix = m.name.slice(prefix.length) + (m.isDirectory ? "/" : " ");
+			line = line.slice(0, cursor) + suffix + line.slice(cursor);
+			cursor += suffix.length;
+			emit(suffix);
+			redrawLine();
+			return;
+		}
+		let common = matches[0].name;
+		for (let i = 1; i < matches.length; i++) while (!matches[i].name.startsWith(common)) common = common.slice(0, -1);
+		const extra = common.slice(prefix.length);
+		if (extra) {
+			line = line.slice(0, cursor) + extra + line.slice(cursor);
+			cursor += extra.length;
+			emit(extra);
+			redrawLine();
+		} else {
+			emit("\r\n" + matches.map((m) => m.name + (m.isDirectory ? "/" : "")).join("  ") + "\r\n");
+			prompt();
+			emit(line);
+			if (cursor < line.length) emit(`\x1b[${line.length - cursor}D`);
+		}
+	}
+	function exit() {
+		if (!alive) return;
+		alive = false;
+		emit("\r\nexit\r\n");
+		for (const cb of exitListeners) cb();
+		dataListeners.clear();
+		exitListeners.clear();
+	}
 	async function exec(command) {
 		const trimmed = command.trim();
 		if (!trimmed) {
 			prompt();
 			return;
 		}
+		if (trimmed === "exit" || trimmed.startsWith("exit ")) {
+			exit();
+			return;
+		}
 		busy = true;
 		try {
-			const result = await bash.exec(trimmed, {
-				cwd,
-				env
-			});
-			if (result.env.PWD) cwd = result.env.PWD;
-			for (const [k, v] of Object.entries(result.env)) env[k] = v;
+			const result = await sandbox.exec(trimmed);
 			if (result.stdout) {
 				const out = result.stdout.endsWith("\n") ? result.stdout.slice(0, -1) : result.stdout;
 				if (out) emit(out.replaceAll("\n", "\r\n") + "\r\n");
@@ -66,45 +146,103 @@ async function spawnVirtualPty(opts) {
 				pending += data;
 				return;
 			}
-			for (const ch of data) switch (ch) {
-				case "\r":
-				case "\n": {
-					emit("\r\n");
-					const cmd = line;
-					line = "";
-					exec(cmd);
-					break;
+			let i = 0;
+			while (i < data.length) {
+				const ch = data[i];
+				if (ch === "\x1B" && data[i + 1] === "[") {
+					const code = data[i + 2];
+					if (code === "C") {
+						if (cursor < line.length) {
+							cursor++;
+							emit("\x1B[C");
+						}
+						i += 3;
+						continue;
+					}
+					if (code === "D") {
+						if (cursor > 0) {
+							cursor--;
+							emit("\x1B[D");
+						}
+						i += 3;
+						continue;
+					}
+					i += 3;
+					continue;
 				}
-				case "":
-				case "\b":
-					if (line.length > 0) {
-						line = line.slice(0, -1);
-						emit("\b \b");
+				switch (ch) {
+					case "\r":
+					case "\n": {
+						emit("\r\n");
+						const cmd = line;
+						line = "";
+						cursor = 0;
+						exec(cmd);
+						break;
 					}
-					break;
-				case "":
-					line = "";
-					emit("^C\r\n");
-					prompt();
-					break;
-				case "":
-					if (line.length === 0) {
-						alive = false;
-						emit("\r\nexit\r\n");
-						for (const cb of exitListeners) cb();
-						dataListeners.clear();
-						exitListeners.clear();
+					case "":
+					case "\b":
+						if (cursor > 0) {
+							line = line.slice(0, cursor - 1) + line.slice(cursor);
+							cursor--;
+							emit("\b");
+							redrawLine();
+						}
+						break;
+					case "	":
+						handleTab();
+						break;
+					case "
":
+						if (cursor > 0) {
+							emit(`\x1b[${cursor}D`);
+							cursor = 0;
+						}
+						break;
+					case "":
+						if (cursor < line.length) {
+							emit(`\x1b[${line.length - cursor}C`);
+							cursor = line.length;
+						}
+						break;
+					case "\v":
+						if (cursor < line.length) {
+							line = line.slice(0, cursor);
+							emit("\x1B[K");
+						}
+						break;
+					case "":
+						if (cursor > 0) {
+							clearLine();
+							line = line.slice(cursor);
+							cursor = 0;
+							prompt();
+							emit(line);
+							if (cursor < line.length) emit(`\x1b[${line.length - cursor}D`);
+						}
+						break;
+					case "":
+						line = "";
+						cursor = 0;
+						emit("^C\r\n");
+						prompt();
+						break;
+					case "":
+						if (line.length === 0) exit();
+						break;
+					case "\f":
+						emit("\x1B[2J\x1B[H");
+						prompt();
+						emit(line);
+						if (cursor < line.length) emit(`\x1b[${line.length - cursor}D`);
+						break;
+					default: if (ch >= " ") {
+						line = line.slice(0, cursor) + ch + line.slice(cursor);
+						cursor++;
+						emit(ch);
+						redrawLine();
 					}
-					break;
-				case "\f":
-					emit("\x1B[2J\x1B[H");
-					prompt();
-					emit(line);
-					break;
-				default: if (ch >= " " || ch === "	") {
-					line += ch;
-					emit(ch);
 				}
+				i++;
 			}
 		},
 		resize() {},

package/.output/server/_id_.delete.mjs

@@ -1,8 +1,11 @@
 import { a as defineHandler, l as getRouterParam } from "./_libs/h3+rou3+srvx.mjs";
-import { t as terminalManager } from "./_chunks/terminal.mjs";
+import { t as deviceBus } from "./_chunks/device-bus.mjs";
+import { t as sandboxManager } from "./_chunks/sandbox.mjs";
 var _id__delete_default = defineHandler((event) => {
 	const id = getRouterParam(event, "id");
-	terminalManager.kill(id);
+	if (!id) return { error: "missing id" };
+	if (!sandboxManager.destroy(id)) return { error: "sandbox not found" };
+	deviceBus.emitDeviceEvent("sandbox");
 	return { ok: true };
 });
 export { _id__delete_default as default };

package/.output/server/_id_.patch.mjs

@@ -1,6 +1,7 @@
 import { t as createLogger } from "./_chunks/logger.mjs";
 import { E as updateTask } from "./_chunks/db.mjs";
 import { a as defineHandler, l as getRouterParam } from "./_libs/h3+rou3+srvx.mjs";
+import { t as deviceBus } from "./_chunks/device-bus.mjs";
 var logger = createLogger("api:tasks");
 var _id__patch_default = defineHandler(async (event) => {
 	const id = decodeURIComponent(getRouterParam(event, "id"));
@@ -15,6 +16,7 @@ var _id__patch_default = defineHandler(async (event) => {
 	const fields = {};
 	for (const key of allowed) if (key in body) fields[key] = body[key];
 	await updateTask(id, fields);
+	deviceBus.emitDeviceEvent("tasks");
 	logger.info({
 		taskId: id,
 		fields

package/.output/server/_id_2.delete.mjs

@@ -0,0 +1,8 @@
+import { a as defineHandler, l as getRouterParam } from "./_libs/h3+rou3+srvx.mjs";
+import { t as terminalManager } from "./_chunks/terminal.mjs";
+var _id__delete_default = defineHandler((event) => {
+	const id = getRouterParam(event, "id");
+	terminalManager.kill(id);
+	return { ok: true };
+});
+export { _id__delete_default as default };

package/.output/server/_jid_.delete.mjs

@@ -1,10 +1,13 @@
-import "./_libs/@aws-sdk/client-bedrock-runtime+[...].mjs";
 import { a as defineHandler, l as getRouterParam } from "./_libs/h3+rou3+srvx.mjs";
-import "./_libs/@mariozechner/pi-agent-core+[...].mjs";
 import { t as server } from "./_chunks/server.mjs";
+import "./_libs/@mariozechner/pi-agent-core+[...].mjs";
+import { t as deviceBus } from "./_chunks/device-bus.mjs";
 var _jid__delete_default = defineHandler(async (event) => {
 	const jid = decodeURIComponent(getRouterParam(event, "jid"));
 	await server.cleanupChat(jid);
+	deviceBus.emitDeviceEvent("groups");
+	deviceBus.emitDeviceEvent("chats");
+	deviceBus.emitDeviceEvent("tasks");
 	return { ok: true };
 });
 export { _jid__delete_default as default };

package/.output/server/_jid_.patch.mjs

@@ -1,15 +1,18 @@
+import { s as config } from "./_chunks/config.mjs";
 import { t as createLogger } from "./_chunks/logger.mjs";
-import "./_libs/@aws-sdk/client-bedrock-runtime+[...].mjs";
 import { a as defineHandler, l as getRouterParam, n as HTTPError } from "./_libs/h3+rou3+srvx.mjs";
-import "./_libs/@mariozechner/pi-agent-core+[...].mjs";
 import { t as server } from "./_chunks/server.mjs";
+import "./_libs/@mariozechner/pi-agent-core+[...].mjs";
+import { t as deviceBus } from "./_chunks/device-bus.mjs";
 var logger = createLogger("api:groups");
 var UPDATABLE_FIELDS = [
 	"name",
 	"trigger",
 	"requiresTrigger",
 	"model",
-	"thinkingLevel"
+	"thinkingLevel",
+	"soul",
+	"sandbox"
 ];
 var VALID_THINKING_LEVELS = [
 	"off",
@@ -27,6 +30,8 @@ var _jid__patch_default = defineHandler(async (event) => {
 	for (const key of Object.keys(body)) if (!UPDATABLE_FIELDS.includes(key)) throw new HTTPError(`Unknown field: ${key}`, { status: 400 });
 	const changes = [];
 	const oldModel = group.model;
+	const oldSoul = group.soul;
+	const oldSandbox = group.sandbox;
 	if ("name" in body) {
 		const val = body.name;
 		if (typeof val !== "string" || val.length < 1 || val.length > 64) throw new HTTPError("name must be a string (1-64 chars)", { status: 400 });
@@ -65,6 +70,18 @@ var _jid__patch_default = defineHandler(async (event) => {
 		}
 		group.thinkingLevel = val === null || val === "off" ? void 0 : val;
 	}
+	if ("soul" in body) {
+		const val = body.soul;
+		if (val !== null && val !== void 0 && typeof val !== "string") throw new HTTPError("soul must be a string or null", { status: 400 });
+		if (typeof val === "string" && val.length > 1e3) throw new HTTPError("soul must be at most 1000 characters", { status: 400 });
+		group.soul = val ? String(val) : void 0;
+	}
+	if ("sandbox" in body) {
+		if (config.get("sandbox") === "enforced") throw new HTTPError("sandbox is globally enforced and cannot be changed per-group", { status: 400 });
+		const val = body.sandbox;
+		if (typeof val !== "boolean" && val !== void 0 && val !== null) throw new HTTPError("sandbox must be a boolean or null", { status: 400 });
+		group.sandbox = val === true ? true : void 0;
+	}
 	await server.setRegisteredGroup(jid, group);
 	if (oldModel !== group.model) {
 		server.pi.kill(jid);
@@ -86,6 +103,19 @@ var _jid__patch_default = defineHandler(async (event) => {
 			newThinkingLevel: group.thinkingLevel
 		}, "Thinking level changed, session killed");
 	}
+	if (oldSoul !== group.soul) {
+		server.pi.kill(jid);
+		changes.push(group.soul ? "soul updated" : "soul cleared");
+		logger.info({ jid }, "Soul changed, session killed");
+	}
+	if (oldSandbox !== group.sandbox) {
+		server.pi.kill(jid);
+		changes.push(`sandbox → ${group.sandbox ? "on" : "off"}`);
+		logger.info({
+			jid,
+			sandbox: !!group.sandbox
+		}, "Sandbox changed, session killed");
+	}
 	if (changes.length > 0) {
 		await server.sendBotMessage(jid, `Config updated: ${changes.join(", ")}`);
 		logger.info({
@@ -93,11 +123,14 @@ var _jid__patch_default = defineHandler(async (event) => {
 			changes
 		}, "Group config updated");
 	}
+	deviceBus.emitDeviceEvent("groups");
+	const enforced = config.get("sandbox") === "enforced";
 	return {
 		ok: true,
 		group: {
 			jid,
-			...group
+			...group,
+			...enforced ? { sandbox: "enforced" } : {}
 		}
 	};
 });

package/.output/server/_jid_2.delete.mjs

@@ -1,10 +1,13 @@
-import "./_libs/@aws-sdk/client-bedrock-runtime+[...].mjs";
 import { a as defineHandler, l as getRouterParam } from "./_libs/h3+rou3+srvx.mjs";
-import "./_libs/@mariozechner/pi-agent-core+[...].mjs";
 import { t as server } from "./_chunks/server.mjs";
+import "./_libs/@mariozechner/pi-agent-core+[...].mjs";
+import { t as deviceBus } from "./_chunks/device-bus.mjs";
 var _jid__delete_default = defineHandler(async (event) => {
 	const jid = decodeURIComponent(getRouterParam(event, "jid"));
 	await server.cleanupChat(jid);
+	deviceBus.emitDeviceEvent("groups");
+	deviceBus.emitDeviceEvent("chats");
+	deviceBus.emitDeviceEvent("tasks");
 	return { ok: true };
 });
 export { _jid__delete_default as default };