claude-yes 1.84.0 → 1.86.0

package/dist/{SUPPORTED_CLIS-DM0fJTMR.js → SUPPORTED_CLIS-5njwpFxr.js}

@@ -1,6 +1,6 @@
-import { t as CLIS_CONFIG } from "./ts-Bw6gQKyU.js";
+import { t as CLIS_CONFIG } from "./ts-DVlEOYHB.js";
 import "./logger-B9h0djqx.js";
-import "./versionChecker-CspuhOwO.js";
+import "./versionChecker-XivGWuhd.js";
 import "./pidStore-C1JXxoPi.js";
 import "./globalPidIndex-Cr-g75QF.js";
 
@@ -9,4 +9,4 @@ const SUPPORTED_CLIS = Object.keys(CLIS_CONFIG);
 
 //#endregion
 export { SUPPORTED_CLIS };
-//# sourceMappingURL=SUPPORTED_CLIS-DM0fJTMR.js.map
+//# sourceMappingURL=SUPPORTED_CLIS-5njwpFxr.js.map

package/dist/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env bun
 import { n as logger } from "./logger-B9h0djqx.js";
-import { i as versionString, n as displayVersion, r as getInstalledPackage, t as checkAndAutoUpdate } from "./versionChecker-CspuhOwO.js";
+import { i as versionString, n as displayVersion, r as getInstalledPackage, t as checkAndAutoUpdate } from "./versionChecker-XivGWuhd.js";
 import { argv } from "process";
 import { execFileSync, spawn } from "child_process";
 import ms from "ms";
