@dylanpiercey/work 0.0.46 → 0.0.48

package/dist/{_P9IsUQm2.js → _CO83dVER.js}

@@ -8,16 +8,16 @@ import { DatabaseSync } from "node:sqlite";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 //#region src/server/config.ts
-var home = os.homedir();
+var home$1 = os.homedir();
 var config = {
 	/** Root directory containing all workspaces. */
-	workRoot: process.env.WORK_ROOT || path.join(home, "work"),
+	workRoot: process.env.WORK_ROOT || path.join(home$1, "work"),
 	/** Shared bare-repo cache, kept inside the work root. */
 	get cacheDir() {
 		return path.join(this.workRoot, ".cache");
 	},
 	/** Data directory for the sqlite db and other server state. */
-	dataDir: process.env.WORK_DATA_DIR || path.join(process.env.XDG_DATA_HOME || path.join(home, ".local", "share"), "work"),
+	dataDir: process.env.WORK_DATA_DIR || path.join(process.env.XDG_DATA_HOME || path.join(home$1, ".local", "share"), "work"),
 	gitHost: "github.com",
 	user: process.env.WORK_USER || os.userInfo().username,
 	host: process.env.WORK_HOST || os.hostname().split(".")[0],
@@ -148,7 +148,7 @@ function subscriberCount() {
 * user's default tmux. */
 var TMUX_SOCKET = "work";
 var execFileAsync = promisify(execFile);
-async function run(cmd, args, cwd, env) {
+async function run$1(cmd, args, cwd, env) {
 	const { stdout } = await execFileAsync(cmd, args, {
 		cwd,
 		env,
@@ -156,22 +156,386 @@ async function run(cmd, args, cwd, env) {
 	});
 	return stdout.trim();
 }
-var git = (args, cwd) => run("git", args, cwd);
-var gh = (args) => run("gh", args);
-var tmux = (args, env) => run("tmux", [
+var git = (args, cwd) => run$1("git", args, cwd);
+var gh = (args) => run$1("gh", args);
+var tmux = (args, env) => run$1("tmux", [
 	"-L",
 	TMUX_SOCKET,
 	...args
 ], void 0, env);
 //#endregion
-//#region src/server/settings.ts
+//#region lib/setup/catalog.mjs
+/** Machine tools. `required` ones gate readiness; the rest are the utilities
+* agents reach for constantly (mirrors DylanPiercey/start). Static binaries via
+* mise, except the system packages the installer provides (git, tmux). */
+var TOOLS = [
+	{
+		id: "git",
+		label: "git",
+		bin: "git",
+		required: true,
+		system: true
+	},
+	{
+		id: "tmux",
+		label: "tmux",
+		bin: "tmux",
+		required: true,
+		system: true,
+		mise: "tmux"
+	},
+	{
+		id: "node",
+		label: "Node.js",
+		bin: "node",
+		mise: "node",
+		required: true
+	},
+	{
+		id: "gh",
+		label: "GitHub CLI",
+		bin: "gh",
+		mise: "gh",
+		required: true
+	},
+	{
+		id: "ripgrep",
+		label: "ripgrep",
+		bin: "rg",
+		mise: "ripgrep"
+	},
+	{
+		id: "fd",
+		label: "fd",
+		bin: "fd",
+		mise: "fd"
+	},
+	{
+		id: "jq",
+		label: "jq",
+		bin: "jq",
+		mise: "jq"
+	},
+	{
+		id: "delta",
+		label: "delta",
+		bin: "delta",
+		mise: "delta"
+	},
+	{
+		id: "ast-grep",
+		label: "ast-grep",
+		bin: "ast-grep",
+		mise: "ast-grep"
+	},
+	{
+		id: "hyperfine",
+		label: "hyperfine",
+		bin: "hyperfine",
+		mise: "hyperfine"
+	},
+	{
+		id: "fzf",
+		label: "fzf",
+		bin: "fzf",
+		mise: "fzf"
+	},
+	{
+		id: "bottom",
+		label: "bottom",
+		bin: "btm",
+		mise: "bottom"
+	},
+	{
+		id: "pnpm",
+		label: "pnpm",
+		bin: "pnpm",
+		mise: "pnpm"
+	}
+];
+/** Coding agent CLIs. Installed via each vendor's own installer (not npm) so
+* self-update works. `bins` lists the executable names a family answers to;
+* numeric suffixes (`claude1`) are discovered on top of these. */
 var AGENTS = [
-	"claude",
-	"codex",
-	"grok",
-	"copilot",
-	"cursor"
+	{
+		id: "claude",
+		label: "Claude",
+		bins: ["claude"],
+		install: {
+			url: "https://claude.ai/install.sh",
+			shell: "bash"
+		}
+	},
+	{
+		id: "codex",
+		label: "Codex",
+		bins: ["codex"],
+		install: {
+			url: "https://chatgpt.com/codex/install.sh",
+			shell: "sh"
+		}
+	},
+	{
+		id: "copilot",
+		label: "Copilot",
+		bins: ["copilot"],
+		install: {
+			url: "https://gh.io/copilot-install",
+			shell: "bash"
+		}
+	},
+	{
+		id: "cursor",
+		label: "Cursor",
+		bins: ["cursor-agent"],
+		install: {
+			url: "https://cursor.com/install",
+			shell: "bash"
+		}
+	},
+	{
+		id: "grok",
+		label: "Grok",
+		bins: ["grok"],
+		install: {
+			url: "https://x.ai/cli/install.sh",
+			shell: "bash"
+		}
+	}
 ];
+var DEFAULT_GITHUB_HOST = "github.com";
+function toolById(id) {
+	return TOOLS.find((t) => t.id === id) || null;
+}
+function agentById(id) {
+	return AGENTS.find((a) => a.id === id) || null;
+}
+/**
+* Agent *instances* are the family id plus an optional numeric suffix —
+* `claude`, `claude1`, `claude2` — one per binary on PATH (`claude1`,
+* `cursor-agent2`, …). This is the canonical id everywhere: sessions,
+* settings, usage rows (`~/.claude-2` reports as `claude2`), icons.
+*/
+function parseAgentId(id) {
+	const m = /^([a-z]+?)(\d*)$/.exec(id || "");
+	const family = m && agentById(m[1]);
+	return family ? {
+		family,
+		suffix: m[2]
+	} : null;
+}
+/** argv0 an instance id launches — the family's binary plus the suffix. */
+function agentCommand(id) {
+	const parsed = parseAgentId(id);
+	return parsed ? `${parsed.family.bins[0]}${parsed.suffix}` : null;
+}
+/** "Claude" / "Claude 2". */
+function agentLabel(id) {
+	const parsed = parseAgentId(id);
+	return parsed ? `${parsed.family.label}${parsed.suffix ? ` ${parsed.suffix}` : ""}` : id;
+}
+//#endregion
+//#region lib/setup/doctor.mjs
+var home = os.homedir();
+/** PATH the service runs with (no login shell) plus the current one, so a
+* probe from the server sees the same binaries a probe from a terminal does. */
+function setupPath(base = process.env.PATH || "") {
+	const extra = [
+		`${home}/.local/share/mise/shims`,
+		`${home}/.local/bin`,
+		"/opt/homebrew/bin",
+		"/usr/local/bin",
+		"/usr/bin",
+		"/bin"
+	];
+	const seen = /* @__PURE__ */ new Set();
+	return [...base.split(path.delimiter), ...extra].filter((p) => p && !seen.has(p) && seen.add(p)).join(path.delimiter);
+}
+/** `~/…` for anything under the home directory — every path here is for
+* display (Settings rows, `work doctor`), never re-used to exec. */
+function tilde(p) {
+	if (!p) return p;
+	return p === home ? "~" : p.startsWith(home + path.sep) ? "~" + p.slice(home.length) : p;
+}
+/** Absolute path of `bin` on setupPath(), or null. */
+function which(bin) {
+	for (const dir of setupPath().split(path.delimiter)) {
+		const full = path.join(dir, bin);
+		try {
+			if (fs.statSync(full).isFile()) return full;
+		} catch {}
+	}
+	return null;
+}
+function run(cmd, args, { timeout = 15e3 } = {}) {
+	return new Promise((resolve) => {
+		execFile(cmd, args, {
+			env: {
+				...process.env,
+				PATH: setupPath()
+			},
+			timeout,
+			maxBuffer: 8 << 20
+		}, (err, stdout, stderr) => resolve({
+			ok: !err,
+			stdout: String(stdout || ""),
+			stderr: String(stderr || "")
+		}));
+	});
+}
+/** Versions of every mise-managed tool (global + any active config), keyed
+* by short name. Local and fast; `mise outdated` (network) is a separate,
+* on-demand call in the server. */
+async function miseVersions() {
+	if (!which("mise")) return null;
+	const { ok, stdout } = await run("mise", ["ls", "--json"]);
+	if (!ok) return {};
+	const out = {};
+	try {
+		for (const [name, list] of Object.entries(JSON.parse(stdout))) {
+			const active = list.find((v) => v.installed && v.active) || list.find((v) => v.installed);
+			if (active) out[name] = active.version;
+		}
+	} catch {}
+	return out;
+}
+/** Hosts `gh` knows about (~/.config/gh/hosts.yml top-level keys) — the
+* source of truth for "which GitHub hosts has this machine signed in to",
+* merged with whatever the caller has configured. */
+function ghKnownHosts() {
+	const file = path.join(process.env.GH_CONFIG_DIR || path.join(home, ".config", "gh"), "hosts.yml");
+	let text = "";
+	try {
+		text = fs.readFileSync(file, "utf8");
+	} catch {
+		return [];
+	}
+	return [...text.matchAll(/^([A-Za-z0-9.-]+):\s*$/gm)].map((m) => m[1]);
+}
+/**
+* Every agent CLI instance on PATH, per family: the plain binary and any
+* numeric-suffixed siblings (`claude1`, `cursor-agent2`). Sync — a PATH
+* scan is cheap and the boot handler needs it without awaiting. First hit
+* on PATH wins per name, like the shell.
+*/
+function discoverAgents() {
+	const dirs = setupPath().split(path.delimiter);
+	const seen = /* @__PURE__ */ new Map();
+	for (const dir of dirs) {
+		let names;
+		try {
+			names = fs.readdirSync(dir);
+		} catch {
+			continue;
+		}
+		for (const name of names) {
+			const hit = AGENTS.find((a) => a.bins.some((b) => name === b || name.startsWith(b) && /^\d+$/.test(name.slice(b.length))));
+			if (!hit || seen.has(name)) continue;
+			const full = path.join(dir, name);
+			try {
+				if (!fs.statSync(full).isFile()) continue;
+			} catch {
+				continue;
+			}
+			const bin = hit.bins.find((b) => name.startsWith(b));
+			seen.set(name, {
+				family: hit,
+				id: `${hit.id}${name.slice(bin.length)}`,
+				command: name,
+				path: tilde(full)
+			});
+		}
+	}
+	return AGENTS.map((a) => {
+		const instances = [...seen.values()].filter((i) => i.family === a).map(({ id, command, path: p }) => ({
+			id,
+			command,
+			path: p,
+			suffix: id.slice(a.id.length)
+		})).sort((x, y) => x.suffix === "" ? -1 : y.suffix === "" ? 1 : Number(x.suffix) - Number(y.suffix));
+		return {
+			id: a.id,
+			label: a.label,
+			installed: instances.length > 0,
+			installable: true,
+			instances
+		};
+	});
+}
+/** Auth status for one host via gh (which owns the tokens). */
+async function githubHostStatus(host) {
+	const isEnterprise = host !== DEFAULT_GITHUB_HOST;
+	if (!which("gh")) return {
+		host,
+		isEnterprise,
+		authed: false,
+		error: "gh not installed"
+	};
+	const { ok, stdout, stderr } = await run("gh", [
+		"auth",
+		"status",
+		"--hostname",
+		host
+	]);
+	const text = stdout + stderr;
+	const user = text.match(/account (\S+)/)?.[1] || text.match(/Logged in to \S+ as (\S+)/)?.[1];
+	return ok ? {
+		host,
+		isEnterprise,
+		authed: true,
+		user
+	} : {
+		host,
+		isEnterprise,
+		authed: false,
+		error: /not logged in/i.test(text) ? void 0 : text.trim().split("\n").pop()
+	};
+}
+/**
+* Full readiness snapshot.
+*
+* @param {{ hosts?: string[] }} [opts] configured GitHub hosts (settings);
+*   github.com and any host gh is already signed in to are always included.
+*/
+async function doctor(opts = {}) {
+	const hostSet = /* @__PURE__ */ new Set([
+		DEFAULT_GITHUB_HOST,
+		...opts.hosts || [],
+		...ghKnownHosts()
+	]);
+	const [versions, github] = await Promise.all([miseVersions(), Promise.all([...hostSet].map(githubHostStatus))]);
+	const tools = TOOLS.map((t) => {
+		const found = which(t.bin);
+		return {
+			id: t.id,
+			label: t.label,
+			required: !!t.required,
+			installed: !!found,
+			path: tilde(found) || void 0,
+			version: t.mise && versions && versions[t.mise] || void 0,
+			installable: !!(t.mise && versions !== null),
+			mise: t.mise
+		};
+	});
+	const agents = discoverAgents();
+	const missing = [];
+	for (const t of tools) if (t.required && !t.installed) missing.push(t.id);
+	if (!github.some((h) => h.authed)) missing.push("github-auth");
+	if (!agents.some((a) => a.installed)) missing.push("agent");
+	return {
+		ready: missing.length === 0,
+		missing,
+		mise: {
+			installed: versions !== null,
+			path: tilde(which("mise")) || void 0
+		},
+		tools,
+		agents,
+		github
+	};
+}
+//#endregion
+//#region src/server/settings.ts
 function getSetting(key) {
 	return get("SELECT value FROM settings WHERE key = ?", key)?.value;
 }
@@ -189,9 +553,57 @@ function setPref(key, value) {
 	if (value === null) db.prepare("DELETE FROM settings WHERE key = ?").run(`ui.${key}`);
 	else setSetting(`ui.${key}`, value);
 }
+/** Instance ids the user switched off in Settings (still installed). */
+function disabledAgents() {
+	try {
+		return new Set(JSON.parse(getSetting("disabledAgents") || "[]"));
+	} catch {
+		return /* @__PURE__ */ new Set();
+	}
+}
+function setDisabledAgents(ids) {
+	setSetting("disabledAgents", JSON.stringify([...new Set(ids)]));
+}
+/** Every agent CLI instance installed on this machine (PATH scan) plus the
+* built-in shell, with the user's enable/disable applied. Cheap and sync so
+* the boot handler and session create can call it directly. */
+function agentChoices() {
+	const off = disabledAgents();
+	const out = [];
+	for (const family of discoverAgents()) for (const inst of family.instances) out.push({
+		id: inst.id,
+		label: agentLabel(inst.id),
+		family: family.id,
+		command: inst.command,
+		enabled: !off.has(inst.id)
+	});
+	out.push({
+		id: "shell",
+		label: "Shell",
+		family: "shell",
+		command: "",
+		enabled: true
+	});
+	return out;
+}
+/** Ids the pickers offer: installed ∧ enabled. `shell` is not listed —
+* every picker appends it itself as the always-there fallback. */
+function enabledAgents() {
+	return agentChoices().filter((a) => a.enabled && a.id !== "shell").map((a) => a.id);
+}
+/** True for any id a session may be created with: a discovered instance,
+* the shell, or a plausible instance id whose binary a login shell can find
+* (PATH here and in the pane can differ). */
+function isKnownAgent(id) {
+	return id === "shell" || !!parseAgentId(id);
+}
+/** Default agent for empty-session Start / auto-create. Falls back to the
+* first enabled non-shell instance when the stored choice is gone. */
 function preferredAgent() {
-	const value = getSetting("preferredAgent");
-	return AGENTS.includes(value) ? value : "claude";
+	const stored = getSetting("preferredAgent");
+	const enabled = enabledAgents();
+	if (stored && enabled.includes(stored)) return stored;
+	return enabled.find((id) => id !== "shell") || stored || "claude";
 }
 //#endregion
 //#region node_modules/.pnpm/bn.js@4.12.5/node_modules/bn.js/lib/bn.js
@@ -6013,7 +6425,7 @@ function publishChange(sessionId) {
 	const row = get("SELECT workspace_id FROM sessions WHERE id = ?", sessionId);
 	if (row?.workspace_id) {
 		const workspaceId = row.workspace_id;
-		import("./_kABYZA6_.js").then((m) => m.notifySessionsChanged(workspaceId));
+		import("./_DjrRGy4k.js").then((m) => m.notifySessionsChanged(workspaceId));
 		return;
 	}
 	publish("sessions.changed");
@@ -6037,11 +6449,17 @@ function stateCurl(state, reason) {
 * believing the screen over that costs it the state its own hook just
 * reported. */
 function reportsWorking(agent) {
-	return agent === "claude";
+	return agentFamily(agent) === "claude";
+}
+/** Family of an instance id (`claude2` → `claude`); flags and hooks are
+* per family, every numbered copy behaves the same. */
+function agentFamily(agent) {
+	return agent ? parseAgentId(agent)?.family.id : void 0;
 }
 /** Extra argv for an agent CLI so it reports working/waiting state. */
 function agentLaunchFlags(agent) {
-	if (agent === "claude") {
+	const family = agentFamily(agent);
+	if (family === "claude") {
 		const hook = (state, reason) => [{ hooks: [{
 			type: "command",
 			command: stateCurl(state, reason)
@@ -6053,7 +6471,7 @@ function agentLaunchFlags(agent) {
 			Notification: hook("waiting", "attention")
 		} })];
 	}
-	if (agent === "codex") return ["-c", `notify=[${[
+	if (family === "codex") return ["-c", `notify=[${[
 		"sh",
 		"-c",
 		`[ -n "$WORK_SESSION_ID" ] && curl -sf -m 3 -X POST "http://127.0.0.1:\${WORK_APP_PORT:-${config.appPort}}/api/agent-state?session=$WORK_SESSION_ID&state=waiting&reason=done" -H 'content-type: application/json' --data "$1" >/dev/null 2>&1; exit 0`,
@@ -6070,7 +6488,7 @@ function getSession(id) {
 	return get("SELECT * FROM sessions WHERE id = ?", id);
 }
 function createSession(workspaceId, agent) {
-	if (!(agent in COMMANDS)) throw new Error(`unknown session kind: ${agent}`);
+	if (!isKnownAgent(agent)) throw new Error(`unknown session kind: ${agent}`);
 	const id = Math.random().toString(36).slice(2, 10);
 	db.prepare("INSERT INTO sessions (id, workspace_id, agent) VALUES (?, ?, ?)").run(id, workspaceId, agent);
 	notifySessionsChanged(workspaceId);
@@ -6085,14 +6503,37 @@ function renameSession(id, title) {
 async function killSession(id) {
 	const session = getSession(id);
 	if (!session) return;
+	await disposeSession(session.id);
+	notifySessionsChanged(session.workspace_id);
+}
+/** Drop tmux + DB row with no sessions.changed — used when the workspace
+* is already gone from the list (delete notifies workspaces first). */
+async function disposeSessions(sessions) {
+	for (const session of sessions) await disposeSession(session.id);
+}
+async function disposeSession(id) {
 	await tmux([
 		"kill-session",
 		"-t",
 		tmuxName(id)
 	]).catch(() => {});
+	clearTmuxStarted(id);
 	clearAgentPhase(id);
 	db.prepare("DELETE FROM sessions WHERE id = ?").run(id);
-	notifySessionsChanged(session.workspace_id);
+}
+/** Session ids that have had a tmux session created at least once in this
+* process. After the agent exits, tmux drops the session; term attach must
+* not `-A` recreate it (that looks like Ctrl-C "reopening" the agent). A
+* deliberate respawn clears and re-marks this. */
+var tmuxStarted = /* @__PURE__ */ new Set();
+function markTmuxStarted(id) {
+	tmuxStarted.add(id);
+}
+function tmuxWasStarted(id) {
+	return tmuxStarted.has(id);
+}
+function clearTmuxStarted(id) {
+	tmuxStarted.delete(id);
 }
 /** SSE payload: session rows + live tmux/hook state so clients don't refetch. */
 function notifySessionsChanged(workspaceId) {
@@ -6129,11 +6570,13 @@ async function sendToSession(id, text, size) {
 		"-t",
 		name
 	], env).then(() => true, () => false)) {
-		if (session.agent === "grok") {
+		if (agentFamily(session.agent) === "grok") {
 			await tmux(newSessionArgs(session, wsPath, "-d", text, size), env);
+			markTmuxStarted(id);
 			return;
 		}
 		await tmux(newSessionArgs(session, wsPath, "-d", void 0, size), env);
+		markTmuxStarted(id);
 		await sleep(AGENT_BOOT_MS);
 	}
 	const buffer = `work-send-${Math.random().toString(36).slice(2, 8)}`;
@@ -6201,7 +6644,7 @@ async function panePids() {
 * (tmux exits when its last session closes). */
 async function ensureTmuxServer() {
 	if (await tmux(["has-session"]).then(() => true, () => false)) return;
-	await run("systemd-run", [
+	await run$1("systemd-run", [
 		"--user",
 		"--unit=work-tmux",
 		"--service-type=forking",
@@ -6357,20 +6800,14 @@ function cleanEnv() {
 }
 var AGENT_BOOT_MS = 1500;
 var PASTE_SETTLE_MS = 150;
-/** Shell command each session kind runs inside its tmux session. */
-var COMMANDS = {
-	shell: [],
-	claude: ["claude"],
-	codex: ["codex"],
-	grok: ["grok"],
-	copilot: ["copilot"],
-	cursor: ["cursor-agent"]
-};
-/** Command for a session kind; `command.<agent>` in settings overrides (e.g. claude → claude1). */
+/** Command for a session kind: the instance's binary (`claude2`,
+* `cursor-agent`), nothing for `shell`; `command.<agent>` in settings still
+* overrides for one-off wrappers. */
 function sessionCommand(agent) {
 	const override = getSetting(`command.${agent}`);
 	if (override) return override.split(/\s+/);
-	return COMMANDS[agent] ?? [];
+	const command = agentCommand(agent);
+	return command ? [command] : [];
 }
 /** tmux new-session env flags so the agent's hooks can report back which
 * session they belong to. */
@@ -6389,4 +6826,4 @@ function sleep(ms) {
 	return new Promise((resolve) => setTimeout(resolve, ms));
 }
 //#endregion
-export { TMUX_SOCKET as A, db as B, pushPublicKey as C, preferredAgent as D, allPrefs as E, publish as F, workspacePath as H, subscribe as I, subscriberCount as L, git as M, run as N, setPref as O, tmux as P, subscriberJoins as R, deleteSubscription as S, AGENTS as T, config as U, get as V, reasonFromHookPayload as _, killSession as a, setSessionViewers as b, newSessionArgs as c, renameSession as d, sendToSession as f, clearAgentPhase as g, reportsWorking as h, getSession as i, gh as j, setSetting as k, notifySessionsChanged as l, tmuxName as m, createSession as n, killWorkspaceSessions as o, sessionStates as p, ensureTmuxServer as r, listSessions as s, cleanEnv as t, panePids as u, setAgentPhase as v, saveSubscription as w, summaryFromHookPayload as x, setScrapedPhase as y, all as z };
+export { all as $, allPrefs as A, which as B, setScrapedPhase as C, pushPublicKey as D, deleteSubscription as E, setPref as F, gh as G, agentById as H, setSetting as I, tmux as J, git as K, doctor as L, enabledAgents as M, preferredAgent as N, saveSubscription as O, setDisabledAgents as P, subscriberJoins as Q, miseVersions as R, setAgentPhase as S, summaryFromHookPayload as T, toolById as U, TOOLS as V, TMUX_SOCKET as W, subscribe as X, publish as Y, subscriberCount as Z, tmuxName as _, ensureTmuxServer as a, clearAgentPhase as b, killWorkspaceSessions as c, newSessionArgs as d, db as et, notifySessionsChanged as f, sessionStates as g, sendToSession as h, disposeSessions as i, disabledAgents as j, agentChoices as k, listSessions as l, renameSession as m, clearTmuxStarted as n, workspacePath as nt, getSession as o, panePids as p, run$1 as q, createSession as r, config as rt, killSession as s, cleanEnv as t, get as tt, markTmuxStarted as u, tmuxWasStarted as v, setSessionViewers as w, reasonFromHookPayload as x, reportsWorking as y, setupPath as z };

package/dist/_DjrRGy4k.js

@@ -0,0 +1,2 @@
+import { f as notifySessionsChanged } from "./_CO83dVER.js";
+export { notifySessionsChanged };