@agentuity/opencode 0.1.41 → 0.1.42

package/src/tmux/manager.ts

@@ -1,4 +1,5 @@
 import type { PluginInput } from '@opencode-ai/plugin';
+import { spawn, spawnSync } from 'bun';
 import type {
 	PaneAction,
 	TmuxConfig,
@@ -16,6 +17,9 @@ import {
 	closeAgentsWindow,
 	closeAgentsWindowSync,
 	closePaneById,
+	killProcessByPid,
+	killOrphanedAttachProcesses,
+	killOrphanedAttachProcessesSync,
 } from './executor';
 
 /**
@@ -76,8 +80,18 @@ export class TmuxSessionManager {
 		parentId: string;
 		title: string;
 	}): Promise<void> {
-		if (!this.isEnabled()) return;
-		if (this.pendingSessions.has(event.sessionId) || this.sessions.has(event.sessionId)) return;
+		this.log(`onSessionCreated called for ${event.sessionId} (${event.title})`);
+
+		if (!this.isEnabled()) {
+			this.log(
+				`Skipping - tmux not enabled (config: ${this.config.enabled}, insideTmux: ${isInsideTmux()})`
+			);
+			return;
+		}
+		if (this.pendingSessions.has(event.sessionId) || this.sessions.has(event.sessionId)) {
+			this.log(`Skipping - session ${event.sessionId} already pending or tracked`);
+			return;
+		}
 		this.pendingSessions.add(event.sessionId);
 
 		try {
@@ -147,7 +161,10 @@ export class TmuxSessionManager {
 				return;
 			}
 
-			this.applyActionResults(decision.actions, result.spawnedPaneId);
+			this.applyActionResults(decision.actions, result.results);
+			this.log(
+				`Successfully spawned pane for ${event.sessionId}. Tracking ${this.sessions.size} sessions. PIDs: ${this.getTrackedPids().join(', ') || 'none'}`
+			);
 			if (this.sessions.size > 0) {
 				this.startPolling();
 			}
@@ -156,6 +173,15 @@ export class TmuxSessionManager {
 		}
 	}
 
+	/**
+	 * Get all tracked PIDs for logging
+	 */
+	private getTrackedPids(): number[] {
+		return Array.from(this.sessions.values())
+			.map((s) => s.pid)
+			.filter((pid): pid is number => pid !== undefined);
+	}
+
 	/**
 	 * Handle a session being deleted
 	 *
@@ -164,20 +190,35 @@ export class TmuxSessionManager {
 	 * terminal that keeps running even after the session goes idle.
 	 */
 	async onSessionDeleted(event: { sessionId: string }): Promise<void> {
-		if (!this.isEnabled()) return;
+		this.log(`onSessionDeleted called for ${event.sessionId}`);
+
+		if (!this.isEnabled()) {
+			this.log(`Skipping delete - tmux not enabled`);
+			return;
+		}
 
 		// Find the session in our mappings
 		const session = this.sessions.get(event.sessionId);
-		if (!session) return;
+		if (!session) {
+			this.log(`Session ${event.sessionId} not found in tracked sessions`);
+			return;
+		}
+
+		this.log(
+			`Closing pane ${session.paneId} (PID: ${session.pid}) for session ${event.sessionId}`
+		);
 
 		// Kill the pane explicitly - opencode attach won't exit on its own
-		const result = await closePaneById(session.paneId);
+		const result = await closePaneById(session.paneId, session.pid);
 		if (!result.success) {
 			this.log(`Failed to close pane ${session.paneId}: ${result.error}`);
+		} else {
+			this.log(`Successfully closed pane ${session.paneId}`);
 		}
 
 		// Update internal state
 		this.sessions.delete(event.sessionId);
+		this.log(`Removed session from tracking. Now tracking ${this.sessions.size} sessions.`);
 
 		if (this.sessions.size === 0) {
 			this.stopPolling();
@@ -188,13 +229,35 @@ export class TmuxSessionManager {
 	 * Clean up all panes on shutdown
 	 *
 	 * Kills the entire "Agents" window, which closes all agent panes at once.
+	 * Falls back to pkill if PID-based cleanup fails.
 	 */
 	async cleanup(): Promise<void> {
+		this.log('Starting cleanup...');
 		this.stopPolling();
 
+		let pidCleanupFailed = false;
+		for (const session of this.sessions.values()) {
+			if (!session.pid) continue;
+			this.log(`Killing process ${session.pid} for session ${session.sessionId}`);
+			const success = await killProcessByPid(session.pid);
+			if (!success) {
+				this.log(`Failed to kill process ${session.pid} for session ${session.sessionId}`);
+				pidCleanupFailed = true;
+			}
+		}
+
 		// Kill the entire agents window - this closes all panes at once
 		await closeAgentsWindow();
 		this.sessions.clear();
+
+		// Fallback: if PID-based cleanup failed, use pkill to catch any orphans
+		if (pidCleanupFailed) {
+			this.log('PID-based cleanup had failures, running fallback cleanup...');
+			const serverUrl = this.getServerUrl();
+			await killOrphanedAttachProcesses(serverUrl, (msg) => this.log(msg));
+		}
+
+		this.log('Cleanup complete');
 	}
 
 	/**
@@ -204,11 +267,35 @@ export class TmuxSessionManager {
 	 * process exits, which is necessary for signal handlers.
 	 */
 	cleanupSync(): void {
+		this.log('Starting sync cleanup...');
 		this.stopPolling();
 
+		let pidCleanupFailed = false;
+		for (const session of this.sessions.values()) {
+			if (!session.pid) continue;
+			this.log(`Killing process ${session.pid} for session ${session.sessionId}`);
+			this.killProcessByPidSync(session.pid);
+			// Check if process is still alive after kill attempt
+			try {
+				process.kill(session.pid, 0);
+				pidCleanupFailed = true; // Process still exists
+			} catch {
+				// Process is dead, good
+			}
+		}
+
 		// Kill the entire agents window synchronously
 		closeAgentsWindowSync();
 		this.sessions.clear();
+
+		// Fallback: if PID-based cleanup failed, use pkill to catch any orphans
+		if (pidCleanupFailed) {
+			this.log('PID-based cleanup had failures, running fallback cleanup...');
+			const serverUrl = this.getServerUrl();
+			killOrphanedAttachProcessesSync(serverUrl, (msg) => this.log(msg));
+		}
+
+		this.log('Sync cleanup complete');
 	}
 
 	/**
@@ -287,9 +374,13 @@ export class TmuxSessionManager {
 		return typeof serverUrl === 'string' ? serverUrl : serverUrl.toString();
 	}
 
-	private applyActionResults(actions: PaneAction[], spawnedPaneId: string | undefined): void {
+	private applyActionResults(
+		actions: PaneAction[],
+		results: Array<{ action: PaneAction; result: { paneId?: string; pid?: number } }>
+	): void {
 		const now = new Date();
-		for (const action of actions) {
+		for (const [index, action] of actions.entries()) {
+			const actionResult = results[index]?.result;
 			switch (action.type) {
 				case 'close':
 					this.sessions.delete(action.sessionId);
@@ -299,17 +390,19 @@ export class TmuxSessionManager {
 					this.sessions.set(action.newSessionId, {
 						sessionId: action.newSessionId,
 						paneId: action.paneId,
+						pid: actionResult?.pid,
 						description: action.description,
 						createdAt: now,
 						lastSeenAt: now,
 					});
 					break;
 				case 'spawn': {
-					const paneId = spawnedPaneId;
+					const paneId = actionResult?.paneId;
 					if (!paneId) break;
 					this.sessions.set(action.sessionId, {
 						sessionId: action.sessionId,
 						paneId,
+						pid: actionResult?.pid,
 						description: action.description,
 						createdAt: now,
 						lastSeenAt: now,
@@ -320,9 +413,162 @@ export class TmuxSessionManager {
 		}
 	}
 
+	/**
+	 * Find and report orphaned processes (does NOT kill them by default).
+	 * Call this manually if you need to identify orphaned processes after a crash.
+	 *
+	 * Note: This method only reports - it does not kill processes because we cannot
+	 * reliably distinguish between processes we spawned vs user-initiated sessions.
+	 * The shutdown cleanup (cleanup/cleanupSync) is safe because it only kills PIDs
+	 * we explicitly tracked during this session.
+	 */
+	async reportOrphanedProcesses(): Promise<number[]> {
+		if (!this.isEnabled()) return [];
+		const serverUrl = this.getServerUrl();
+		if (!serverUrl) return [];
+
+		const trackedSessionIds = new Set(this.sessions.keys());
+		const orphanedPids = await this.findOrphanedAttachPids(serverUrl, trackedSessionIds);
+
+		if (orphanedPids.length > 0) {
+			this.log(
+				`Found ${orphanedPids.length} potentially orphaned processes: ${orphanedPids.join(', ')}`
+			);
+			this.log(
+				'These may be user-initiated sessions. Run "pkill -f opencode\\ attach" to clean them up manually if needed.'
+			);
+		}
+
+		return orphanedPids;
+	}
+
+	private async findOrphanedAttachPids(
+		serverUrl: string,
+		trackedSessionIds: Set<string>
+	): Promise<number[]> {
+		try {
+			const proc = spawn(['ps', 'aux'], { stdout: 'pipe', stderr: 'pipe' });
+			await proc.exited;
+			const output = await new Response(proc.stdout).text();
+			const lines = output.split('\n');
+			const matches: number[] = [];
+
+			for (const line of lines) {
+				if (!line.includes('opencode attach')) continue;
+				if (!line.includes(serverUrl)) continue;
+				const parts = line.trim().split(/\s+/);
+				const pid = Number(parts[1]);
+				if (!Number.isFinite(pid) || pid <= 0) continue;
+				if (pid === process.pid) continue;
+				const sessionId = this.extractSessionId(line);
+				if (sessionId && trackedSessionIds.has(sessionId)) continue;
+				matches.push(pid);
+			}
+
+			return matches;
+		} catch {
+			return [];
+		}
+	}
+
+	private extractSessionId(line: string): string | undefined {
+		const match = line.match(/--session\s+(['"]?)([^'";\s]+)\1/);
+		return match?.[2];
+	}
+
+	/**
+	 * Kill a process and all its children synchronously.
+	 *
+	 * This is necessary because we spawn `bash -c "opencode attach ...; tmux kill-pane"`
+	 * and #{pane_pid} returns the bash PID, not the opencode attach PID.
+	 */
+	private killProcessByPidSync(pid: number): void {
+		if (!Number.isFinite(pid) || pid <= 0) return;
+
+		// First, kill all child processes
+		try {
+			spawnSync(['pkill', '-TERM', '-P', String(pid)]);
+		} catch {
+			// Ignore errors - children may not exist
+		}
+
+		// Then kill the parent
+		try {
+			process.kill(pid, 'SIGTERM');
+		} catch (error) {
+			const code = (error as NodeJS.ErrnoException).code;
+			if (code === 'ESRCH') return;
+			return;
+		}
+
+		// Wait for processes to die
+		try {
+			const buffer = new SharedArrayBuffer(4);
+			const view = new Int32Array(buffer);
+			Atomics.wait(view, 0, 0, 1000);
+		} catch {
+			// ignore sleep errors
+		}
+
+		// Check if parent is dead
+		try {
+			process.kill(pid, 0);
+		} catch (error) {
+			const code = (error as NodeJS.ErrnoException).code;
+			if (code === 'ESRCH') return; // Dead, good
+		}
+
+		// Force kill children
+		try {
+			spawnSync(['pkill', '-KILL', '-P', String(pid)]);
+		} catch {
+			// Ignore errors
+		}
+
+		// Force kill parent
+		try {
+			process.kill(pid, 'SIGKILL');
+		} catch {
+			// ignore errors
+		}
+	}
+
 	private log(message: string): void {
 		this.callbacks?.onLog?.(`[tmux] ${message}`);
 	}
+
+	/**
+	 * Static method to clean up orphaned processes without needing an instance.
+	 * This is useful for manual cleanup commands.
+	 *
+	 * @param serverUrl - Optional server URL to filter processes
+	 * @param logger - Optional logging function
+	 * @returns Object with cleanup results
+	 */
+	static async cleanupOrphans(
+		serverUrl?: string,
+		logger?: (msg: string) => void
+	): Promise<{ killed: number; windowClosed: boolean }> {
+		const log = logger ?? (() => {});
+
+		log('Starting orphan cleanup...');
+
+		// First, try to close the agents window (recovers from persisted file)
+		let windowClosed = false;
+		try {
+			await closeAgentsWindow();
+			windowClosed = true;
+			log('Closed agents window');
+		} catch {
+			log('No agents window to close');
+		}
+
+		// Then kill any orphaned processes
+		const killed = await killOrphanedAttachProcesses(serverUrl, log);
+
+		log(`Orphan cleanup complete: ${killed} processes killed, window closed: ${windowClosed}`);
+		return { killed, windowClosed };
+	}
 }
 
 function findPane(state: WindowState, paneId: string): TmuxPaneInfo | undefined {

package/src/tmux/state-query.ts

@@ -32,6 +32,9 @@ export async function queryWindowState(sourcePaneId: string): Promise<WindowStat
 		const parts = line.split(',');
 		if (parts.length < 9) continue;
 
+		const paneId = parts[0];
+		if (!paneId) continue;
+
 		const windowWidthValue = Number(parts[parts.length - 2]);
 		const windowHeightValue = Number(parts[parts.length - 1]);
 		const isActiveValue = parts[parts.length - 3] === '1';
@@ -46,7 +49,7 @@ export async function queryWindowState(sourcePaneId: string): Promise<WindowStat
 		}
 
 		const paneInfo: TmuxPaneInfo = {
-			paneId: parts[0],
+			paneId,
 			width,
 			height,
 			left,

package/src/tmux/types.ts

@@ -27,6 +27,7 @@ export interface WindowState {
 export interface TrackedSession {
 	sessionId: string; // OpenCode session ID
 	paneId: string; // Tmux pane ID
+	pid?: number; // Process ID for direct killing
 	description: string; // Task description
 	createdAt: Date;
 	lastSeenAt: Date;