@generativereality/cctabs 0.1.2 → 0.1.4

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.1.2",
+  "version": "0.1.4",
   "author": {
     "name": "generativereality",
     "url": "https://cctabs.com"

package/dist/index.js

@@ -10,7 +10,7 @@ import { consola } from "consola";
 import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "fs";
 //#region package.json
 var name = "@generativereality/cctabs";
-var version = "0.1.2";
+var version = "0.1.4";
 var description = "Claude Code tab manager. Terminal tabs as the UI, no tmux.";
 var package_default = {
 	name,
@@ -202,14 +202,17 @@ var WaveAdapter = class {
 		this.jwt = process.env.WAVETERM_JWT ?? "";
 	}
 	blocksList() {
+		const wsId = process.env.WAVETERM_WORKSPACEID ?? "";
+		const args = [
+			"blocks",
+			"list",
+			"--json",
+			"--timeout",
+			"15000"
+		];
+		if (wsId) args.push("--workspace", wsId);
 		try {
-			const out = execFileSync("wsh", [
-				"blocks",
-				"list",
-				"--json",
-				"--timeout",
-				"15000"
-			], { encoding: "utf-8" });
+			const out = execFileSync("wsh", args, { encoding: "utf-8" });
 			return JSON.parse(out);
 		} catch {
 			return [];
@@ -325,27 +328,37 @@ var WaveAdapter = class {
 			tabsById.set(b.tabid, arr);
 		}
 		const tabNames = /* @__PURE__ */ new Map();
-		let workspaces = [];
+		let rawWorkspaces = [];
 		try {
 			for (const tabId of tabsById.keys()) {
 				const td = await this.getTab(tabId);
 				tabNames.set(tabId, td.name ?? tabId.slice(0, 8));
 			}
-			workspaces = await this.workspaceList();
+			rawWorkspaces = await this.workspaceList();
 		} catch {} finally {
 			this.closeSocket();
 		}
-		if (!workspaces.length) {
-			const wsId = process.env.WAVETERM_WORKSPACEID ?? "";
-			workspaces = [{
-				workspacedata: {
-					oid: wsId,
-					name: wsId.slice(0, 8) || "default",
-					tabids: [...tabsById.keys()]
-				},
-				windowid: ""
-			}];
-		}
+		const currentWsId = process.env.WAVETERM_WORKSPACEID ?? "";
+		const tabIdsHere = [...tabsById.keys()];
+		const existing = rawWorkspaces.find((w) => w.workspacedata.oid === currentWsId);
+		const workspaces = [];
+		if (currentWsId) workspaces.push({
+			workspacedata: {
+				oid: currentWsId,
+				name: existing?.workspacedata.name ?? (currentWsId.slice(0, 8) || "current"),
+				tabids: tabIdsHere
+			},
+			windowid: existing?.windowid ?? ""
+		});
+		for (const ws of rawWorkspaces) if (ws.workspacedata.oid !== currentWsId) workspaces.push(ws);
+		if (!workspaces.length) workspaces.push({
+			workspacedata: {
+				oid: "",
+				name: "default",
+				tabids: tabIdsHere
+			},
+			windowid: ""
+		});
 		return {
 			blocks,
 			tabsById,
@@ -763,6 +776,72 @@ function findSessionsByName(dir, name) {
 	return matches.sort((a, b) => b.mtime - a.mtime);
 }
 /**
+* Like findSessionsByName, but searches every project directory under
+* ~/.claude/projects. Each match carries the cwd recorded in the session.
+* Used by `cctabs restore` so callers don't have to guess the right dir.
+*/
+function findSessionsByNameGlobally(name) {
+	const projectsRoot = join(homedir(), ".claude", "projects");
+	if (!existsSync(projectsRoot)) return [];
+	const matches = [];
+	for (const slug of readdirSync(projectsRoot)) {
+		const projectDir = join(projectsRoot, slug);
+		let isDir = false;
+		try {
+			isDir = statSync(projectDir).isDirectory();
+		} catch {
+			continue;
+		}
+		if (!isDir) continue;
+		const files = readdirSync(projectDir).filter((f) => extname(f) === ".jsonl");
+		for (const f of files) {
+			const fullPath = join(projectDir, f);
+			try {
+				const lines = readFileSync(fullPath, "utf-8").split("\n");
+				let currentTitle = "";
+				let cwd = "";
+				let firstPrompt = "";
+				let lastActivity = "";
+				for (const line of lines) {
+					if (!line.trim()) continue;
+					try {
+						const entry = JSON.parse(line);
+						if (entry.customTitle !== void 0) currentTitle = entry.customTitle;
+						if (!cwd && typeof entry.cwd === "string") cwd = entry.cwd;
+						if (!firstPrompt && entry.type === "user" && entry.message?.content) {
+							const text = typeof entry.message.content === "string" ? entry.message.content : entry.message.content.find((c) => c.type === "text")?.text ?? "";
+							if (text.startsWith("<")) continue;
+							firstPrompt = text.slice(0, 120).replace(/\n/g, " ").trim();
+							if (text.length > 120) firstPrompt += "…";
+						}
+						if (entry.message?.role === "assistant" && entry.message?.content) {
+							const parts = Array.isArray(entry.message.content) ? entry.message.content : [{
+								type: "text",
+								text: entry.message.content
+							}];
+							for (const p of parts) if (p.type === "text" && p.text?.trim()) {
+								lastActivity = p.text.slice(0, 120).replace(/\n/g, " ").trim();
+								if (p.text.length > 120) lastActivity += "…";
+							}
+						}
+					} catch {}
+				}
+				if (currentTitle !== name || !cwd) continue;
+				const stat = statSync(fullPath);
+				matches.push({
+					id: basename(f, ".jsonl"),
+					mtime: stat.mtimeMs,
+					size: stat.size,
+					firstPrompt,
+					lastActivity,
+					dir: cwd
+				});
+			} catch {}
+		}
+	}
+	return matches.sort((a, b) => b.mtime - a.mtime);
+}
+/**
 * List all unique session names (customTitle) in a project directory.
 * Used to show available names when a resume lookup fails.
 */
@@ -790,6 +869,39 @@ function listSessionNames(dir) {
 	}
 	return results.sort((a, b) => b.mtime - a.mtime);
 }
+/**
+* Resolve a session ID prefix (e.g. "19aae7b4") to the full UUID by scanning
+* `~/.claude/projects/`. Returns the input unchanged if it already looks like
+* a full UUID, or null if no unique match exists. Pass `dir` to scope the
+* search to one project; otherwise every project is checked.
+*
+* `claude --resume <prefix>` does NOT accept truncated IDs — it treats them
+* as a search query and shows the picker. So callers must expand prefixes
+* before forwarding to claude.
+*/
+function expandSessionId(input, dir) {
+	if (!input) return null;
+	if (/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/i.test(input)) return input;
+	const projectsRoot = join(homedir(), ".claude", "projects");
+	if (!existsSync(projectsRoot)) return null;
+	const projectDirs = dir ? [join(projectsRoot, pathToProjectSlug(dir))] : readdirSync(projectsRoot).map((d) => join(projectsRoot, d)).filter((p) => {
+		try {
+			return statSync(p).isDirectory();
+		} catch {
+			return false;
+		}
+	});
+	const matches = [];
+	for (const pd of projectDirs) {
+		if (!existsSync(pd)) continue;
+		for (const f of readdirSync(pd)) {
+			if (extname(f) !== ".jsonl") continue;
+			const id = basename(f, ".jsonl");
+			if (id.startsWith(input) && !matches.includes(id)) matches.push(id);
+		}
+	}
+	return matches.length === 1 ? matches[0] : null;
+}
 //#endregion
 //#region src/commands/resume.ts
 function formatAge(mtimeMs) {
@@ -831,8 +943,14 @@ const resumeCommand = define({
 		}
 		const explicitSession = ctx.values.session;
 		let sessionId;
-		if (explicitSession) sessionId = explicitSession;
-		else {
+		if (explicitSession) {
+			const expanded = expandSessionId(explicitSession, dir) ?? expandSessionId(explicitSession);
+			if (!expanded) {
+				consola.error(`Session '${explicitSession}' not found (or matches multiple sessions). Pass the full UUID.`);
+				process.exit(1);
+			}
+			sessionId = expanded;
+		} else {
 			const sessions = findSessionsByName(dir, name);
 			if (sessions.length === 0) {
 				consola.error(`No session named "${name}" in ${dir}`);
@@ -1232,20 +1350,15 @@ const configCommand = define({
 //#region src/commands/restore.ts
 const restoreCommand = define({
 	name: "restore",
-	description: "Resume Claude sessions in all terminal-state tabs (e.g. after a reboot)",
-	args: {
-		dir: {
-			type: "positional",
-			description: "Working directory (default: cwd)"
-		},
-		dry: {
-			type: "boolean",
-			short: "n",
-			description: "Show what would be resumed without actually doing it"
-		}
-	},
+	description: "Resume Claude sessions in all terminal-state tabs (e.g. after a reboot). Searches every Claude project dir by default; pass an explicit dir to scope the search.",
+	args: { dry: {
+		type: "boolean",
+		short: "n",
+		description: "Show what would be resumed without actually doing it"
+	} },
 	async run(ctx) {
-		const dir = resolve((ctx.positionals[1] ?? process.cwd()).replace(/^~/, homedir()));
+		const rawDir = ctx.positionals[1];
+		const scopedDir = rawDir ? resolve(rawDir.replace(/^~/, homedir())) : null;
 		const dryRun = ctx.values.dry;
 		const adapter = requireWaveAdapter();
 		const { tabsById, workspaces, tabNames } = await adapter.getAllData();
@@ -1277,27 +1390,45 @@ const restoreCommand = define({
 		const results = [];
 		const toRecreate = [];
 		for (const tab of toResume) {
-			const sessions = findSessionsByName(dir, tab.name);
-			if (sessions.length === 0) {
-				consola.log(`  ${tab.name} — no session named "${tab.name}" found, skipping`);
-				results.push({
-					name: tab.name,
-					result: "no matching session"
-				});
-				continue;
-			}
-			if (sessions.length > 1) {
-				consola.log(`  ${tab.name} — multiple sessions found, skipping (use cctabs resume --session to pick one)`);
-				results.push({
-					name: tab.name,
-					result: "ambiguous (multiple sessions)"
-				});
-				continue;
+			let sessionId = null;
+			let sessionDir = null;
+			if (scopedDir) {
+				const sessions = findSessionsByName(scopedDir, tab.name);
+				if (sessions.length === 0) {
+					consola.log(`  ${tab.name} — no session named "${tab.name}" found in ${scopedDir}, skipping`);
+					results.push({
+						name: tab.name,
+						result: "no matching session"
+					});
+					continue;
+				}
+				if (sessions.length > 1) {
+					consola.log(`  ${tab.name} — multiple sessions found, skipping (use cctabs resume --session to pick one)`);
+					results.push({
+						name: tab.name,
+						result: "ambiguous (multiple sessions)"
+					});
+					continue;
+				}
+				sessionId = sessions[0].id;
+				sessionDir = scopedDir;
+			} else {
+				const sessions = findSessionsByNameGlobally(tab.name);
+				if (sessions.length === 0) {
+					consola.log(`  ${tab.name} — no session named "${tab.name}" found in any project, skipping`);
+					results.push({
+						name: tab.name,
+						result: "no matching session"
+					});
+					continue;
+				}
+				if (sessions.length > 1) consola.log(`  ${tab.name} — multiple sessions found across projects, picking newest (${sessions[0].dir})`);
+				sessionId = sessions[0].id;
+				sessionDir = sessions[0].dir;
 			}
-			const sessionId = sessions[0].id;
 			if (dryRun) {
 				const mode = tab.status === "unknown" ? "recreate" : "send";
-				consola.log(`  ${tab.name} → would ${mode} session ${sessionId.slice(0, 8)}…`);
+				consola.log(`  ${tab.name} → would ${mode} session ${sessionId.slice(0, 8)}… in ${sessionDir}`);
 				results.push({
 					name: tab.name,
 					result: `dry run: ${sessionId.slice(0, 8)}…`
@@ -1310,6 +1441,7 @@ const restoreCommand = define({
 					toRecreate.push({
 						name: tab.name,
 						sessionId,
+						sessionDir,
 						blockIds,
 						tabId: tab.tabId
 					});
@@ -1320,8 +1452,8 @@ const restoreCommand = define({
 					continue;
 				}
 			}
-			consola.log(`  ${tab.name} → resuming session ${sessionId.slice(0, 8)}… (send)`);
-			const cmd = `cd ${JSON.stringify(dir)} && claude${extraFlags ? " " + extraFlags : ""} --resume ${sessionId} --name ${JSON.stringify(tab.name)}\r`;
+			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({
@@ -1350,7 +1482,7 @@ const restoreCommand = define({
 			for (const t of toRecreate) try {
 				const newTabId = await openSession({
 					tabName: t.name,
-					dir,
+					dir: t.sessionDir,
 					claudeCmd: `claude --resume ${t.sessionId} --name ${JSON.stringify(t.name)}`
 				});
 				const r = results.find((x) => x.name === t.name);

package/package.json

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

package/skills/cctabs/SKILL.md

@@ -71,6 +71,7 @@ cctabs sessions                          # list all tabs with session status
 cctabs list                              # list all workspaces, tabs, and blocks
 cctabs new <name> [dir] [-w workspace] [-p "prompt"] [-f file]  # new tab + claude
 cctabs resume <name> [dir]               # resume last session (reuses tab or creates one)
+cctabs restore [dir] [--dry]             # resume every dead tab (e.g. after a reboot)
 cctabs fork <tab-name> [-n new-name]     # fork session into new tab (--resume <id> --fork-session)
 cctabs close <name-or-id>                # close a tab
 cctabs rename <name-or-id> <new-name>    # rename a tab
@@ -126,6 +127,18 @@ cctabs resume api ~/Dev/myapp
 **Use `cctabs resume` instead of `cctabs new` when you want to continue a previous conversation.**
 `cctabs new` always starts a fresh Claude session. `cctabs resume` picks up where the last session left off.
 
+## 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.
+
+```bash
+cctabs restore                    # search all projects (default)
+cctabs restore --dry              # preview what would be resumed without doing it
+cctabs restore ~/Dev/myapp        # restrict the search to one project dir
+```
+
+If a session was started in a different `cwd` than the tab's current directory (common after `cd`-ing inside the tab), the global search still finds it via the recorded session metadata — no need to guess the right dir.
+
 ## Workflow: Forking a Session
 
 Use `fork` when you want to explore an alternative approach without disrupting the original.