@generativereality/cctabs 0.4.0 → 0.4.2

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "cctabs",
   "description": "Claude Code tab manager. Terminal tabs as the UI, no tmux. Claude can orchestrate its own sibling sessions.",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "author": {
     "name": "generativereality",
     "url": "https://cctabs.com"

package/dist/index.js

@@ -11,7 +11,7 @@ import { consola } from "consola";
 import * as p from "@clack/prompts";
 //#region package.json
 var name = "@generativereality/cctabs";
-var version = "0.4.0";
+var version = "0.4.2";
 var description = "Claude Code tab manager. Terminal tabs as the UI, no tmux.";
 var package_default = {
 	name,
@@ -651,6 +651,8 @@ var TabbyAdapter = class {
 			"claude.ai/code",
 			"⏵⏵ bypass",
 			"⏵⏵ auto",
+			"new task?",
+			"Checking for updates",
 			"Thinking",
 			"Hatching",
 			"Composing",
@@ -694,6 +696,27 @@ var TabbyAdapter = class {
 	async renameTab(tabId, name) {
 		await this.http("PUT", `/api/tabs/${tabId}/title`, { title: name });
 	}
+	/**
+	* Fast path: the plugin's POST /api/tabs/new accepts {cwd, title, command,
+	* args} and returns the new tab's uuid synchronously. This collapses the
+	* whole newTab → waitForNewBlock → renameTab → wait-for-shell-prompt →
+	* sendInput sequence into a single round-trip, and (because the uuid is
+	* returned, not discovered by diffing) lets the caller open many tabs at once.
+	*/
+	async openTabDirect(opts) {
+		this.ensureHealthy();
+		const uuid = (await this.http("POST", "/api/tabs/new", {
+			cwd: opts.cwd,
+			title: opts.title,
+			command: opts.command,
+			args: opts.args
+		}))?.uuid;
+		if (!uuid) throw new Error("Tabby plugin did not return a tab uuid");
+		return {
+			blockId: uuid,
+			tabId: uuid
+		};
+	}
 	async sendInput(blockId, text) {
 		return this.http("POST", `/api/tabs/${blockId}/send`, { data: text });
 	}
@@ -1259,66 +1282,115 @@ async function waitForScrollbackMatch(adapter, blockId, pattern, label, timeoutM
 	}
 	throw new Error(`Timed out waiting for ${label}`);
 }
+/**
+* Wait for Claude's input prompt, then send the initial task and reliably
+* submit it.
+*
+* Reliability matters because a naive "send text, then send \r" loses the
+* Enter for multi-line prompts: the terminal treats the burst as a bracketed
+* paste and swallows a \r that arrives inside the paste window, leaving the
+* text sitting unsent in the input box. We fix that two ways:
+*   1. Wrap the prompt in explicit bracketed-paste markers so the (possibly
+*      multi-line) text is ingested as one paste and the following Enter lands
+*      *outside* it — an unambiguous submit, not a newline.
+*   2. Verify the turn actually started (a spinner / "esc to interrupt" hint
+*      appears only while Claude is processing, never at the idle prompt), and
+*      re-send Enter a few times if not, since a large paste can still be
+*      mid-ingest when the first Enter arrives.
+*/
+async function sendInitialPrompt(adapter, blockId, initialPromptFile) {
+	try {
+		await waitForScrollbackMatch(adapter, blockId, "❯", "Claude prompt", 3e4);
+	} catch {
+		adapter.closeSocket();
+		throw new Error("Claude prompt (❯) never appeared — not sending initial prompt. Check that claude started successfully.");
+	}
+	const prompt = readFileSync(initialPromptFile, "utf-8").trimEnd();
+	await adapter.sendInput(blockId, `\x1b[200~${prompt}\x1b[201~`);
+	for (let attempt = 0; attempt < 4; attempt++) {
+		await new Promise((r) => setTimeout(r, attempt === 0 ? 300 : 500));
+		await adapter.sendInput(blockId, "\r");
+		await new Promise((r) => setTimeout(r, 500));
+		const tail = adapter.scrollback(blockId, 40);
+		const compact = tail.replace(/\s+/g, "");
+		if (/[✻✽✶✳✢]/.test(tail) || /esctointerrupt/i.test(compact)) return;
+	}
+	consola.warn("Could not confirm the initial prompt was submitted — it may be sitting in the input box. Press Enter in the tab to send it.");
+}
 async function openSession(opts) {
 	const { tabName, claudeCmd, workspaceQuery, initialPromptFile, envVars, modelOverride } = opts;
+	const tailDelayMs = opts.tailDelayMs ?? 2e3;
 	const dir = resolve(opts.dir.replace(/^~/, homedir()));
-	if (!existsSync(dir)) {
-		consola.error(`Directory does not exist: ${dir}`);
-		process.exit(1);
-	}
+	if (!existsSync(dir)) throw new Error(`Directory does not exist: ${dir}`);
 	const config = loadConfig();
 	const adapter = requireAdapter();
+	const timing = !!process.env.CCTABS_TIMING;
+	let tPhase = Date.now();
+	const mark = (label) => {
+		if (!timing) return;
+		const now = Date.now();
+		consola.log(`    ⏱ ${tabName} ${label}: ${now - tPhase}ms`);
+		tPhase = now;
+	};
+	if (adapter.openTabDirect) {
+		const extraFlags = config.claude.flags.join(" ");
+		const namePart = claudeCmd.includes("--resume") ? "" : ` --name ${JSON.stringify(tabName)}`;
+		const modelPart = modelOverride ? ` --model ${JSON.stringify(modelOverride)}` : "";
+		const envPrefix = envVars ? shellQuoteEnv$1(envVars) : "";
+		const claudeCore = `claude${extraFlags ? " " + extraFlags : ""} ${claudeCmd.replace(/^claude\s*/, "")}${namePart}${modelPart}`.replace(/\s+/g, " ").trim();
+		const shell = process.env.SHELL ?? "/bin/zsh";
+		const launch = `${envPrefix}exec ${claudeCore}`;
+		const { blockId, tabId } = await adapter.openTabDirect({
+			cwd: dir,
+			title: tabName,
+			command: shell,
+			args: [
+				"-l",
+				"-i",
+				"-c",
+				launch
+			]
+		});
+		mark("openTabDirect");
+		if (initialPromptFile) await sendInitialPrompt(adapter, blockId, initialPromptFile);
+		adapter.closeSocket();
+		return tabId;
+	}
 	let focusWindowId;
 	if (workspaceQuery) {
 		const { workspaces } = await adapter.getAllData();
 		const matches = adapter.resolveWorkspace(workspaces, workspaceQuery);
-		if (!matches.length) {
-			consola.error(`No workspace matching '${workspaceQuery}'`);
-			process.exit(1);
-		}
+		if (!matches.length) throw new Error(`No workspace matching '${workspaceQuery}'`);
 		const { data, windowId } = matches[0];
-		if (!windowId) {
-			consola.error(`Workspace '${data.name}' has no open window`);
-			process.exit(1);
-		}
+		if (!windowId) throw new Error(`Workspace '${data.name}' has no open window`);
 		focusWindowId = windowId;
 		consola.info(`Workspace: ${data.name}`);
 	}
 	const beforeIds = new Set(adapter.blocksList().filter((b) => b.view === "term").map((b) => b.blockid));
+	mark("beforeIds");
 	await adapter.newTab(focusWindowId);
+	mark("newTab");
 	const result = await adapter.waitForNewBlock(beforeIds);
-	if (!result) {
-		consola.error("Timed out waiting for new terminal block");
-		process.exit(1);
-	}
+	if (!result) throw new Error("Timed out waiting for new terminal block");
+	mark("waitForNewBlock");
 	const { blockId, tabId } = result;
 	await adapter.renameTab(tabId, tabName);
+	mark("renameTab");
 	try {
 		await waitForScrollbackMatch(adapter, blockId, /[$%>]\s*$/, "shell prompt", 1e4, 250);
 	} catch {
-		consola.error("Shell prompt never appeared in new tab — aborting. Check your shell profile (e.g. nvm default alias).");
-		process.exit(1);
+		throw new Error("Shell prompt never appeared in new tab — aborting. Check your shell profile (e.g. nvm default alias).");
 	}
+	mark("shellPrompt");
 	const extraFlags = config.claude.flags.join(" ");
 	const namePart = claudeCmd.includes("--resume") ? "" : ` --name ${JSON.stringify(tabName)}`;
 	const modelPart = modelOverride ? ` --model ${JSON.stringify(modelOverride)}` : "";
 	const envPrefix = envVars ? shellQuoteEnv$1(envVars) : "";
 	const cmd = `cd ${JSON.stringify(dir)} && ${envPrefix}claude${extraFlags ? " " + extraFlags : ""} ${claudeCmd.replace(/^claude\s*/, "")}${namePart}${modelPart}\r`;
 	await adapter.sendInput(blockId, cmd);
-	if (initialPromptFile) {
-		try {
-			await waitForScrollbackMatch(adapter, blockId, "❯", "Claude prompt", 3e4);
-		} catch {
-			consola.error("Claude prompt (❯) never appeared — not sending initial prompt. Check that claude started successfully.");
-			adapter.closeSocket();
-			process.exit(1);
-		}
-		const prompt = readFileSync(initialPromptFile, "utf-8").trimEnd();
-		await adapter.sendInput(blockId, prompt);
-		await new Promise((r) => setTimeout(r, 100));
-		await adapter.sendInput(blockId, "\r");
-	}
-	await new Promise((r) => setTimeout(r, 2e3));
+	if (initialPromptFile) await sendInitialPrompt(adapter, blockId, initialPromptFile);
+	if (tailDelayMs > 0) await new Promise((r) => setTimeout(r, tailDelayMs));
+	mark("tail");
 	adapter.closeSocket();
 	return tabId;
 }
@@ -2339,24 +2411,29 @@ async function runManifestMode(manifestPath, createMissing, dryRun) {
 		}
 	}
 	adapter.closeSocket();
-	for (const entry of toSpawn) try {
-		const claudeCmd = entry.session_id ? `claude --resume ${entry.session_id} --name ${JSON.stringify(entry.name)}` : "claude";
-		const newTabId = await openSession({
-			tabName: entry.name,
-			dir: entry.dir,
-			claudeCmd
-		});
-		const sid = entry.session_id ? entry.session_id.slice(0, 8) + "…" : "fresh";
-		results.push({
-			name: entry.name,
-			result: `✔ spawned [${newTabId.slice(0, 8)}] (${sid})`
-		});
-	} catch (err) {
-		results.push({
-			name: entry.name,
-			result: `✘ spawn failed: ${err.message}`
-		});
-	}
+	const spawnOne = async (entry) => {
+		try {
+			const claudeCmd = entry.session_id ? `claude --resume ${entry.session_id} --name ${JSON.stringify(entry.name)}` : "claude";
+			const newTabId = await openSession({
+				tabName: entry.name,
+				dir: entry.dir,
+				claudeCmd,
+				tailDelayMs: 500
+			});
+			const sid = entry.session_id ? entry.session_id.slice(0, 8) + "…" : "fresh";
+			results.push({
+				name: entry.name,
+				result: `✔ spawned [${newTabId.slice(0, 8)}] (${sid})`
+			});
+		} catch (err) {
+			results.push({
+				name: entry.name,
+				result: `✘ spawn failed: ${err.message}`
+			});
+		}
+	};
+	if (typeof adapter.openTabDirect === "function") await Promise.all(toSpawn.map(spawnOne));
+	else for (const entry of toSpawn) await spawnOne(entry);
 	console.log("\nRestore summary:");
 	for (const r of results) console.log(`  ${r.name}: ${r.result}`);
 }
@@ -2391,6 +2468,7 @@ async function runLegacyMode(rawDir, dryRun) {
 	const extraFlags = loadConfig().claude.flags.join(" ");
 	const results = [];
 	const toRecreate = [];
+	const resolved = [];
 	for (const tab of toResume) {
 		let sessionId = null;
 		let sessionDir = null;
@@ -2437,8 +2515,21 @@ async function runLegacyMode(rawDir, dryRun) {
 			});
 			continue;
 		}
-		if (tab.status === "unknown") {
-			if (await adapter.confirmScrollbackEmpty(tab.blockId)) {
+		resolved.push({
+			tab,
+			sessionId,
+			sessionDir
+		});
+	}
+	if (!dryRun) {
+		const unknownTabs = resolved.filter((r) => r.tab.status === "unknown");
+		const emptyById = /* @__PURE__ */ new Map();
+		await Promise.all(unknownTabs.map(async (r) => {
+			emptyById.set(r.tab.tabId, await adapter.confirmScrollbackEmpty(r.tab.blockId));
+		}));
+		for (const r of resolved) {
+			const { tab, sessionId, sessionDir } = r;
+			if (tab.status === "unknown" && emptyById.get(tab.tabId)) {
 				const blockIds = (tabsById.get(tab.tabId) ?? []).map((b) => b.blockid);
 				toRecreate.push({
 					name: tab.name,
@@ -2453,15 +2544,15 @@ async function runLegacyMode(rawDir, dryRun) {
 				});
 				continue;
 			}
+			consola.log(`  ${tab.name} → resuming session ${sessionId.slice(0, 8)}… in ${sessionDir} (send)`);
+			const cmd = `cd ${JSON.stringify(sessionDir)} && claude${extraFlags ? " " + extraFlags : ""} --resume ${sessionId} --name ${JSON.stringify(tab.name)}\r`;
+			await adapter.sendInput(tab.blockId, cmd);
+			await new Promise((r) => setTimeout(r, 500));
+			results.push({
+				name: tab.name,
+				result: "sent"
+			});
 		}
-		consola.log(`  ${tab.name} → resuming session ${sessionId.slice(0, 8)}… in ${sessionDir} (send)`);
-		const cmd = `cd ${JSON.stringify(sessionDir)} && claude${extraFlags ? " " + extraFlags : ""} --resume ${sessionId} --name ${JSON.stringify(tab.name)}\r`;
-		await adapter.sendInput(tab.blockId, cmd);
-		await new Promise((r) => setTimeout(r, 500));
-		results.push({
-			name: tab.name,
-			result: "sent"
-		});
 	}
 	if (!dryRun) {
 		const sent = results.filter((r) => r.result === "sent");
@@ -2481,18 +2572,23 @@ async function runLegacyMode(rawDir, dryRun) {
 		for (const t of toRecreate) for (const bid of t.blockIds) adapter.deleteBlock(bid);
 		adapter.closeSocket();
 		consola.info(`Recreating ${toRecreate.length} dead tab(s)…`);
-		for (const t of toRecreate) try {
-			const newTabId = await openSession({
-				tabName: t.name,
-				dir: t.sessionDir,
-				claudeCmd: `claude --resume ${t.sessionId} --name ${JSON.stringify(t.name)}`
-			});
-			const r = results.find((x) => x.name === t.name);
-			r.result = `✔ recreated [${newTabId.slice(0, 8)}]`;
-		} catch (err) {
-			const r = results.find((x) => x.name === t.name);
-			r.result = `✘ recreate failed: ${err.message}`;
-		}
+		const recreateOne = async (t) => {
+			try {
+				const newTabId = await openSession({
+					tabName: t.name,
+					dir: t.sessionDir,
+					claudeCmd: `claude --resume ${t.sessionId} --name ${JSON.stringify(t.name)}`,
+					tailDelayMs: 500
+				});
+				const r = results.find((x) => x.name === t.name);
+				r.result = `✔ recreated [${newTabId.slice(0, 8)}]`;
+			} catch (err) {
+				const r = results.find((x) => x.name === t.name);
+				r.result = `✘ recreate failed: ${err.message}`;
+			}
+		};
+		if (typeof adapter.openTabDirect === "function") await Promise.all(toRecreate.map(recreateOne));
+		else for (const t of toRecreate) await recreateOne(t);
 	} else adapter.closeSocket();
 	console.log("\nRestore summary:");
 	for (const r of results) console.log(`  ${r.name}: ${r.result}`);
@@ -2603,18 +2699,18 @@ function checkTabbyPlugin() {
 }
 /**
 * Probe whether `node` is findable in a freshly spawned shell — the canonical
-* symptom of the macOS non-login PATH bug. Spawning `zsh -l -c 'command -v
-* node'` simulates the same login-shell init (/etc/zprofile → path_helper)
-* that cctabs now uses when it opens new Tabby tabs. If this fails, brand-new
-* tabs will also fail to find Node, every plugin MCP that shells out to npx
-* will ENOENT, and the cctabs CLI itself becomes unusable from inside those
-* tabs (chicken-and-egg). The remediation hint covers both the upstream-fix
-* path (rely on a recent cctabs that defaults to `-l`) and the dotfile
-* workaround for users on older versions or non-Tabby terminals.
+* symptom of the macOS PATH-sourcing bug. Spawning `zsh -l -i -c 'command -v
+* node'` simulates the same login + interactive shell init (/etc/zprofile →
+* path_helper, then ~/.zshrc) that cctabs uses when it opens new Tabby tabs.
+* If this fails, brand-new tabs will also fail to find Node, every plugin MCP
+* that shells out to npx will ENOENT, and the cctabs CLI itself becomes
+* unusable from inside those tabs (chicken-and-egg). The flags must match
+* open-session.ts to keep the doctor honest.
 */
 function checkSpawnedShellPath() {
 	const r = spawnSync("zsh", [
 		"-l",
+		"-i",
 		"-c",
 		"command -v node"
 	], {
@@ -2629,8 +2725,8 @@ function checkSpawnedShellPath() {
 	return {
 		name: "Spawned shell PATH",
 		status: "warn",
-		detail: r.error?.message ?? r.stderr?.trim() ?? "node not found in a login zsh",
-		hint: "A login zsh cannot find `node`. Either node is not installed, or PATH is broken. On macOS, `/usr/local/bin` is added by /etc/zprofile's path_helper — non-login shells skip it. Add `export PATH=\"/usr/local/bin:$PATH\"` to ~/.zshenv as a belt-and-braces fix."
+		detail: r.error?.message ?? r.stderr?.trim() ?? "node not found in a login+interactive zsh",
+		hint: "A login+interactive zsh cannot find `node`. Either node is not installed, or PATH is broken. cctabs spawns tabs with `zsh -l -i -c` so both ~/.zprofile and ~/.zshrc are sourced — if your PATH-extending logic lives elsewhere (e.g. a sourced file that bails on non-interactive), move the `export PATH=...` lines into ~/.zshenv as a belt-and-braces fix."
 	};
 }
 function checkWaveDb() {
@@ -3301,7 +3397,12 @@ async function run() {
 }
 //#endregion
 //#region src/index.ts
-updateNotifier({ pkg: package_default }).notify();
+const notifier = updateNotifier({ pkg: package_default });
+notifier.notify();
+if (notifier.update && notifier.update.latest !== notifier.update.current) {
+	const { current, latest } = notifier.update;
+	process.stdout.write(`[cctabs] OUTDATED ${current} < ${latest} — run: npm install -g ${name}@latest\n`);
+}
 run().catch((err) => {
 	console.error(err instanceof Error ? err.message : String(err));
 	process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@generativereality/cctabs",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "Claude Code tab manager. Terminal tabs as the UI, no tmux.",
   "type": "module",
   "bin": {

package/skills/cctabs/SKILL.md

@@ -44,6 +44,14 @@ npm install -g @generativereality/cctabs
 
 Do not modify PATH or npm configuration beyond this.
 
+### Check the installed version isn't stale
+
+On your first cctabs invocation in a session, look at the version banner cctabs prints (`(@generativereality/cctabs vX.Y.Z)`) and at any `[cctabs] OUTDATED ...` warning line in the output. If you see the warning — or if the banner version is older than the version in this skill's `plugin.json` — tell the user:
+
+> *"Your installed cctabs is `vX.Y.Z`; the current release is `vA.B.C`. Want me to upgrade with `npm install -g @generativereality/cctabs@latest` before continuing?"*
+
+Don't silently work around an outdated CLI: detection heuristics, command flags, and bug fixes diverge between versions, so misbehavior on the user's machine is often "binary on PATH lags behind the plugin docs you're reading." The Claude Code marketplace plugin update path only refreshes this skill — the npm-installed CLI binary is a separate channel and must be upgraded explicitly.
+
 ### Tabby users: a one-time plugin install is needed
 
 Wave Terminal works out of the box. **Tabby additionally needs a small companion plugin** that exposes a localhost HTTP API the cctabs CLI talks to.
@@ -66,7 +74,7 @@ On approval, run `cctabs install-tabby-plugin --yes`. Tabby quits ~2s after the
 
 If the user wants to keep their other Tabby tabs intact, run `cctabs install-tabby-plugin --no-restart` instead and tell them to quit + reopen Tabby themselves.
 
-`cctabs doctor` is also available for a deliberate environment check (terminal, Wave Accessibility, plugin reachability, Wave DB) — useful if something feels off, but **not required as a preflight** since every command fails loudly on its own.
+`cctabs doctor` is also available for a deliberate environment check. It adapts to whichever terminal you're running in — terminal detection runs either way; on Wave it additionally inspects Accessibility permission and scans the Wave DB for orphan tabids; on Tabby it probes the cctabs plugin's localhost health endpoint. Useful if something feels off, but **not required as a preflight** since every command fails loudly on its own.
 
 #### Auto-install + auto-restart (recommended)
 
@@ -263,7 +271,7 @@ cctabs resume api ~/Dev/myapp
 
 ## Workflow: Restoring tabs after a reboot
 
-After a Wave/computer restart, every tab loses its Claude session and shows up with `terminal` or `unknown` status. `cctabs restore` walks every such tab, looks up its session by name across **all** Claude project directories, and re-attaches in place.
+After a terminal restart or computer reboot, every tab loses its Claude session and shows up with `terminal` or `unknown` status (true for both Wave and Tabby). `cctabs restore` walks every such tab, looks up its session by name across **all** Claude project directories, and re-attaches in place.
 
 ```bash
 cctabs restore                    # search all projects (default)