@agentuity/opencode 0.1.41 → 0.1.43

package/src/tmux/index.ts

@@ -7,5 +7,11 @@ export {
 	executeActions,
 	closeAgentsWindow,
 	closeAgentsWindowSync,
+	getAgentsWindowId,
+	cleanupOwnedResources,
+	cleanupOwnedResourcesSync,
+	findOwnedAgentPanes,
+	getPanePid,
+	getPanePidSync,
 } from './executor';
 export { TmuxSessionManager } from './manager';

package/src/tmux/manager.ts

@@ -1,4 +1,6 @@
 import type { PluginInput } from '@opencode-ai/plugin';
+import { spawnSync } from 'bun';
+import { randomUUID } from 'node:crypto';
 import type {
 	PaneAction,
 	TmuxConfig,
@@ -8,7 +10,13 @@ import type {
 	SessionMapping,
 } from './types';
 import { POLL_INTERVAL_MS, SESSION_MISSING_GRACE_MS, SESSION_TIMEOUT_MS } from './types';
-import { getCurrentPaneId, getTmuxPath, isInsideTmux } from './utils';
+import {
+	canonicalizeServerUrl,
+	getCurrentPaneId,
+	getTmuxPath,
+	getTmuxSessionId,
+	isInsideTmux,
+} from './utils';
 import { queryWindowState } from './state-query';
 import { decideSpawnActions } from './decision-engine';
 import {
@@ -16,6 +24,12 @@ import {
 	closeAgentsWindow,
 	closeAgentsWindowSync,
 	closePaneById,
+	killProcessByPid,
+	getPanePid,
+	getPanePidSync,
+	cleanupOwnedResources,
+	cleanupOwnedResourcesSync,
+	findOwnedAgentPanes,
 } from './executor';
 
 /**
@@ -51,6 +65,16 @@ export class TmuxSessionManager {
 	private pendingSessions = new Set<string>();
 	private pollInterval?: ReturnType<typeof setInterval>;
 	private sourcePaneId: string | undefined;
+	private tmuxSessionId: string | undefined;
+	private instanceId = randomUUID().slice(0, 8);
+	private ownerPid = process.pid;
+	private serverKey: string | undefined;
+	private statusMissingSince = new Map<string, number>();
+	/**
+	 * Operation queue to serialize tmux mutations.
+	 * This prevents race conditions when multiple sessions are created rapidly.
+	 */
+	private tmuxOpQueue: Promise<void> = Promise.resolve();
 
 	constructor(
 		private ctx: PluginInput,
@@ -60,6 +84,20 @@ export class TmuxSessionManager {
 		this.sourcePaneId = getCurrentPaneId();
 	}
 
+	/**
+	 * Enqueue a tmux operation to ensure sequential execution.
+	 * This prevents race conditions when multiple sessions are created/deleted rapidly.
+	 */
+	private enqueue<T>(fn: () => Promise<T>): Promise<T> {
+		const result = this.tmuxOpQueue.then(fn, fn); // Run even if previous failed
+		// Update queue but don't propagate errors to next operation
+		this.tmuxOpQueue = result.then(
+			() => {},
+			() => {}
+		);
+		return result;
+	}
+
 	/**
 	 * Check if tmux integration is enabled and available
 	 */
@@ -70,14 +108,38 @@ export class TmuxSessionManager {
 	/**
 	 * Handle a new background session being created
 	 * This is called by BackgroundManager when a background task starts
+	 *
+	 * Operations are queued to prevent race conditions when multiple sessions
+	 * are created rapidly.
 	 */
 	async onSessionCreated(event: {
 		sessionId: string;
 		parentId: string;
 		title: string;
 	}): Promise<void> {
-		if (!this.isEnabled()) return;
-		if (this.pendingSessions.has(event.sessionId) || this.sessions.has(event.sessionId)) return;
+		return this.enqueue(() => this.doSessionCreated(event));
+	}
+
+	/**
+	 * Internal implementation of session creation (runs within the queue)
+	 */
+	private async doSessionCreated(event: {
+		sessionId: string;
+		parentId: string;
+		title: string;
+	}): Promise<void> {
+		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 {
@@ -96,6 +158,14 @@ export class TmuxSessionManager {
 				return;
 			}
 
+			// Get the tmux session ID for this pane (cached after first lookup)
+			if (!this.tmuxSessionId) {
+				this.tmuxSessionId = await getTmuxSessionId(this.sourcePaneId);
+				if (this.tmuxSessionId) {
+					this.log(`Resolved tmux session ID: ${this.tmuxSessionId}`);
+				}
+			}
+
 			const state = await queryWindowState(this.sourcePaneId);
 			if (!state) {
 				this.log('Failed to query tmux window state.');
@@ -136,10 +206,19 @@ export class TmuxSessionManager {
 				return;
 			}
 
+			const serverKey = canonicalizeServerUrl(serverUrl);
+			this.serverKey = serverKey;
+
 			const result = await executeActions(decision.actions, {
 				config: this.config,
 				serverUrl,
 				windowState: state,
+				ownership: {
+					instanceId: this.instanceId,
+					ownerPid: this.ownerPid,
+					serverKey,
+					tmuxSessionId: this.tmuxSessionId,
+				},
 			});
 
 			if (!result.success) {
@@ -147,7 +226,11 @@ export class TmuxSessionManager {
 				return;
 			}
 
-			this.applyActionResults(decision.actions, result.spawnedPaneId);
+			this.applyActionResults(decision.actions, result.results);
+			await this.refreshMissingPids();
+			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,28 +239,62 @@ 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
 	 *
 	 * Explicitly kills the pane when a background session completes.
 	 * We can't rely on `opencode attach` exiting because it's an interactive
 	 * terminal that keeps running even after the session goes idle.
+	 *
+	 * Operations are queued to prevent race conditions.
 	 */
 	async onSessionDeleted(event: { sessionId: string }): Promise<void> {
-		if (!this.isEnabled()) return;
+		return this.enqueue(() => this.doSessionDeleted(event));
+	}
+
+	/**
+	 * Internal implementation of session deletion (runs within the queue)
+	 */
+	private async doSessionDeleted(event: { sessionId: string }): Promise<void> {
+		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.statusMissingSince.delete(event.sessionId);
+		this.log(`Removed session from tracking. Now tracking ${this.sessions.size} sessions.`);
 
 		if (this.sessions.size === 0) {
 			this.stopPolling();
@@ -188,13 +305,38 @@ 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();
 
-		// Kill the entire agents window - this closes all panes at once
-		await closeAgentsWindow();
+		for (const session of this.sessions.values()) {
+			let pid = session.pid;
+			if (!pid) {
+				pid = await getPanePid(session.paneId);
+				if (pid) {
+					session.pid = pid;
+				}
+			}
+			if (!pid) continue;
+			this.log(`Killing process ${pid} for session ${session.sessionId}`);
+			const success = await killProcessByPid(pid);
+			if (!success) {
+				this.log(`Failed to kill process ${pid} for session ${session.sessionId}`);
+			}
+		}
+
+		const serverKey = this.getServerKey();
+		if (serverKey) {
+			await cleanupOwnedResources(serverKey, this.instanceId);
+		} else {
+			await closeAgentsWindow();
+		}
 		this.sessions.clear();
+		this.statusMissingSince.clear();
+
+		this.log('Cleanup complete');
 	}
 
 	/**
@@ -204,11 +346,32 @@ export class TmuxSessionManager {
 	 * process exits, which is necessary for signal handlers.
 	 */
 	cleanupSync(): void {
+		this.log('Starting sync cleanup...');
 		this.stopPolling();
 
-		// Kill the entire agents window synchronously
-		closeAgentsWindowSync();
+		for (const session of this.sessions.values()) {
+			let pid = session.pid;
+			if (!pid) {
+				pid = getPanePidSync(session.paneId);
+				if (pid) {
+					session.pid = pid;
+				}
+			}
+			if (!pid) continue;
+			this.log(`Killing process ${pid} for session ${session.sessionId}`);
+			this.killProcessByPidSync(pid);
+		}
+
+		const serverKey = this.getServerKey();
+		if (serverKey) {
+			cleanupOwnedResourcesSync(serverKey, this.instanceId);
+		} else {
+			closeAgentsWindowSync();
+		}
 		this.sessions.clear();
+		this.statusMissingSince.clear();
+
+		this.log('Sync cleanup complete');
 	}
 
 	/**
@@ -234,32 +397,75 @@ export class TmuxSessionManager {
 	 * Poll active sessions for status changes
 	 */
 	private async pollSessions(): Promise<void> {
+		return this.enqueue(() => this.doPollSessions());
+	}
+
+	/**
+	 * Poll active sessions for status changes
+	 */
+	private async doPollSessions(): Promise<void> {
 		if (!this.isEnabled()) return;
 		if (!this.sourcePaneId) return;
 
 		const state = await queryWindowState(this.sourcePaneId);
 		if (!state) return;
+		const statusMap = await this.fetchSessionStatuses();
 
 		const now = Date.now();
+		const sessionsToClose: TrackedSession[] = [];
 		for (const session of this.sessions.values()) {
 			const pane = findPane(state, session.paneId);
 			if (pane) {
 				session.lastSeenAt = new Date();
-				continue;
+				if (!session.pid) {
+					const pid = await getPanePid(session.paneId);
+					if (pid) {
+						session.pid = pid;
+					}
+				}
+			} else {
+				const missingFor = now - session.lastSeenAt.getTime();
+				if (missingFor > SESSION_MISSING_GRACE_MS) {
+					if (session.pid) {
+						await killProcessByPid(session.pid);
+					}
+					this.sessions.delete(session.sessionId);
+					this.statusMissingSince.delete(session.sessionId);
+					continue;
+				}
 			}
 
-			const missingFor = now - session.lastSeenAt.getTime();
-			if (missingFor > SESSION_MISSING_GRACE_MS) {
-				this.sessions.delete(session.sessionId);
-				continue;
+			const status = statusMap[session.sessionId];
+			if (status) {
+				this.statusMissingSince.delete(session.sessionId);
+			} else if (!this.statusMissingSince.has(session.sessionId)) {
+				this.statusMissingSince.set(session.sessionId, now);
 			}
 
+			const statusMissingAt = this.statusMissingSince.get(session.sessionId);
+			const missingTooLong =
+				statusMissingAt !== undefined && now - statusMissingAt > SESSION_MISSING_GRACE_MS;
 			const age = now - session.createdAt.getTime();
-			if (age > SESSION_TIMEOUT_MS) {
-				this.sessions.delete(session.sessionId);
+			const isTimedOut = age > SESSION_TIMEOUT_MS;
+			const isIdle = status?.type === 'idle';
+
+			if (isIdle || missingTooLong || isTimedOut) {
+				sessionsToClose.push(session);
 			}
 		}
 
+		for (const session of sessionsToClose) {
+			this.log(`Closing idle session ${session.sessionId} (pane: ${session.paneId})`);
+			const result = await closePaneById(session.paneId, session.pid);
+			if (!result.success) {
+				this.log(
+					`Failed to close pane ${session.paneId} for session ${session.sessionId}: ${result.error}`
+				);
+			}
+			this.sessions.delete(session.sessionId);
+			this.statusMissingSince.delete(session.sessionId);
+		}
+
 		if (this.sessions.size === 0) {
 			this.stopPolling();
 		}
@@ -287,29 +493,50 @@ export class TmuxSessionManager {
 		return typeof serverUrl === 'string' ? serverUrl : serverUrl.toString();
 	}
 
-	private applyActionResults(actions: PaneAction[], spawnedPaneId: string | undefined): void {
+	private getServerKey(): string | undefined {
+		if (this.serverKey) return this.serverKey;
+		const serverUrl = this.getServerUrl();
+		if (!serverUrl) return undefined;
+		try {
+			const serverKey = canonicalizeServerUrl(serverUrl);
+			this.serverKey = serverKey;
+			return serverKey;
+		} catch (error) {
+			this.log(`Failed to canonicalize server URL "${serverUrl}": ${error}`);
+			return undefined;
+		}
+	}
+
+	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);
 					break;
 				case 'replace':
 					this.sessions.delete(action.oldSessionId);
+					this.statusMissingSince.delete(action.oldSessionId);
 					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,12 +547,174 @@ export class TmuxSessionManager {
 		}
 	}
 
+	private async refreshMissingPids(): Promise<void> {
+		for (const session of this.sessions.values()) {
+			if (session.pid) continue;
+			const pid = await getPanePid(session.paneId);
+			if (pid) {
+				session.pid = pid;
+			}
+		}
+	}
+
+	private async fetchSessionStatuses(): Promise<Record<string, { type?: string }>> {
+		try {
+			const result = await this.ctx.client.session.status({
+				path: undefined,
+				throwOnError: false,
+			});
+			const data = unwrapResponse<Record<string, { type?: string }>>(result);
+			if (!data || typeof data !== 'object') return {};
+			return data;
+		} catch {
+			return {};
+		}
+	}
+
+	/**
+	 * 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 serverKey = this.getServerKey();
+		if (!serverKey) return [];
+
+		const trackedSessionIds = new Set(this.sessions.keys());
+		const panes = await findOwnedAgentPanes(serverKey);
+		const orphanedPanes = panes.filter((pane) => {
+			if (!pane.sessionId) return false;
+			return !trackedSessionIds.has(pane.sessionId);
+		});
+
+		if (orphanedPanes.length > 0) {
+			const sessionIds = orphanedPanes
+				.map((pane) => pane.sessionId)
+				.filter((sessionId): sessionId is string => !!sessionId);
+			this.log(
+				`Found ${orphanedPanes.length} potentially orphaned sessions: ${sessionIds.join(', ')}`
+			);
+			this.log(
+				'These may be user-initiated sessions. Close their tmux panes manually if needed.'
+			);
+		}
+
+		return orphanedPanes
+			.map((pane) => pane.panePid)
+			.filter((pid): pid is number => typeof pid === 'number');
+	}
+
+	/**
+	 * 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
+	 * @param instanceId - Ownership instance id to target cleanup
+	 * @returns Object with cleanup results
+	 */
+	static async cleanupOrphans(
+		serverUrl?: string,
+		logger?: (msg: string) => void,
+		instanceId?: string
+	): Promise<{ killed: number; windowClosed: boolean }> {
+		const log = logger ?? (() => {});
+
+		log('Starting orphan cleanup...');
+
+		let serverKey: string | undefined;
+		try {
+			serverKey = serverUrl ? canonicalizeServerUrl(serverUrl) : undefined;
+		} catch {
+			serverKey = undefined;
+		}
+		if (!serverKey || !instanceId) {
+			log('No server URL or instance ID provided; skipping ownership cleanup.');
+			return { killed: 0, windowClosed: false };
+		}
+
+		const result = await cleanupOwnedResources(serverKey, instanceId);
+		log(
+			`Orphan cleanup complete: ${result.panesClosed} panes closed, window closed: ${result.windowClosed}`
+		);
+		return { killed: result.panesClosed, windowClosed: result.windowClosed };
+	}
 }
 
 function findPane(state: WindowState, paneId: string): TmuxPaneInfo | undefined {
 	if (state.mainPane?.paneId === paneId) return state.mainPane;
 	return state.agentPanes.find((pane) => pane.paneId === paneId);
 }
+
+function unwrapResponse<T>(result: unknown): T | undefined {
+	if (typeof result === 'object' && result !== null && 'data' in result) {
+		return (result as { data?: T }).data;
+	}
+	return result as T;
+}

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

@@ -11,6 +11,17 @@ export interface TmuxPaneInfo {
 	isActive: boolean; // Is this the active pane?
 }
 
+/**
+ * Ownership tags stored in tmux user options
+ */
+export interface TmuxOwnershipTags {
+	isOpencode: boolean; // @agentuity.opencode = "1"
+	serverKey: string; // @agentuity.opencode.server
+	ownerPid: number; // @agentuity.opencode.ownerPid
+	instanceId: string; // @agentuity.opencode.instance
+	sessionId?: string; // @agentuity.opencode.session (pane-level)
+}
+
 /**
  * Current state of the tmux window
  */
@@ -27,6 +38,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;

package/src/tmux/utils.ts

@@ -83,3 +83,42 @@ export function getTmuxPathSync(): string | null {
 		return null;
 	}
 }
+
+/**
+ * Get the tmux session ID for a given pane.
+ * This is used to ensure windows are created in the correct tmux session
+ * when multiple opencode instances run in different sessions.
+ */
+export async function getTmuxSessionId(paneId: string): Promise<string | undefined> {
+	const result = await runTmuxCommand(['display', '-p', '-t', paneId, '#{session_id}']);
+	if (!result.success || !result.output) return undefined;
+	return result.output.trim() || undefined;
+}
+
+/**
+ * Get the tmux session ID synchronously (for shutdown scenarios)
+ */
+export function getTmuxSessionIdSync(paneId: string): string | undefined {
+	const result = runTmuxCommandSync(['display', '-p', '-t', paneId, '#{session_id}']);
+	if (!result.success || !result.output) return undefined;
+	return result.output.trim() || undefined;
+}
+
+/**
+ * Canonicalize server URL for consistent ownership tagging.
+ * Normalizes loopback addresses (127.0.0.1, ::1) to localhost.
+ *
+ * @throws Error if URL is invalid
+ */
+export function canonicalizeServerUrl(url: string): string {
+	try {
+		const parsed = new URL(url);
+		let host = parsed.hostname.toLowerCase();
+		if (host === '127.0.0.1' || host === '::1') {
+			host = 'localhost';
+		}
+		return `${parsed.protocol}//${host}:${parsed.port}`;
+	} catch (error) {
+		throw new Error(`Invalid server URL: ${url}`, { cause: error });
+	}
+}