@agentuity/coder-tui 2.0.10 → 2.0.12

package/src/local-init-filter.ts

@@ -0,0 +1,54 @@
+import type { AgentDefinition, HubToolDefinition, InitMessage } from './protocol.ts';
+
+const LOCAL_TUI_HIDDEN_HUB_TOOL_NAMES = new Set(['sandbox_exec']);
+
+function filterHubToolsForLocalTui(tools?: HubToolDefinition[]): HubToolDefinition[] | undefined {
+	if (!tools) return tools;
+
+	const filtered = tools.filter((tool) => !LOCAL_TUI_HIDDEN_HUB_TOOL_NAMES.has(tool.name));
+	return filtered.length === tools.length ? tools : filtered;
+}
+
+function filterAgentHubToolsForLocalTui(agents?: AgentDefinition[]): AgentDefinition[] | undefined {
+	if (!agents) return agents;
+
+	let changed = false;
+	const filteredAgents = agents.map((agent) => {
+		const filteredHubTools = filterHubToolsForLocalTui(agent.hubTools);
+		if (filteredHubTools === agent.hubTools) {
+			return agent;
+		}
+
+		changed = true;
+		return {
+			...agent,
+			hubTools: filteredHubTools && filteredHubTools.length > 0 ? filteredHubTools : undefined,
+		};
+	});
+
+	return changed ? filteredAgents : agents;
+}
+
+export function adaptInitMessageForLocalTui(
+	init: InitMessage,
+	options: {
+		isRemoteSession: boolean;
+	}
+): InitMessage {
+	if (options.isRemoteSession) {
+		return init;
+	}
+
+	const tools = filterHubToolsForLocalTui(init.tools);
+	const agents = filterAgentHubToolsForLocalTui(init.agents);
+
+	if (tools === init.tools && agents === init.agents) {
+		return init;
+	}
+
+	return {
+		...init,
+		tools,
+		agents,
+	};
+}

package/src/protocol.ts

