agent-yes 1.197.0 → 1.198.1

package/dist/ws-XM0AQ7Qk.js

@@ -0,0 +1,399 @@
+import "./logger-CDIsZ-Pp.js";
+import "./globalPidIndex-CoNr7tS8.js";
+import "./messageLog-CxrKJj77.js";
+import "./configShared-aKTg-sa5.js";
+import { S as listRecords } from "./subcommands-BeUGFe4x.js";
+import "./e2e-jb0Hp43q.js";
+import "./webrtcLink-B7REGtK2.js";
+import "./remotes-Cim0dBU7.js";
+import { i as getProvisionRoot } from "./workspaceConfig-CjaRvTjf.js";
+import { existsSync } from "fs";
+import { lstat, opendir } from "fs/promises";
+import path from "path";
+
+//#region ts/ws.ts
+/**
+* `ay ws` — workspace management over the codehost/provision standard layout
+* (`<wsRoot>/<owner>/<repo>/tree/<branch>`, independent clones except forked
+* linked worktrees).
+*
+* v1 surface (read/list/new/fork only — deletion/gc/doctor are deliberately
+* deferred until workspace lifecycle data exists to design them around):
+*
+*   ay ws ls [--status] [--json]
+*   ay ws status [<spec-or-path>] [--path|--spec] [--json]
+*   ay ws new <source> [--create]
+*   ay ws fork <branch> [--from <path>] [--wip]
+*
+* `--json` schema (stable, versioned via `schema`):
+*   ls:     { schema:"ay-ws/v1", wsRoot, workspaces: WsEntry[] }
+*   status: { schema:"ay-ws/v1", workspace: WsEntry }
+*   WsEntry = { owner, repo, branch, path, agents: { live: number },
+*               git?: GitStatus | null, gitError?: string }
+*
+* codehost/provision is a peer package (bun-linked in dev). Like serve.ts's
+* fork path, it is imported lazily so `ay ls` etc. never pay for it and a
+* missing install produces a clear actionable error instead of a module crash.
+*/
+async function loadProvision() {
+	try {
+		return await import("codehost/provision");
+	} catch (e) {
+		throw new Error(`'ay ws' needs the 'codehost' package (codehost/provision) — install it (npm i -g codehost) or 'bun link' it for local dev: ${e.message}`);
+	}
+}
+const WS_JSON_SCHEMA = "ay-ws/v1";
+const STATUS_CONCURRENCY = 8;
+const MAX_BRANCH_DEPTH = 8;
+/**
+* Path containment that matches how the OS actually compares paths: segment
+* boundaries via path.relative (never a raw startsWith), case-insensitive on
+* Windows (and macOS's default case-insensitive FS is fine with this too —
+* false positives there require two dirs differing only by case).
+*/
+function isPathInside(parent, child) {
+	let p = path.resolve(parent);
+	let c = path.resolve(child);
+	if (process.platform === "win32") {
+		p = p.toLowerCase();
+		c = c.toLowerCase();
+	}
+	const rel = path.relative(p, c);
+	return rel === "" || !rel.startsWith("..") && !path.isAbsolute(rel);
+}
+/** True when `dir` is a git checkout root (`.git` file = linked worktree, dir = clone). */
+function isCheckoutRoot(dir) {
+	return existsSync(path.join(dir, ".git"));
+}
+async function subdirs(dir) {
+	const out = [];
+	let d;
+	try {
+		d = await opendir(dir);
+	} catch {
+		return out;
+	}
+	for await (const ent of d) {
+		if (ent.name.startsWith(".")) continue;
+		if (ent.isDirectory()) out.push(ent.name);
+		else if (ent.isSymbolicLink()) continue;
+	}
+	return out.sort();
+}
+/**
+* Walk `<wsRoot>/<owner>/<repo>/tree/**` collecting checkout roots. The branch
+* may contain `/`, so below `tree/` we descend until a `.git` marker is found
+* (a checkout root is never nested inside another checkout in this layout),
+* bounded by MAX_BRANCH_DEPTH.
+*/
+async function walkWorkspaces(wsRoot) {
+	const found = [];
+	async function walkBranches(dir, owner, repo, segs) {
+		if (segs.length > MAX_BRANCH_DEPTH) return;
+		for (const name of await subdirs(dir)) {
+			const p = path.join(dir, name);
+			const branchSegs = [...segs, name];
+			if (isCheckoutRoot(p)) found.push({
+				owner,
+				repo,
+				branch: branchSegs.join("/"),
+				path: p
+			});
+			else await walkBranches(p, owner, repo, branchSegs);
+		}
+	}
+	for (const owner of await subdirs(wsRoot)) for (const repo of await subdirs(path.join(wsRoot, owner))) {
+		const tree = path.join(wsRoot, owner, repo, "tree");
+		try {
+			if (!(await lstat(tree)).isDirectory()) continue;
+		} catch {
+			continue;
+		}
+		await walkBranches(tree, owner, repo, []);
+	}
+	return found;
+}
+/** Live (non-exited) agents whose cwd sits inside `wsPath`. */
+function liveAgentsIn(records, wsPath) {
+	return records.filter((r) => r.cwd && isPathInside(wsPath, r.cwd));
+}
+async function mapBounded(items, limit, fn) {
+	const out = new Array(items.length);
+	let next = 0;
+	const workers = Array.from({ length: Math.min(limit, items.length) }, async () => {
+		while (next < items.length) {
+			const i = next++;
+			out[i] = await fn(items[i]);
+		}
+	});
+	await Promise.all(workers);
+	return out;
+}
+/**
+* Resolve a status/inspect operand deterministically:
+*   1. `--path` forces path, `--spec` forces source-spec parsing
+*   2. an operand that exists on disk is a path
+*   3. otherwise it must parse as a source (owner/repo[@branch|/tree/branch] or URL)
+* Prints the normalized resolution so the user always sees what was addressed.
+*/
+async function resolveOperand(prov, operand, mode, wsRoot) {
+	const asPath = () => {
+		const dir = path.resolve(operand);
+		if (!existsSync(dir)) throw new Error(`path does not exist: ${dir}`);
+		if (!isCheckoutRoot(dir)) throw new Error(`not a git checkout root (no .git): ${dir}`);
+		return {
+			dir,
+			spec: null
+		};
+	};
+	const asSpec = () => {
+		const spec = prov.parseSource(operand);
+		if (!spec) throw new Error(`cannot parse "${operand}" as a source — expected <owner>/<repo>, <owner>/<repo>@<branch>, <owner>/<repo>/tree/<branch>, or a github URL` + (existsSync(operand) ? "" : " (and it is not an existing path)"));
+		const dir = prov.folderFor(spec, wsRoot);
+		if (!existsSync(dir)) throw new Error(`workspace not provisioned: ${dir}  (ay ws new ${operand})`);
+		return {
+			dir,
+			spec
+		};
+	};
+	if (mode === "path") return asPath();
+	if (mode === "spec") return asSpec();
+	if (existsSync(path.resolve(operand))) return asPath();
+	return asSpec();
+}
+/**
+* Default source for `ws fork`: the calling agent's registered cwd when run
+* inside an agent (AGENT_YES_PID is the wrapper pid of the enclosing agent),
+* else the current directory.
+*/
+async function defaultForkFrom() {
+	const envPid = Number(process.env.AGENT_YES_PID);
+	if (envPid > 0) {
+		const recs = await listRecords(void 0, {
+			all: true,
+			active: false,
+			json: false,
+			latest: false,
+			cwdScope: null
+		});
+		const self = recs.find((r) => r.wrapper_pid === envPid) ?? recs.find((r) => r.pid === envPid);
+		if (self?.cwd) return self.cwd;
+	}
+	return process.cwd();
+}
+function parseFlags(args, known) {
+	const flags = {};
+	const positional = [];
+	for (let i = 0; i < args.length; i++) {
+		const a = args[i];
+		if (!a.startsWith("--")) {
+			positional.push(a);
+			continue;
+		}
+		const eq = a.indexOf("=");
+		const name = eq === -1 ? a.slice(2) : a.slice(2, eq);
+		const kind = known[name];
+		if (!kind) throw new Error(`unknown flag --${name}`);
+		if (kind === "bool") {
+			if (eq !== -1) throw new Error(`--${name} takes no value`);
+			flags[name] = true;
+		} else {
+			const v = eq !== -1 ? a.slice(eq + 1) : args[++i];
+			if (v === void 0) throw new Error(`--${name} requires a value`);
+			flags[name] = v;
+		}
+	}
+	return {
+		flags,
+		positional
+	};
+}
+async function cmdWsLs(args) {
+	const { flags, positional } = parseFlags(args, {
+		status: "bool",
+		json: "bool"
+	});
+	if (positional.length > 0) throw new Error(`ws ls takes no positional args`);
+	const prov = await loadProvision();
+	const wsRoot = prov.resolveWsRoot(getProvisionRoot());
+	const [bare, records] = await Promise.all([walkWorkspaces(wsRoot), listRecords(void 0, {
+		all: false,
+		active: false,
+		json: false,
+		latest: false,
+		cwdScope: null
+	})]);
+	let entries = bare.map((w) => ({
+		...w,
+		agents: { live: liveAgentsIn(records, w.path).length }
+	}));
+	if (flags.status) entries = await mapBounded(entries, STATUS_CONCURRENCY, async (e) => {
+		try {
+			return {
+				...e,
+				git: await prov.readStatus(e.path)
+			};
+		} catch (err) {
+			return {
+				...e,
+				git: null,
+				gitError: err.message.slice(0, 200)
+			};
+		}
+	});
+	if (flags.json) {
+		process.stdout.write(JSON.stringify({
+			schema: WS_JSON_SCHEMA,
+			wsRoot,
+			workspaces: entries
+		}, null, 2) + "\n");
+		return 0;
+	}
+	if (entries.length === 0) {
+		process.stderr.write(`no workspaces under ${wsRoot} (layout <owner>/<repo>/tree/<branch>)\n`);
+		return 0;
+	}
+	const specOf = (e) => `${e.owner}/${e.repo}@${e.branch}`;
+	const specW = Math.max(9, ...entries.map((e) => specOf(e).length));
+	const agentsW = 6;
+	const header = flags.status ? `${"WORKSPACE".padEnd(specW)}  ${"AGENTS".padEnd(agentsW)}  GIT\n` : `${"WORKSPACE".padEnd(specW)}  ${"AGENTS".padEnd(agentsW)}  PATH\n`;
+	process.stdout.write(header);
+	for (const e of entries) {
+		const agents = e.agents.live > 0 ? String(e.agents.live) : "-";
+		const tail = flags.status ? gitSummary(e) : e.path;
+		process.stdout.write(`${specOf(e).padEnd(specW)}  ${agents.padEnd(agentsW)}  ${tail}\n`);
+	}
+	if (entries.some((e) => e.agents.live > 0)) process.stderr.write(`\n  ay ls --cwd <path>    # the agents inside a workspace\n`);
+	return 0;
+}
+function gitSummary(e) {
+	if (e.gitError) return `error: ${e.gitError}`;
+	const g = e.git;
+	if (!g) return "?";
+	const parts = [];
+	if (g.dirty) parts.push("dirty");
+	if (g.ahead > 0) parts.push(`ahead ${g.ahead}`);
+	if (g.behind > 0) parts.push(`behind ${g.behind}`);
+	if (!g.hasUpstream) parts.push("no-upstream");
+	return parts.length ? parts.join(", ") : "clean";
+}
+async function cmdWsStatus(args) {
+	const { flags, positional } = parseFlags(args, {
+		json: "bool",
+		path: "bool",
+		spec: "bool"
+	});
+	if (flags.path && flags.spec) throw new Error("--path and --spec are mutually exclusive");
+	if (positional.length > 1) throw new Error("ws status takes at most one target");
+	const prov = await loadProvision();
+	const wsRoot = getProvisionRoot();
+	const { dir, spec } = await resolveOperand(prov, positional[0] ?? ".", flags.path ? "path" : flags.spec ? "spec" : "auto", wsRoot);
+	const git = await prov.readStatus(dir);
+	const layoutSpec = spec ?? (() => {
+		const root = prov.resolveWsRoot(wsRoot);
+		if (!isPathInside(root, dir)) return null;
+		const segs = path.relative(root, dir).split(path.sep);
+		return segs.length >= 4 && segs[2] === "tree" ? {
+			owner: segs[0],
+			repo: segs[1],
+			branch: segs.slice(3).join("/")
+		} : null;
+	})();
+	const entry = {
+		owner: layoutSpec?.owner ?? "",
+		repo: layoutSpec?.repo ?? "",
+		branch: layoutSpec?.branch ?? git.branch,
+		path: dir,
+		agents: { live: liveAgentsIn(await listRecords(void 0, {
+			all: false,
+			active: false,
+			json: false,
+			latest: false,
+			cwdScope: null
+		}), dir).length },
+		git
+	};
+	if (flags.json) {
+		process.stdout.write(JSON.stringify({
+			schema: WS_JSON_SCHEMA,
+			workspace: entry
+		}, null, 2) + "\n");
+		return 0;
+	}
+	process.stdout.write(`${dir}\n` + (layoutSpec ? `  spec:     ${layoutSpec.owner}/${layoutSpec.repo}@${layoutSpec.branch}\n` : "") + `  branch:   ${git.branch} @ ${git.head}\n  state:    ${gitSummary(entry)}\n  agents:   ${entry.agents.live} live\n`);
+	if (entry.agents.live > 0) process.stderr.write(`\n  ay ls --cwd ${dir}\n`);
+	return 0;
+}
+async function cmdWsNew(args) {
+	const { flags, positional } = parseFlags(args, { create: "bool" });
+	const source = positional[0];
+	if (!source || positional.length > 1) throw new Error("usage: ay ws new <owner>/<repo>[@branch] [--create]");
+	const prov = await loadProvision();
+	const wsRoot = getProvisionRoot();
+	const spec = prov.parseSource(source);
+	if (!spec) throw new Error(`cannot parse "${source}" as a source (owner/repo[@branch] or URL)`);
+	process.stderr.write(`provisioning ${spec.owner}/${spec.repo}@${spec.branch} …\n`);
+	let res = await prov.provision(spec, { wsRoot });
+	if (!res.ok && res.reason === "branch-not-found" && flags.create) {
+		process.stderr.write(`branch not found on remote — creating it locally (--create)\n`);
+		res = await prov.createBranch(spec, { wsRoot });
+	}
+	if (!res.ok) {
+		process.stderr.write(`provision failed (${res.reason ?? "error"}): ${res.error ?? "unknown"}\n` + (res.reason === "branch-not-found" && !flags.create ? `  (branch missing on the remote — re-run with --create to branch off the default)\n` : ""));
+		return 1;
+	}
+	process.stdout.write(`${res.action}  ${res.folder}\n`);
+	return 0;
+}
+async function cmdWsFork(args) {
+	const { flags, positional } = parseFlags(args, {
+		from: "value",
+		wip: "bool"
+	});
+	const branch = positional[0];
+	if (!branch || positional.length > 1) throw new Error("usage: ay ws fork <new-branch> [--from <path>] [--wip]");
+	const prov = await loadProvision();
+	const fromCwd = path.resolve(typeof flags.from === "string" ? flags.from : await defaultForkFrom());
+	process.stderr.write(`forking ${fromCwd} → branch ${branch}${flags.wip ? " (with WIP)" : ""} …\n`);
+	const res = await prov.forkWorktree({
+		fromCwd,
+		branch,
+		wsRoot: getProvisionRoot(),
+		wip: !!flags.wip
+	});
+	if (!res.ok) {
+		process.stderr.write(`fork failed: ${res.error ?? "unknown"}\n`);
+		return 1;
+	}
+	process.stdout.write(`${res.action}  ${res.folder}\n`);
+	process.stderr.write(`\n  ay claude --cwd ${res.folder} -- "<prompt>"   # work there\n`);
+	return 0;
+}
+function wsHelp() {
+	process.stdout.write("ay ws - workspaces under <wsRoot>/<owner>/<repo>/tree/<branch>\n\n  ay ws ls [--status] [--json]           list workspaces (+git state, +live agent count)\n  ay ws status [<spec|path>] [--json]    one workspace's git state (default: cwd)\n  ay ws new <owner>/<repo>[@branch]      clone/refresh a workspace  (--create: new branch)\n  ay ws fork <branch> [--from <path>]    sibling worktree off HEAD  (--wip: carry changes)\n\n  targets: owner/repo, owner/repo@branch, owner/repo/tree/branch, github URL, or a path\n  wsRoot:  CODEHOST_WS_ROOT > config provisionRoot > ~/ws\n");
+	return 0;
+}
+/** `ay ws <sub> …` dispatcher (called from runSubcommand). */
+async function cmdWs(args) {
+	const sub = args[0];
+	const rest = args.slice(1);
+	switch (sub) {
+		case "ls":
+		case "list": return cmdWsLs(rest);
+		case "status": return cmdWsStatus(rest);
+		case "new": return cmdWsNew(rest);
+		case "fork": return cmdWsFork(rest);
+		case void 0:
+		case "help":
+		case "--help":
+		case "-h": return wsHelp();
+		default:
+			process.stderr.write(`ay ws: unknown subcommand "${sub}"\n\n`);
+			wsHelp();
+			return 1;
+	}
+}
+
+//#endregion
+export { cmdWs };
+//# sourceMappingURL=ws-XM0AQ7Qk.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-yes",
-  "version": "1.197.0",
+  "version": "1.198.1",
   "description": "A wrapper tool that automates interactions with various AI CLI tools by automatically handling common prompts and responses.",
   "keywords": [
     "ai",

package/ts/serve.ts

@@ -763,8 +763,12 @@ async function cmdServeDaemon(sub: string, args: string[]): Promise<number> {
       removed++;
       process.stdout.write(`removed '${DAEMON_NAME}' from ${m.id}\n`);
       if (m.id === "pm2") {
-        // Drop it from the persisted pm2 list too, so `pm2 resurrect` won't revive it.
-        await spawnExit([m.bin, "save"]);
+        // Drop it from the persisted pm2 list too, so `pm2 resurrect` won't
+        // revive it. --force is required: with the process list now empty, a
+        // plain `pm2 save` REFUSES to overwrite the dump ("Nothing to save!
+        // Please use --force") and the deleted daemon stays in dump.pm2 —
+        // resurrect/startup would then boot it alongside the new manager's.
+        await spawnExit([m.bin, "save", "--force"]);
         // Remove the Windows login auto-start entry we added at install time.
         if (process.platform === "win32")
           await spawnExit(["reg", "delete", WIN_RUN_KEY, "/v", WIN_RUN_VALUE, "/f"]);

package/ts/subcommands.ts

@@ -368,7 +368,7 @@ const SUBCOMMANDS = new Set([
 // alias like `cy` (= claude-yes = "agent-yes claude") must NOT treat these as
 // subcommands — `cy setup …` should run claude with that text, not manage the
 // host. Kept separate from SUBCOMMANDS so a runner alias falls straight through.
-const MANAGER_SUBCOMMANDS = new Set(["setup"]);
+const MANAGER_SUBCOMMANDS = new Set(["setup", "ws"]);
 
 const IDLE_THRESHOLD_MS = 60 * 1000;
 
@@ -475,6 +475,10 @@ export async function runSubcommand(argv: string[]): Promise<number | null> {
         const { cmdSetup } = await import("./setup.ts");
         return cmdSetup(rest);
       }
+      case "ws": {
+        const { cmdWs } = await import("./ws.ts");
+        return cmdWs(rest);
+      }
       case "schedule": {
         const { cmdSchedule } = await import("./schedule.ts");
         return cmdSchedule(rest);
@@ -572,6 +576,11 @@ export async function cmdHelp(managerCommands = true): Promise<number> {
   const setupLine = managerCommands
     ? `  ay setup                            guided setup: pick a workspace, share to agent-yes.com\n`
     : ``;
+  // `ws` is manager-only for the same reason as `setup`.
+  const wsLines = managerCommands
+    ? `  ay ws ls [--status]                 list <owner>/<repo>/tree/<branch> workspaces\n` +
+      `  ay ws new <owner>/<repo>[@branch]   clone/refresh a workspace (ay ws help for more)\n`
+    : ``;
   // Only agents carry AGENT_YES_PID — a human shell never sets it — so this
   // section is skipped entirely (no async work at all) for interactive use.
   const self = process.env.AGENT_YES_PID ? await resolveSender() : null;
@@ -599,6 +608,7 @@ export async function cmdHelp(managerCommands = true): Promise<number> {
       `  ay result <keyword> [--wait]        pull an agent's structured result envelope\n` +
       `  ay result set '<json>'              (inside an agent) deposit your result envelope\n` +
       `  ay reap                             kill process groups leaked by dead agents\n` +
+      wsLines +
       `\n` +
       `Remote:\n` +
       setupLine +