@@ -480,7 +480,7 @@ function buildRustArgs(argv, cliFromScript, supportedClis) {
 	}
 }
 {
-	const { isSubcommand, runSubcommand } = await import("./subcommands-DjO8lthH.js");
+	const { isSubcommand, runSubcommand } = await import("./subcommands-BDiS305D.js");
 	if (isSubcommand(process.argv[2])) {
 		const code = await runSubcommand(process.argv);
 		process.exit(code ?? 0);
@@ -490,12 +490,12 @@ await checkAndAutoUpdate();
 logger.info(versionString());
 const config = parseCliArgs(process.argv);
 if (config.tray) {
-	const { startTray } = await import("./tray-CH_G7aXM.js");
+	const { startTray } = await import("./tray-DHuD0nEk.js");
 	await startTray();
 	await new Promise(() => {});
 }
 {
-	const { ensureTray } = await import("./tray-CH_G7aXM.js");
+	const { ensureTray } = await import("./tray-DHuD0nEk.js");
 	ensureTray();
 }
 if (config.useRust) {
@@ -509,7 +509,7 @@ if (config.useRust) {
 		}
 	}
 	if (rustBinary) {
-		const { SUPPORTED_CLIS } = await import("./SUPPORTED_CLIS-DM0fJTMR.js");
+		const { SUPPORTED_CLIS } = await import("./SUPPORTED_CLIS-5njwpFxr.js");
 		const rustArgs = buildRustArgs(process.argv, config.cli, SUPPORTED_CLIS);
 		if (config.verbose) {
 			console.log(`[rust] Using binary: ${rustBinary}`);

package/dist/index.js

@@ -1,6 +1,6 @@
-import { a as removeControlCharacters, i as AgentContext, n as agentYes, r as config, t as CLIS_CONFIG } from "./ts-Bw6gQKyU.js";
+import { a as removeControlCharacters, i as AgentContext, n as agentYes, r as config, t as CLIS_CONFIG } from "./ts-DVlEOYHB.js";
 import "./logger-B9h0djqx.js";
-import "./versionChecker-CspuhOwO.js";
+import "./versionChecker-XivGWuhd.js";
 import "./pidStore-C1JXxoPi.js";
 import "./globalPidIndex-Cr-g75QF.js";
 

package/dist/remotes-CFrho898.js

@@ -0,0 +1,131 @@
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { homedir } from "os";
+import path from "path";
+import yaml from "yaml";
+
+//#region ts/remotes.ts
+function remotesPath() {
+	const dir = process.env.AGENT_YES_HOME ?? path.join(homedir(), ".agent-yes");
+	return path.join(dir, "remotes.yaml");
+}
+async function readRemotes() {
+	let raw;
+	try {
+		raw = await readFile(remotesPath(), "utf-8");
+	} catch {
+		return /* @__PURE__ */ new Map();
+	}
+	const remotes = (yaml.parse(raw) ?? {}).remotes ?? {};
+	const map = /* @__PURE__ */ new Map();
+	for (const [alias, cfg] of Object.entries(remotes)) if (cfg && typeof cfg.url === "string" && typeof cfg.token === "string") map.set(alias, {
+		url: cfg.url,
+		token: cfg.token
+	});
+	return map;
+}
+async function writeRemoteAlias(alias, config) {
+	const remotes = await readRemotes();
+	remotes.set(alias, config);
+	const doc = {};
+	for (const [k, v] of remotes) doc[k] = v;
+	await mkdir(path.dirname(remotesPath()), { recursive: true });
+	await writeFile(remotesPath(), yaml.stringify({ remotes: doc }));
+}
+async function deleteRemoteAlias(alias) {
+	const remotes = await readRemotes();
+	remotes.delete(alias);
+	const doc = {};
+	for (const [k, v] of remotes) doc[k] = v;
+	await writeFile(remotesPath(), yaml.stringify({ remotes: doc }));
+}
+/** Parse token@host:port[:keyword] — the `@` is a hard signal this is remote. */
+function parseDirectRemoteSpec(spec) {
+	const m = /^([^@]+)@([^:@]+):(\d+)(?::(.+))?$/.exec(spec);
+	if (!m) return null;
+	const host = m[2];
+	const port = parseInt(m[3], 10);
+	return {
+		token: m[1],
+		host,
+		port,
+		keyword: m[4] || void 0,
+		baseUrl: `http://${host}:${port}`
+	};
+}
+/**
+* Resolve a spec to connection details.
+* Accepts:
+*   token@host:port[:keyword]   — direct
+*   alias[:keyword]             — looked up in ~/.agent-yes/remotes.yaml
+* Returns null if the spec doesn't match any remote.
+*/
+async function resolveRemoteSpec(spec) {
+	const direct = parseDirectRemoteSpec(spec);
+	if (direct) return {
+		url: direct.baseUrl,
+		token: direct.token,
+		keyword: direct.keyword
+	};
+	const colonIdx = spec.indexOf(":");
+	const alias = colonIdx >= 0 ? spec.slice(0, colonIdx) : spec;
+	const keyword = colonIdx >= 0 ? spec.slice(colonIdx + 1) || void 0 : void 0;
+	const cfg = (await readRemotes()).get(alias);
+	if (!cfg) return null;
+	return {
+		url: cfg.url,
+		token: cfg.token,
+		keyword
+	};
+}
+async function cmdRemote(rest) {
+	const sub = rest[0];
+	if (!sub || sub === "ls" || sub === "list") {
+		const remotes = await readRemotes();
+		if (remotes.size === 0) {
+			process.stdout.write("no remotes configured\n");
+			process.stderr.write("\n  ay remote add <alias> <url> <token>   # add a remote\n  ay serve                               # start server (prints token)\n");
+			return 0;
+		}
+		for (const [alias, cfg] of remotes) {
+			const preview = cfg.token.length > 8 ? cfg.token.slice(0, 8) + "..." : cfg.token;
+			process.stdout.write(`${alias}\t${cfg.url}\ttoken:${preview}\n`);
+		}
+		return 0;
+	}
+	if (sub === "add") {
+		const [, alias, url, token] = rest;
+		if (!alias || !url || !token) {
+			process.stderr.write("usage: ay remote add <alias> <url> <token>\n");
+			process.stderr.write("  example: ay remote add work-mac http://192.168.1.5:7432 mytoken123\n");
+			return 1;
+		}
+		await writeRemoteAlias(alias, {
+			url,
+			token
+		});
+		process.stdout.write(`remote '${alias}' added → ${url}\n`);
+		process.stderr.write(`\n  ay ls ${alias}            # list agents on ${alias}\n`);
+		return 0;
+	}
+	if (sub === "rm" || sub === "remove" || sub === "delete") {
+		const alias = rest[1];
+		if (!alias) {
+			process.stderr.write("usage: ay remote rm <alias>\n");
+			return 1;
+		}
+		if (!(await readRemotes()).has(alias)) {
+			process.stderr.write(`remote '${alias}' not found\n`);
+			return 1;
+		}
+		await deleteRemoteAlias(alias);
+		process.stdout.write(`remote '${alias}' removed\n`);
+		return 0;
+	}
+	process.stderr.write(`ay remote: unknown subcommand '${sub}'\n`);
+	process.stderr.write("  ay remote ls                           # list configured remotes\n  ay remote add <alias> <url> <token>   # add a remote\n  ay remote rm <alias>                   # remove a remote\n");
+	return 1;
+}
+
+//#endregion
+export { resolveRemoteSpec as a, readRemotes as i, deleteRemoteAlias as n, writeRemoteAlias as o, parseDirectRemoteSpec as r, cmdRemote as t };
+//# sourceMappingURL=remotes-CFrho898.js.map

package/dist/remotes-kfUzk-JT.js

@@ -0,0 +1,3 @@
+import { a as resolveRemoteSpec, i as readRemotes, n as deleteRemoteAlias, o as writeRemoteAlias, r as parseDirectRemoteSpec, t as cmdRemote } from "./remotes-CFrho898.js";
+
+export { cmdRemote };

package/dist/serve-D0NnTXRD.js

@@ -0,0 +1,303 @@
+import "./logger-B9h0djqx.js";
+import "./globalPidIndex-Cr-g75QF.js";
+import "./remotes-CFrho898.js";
+import { c as resolveOne, d as writeToIpc, i as listRecords, o as readNotes, s as renderRawLog, t as controlCodeFromName, u as snapshotStatus } from "./subcommands-BpGEGOQM.js";
+import yargs from "yargs";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { homedir } from "os";
+import path from "path";
+import { randomBytes, timingSafeEqual } from "crypto";
+
+//#region ts/serve.ts
+const DEFAULT_PORT = 7432;
+function agentYesHome() {
+	return process.env.AGENT_YES_HOME ?? path.join(homedir(), ".agent-yes");
+}
+function tokenPath() {
+	return path.join(agentYesHome(), ".serve-token");
+}
+async function loadOrCreateToken(tokenFlag) {
+	if (tokenFlag) return tokenFlag;
+	try {
+		return (await readFile(tokenPath(), "utf-8")).trim();
+	} catch {
+		const token = randomBytes(20).toString("hex");
+		await mkdir(agentYesHome(), { recursive: true });
+		await writeFile(tokenPath(), token, { mode: 384 });
+		return token;
+	}
+}
+function checkAuth(req, expectedToken) {
+	const auth = req.headers.get("authorization") ?? "";
+	if (!auth.startsWith("Bearer ")) return false;
+	const provided = auth.slice(7);
+	const maxLen = Math.max(provided.length, expectedToken.length);
+	return timingSafeEqual(Buffer.from(provided.padEnd(maxLen, "\0")), Buffer.from(expectedToken.padEnd(maxLen, "\0"))) && provided.length === expectedToken.length;
+}
+const defaultOpts = (overrides = {}) => ({
+	all: false,
+	active: false,
+	json: true,
+	latest: true,
+	cwdScope: null,
+	...overrides
+});
+const DAEMON_NAME = "agent-yes";
+async function cmdServeDaemon(sub, args) {
+	const oxmgrBin = Bun.which("oxmgr");
+	if (!oxmgrBin) {
+		process.stderr.write("ay serve install: oxmgr not found\n  install with:  cargo install oxmgr\n             or: bun add -g oxmgr\n");
+		return 1;
+	}
+	if (sub === "install") {
+		const token = await loadOrCreateToken(void 0);
+		const serveCmd = [
+			"ay",
+			"serve",
+			...args
+		].join(" ");
+		const code = await Bun.spawn([
+			oxmgrBin,
+			"start",
+			serveCmd,
+			"--name",
+			DAEMON_NAME,
+			"--restart",
+			"always"
+		], { stdio: [
+			"ignore",
+			"inherit",
+			"inherit"
+		] }).exited;
+		if (code === 0) {
+			process.stdout.write(`\ninstalled '${DAEMON_NAME}' as a daemon via oxmgr\n`);
+			process.stdout.write(`token: ${token}\n\n`);
+			process.stdout.write(`  ay ls ${token}@<host>:${DEFAULT_PORT}\n`);
+			process.stdout.write(`  ay serve logs                # view server logs\n`);
+			process.stdout.write(`  ay serve uninstall           # remove daemon\n`);
+		}
+		return code ?? 1;
+	}
+	if (sub === "uninstall") return await Bun.spawn([
+		oxmgrBin,
+		"delete",
+		DAEMON_NAME
+	], { stdio: [
+		"ignore",
+		"inherit",
+		"inherit"
+	] }).exited ?? 1;
+	if (sub === "logs") return await Bun.spawn([
+		oxmgrBin,
+		"logs",
+		DAEMON_NAME,
+		...args
+	], { stdio: [
+		"ignore",
+		"inherit",
+		"inherit"
+	] }).exited ?? 1;
+	return 1;
+}
+async function cmdServe(rest) {
+	const sub = rest[0];
+	if (sub === "install" || sub === "uninstall" || sub === "logs") return cmdServeDaemon(sub, rest.slice(1));
+	const argv = await yargs(rest).usage("Usage: ay serve [options]").option("port", {
+		type: "number",
+		default: DEFAULT_PORT,
+		description: "Port to listen on"
+	}).option("host", {
+		type: "string",
+		default: "127.0.0.1",
+		description: "Interface to bind (use 0.0.0.0 to expose)"
+	}).option("token", {
+		type: "string",
+		description: "Auth token (auto-generated if omitted)"
+	}).option("tls-cert", {
+		type: "string",
+		description: "TLS certificate file (PEM)"
+	}).option("tls-key", {
+		type: "string",
+		description: "TLS private key file (PEM)"
+	}).help(false).version(false).exitProcess(false).parseAsync();
+	const port = argv.port ?? DEFAULT_PORT;
+	const host = argv.host ?? "127.0.0.1";
+	const tokenFlag = typeof argv.token === "string" ? argv.token : void 0;
+	const certPath = typeof argv["tls-cert"] === "string" ? argv["tls-cert"] : void 0;
+	const keyPath = typeof argv["tls-key"] === "string" ? argv["tls-key"] : void 0;
+	if (certPath && !keyPath || !certPath && keyPath) {
+		process.stderr.write("ay serve: --tls-cert and --tls-key must both be provided\n");
+		return 1;
+	}
+	const useHttps = !!(certPath && keyPath);
+	const scheme = useHttps ? "https" : "http";
+	if (host !== "127.0.0.1" && host !== "localhost") process.stderr.write("ay serve: warning: binding to non-loopback — ensure your network is trusted or use Tailscale/VPN\n");
+	const token = await loadOrCreateToken(tokenFlag);
+	const serverOpts = {
+		hostname: host,
+		port,
+		async fetch(req) {
+			if (!checkAuth(req, token)) return new Response("Unauthorized", { status: 401 });
+			const url = new URL(req.url);
+			const p = url.pathname;
+			if (req.method === "GET" && p === "/api/ls") {
+				const keyword = url.searchParams.get("keyword") ?? void 0;
+				const opts = defaultOpts({
+					all: url.searchParams.get("all") === "1",
+					active: url.searchParams.get("active") === "1"
+				});
+				try {
+					const records = await listRecords(keyword, opts);
+					return Response.json(records);
+				} catch (e) {
+					return new Response(e.message, { status: 500 });
+				}
+			}
+			if (req.method === "GET" && p === "/api/notes") {
+				const notes = await readNotes();
+				return Response.json(Object.fromEntries(notes));
+			}
+			const statusM = /^\/api\/status\/(.+)$/.exec(p);
+			if (req.method === "GET" && statusM) {
+				const keyword = decodeURIComponent(statusM[1]);
+				try {
+					const snap = await snapshotStatus(await resolveOne(keyword, defaultOpts({ all: true })));
+					return Response.json(snap);
+				} catch (e) {
+					return new Response(e.message, { status: 404 });
+				}
+			}
+			const readM = /^\/api\/read\/(.+)$/.exec(p);
+			if (req.method === "GET" && readM) {
+				const keyword = decodeURIComponent(readM[1]);
+				const mode = url.searchParams.get("mode") ?? "tail";
+				const n = parseInt(url.searchParams.get("n") ?? "96", 10) || 96;
+				try {
+					const record = await resolveOne(keyword, defaultOpts());
+					if (!record.log_file) return new Response(`pid ${record.pid}: no log_file`, { status: 404 });
+					const text = await renderRawLog(await readFile(record.log_file), {
+						mode,
+						n
+					});
+					return new Response(text, { headers: { "Content-Type": "text/plain; charset=utf-8" } });
+				} catch (e) {
+					return new Response(e.message, { status: 404 });
+				}
+			}
+			const tailM = /^\/api\/tail\/(.+)$/.exec(p);
+			if (req.method === "GET" && tailM) {
+				const keyword = decodeURIComponent(tailM[1]);
+				try {
+					const record = await resolveOne(keyword, defaultOpts());
+					if (!record.log_file) return new Response(`pid ${record.pid}: no log_file`, { status: 404 });
+					const logPath = record.log_file;
+					const stream = new ReadableStream({ async start(ctrl) {
+						const enc = new TextEncoder();
+						const send = (text) => ctrl.enqueue(enc.encode(`data: ${JSON.stringify(text)}\n\n`));
+						const ping = () => ctrl.enqueue(enc.encode(": ping\n\n"));
+						const initBuf = await readFile(logPath).catch(() => Buffer.alloc(0));
+						send(await renderRawLog(initBuf, {
+							mode: "tail",
+							n: 96
+						}));
+						let offset = initBuf.length;
+						let closed = false;
+						const heartbeat = setInterval(() => {
+							if (closed) {
+								clearInterval(heartbeat);
+								return;
+							}
+							ping();
+						}, 15e3);
+						const ansiRe = /\x1b\[[0-?]*[ -/]*[@-~]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b[@-Z\\-_]/g;
+						const ctrlRe = /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g;
+						const poller = setInterval(async () => {
+							if (closed) {
+								clearInterval(poller);
+								return;
+							}
+							try {
+								const full = await readFile(logPath);
+								if (full.length <= offset) return;
+								const chunk = full.slice(offset);
+								offset = full.length;
+								const text = new TextDecoder().decode(chunk).replace(ansiRe, "").replace(ctrlRe, "");
+								if (text.trim()) send(text.trimStart());
+							} catch {}
+						}, 300);
+						req.signal.addEventListener("abort", () => {
+							closed = true;
+							clearInterval(heartbeat);
+							clearInterval(poller);
+							try {
+								ctrl.close();
+							} catch {}
+						});
+					} });
+					return new Response(stream, { headers: {
+						"Content-Type": "text/event-stream",
+						"Cache-Control": "no-cache",
+						Connection: "keep-alive"
+					} });
+				} catch (e) {
+					return new Response(e.message, { status: 404 });
+				}
+			}
+			if (req.method === "POST" && p === "/api/send") {
+				let body;
+				try {
+					body = await req.json();
+				} catch {
+					return new Response("invalid JSON body", { status: 400 });
+				}
+				const { keyword, msg = "", code = "enter" } = body;
+				if (!keyword || typeof keyword !== "string") return new Response("missing keyword", { status: 400 });
+				try {
+					const record = await resolveOne(keyword, defaultOpts());
+					if (!record.fifo_file) return new Response(`pid ${record.pid}: no fifo_file`, { status: 409 });
+					const trailing = controlCodeFromName(code.toLowerCase());
+					if (msg && trailing) {
+						await writeToIpc(record.fifo_file, msg);
+						await new Promise((r) => setTimeout(r, 200));
+						await writeToIpc(record.fifo_file, trailing);
+					} else await writeToIpc(record.fifo_file, msg + trailing);
+					return Response.json({
+						ok: true,
+						pid: record.pid
+					});
+				} catch (e) {
+					return new Response(e.message, { status: 404 });
+				}
+			}
+			return new Response("Not Found", { status: 404 });
+		}
+	};
+	if (useHttps) serverOpts.tls = {
+		cert: Bun.file(certPath),
+		key: Bun.file(keyPath)
+	};
+	const server = Bun.serve(serverOpts);
+	process.stdout.write(`ay serve  ${scheme}://${host}:${port}\n`);
+	process.stdout.write(`token:    ${token}\n\n`);
+	process.stdout.write(`connect from another machine:\n`);
+	process.stdout.write(`  ay ls   ${token}@<host>:${port}\n`);
+	process.stdout.write(`  ay tail ${token}@<host>:${port}:<keyword>\n`);
+	process.stdout.write(`  ay send ${token}@<host>:${port}:<keyword> "message"\n\n`);
+	if (!useHttps) process.stdout.write("for HTTPS: ay serve --tls-cert cert.pem --tls-key key.pem\n  openssl req -x509 -newkey rsa:2048 -keyout key.pem -out cert.pem -days 365 -nodes -subj '/CN=localhost'\n\n");
+	process.stdout.write(`(Ctrl-C to stop)\n`);
+	await new Promise((resolve) => {
+		process.on("SIGINT", () => {
+			server.stop();
+			resolve();
+		});
+		process.on("SIGTERM", () => {
+			server.stop();
+			resolve();
+		});
+	});
+	return 0;
+}
+
+//#endregion
+export { cmdServe };
+//# sourceMappingURL=serve-D0NnTXRD.js.map

package/dist/subcommands-BDiS305D.js

@@ -0,0 +1,6 @@
+import "./logger-B9h0djqx.js";
+import "./globalPidIndex-Cr-g75QF.js";
+import "./remotes-CFrho898.js";
+import { a as matchKeyword, c as resolveOne, d as writeToIpc, i as listRecords, l as runSubcommand, n as isPidAlive, o as readNotes, r as isSubcommand, s as renderRawLog, t as controlCodeFromName, u as snapshotStatus } from "./subcommands-BpGEGOQM.js";
+
+export { isSubcommand, runSubcommand };