@@ -75,6 +75,7 @@ export type HubAction =
 export interface AgentDefinition {
 	name: string;
 	displayName?: string;
+	source?: 'builtin' | 'custom';
 	description: string;
 	systemPrompt: string;
 	model?: string;
@@ -84,6 +85,7 @@ export interface AgentDefinition {
 	readOnly?: boolean;
 	hubTools?: HubToolDefinition[];
 	capabilities?: string[];
+	strictToolSelection?: boolean;
 	status?: 'available' | 'busy' | 'offline';
 }
 
@@ -381,6 +383,7 @@ export interface SessionListItem {
 	participantCount: number;
 	tags: string[];
 	skills: SessionSkillRef[];
+	enabledAgents: string[];
 	defaultAgent?: string;
 	bucket: SessionBucket;
 	runtimeAvailable: boolean;
@@ -529,6 +532,7 @@ export interface SessionSnapshotMetadataExtensions {
 	product?: SessionProductProjection;
 	tags: string[];
 	skills: SessionSkillRef[];
+	enabledAgents: string[];
 	defaultAgent?: string;
 	workers?: SessionListItem[];
 }

package/src/remote-runtime.ts

@@ -0,0 +1,45 @@
+import type { RpcEvent } from './remote-session.ts';
+
+export const REMOTE_RUNTIME_OPERATION_MESSAGE =
+	'Remote controller mode only supports the current sandbox session.';
+
+type RemoteRuntimeOperation = '/new' | '/resume' | '/fork' | '/import';
+
+interface RemoteRuntimeGuards {
+	newSession?: () => Promise<unknown>;
+	switchSession?: () => Promise<unknown>;
+	fork?: () => Promise<unknown>;
+	importFromJsonl?: () => Promise<unknown>;
+}
+
+interface RemoteSessionEventTarget {
+	_handleAgentEvent?: (event: RpcEvent) => void;
+}
+
+export function dispatchRemoteSessionEvent(
+	session: RemoteSessionEventTarget,
+	event: RpcEvent
+): void {
+	if (typeof session._handleAgentEvent !== 'function') {
+		throw new Error(
+			'Pi AgentSession no longer exposes _handleAgentEvent; remote TUI event dispatch needs an update.'
+		);
+	}
+
+	session._handleAgentEvent(event);
+}
+
+export function installRemoteRuntimeOperationGuards(
+	runtime: RemoteRuntimeGuards,
+	onBlocked: (operation: RemoteRuntimeOperation) => void
+): void {
+	const block = (operation: RemoteRuntimeOperation) => async (): Promise<{ cancelled: true }> => {
+		onBlocked(operation);
+		return { cancelled: true };
+	};
+
+	runtime.newSession = block('/new');
+	runtime.switchSession = block('/resume');
+	runtime.fork = block('/fork');
+	runtime.importFromJsonl = block('/import');
+}

package/src/remote-session.ts

@@ -22,6 +22,8 @@ import {
 	syncRemoteLifecycleWorkingMessage,
 	type RemoteLifecycleState,
 } from './remote-lifecycle.ts';
+import { resolveCoderOrgId } from './auth.ts';
+import { formatToolDisplay } from './agentuity-cli.ts';
 
 const DEBUG = !!process.env['AGENTUITY_DEBUG'];
 
@@ -267,9 +269,10 @@ export class RemoteSession {
 					wsHeaders['Authorization'] = `Bearer ${this.apiKey}`;
 				}
 			}
-			if (this.orgId) {
-				url.searchParams.set('orgId', this.orgId);
-				wsHeaders['x-agentuity-orgid'] = this.orgId;
+			const orgId = resolveCoderOrgId(this.orgId);
+			if (orgId) {
+				url.searchParams.set('orgId', orgId);
+				wsHeaders['x-agentuity-orgid'] = orgId;
 			}
 
 			log(`${isReconnect ? 'Reconnecting' : 'Connecting'} to ${url.toString()}`);
@@ -999,18 +1002,23 @@ export async function setupRemoteMode(
 				break;
 
 			case 'tool_execution_start': {
-				const tool = (event as { toolName?: string }).toolName ?? 'tool';
-				currentTool = tool;
+				const rawTool = (event as { toolName?: string }).toolName ?? 'tool';
+				const rawArgs = (event as { args?: string | Record<string, unknown> }).args;
+				const display = formatToolDisplay(rawTool, rawArgs);
+				currentTool = display.toolName;
 				if (extensionCtxRef?.hasUI) {
-					setNonLifecycleWorkingMessage(`Running ${tool}...`);
-					extensionCtxRef.ui.setStatus('remote_activity', `Running ${tool}...`);
+					setNonLifecycleWorkingMessage(`Running ${display.fullLabel}...`);
+					extensionCtxRef.ui.setStatus('remote_activity', `Running ${display.fullLabel}...`);
 				}
-				log(`Tool: ${tool}`);
+				log(`Tool: ${display.fullLabel}`);
 				break;
 			}
 
 			case 'tool_execution_end': {
-				const tool = (event as { toolName?: string }).toolName ?? currentTool ?? 'tool';
+				const rawTool = (event as { toolName?: string }).toolName ?? currentTool ?? 'tool';
+				const rawArgs = (event as { args?: string | Record<string, unknown> }).args;
+				const display = rawArgs ? formatToolDisplay(rawTool, rawArgs) : null;
+				const tool = display?.fullLabel ?? currentTool ?? rawTool;
 				currentTool = null;
 				if (extensionCtxRef?.hasUI) {
 					clearWorkingMessage();

package/src/remote-tui.ts

@@ -1,14 +1,14 @@
 /**
  * Remote TUI — Native Pi Coding Agent Renderer for Remote Sessions
  *
- * Creates a real AgentSession + InteractiveMode backed by a remote sandbox
+ * Creates a real AgentSessionRuntime + InteractiveMode backed by a remote sandbox
  * via Hub WebSocket, with the coder extension loaded for Hub UI (footer,
  * /hub overlay, commands, titlebar).
  *
  * Architecture:
  *   Remote TUI → Hub WebSocket (controller) → Sandbox (Pi RPC mode)
  *   - User input  → agent.prompt() (monkey-patched) → RPC `prompt` → Hub → sandbox
- *   - Sandbox Pi  → AgentEvent stream → Hub broadcast → Agent.emit() → InteractiveMode renders natively
+ *   - Sandbox Pi  → AgentEvent stream → Hub broadcast → AgentSession event handling → InteractiveMode renders natively
  *   - Hub UI      → coder extension (loaded via DefaultResourceLoader) provides footer, /hub, commands
  *
  * The local Agent never calls an LLM. Its prompt/steer/abort are monkey-patched
@@ -22,14 +22,16 @@
  *
  * IMPORTANT: Initialization order matters!
  *   1. Create RemoteSession (no connection yet)
- *   2. Create AgentSession, patch Agent/Session methods
+ *   2. Create AgentSessionRuntime, patch Agent/Session methods
  *   3. Register ALL event handlers on RemoteSession
  *   4. THEN connect — so hydration + replay events are captured
  */
 
 import {
-	createAgentSession,
-	DefaultResourceLoader,
+	createAgentSessionFromServices,
+	createAgentSessionRuntime,
+	createAgentSessionServices,
+	getAgentDir,
 	InteractiveMode,
 	SessionManager,
 } from '@mariozechner/pi-coding-agent';
@@ -49,6 +51,11 @@ import { RemoteSession } from './remote-session.ts';
 import type { RpcEvent } from './remote-session.ts';
 import { agentuityCoderHub } from './index.ts';
 import { handleRemoteUiRequest, REMOTE_FIRE_AND_FORGET_UI_METHODS } from './remote-ui-handler.ts';
+import {
+	dispatchRemoteSessionEvent,
+	installRemoteRuntimeOperationGuards,
+	REMOTE_RUNTIME_OPERATION_MESSAGE,
+} from './remote-runtime.ts';
 
 const DEBUG = !!process.env['AGENTUITY_DEBUG'];
 
@@ -60,7 +67,7 @@ function log(msg: string): void {
  * Run the native Pi TUI connected to a remote sandbox session.
  *
  * This is the entry point for `agentuity coder start --remote <sessionId>`.
- * Creates an AgentSession with the coder extension loaded (Hub UI), then
+ * Creates an AgentSessionRuntime with the coder extension loaded (Hub UI), then
  * monkey-patches the Agent for remote-backed execution.
  */
 export async function runRemoteTui(options: {
@@ -90,33 +97,74 @@ export async function runRemoteTui(options: {
 	let hydrationStreamingDetected = false;
 	let sessionResumeSeen = false;
 
-	// ── 2. Create AgentSession with coder extension loaded ──
+	// ── 2. Create AgentSessionRuntime with coder extension loaded ──
 	// The extension provides Hub UI (footer, /hub overlay, commands, titlebar).
 	// AGENTUITY_CODER_NATIVE_REMOTE=1 tells it to skip legacy event rendering.
 	const cwd = process.cwd();
-	const resourceLoader = new DefaultResourceLoader({
-		cwd,
-		noExtensions: true, // Skip file-system extension discovery
-		extensionFactories: [agentuityCoderHub], // Load coder extension directly
-	});
-	await resourceLoader.reload();
+	const runtime = await createAgentSessionRuntime(
+		async ({ cwd, agentDir, sessionManager, sessionStartEvent }) => {
+			const services = await createAgentSessionServices({
+				cwd,
+				agentDir,
+				resourceLoaderOptions: {
+					noExtensions: true, // Skip file-system extension discovery
+					extensionFactories: [agentuityCoderHub], // Load coder extension directly
+				},
+			});
+
+			return {
+				...(await createAgentSessionFromServices({
+					services,
+					sessionManager,
+					sessionStartEvent,
+					tools: [], // No local tools — sandbox has all the tools
+				})),
+				services,
+				diagnostics: services.diagnostics,
+			};
+		},
+		{
+			cwd,
+			agentDir: getAgentDir(),
+			sessionManager: SessionManager.inMemory(),
+		}
+	);
+	const session = runtime.session;
+	const agent: any = session.agent;
+	let runtimeDisposed = false;
+	log('AgentSessionRuntime created');
 
-	const { session } = await createAgentSession({
-		sessionManager: SessionManager.inMemory(),
-		tools: [], // No local tools — sandbox has all the tools
-		resourceLoader,
-	});
-	log('AgentSession created');
+	function notifyBlockedRuntimeOperation(operation: string): void {
+		const message = `${REMOTE_RUNTIME_OPERATION_MESSAGE} (${operation})`;
+		const ctx = getNativeRemoteExtensionContext();
+		if (ctx?.hasUI) {
+			ctx.ui.notify(message, 'warning');
+			ctx.ui.setStatus('remote_runtime', operation);
+			return;
+		}
+		log(message);
+	}
+
+	installRemoteRuntimeOperationGuards(runtime as any, (operation) =>
+		notifyBlockedRuntimeOperation(operation)
+	);
+
+	async function disposeRuntime(): Promise<void> {
+		if (runtimeDisposed) return;
+		runtimeDisposed = true;
+		await runtime.dispose();
+	}
 
 	// NOTE: Do NOT call session.bindExtensions() here.
 	// InteractiveMode.initExtensions() calls it with the proper uiContext.
 	// Calling it early fires session_start twice, duplicating extension init.
-
-	// Access the Agent instance (typed as `any` for monkey-patching)
-	const agent: any = session.agent;
 	let lifecycleState = remote.getLifecycleState();
 	let lifecycleOwnsWorkingMessage = false;
 
+	function emitSessionEvent(event: RpcEvent): void {
+		dispatchRemoteSessionEvent(session as any, event);
+	}
+
 	function applyLifecycleUi(state: RemoteLifecycleState): void {
 		const ctx = getNativeRemoteExtensionContext();
 		if (!ctx?.hasUI) return;
@@ -174,7 +222,7 @@ export async function runRemoteTui(options: {
 
 		// Emit synthetic agent_start so InteractiveMode shows "working" immediately
 		syntheticAgentStartEmitted = true;
-		agent.emit({ type: 'agent_start', agentName: 'lead', timestamp: Date.now() });
+		emitSessionEvent({ type: 'agent_start', agentName: 'lead', timestamp: Date.now() } as any);
 
 		// Send RPC command to sandbox
 		remote.prompt(text);
@@ -268,7 +316,7 @@ export async function runRemoteTui(options: {
 	//
 	// Events that arrive before InteractiveMode is initialized are buffered
 	// and flushed after init (InteractiveMode registers listeners during init,
-	// so agent.emit() before that fires into the void).
+	// so session event dispatch before that fires into the void).
 	let interactiveModeReady = false;
 	let eventBuffer: RpcEvent[] = [];
 	let seenMessageStart = false;
@@ -315,7 +363,7 @@ export async function runRemoteTui(options: {
 		}
 
 		for (const event of syntheticEvents) {
-			agent.emit(event);
+			emitSessionEvent(event);
 		}
 	}
 
@@ -507,10 +555,14 @@ export async function runRemoteTui(options: {
 		) {
 			log(`Live ${rpcEvent.type} without prior message_start — injecting synthetics`);
 			if (!hadSeenAgentStart) {
-				agent.emit({ type: 'agent_start', agentName: 'lead', timestamp: Date.now() } as any);
+				emitSessionEvent({
+					type: 'agent_start',
+					agentName: 'lead',
+					timestamp: Date.now(),
+				} as any);
 				seenAgentStart = true;
 			}
-			agent.emit({
+			emitSessionEvent({
 				type: 'message_start',
 				message: {
 					role: 'assistant',
@@ -535,7 +587,7 @@ export async function runRemoteTui(options: {
 		}
 
 		// Emit to subscribers — InteractiveMode.handleEvent processes this
-		agent.emit(rpcEvent);
+		emitSessionEvent(rpcEvent);
 		if (injectedSyntheticMessageStart && rpcEvent.type === 'message_end') {
 			seenMessageStart = false;
 			seenAgentStart = hadSeenAgentStart;
@@ -787,7 +839,7 @@ export async function runRemoteTui(options: {
 
 	// ── 9. Start InteractiveMode — full native Pi TUI ──
 	log('Creating InteractiveMode');
-	const interactive = new InteractiveMode(session);
+	const interactive = new InteractiveMode(runtime);
 	log('InteractiveMode created, calling init...');
 	await interactive.init();
 
@@ -803,8 +855,8 @@ export async function runRemoteTui(options: {
 		// the streaming indicator right away, before any buffered events flush.
 		// This prevents the blank screen gap between connect and first event.
 		log('Hydration detected streaming — emitting immediate synthetics');
-		agent.emit({ type: 'agent_start', agentName: 'lead', timestamp: Date.now() } as any);
-		agent.emit({
+		emitSessionEvent({ type: 'agent_start', agentName: 'lead', timestamp: Date.now() } as any);
+		emitSessionEvent({
 			type: 'message_start',
 			message: {
 				role: 'assistant',
@@ -836,7 +888,7 @@ export async function runRemoteTui(options: {
 	if (eventBuffer.length > 0) {
 		log(`Flushing ${eventBuffer.length} events: ${eventBuffer.map((e) => e.type).join(', ')}`);
 		for (const buffered of eventBuffer) {
-			agent.emit(buffered);
+			emitSessionEvent(buffered);
 			if (buffered.type === 'agent_end') {
 				resolveRunningPrompt();
 			}
@@ -851,6 +903,11 @@ export async function runRemoteTui(options: {
 		remote.close();
 		setNativeRemoteExtensionContext(null);
 		interactive.stop();
+		void disposeRuntime().catch((err) => {
+			log(
+				`Runtime dispose error during cleanup: ${err instanceof Error ? err.message : String(err)}`
+			);
+		});
 	};
 	process.on('SIGINT', cleanup);
 	process.on('SIGTERM', cleanup);
@@ -863,6 +920,9 @@ export async function runRemoteTui(options: {
 	} finally {
 		remote.close();
 		setNativeRemoteExtensionContext(null);
+		await disposeRuntime().catch((err) => {
+			log(`Runtime dispose error: ${err instanceof Error ? err.message : String(err)}`);
+		});
 		log('Remote TUI exited');
 	}
 

package/src/renderers.ts

@@ -12,6 +12,7 @@ import type {
 	AgentToolResult,
 } from '@mariozechner/pi-coding-agent';
 import { Box, Text, Container, type Component } from '@mariozechner/pi-tui';
+import { formatToolDisplay } from './agentuity-cli.ts';
 
 // ──────────────────────────────────────────────
 // Line-safety helper — must be declared before SimpleText so
@@ -125,6 +126,32 @@ function truncate(str: string, max: number): string {
 	return str.slice(0, max - 1) + '\u2026';
 }
 
+function toSingleLinePreview(value: string): string {
+	return value.replace(/\s+/g, ' ').trim();
+}
+
+function isCommandToolName(toolName: string): boolean {
+	const normalized = toolName.trim().toLowerCase();
+	return normalized === 'bash' || normalized === 'execute_command' || normalized.includes('shell');
+}
+
+function getCommandArg(args: Record<string, unknown>): string | undefined {
+	const value = args['command'] ?? args['cmd'];
+	return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+
+function getCommandTimeoutLabel(args: Record<string, unknown>): string | undefined {
+	const timeout = args['timeout'];
+	if (typeof timeout === 'number' && Number.isFinite(timeout) && timeout > 0) {
+		return `${timeout}s`;
+	}
+	if (typeof timeout === 'string' && timeout.trim()) {
+		const value = timeout.trim();
+		return /s$/i.test(value) ? value : `${value}s`;
+	}
+	return undefined;
+}
+
 // ──────────────────────────────────────────────
 // Individual tool renderers
 // ──────────────────────────────────────────────
@@ -709,6 +736,37 @@ function parallelTasksRenderers(): ToolRenderers {
 	};
 }
 
+function commandToolRenderers(toolName: string): ToolRenderers {
+	return {
+		renderCall(args, theme) {
+			const display = formatToolDisplay(toolName, args);
+			const timeout = getCommandTimeoutLabel(args);
+
+			if (display.branded) {
+				let text = theme.fg('toolTitle', theme.bold(display.toolName));
+				if (display.toolArgs) {
+					text += theme.fg('accent', ` ${display.toolArgs}`);
+				}
+				if (timeout) {
+					text += theme.fg('dim', ` (timeout ${timeout})`);
+				}
+				return new SimpleText(text);
+			}
+
+			let text = theme.fg('toolTitle', theme.bold('$ '));
+			const commandPreview = getCommandArg(args);
+			text += theme.fg(
+				'accent',
+				truncate(commandPreview ? toSingleLinePreview(commandPreview) : display.toolName, 80)
+			);
+			if (timeout) {
+				text += theme.fg('dim', ` (timeout ${timeout})`);
+			}
+			return new SimpleText(text);
+		},
+	};
+}
+
 // ──────────────────────────────────────────────
 
 const RENDERERS: Record<string, () => ToolRenderers> = {
@@ -736,5 +794,7 @@ const RENDERERS: Record<string, () => ToolRenderers> = {
  */
 export function getToolRenderers(toolName: string): ToolRenderers | undefined {
 	const factory = RENDERERS[toolName];
-	return factory?.();
+	if (factory) return factory();
+	if (isCommandToolName(toolName)) return commandToolRenderers(toolName);
+	return undefined;
 }

package/src/subagent-tool-selection.ts

@@ -0,0 +1,33 @@
+import type { AgentDefinition } from './protocol.ts';
+
+const READ_ONLY_TOOL_NAMES = ['read', 'grep', 'find', 'ls'] as const;
+const CODING_TOOL_NAMES = ['read', 'bash', 'edit', 'write'] as const;
+
+function normalizeToolName(name: string): string {
+	return name.trim().toLowerCase();
+}
+
+export function selectSubAgentToolNames(agentConfig: AgentDefinition): string[] {
+	const declared = new Set(
+		(agentConfig.tools ?? [])
+			.filter((name): name is string => typeof name === 'string' && name.trim().length > 0)
+			.map(normalizeToolName)
+	);
+	const needsBash = declared.has('bash');
+	const baseToolNames =
+		agentConfig.readOnly && !needsBash ? READ_ONLY_TOOL_NAMES : CODING_TOOL_NAMES;
+	const allowLegacyFallback =
+		agentConfig.strictToolSelection !== true && agentConfig.source === 'builtin';
+
+	if (declared.size === 0) {
+		return allowLegacyFallback ? [...baseToolNames] : [];
+	}
+
+	const filtered = baseToolNames.filter((toolName) => declared.has(toolName));
+
+	if (filtered.length > 0) {
+		return filtered;
+	}
+
+	return allowLegacyFallback ? [...baseToolNames] : [];
+}