@generativereality/cctabs 0.1.2 → 0.1.3

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.3",
   "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.3";
 var description = "Claude Code tab manager. Terminal tabs as the UI, no tmux.";
 var package_default = {
 	name,
@@ -763,6 +763,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.
 */
@@ -1232,20 +1298,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 +1338,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 +1389,7 @@ const restoreCommand = define({
 					toRecreate.push({
 						name: tab.name,
 						sessionId,
+						sessionDir,
 						blockIds,
 						tabId: tab.tabId
 					});
@@ -1320,8 +1400,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 +1430,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.3",
   "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.