ccdock 0.1.0

package/src/workspace/editor.ts

@@ -0,0 +1,32 @@
+import {
+	focusAndPositionEditor,
+	getSidebarBounds,
+	positionEditorWindow,
+	editorWindowExists,
+} from "./window.ts";
+
+export async function openEditor(worktreePath: string, editor: string): Promise<void> {
+	Bun.spawn([editor, "--new-window", worktreePath], {
+		stdout: "ignore",
+		stderr: "ignore",
+	});
+
+	const basename = worktreePath.split("/").pop() ?? "";
+
+	// Wait for the VS Code window to actually appear (up to 10 seconds)
+	for (let i = 0; i < 20; i++) {
+		await Bun.sleep(500);
+		if (await editorWindowExists(basename)) break;
+	}
+
+	// Position the new window next to the sidebar
+	const sidebar = await getSidebarBounds();
+	if (sidebar) {
+		await positionEditorWindow(basename, sidebar);
+	}
+}
+
+export async function focusEditor(worktreePath: string, _editor: string): Promise<boolean> {
+	const basename = worktreePath.split("/").pop() ?? "";
+	return focusAndPositionEditor(basename);
+}

package/src/workspace/state.ts

@@ -0,0 +1,150 @@
+import {
+	existsSync,
+	mkdirSync,
+	readFileSync,
+	readdirSync,
+	unlinkSync,
+	writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import type { AgentState, WorkspaceSession } from "../types.ts";
+
+const STATE_DIR_NAME = "ccdock";
+const STALE_THRESHOLD_MS = 5 * 60 * 1000; // 5 minutes
+
+export function getStateDir(): string {
+	const home = process.env.HOME ?? "";
+	const stateBase = process.env.XDG_STATE_HOME ?? join(home, ".local", "state");
+	return join(stateBase, STATE_DIR_NAME);
+}
+
+function getSessionsDir(): string {
+	return join(getStateDir(), "sessions");
+}
+
+function getAgentsDir(): string {
+	return join(getStateDir(), "agents");
+}
+
+let dirsEnsured = false;
+
+function ensureDirs(): void {
+	if (dirsEnsured) return;
+	const sessionsDir = getSessionsDir();
+	const agentsDir = getAgentsDir();
+	if (!existsSync(sessionsDir)) {
+		mkdirSync(sessionsDir, { recursive: true });
+	}
+	if (!existsSync(agentsDir)) {
+		mkdirSync(agentsDir, { recursive: true });
+	}
+	dirsEnsured = true;
+}
+
+export function saveSession(session: WorkspaceSession): void {
+	ensureDirs();
+	const filePath = join(getSessionsDir(), `${session.id}.json`);
+	const { agents: _agents, editorState: _editorState, ...serializable } = session;
+	writeFileSync(filePath, JSON.stringify(serializable, null, 2));
+}
+
+export function loadSessions(): WorkspaceSession[] {
+	ensureDirs();
+	const sessionsDir = getSessionsDir();
+	const files = readdirSync(sessionsDir).filter((f) => f.endsWith(".json"));
+	const sessions: WorkspaceSession[] = [];
+
+	for (const file of files) {
+		try {
+			const raw = readFileSync(join(sessionsDir, file), "utf-8");
+			const parsed = JSON.parse(raw) as WorkspaceSession;
+			parsed.agents = [];
+			parsed.editorState = parsed.editorState ?? "closed";
+			sessions.push(parsed);
+		} catch {
+			// Skip malformed files
+		}
+	}
+
+	return sessions.sort((a, b) => b.lastActiveAt - a.lastActiveAt);
+}
+
+export function deleteSession(id: string): void {
+	const filePath = join(getSessionsDir(), `${id}.json`);
+	if (existsSync(filePath)) {
+		unlinkSync(filePath);
+	}
+}
+
+export function loadAgentStates(): AgentState[] {
+	ensureDirs();
+	const agentsDir = getAgentsDir();
+	const files = readdirSync(agentsDir).filter((f) => f.endsWith(".json"));
+	const states: AgentState[] = [];
+
+	for (const file of files) {
+		try {
+			const raw = readFileSync(join(agentsDir, file), "utf-8");
+			const parsed = JSON.parse(raw) as AgentState;
+			states.push(parsed);
+		} catch {
+			// Skip malformed files
+		}
+	}
+
+	return states;
+}
+
+export function cleanStaleAgents(): void {
+	ensureDirs();
+	const agentsDir = getAgentsDir();
+	const files = readdirSync(agentsDir).filter((f) => f.endsWith(".json"));
+	const now = Date.now();
+
+	for (const file of files) {
+		try {
+			const filePath = join(agentsDir, file);
+			const raw = readFileSync(filePath, "utf-8");
+			const parsed = JSON.parse(raw) as AgentState;
+			if (now - parsed.updatedAt > STALE_THRESHOLD_MS) {
+				unlinkSync(filePath);
+			}
+		} catch {
+			// Skip
+		}
+	}
+}
+
+export function findSessionByPath(cwd: string): string {
+	const sessions = loadSessions();
+	for (const session of sessions) {
+		if (cwd.startsWith(session.worktreePath)) {
+			return session.id;
+		}
+	}
+	return "";
+}
+
+export function readAgentState(filename: string): AgentState | null {
+	const filePath = join(getAgentsDir(), filename);
+	if (!existsSync(filePath)) return null;
+	try {
+		const raw = readFileSync(filePath, "utf-8");
+		return JSON.parse(raw) as AgentState;
+	} catch {
+		return null;
+	}
+}
+
+export function writeAgentState(state: AgentState, filename: string): void {
+	ensureDirs();
+	const filePath = join(getAgentsDir(), filename);
+	writeFileSync(filePath, JSON.stringify(state, null, 2));
+}
+
+export function removeAgentFile(filename: string): void {
+	const filePath = join(getAgentsDir(), filename);
+	if (existsSync(filePath)) {
+		unlinkSync(filePath);
+	}
+}

package/src/workspace/window.ts

@@ -0,0 +1,323 @@
+/**
+ * macOS native window management via AppleScript/osascript.
+ * macOS native window management via AppleScript/System Events.
+ */
+
+interface WindowBounds {
+	x: number;
+	y: number;
+	width: number;
+	height: number;
+}
+
+async function runOsascript(script: string): Promise<string> {
+	const proc = Bun.spawn(["osascript", "-e", script], {
+		stdout: "pipe",
+		stderr: "pipe",
+	});
+	const out = await new Response(proc.stdout).text();
+	await proc.exited;
+	return out.trim();
+}
+
+/**
+ * Get the bounds of the sidebar terminal window (the frontmost Ghostty window).
+ */
+export async function getSidebarBounds(): Promise<WindowBounds | null> {
+	try {
+		const result = await runOsascript(`
+tell application "System Events"
+	tell process "Ghostty"
+		set w to front window
+		set p to position of w
+		set s to size of w
+		return "" & (item 1 of p) & "," & (item 2 of p) & "," & (item 1 of s) & "," & (item 2 of s)
+	end tell
+end tell
+`);
+		const parts = result.split(",").map((s) => Number.parseInt(s.trim(), 10));
+		if (parts.length < 4) return null;
+		return { x: parts[0]!, y: parts[1]!, width: parts[2]!, height: parts[3]! };
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Get the screen bounds that the sidebar is on.
+ * Returns the full screen dimensions for the monitor containing the sidebar.
+ */
+export async function getScreenBounds(): Promise<WindowBounds | null> {
+	try {
+		const result = await runOsascript(`
+tell application "Finder"
+	set db to bounds of window of desktop
+	return "" & (item 1 of db) & "," & (item 2 of db) & "," & (item 3 of db) & "," & (item 4 of db)
+end tell
+`);
+		const parts = result.split(",").map((s) => Number.parseInt(s.trim(), 10));
+		if (parts.length < 4) return null;
+		return {
+			x: parts[0]!,
+			y: parts[1]!,
+			width: parts[2]! - parts[0]!,
+			height: parts[3]! - parts[1]!,
+		};
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Move and resize a VS Code window to fill the area right of the sidebar.
+ * The VS Code window is brought to the current space and positioned
+ * adjacent to the sidebar terminal.
+ */
+export async function positionEditorWindow(
+	windowTitle: string,
+	sidebarBounds: WindowBounds,
+): Promise<boolean> {
+	// Calculate editor position: right of sidebar, same height
+	const editorX = sidebarBounds.x + sidebarBounds.width + 4; // 4px gap
+	const editorY = sidebarBounds.y;
+	// Editor width: fill remaining screen width (estimate with a large number)
+	// We'll get the actual screen width for precision
+	const screen = await getScreenBounds();
+	const screenRight = screen ? screen.x + screen.width : 5120; // fallback
+	const editorWidth = screenRight - editorX;
+	const editorHeight = sidebarBounds.height;
+
+	try {
+		// Escape single quotes in title for AppleScript
+		const escapedTitle = windowTitle.replace(/'/g, "'\"'\"'");
+
+		await runOsascript(`
+tell application "System Events"
+	tell process "Code"
+		set targetWindow to missing value
+		repeat with w in every window
+			if name of w contains "${escapedTitle}" then
+				set targetWindow to w
+				exit repeat
+			end if
+		end repeat
+		if targetWindow is not missing value then
+			set position of targetWindow to {${editorX}, ${editorY}}
+			set size of targetWindow to {${editorWidth}, ${editorHeight}}
+		end if
+	end tell
+end tell
+`);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Check if a VS Code window with the given title exists.
+ */
+export async function editorWindowExists(windowTitle: string): Promise<boolean> {
+	const windows = await listEditorWindows();
+	return windows.some((w) => w.includes(windowTitle));
+}
+
+/**
+ * Bring a VS Code window to front and position it next to the sidebar.
+ * Returns false if the window doesn't exist.
+ */
+export async function focusAndPositionEditor(windowTitle: string): Promise<boolean> {
+	// First check if the window actually exists
+	if (!(await editorWindowExists(windowTitle))) {
+		return false;
+	}
+
+	const sidebar = await getSidebarBounds();
+	if (!sidebar) return false;
+
+	try {
+		const escapedTitle = windowTitle.replace(/'/g, "'\"'\"'");
+
+		// Activate VS Code and raise the specific window
+		await runOsascript(`
+tell application "System Events"
+	tell process "Code"
+		set frontmost to true
+		repeat with w in every window
+			if name of w contains "${escapedTitle}" then
+				perform action "AXRaise" of w
+				exit repeat
+			end if
+		end repeat
+	end tell
+end tell
+`);
+
+		// Position it next to sidebar
+		await positionEditorWindow(windowTitle, sidebar);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Check if VS Code process is running.
+ */
+async function isEditorRunning(): Promise<boolean> {
+	try {
+		const proc = Bun.spawn(["pgrep", "-x", "Code"], { stdout: "ignore", stderr: "ignore" });
+		await proc.exited;
+		return proc.exitCode === 0;
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * List all VS Code window titles.
+ */
+export async function listEditorWindows(): Promise<string[]> {
+	if (!(await isEditorRunning())) return [];
+	try {
+		const result = await runOsascript(`
+tell application "System Events"
+	tell process "Code"
+		set titles to {}
+		repeat with w in every window
+			set end of titles to name of w
+		end repeat
+		set AppleScript's text item delimiters to "|||"
+		return titles as text
+	end tell
+end tell
+`);
+		if (!result) return [];
+		return result.split("|||").filter((t) => t.length > 0);
+	} catch {
+		return [];
+	}
+}
+
+/**
+ * Get the focused (front) VS Code window title, and whether VS Code is frontmost app.
+ */
+export async function getFocusedEditorWindow(): Promise<{
+	frontWindow: string;
+	isFrontmost: boolean;
+}> {
+	if (!(await isEditorRunning())) return { frontWindow: "", isFrontmost: false };
+	try {
+		const result = await runOsascript(`
+tell application "System Events"
+	tell process "Code"
+		set isFront to frontmost
+		set wName to name of front window
+		return (isFront as text) & "|||" & wName
+	end tell
+end tell
+`);
+		const [isFrontStr, windowName] = result.split("|||");
+		return {
+			frontWindow: windowName ?? "",
+			isFrontmost: isFrontStr === "true",
+		};
+	} catch {
+		return { frontWindow: "", isFrontmost: false };
+	}
+}
+
+/**
+ * Focus the sidebar terminal (bring Ghostty to front).
+ */
+export async function focusSidebar(): Promise<void> {
+	try {
+		await runOsascript(`
+tell application "Ghostty" to activate
+`);
+	} catch {
+		// Ghostty not available
+	}
+}
+
+/**
+ * Close a specific VS Code window by title match.
+ * Raises the window then sends Cmd+W to close it.
+ */
+export async function closeEditorWindow(windowTitle: string): Promise<void> {
+	if (!(await isEditorRunning())) return;
+	try {
+		const escapedTitle = windowTitle.replace(/'/g, "'\"'\"'");
+		await runOsascript(`
+tell application "System Events"
+	tell process "Code"
+		set frontmost to true
+		repeat with w in every window
+			if name of w contains "${escapedTitle}" then
+				perform action "AXRaise" of w
+				delay 0.2
+				keystroke "w" using {command down, shift down}
+				exit repeat
+			end if
+		end repeat
+	end tell
+end tell
+`);
+	} catch {
+		// Window not found or already closed
+	}
+}
+
+/**
+ * Close all VS Code windows (without quitting the app).
+ */
+export async function closeAllEditors(): Promise<void> {
+	if (!(await isEditorRunning())) return;
+	try {
+		// Close each window one by one with Cmd+Shift+W (close window, not tab)
+		await runOsascript(`
+tell application "System Events"
+	tell process "Code"
+		set frontmost to true
+		repeat while (count of windows) > 0
+			keystroke "w" using {command down, shift down}
+			delay 0.3
+		end repeat
+	end tell
+end tell
+`);
+	} catch {
+		// VS Code not running
+	}
+}
+
+/**
+ * Reposition ALL VS Code windows to fill the area right of the sidebar.
+ * Called when the sidebar terminal is resized.
+ */
+export async function repositionAllEditors(): Promise<void> {
+	if (!(await isEditorRunning())) return;
+	const [sidebar, screen] = await Promise.all([getSidebarBounds(), getScreenBounds()]);
+	if (!sidebar) return;
+
+	try {
+		const editorX = sidebar.x + sidebar.width + 4;
+		const editorY = sidebar.y;
+		const screenRight = screen ? screen.x + screen.width : 5120;
+		const editorWidth = screenRight - editorX;
+		const editorHeight = sidebar.height;
+
+		await runOsascript(`
+tell application "System Events"
+	tell process "Code"
+		repeat with w in every window
+			set position of w to {${editorX}, ${editorY}}
+			set size of w to {${editorWidth}, ${editorHeight}}
+		end repeat
+	end tell
+end tell
+`);
+	} catch {
+		// VS Code not running or no windows
+	}
+}

package/src/worktree/manager.ts

@@ -0,0 +1,120 @@
+import { existsSync } from "node:fs";
+import type { WorktreeEntry } from "../types.ts";
+
+export async function createWorktree(repoPath: string, branchName: string): Promise<string> {
+	const proc = Bun.spawn(["git", "wt", branchName], {
+		cwd: repoPath,
+		stdout: "pipe",
+		stderr: "pipe",
+	});
+	const [stdout, stderr] = await Promise.all([
+		new Response(proc.stdout).text(),
+		new Response(proc.stderr).text(),
+	]);
+	const code = await proc.exited;
+	if (code !== 0) {
+		throw new Error(stderr.trim() || `git wt exited with code ${code}`);
+	}
+
+	// Parse worktree path from output - look for absolute paths
+	const output = stdout.trim();
+	const lines = output.split("\n");
+	for (const line of [...lines].reverse()) {
+		const trimmed = line.trim();
+		if (trimmed.startsWith("/")) return trimmed;
+	}
+
+	// Fallback: find worktree via git worktree list
+	const listProc = Bun.spawn(["git", "-C", repoPath, "worktree", "list", "--porcelain"], {
+		stdout: "pipe",
+		stderr: "pipe",
+	});
+	const listOutput = await new Response(listProc.stdout).text();
+	await listProc.exited;
+
+	let currentPath = "";
+	for (const line of listOutput.split("\n")) {
+		if (line.startsWith("worktree ")) currentPath = line.slice(9);
+		else if (line.startsWith("branch ")) {
+			const branch = line.slice(7).replace("refs/heads/", "");
+			if (branch === branchName) return currentPath;
+		}
+	}
+
+	throw new Error(`Could not determine worktree path from git wt output:\n${output}`);
+}
+
+export async function removeWorktree(worktreePath: string): Promise<void> {
+	if (!existsSync(worktreePath)) return;
+
+	// Find the main repo for this worktree
+	const proc = Bun.spawn(["git", "-C", worktreePath, "worktree", "list", "--porcelain"], {
+		stdout: "pipe",
+		stderr: "pipe",
+	});
+	const output = await new Response(proc.stdout).text();
+	await proc.exited;
+
+	// First entry in worktree list is the main worktree
+	const lines = output.split("\n");
+	const mainWorktreeLine = lines.find((l) => l.startsWith("worktree "));
+	if (!mainWorktreeLine) {
+		throw new Error("Could not determine main worktree");
+	}
+	const mainPath = mainWorktreeLine.replace("worktree ", "");
+
+	// Remove the worktree
+	const removeProc = Bun.spawn(
+		["git", "-C", mainPath, "worktree", "remove", worktreePath, "--force"],
+		{
+			stdout: "pipe",
+			stderr: "pipe",
+		},
+	);
+	const stderr = await new Response(removeProc.stderr).text();
+	await removeProc.exited;
+
+	if (removeProc.exitCode !== 0) {
+		throw new Error(`Failed to remove worktree: ${stderr}`);
+	}
+}
+
+export async function listWorktrees(repoPath: string): Promise<WorktreeEntry[]> {
+	const proc = Bun.spawn(["git", "-C", repoPath, "worktree", "list", "--porcelain"], {
+		stdout: "pipe",
+		stderr: "pipe",
+	});
+	const output = await new Response(proc.stdout).text();
+	await proc.exited;
+
+	if (proc.exitCode !== 0) return [];
+
+	const entries: WorktreeEntry[] = [];
+	const blocks = output.split("\n\n").filter((b) => b.trim());
+
+	for (const block of blocks) {
+		const lines = block.split("\n");
+		let path = "";
+		let branch = "";
+		let isBare = false;
+
+		for (const line of lines) {
+			if (line.startsWith("worktree ")) {
+				path = line.replace("worktree ", "");
+			} else if (line.startsWith("branch ")) {
+				// refs/heads/main -> main
+				const ref = line.replace("branch ", "");
+				const parts = ref.split("/");
+				branch = parts.slice(2).join("/");
+			} else if (line === "bare") {
+				isBare = true;
+			}
+		}
+
+		if (path && !isBare) {
+			entries.push({ path, branch });
+		}
+	}
+
+	return entries;
+}

package/src/worktree/scanner.ts

@@ -0,0 +1,82 @@
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import type { RepoInfo } from "../types.ts";
+
+async function getDefaultBranch(repoPath: string): Promise<string> {
+	try {
+		const proc = Bun.spawn(["git", "-C", repoPath, "symbolic-ref", "refs/remotes/origin/HEAD"], {
+			stdout: "pipe",
+			stderr: "pipe",
+		});
+		const output = await new Response(proc.stdout).text();
+		await proc.exited;
+		if (proc.exitCode === 0) {
+			// refs/remotes/origin/main -> main
+			const parts = output.trim().split("/");
+			return parts[parts.length - 1] ?? "main";
+		}
+	} catch {
+		// Fall through
+	}
+
+	// Fallback: check if main or master exists
+	try {
+		const proc = Bun.spawn(["git", "-C", repoPath, "branch", "--list", "main", "master"], {
+			stdout: "pipe",
+			stderr: "pipe",
+		});
+		const output = await new Response(proc.stdout).text();
+		await proc.exited;
+		const branches = output
+			.trim()
+			.split("\n")
+			.map((b) => b.trim().replace("* ", ""));
+		if (branches.includes("main")) return "main";
+		if (branches.includes("master")) return "master";
+	} catch {
+		// Fall through
+	}
+
+	return "main";
+}
+
+export async function scanRepos(workspaceDirs: string[]): Promise<RepoInfo[]> {
+	// Collect all repo paths first
+	const repoPaths: { name: string; path: string }[] = [];
+
+	for (const dir of workspaceDirs) {
+		if (!existsSync(dir)) continue;
+
+		let entries: string[];
+		try {
+			entries = readdirSync(dir);
+		} catch {
+			continue;
+		}
+
+		for (const entry of entries) {
+			const fullPath = join(dir, entry);
+			try {
+				const stat = statSync(fullPath);
+				if (!stat.isDirectory()) continue;
+
+				const gitDir = join(fullPath, ".git");
+				if (!existsSync(gitDir)) continue;
+
+				repoPaths.push({ name: entry, path: fullPath });
+			} catch {
+				// Skip entries that can't be processed
+			}
+		}
+	}
+
+	// Resolve default branches in parallel
+	const repos = await Promise.all(
+		repoPaths.map(async ({ name, path }) => {
+			const defaultBranch = await getDefaultBranch(path);
+			return { name, path, defaultBranch };
+		}),
+	);
+
+	return repos.sort((a, b) => a.name.localeCompare(b.name));
+}