Files
kandev/apps/web/components/task/shell-terminal.tsx
T
João Salavisa 2e108b040f refactor: session resumption cleanup and AgentInstance → AgentExecution rename (#23)
* feat: session resumption with ACP session ID support

- Add useSessionResumption hook for automatic session recovery on page reload
- Fix ACPSessionID not being set on AgentInstance in Launch() and createInstance()
- Add task.session.status and task.session.resume WebSocket actions
- Fix shell terminal retry logic for resumed sessions
- Fix taskSessionState reading from Zustand store instead of local state
- Remove dead code: unused stream handling functions in lifecycle/manager.go
- Fix test mock interfaces (CleanupStaleInstanceByTaskID, NewManager signature)
- Add enhanced logging for session resumption debugging
- Simplify page-client.tsx state merging logic

* refactor: remove unused AgentController (dead code)

- Delete agent_controller.go - entirely unused duplicate of Manager methods
- Remove agentController field from Manager struct
- Remove AgentController initialization in NewManager

The AgentController duplicated StartAgentProcess, initializeACPSession, and
PromptAgent from Manager but was never called. All agent control operations
go through Manager's own methods.

* refactor: remove unused MemoryRepository (dead code)

- Delete memory.go - entire MemoryRepository implementation unused
  (replaced by SQLite repository)
- Delete memory_test.go - tests for removed MemoryRepository

Found via 'deadcode' tool analysis.

* refactor: consolidate agentctl packages into server/client structure

Reorganize the confusing dual agentctl packages:
- internal/agentctl/* → internal/agentctl/server/
- internal/agent/agentctl/* → internal/agentctl/client/

Structure is now:
  internal/agentctl/
  ├── client/      - HTTP client for talking to agentctl servers
  │   ├── client.go
  │   ├── standalone.go
  │   ├── acp.go
  │   └── launcher/
  ├── server/      - agentctl server implementation (runs in containers)
  │   ├── api/
  │   ├── adapter/
  │   ├── acp/
  │   ├── config/
  │   ├── instance/
  │   ├── process/
  │   └── shell/
  └── types/       - Shared types used by both client and server

Also consolidated shared types (GitStatusUpdate, FileInfo, etc.) from
process/types.go into the shared types/ package.

* refactor: rename AgentInstance to AgentExecution for clarity

Rename AgentInstance -> AgentExecution across the entire codebase to better
reflect what it represents: an agent actively working on a task, not just
a generic 'instance'.

Changes:
- AgentInstance struct -> AgentExecution
- InstanceStore -> ExecutionStore (new file: execution_store.go)
- RecoveredInstance -> RecoveredExecution
- All method names: GetInstance* -> GetExecution*, ListInstances -> ListExecutions, etc.
- All parameters: instanceID -> executionID
- All local variables: instance -> execution
- DTOs and JSON tags: agent_instance_id -> agent_execution_id
- Database columns: agent_instance_id -> agent_execution_id

Also consolidates duplicate prompt logic:
- Merge sendInitialPrompt and SendPrompt into single SendPrompt method
- Add validateStatus parameter to differentiate initial vs follow-up prompts

Also extracts ACP session management to session.go:
- Move initializeACPSession logic to SessionManager.InitializeAndPrompt
- Move PromptAgent logic to SessionManager.SendPrompt
- Manager now delegates to SessionManager for all prompt operations

Also removes duplicate event publishing:
- Remove 9 duplicate m.publish*() methods from manager.go
- Use existing EventPublisher methods via m.eventPublisher.Publish*()

Also extracts types to dedicated file:
- Move AgentExecution, LaunchRequest, PromptResult, etc. to types.go

Net reduction: ~600 lines removed from manager.go through deduplication
and better separation of concerns.

* fix(backend): Docker runtime now creates instance via ControlServer

The Docker runtime was incorrectly creating an agentctl.Client pointing
directly to port 9999 (the ControlServer port), then trying to call
instance-specific APIs like /api/v1/agent/configure which only exist
on per-instance servers.

Fixed by making Docker runtime follow the same flow as standalone mode:
- LaunchContainer now uses StandaloneCtl to create an instance via the
  control API, then creates Client pointing to the instance port
- RecoverInstances queries the ControlServer to get the instance port
- Added waitForHealth helper to wait for agentctl to be ready

Also improved HTTP error handling in agentctl client:
- All client methods now check HTTP status codes before JSON decoding
- Better error messages include status code and response body

* fix: restore session resumption imports and variables

* fix: add sessionId prop back to TaskLayout
2026-01-16 22:14:19 +00:00

175 lines
5.2 KiB
TypeScript

'use client';
import { useEffect, useRef, useCallback } from 'react';
import { Terminal } from '@xterm/xterm';
import { FitAddon } from '@xterm/addon-fit';
import '@xterm/xterm/css/xterm.css';
import { useAppStore, useAppStoreApi } from '@/components/state-provider';
import { getWebSocketClient } from '@/lib/ws/connection';
type ShellTerminalProps = {
taskId: string;
sessionId: string | null;
};
export function ShellTerminal({ taskId, sessionId }: ShellTerminalProps) {
const terminalRef = useRef<HTMLDivElement>(null);
const xtermRef = useRef<Terminal | null>(null);
const fitAddonRef = useRef<FitAddon | null>(null);
const lastOutputLengthRef = useRef(0);
const subscriptionIdRef = useRef(0);
const storeApi = useAppStoreApi();
const shellOutput = useAppStore((state) => state.shell.outputs[taskId] || '');
const send = useCallback(
(action: string, payload: Record<string, unknown>) => {
const client = getWebSocketClient();
if (client) {
client.send({ type: 'request', action, payload });
}
},
[]
);
// Initialize terminal
useEffect(() => {
if (!terminalRef.current || xtermRef.current) return;
const terminal = new Terminal({
cursorBlink: true,
fontSize: 13,
fontFamily: 'Menlo, Monaco, "Courier New", monospace',
theme: {
background: '#1e1e1e',
foreground: '#d4d4d4',
cursor: '#d4d4d4',
cursorAccent: '#1e1e1e',
selectionBackground: '#264f78',
black: '#1e1e1e',
red: '#f44747',
green: '#6a9955',
yellow: '#dcdcaa',
blue: '#569cd6',
magenta: '#c586c0',
cyan: '#4ec9b0',
white: '#d4d4d4',
brightBlack: '#808080',
brightRed: '#f44747',
brightGreen: '#6a9955',
brightYellow: '#dcdcaa',
brightBlue: '#569cd6',
brightMagenta: '#c586c0',
brightCyan: '#4ec9b0',
brightWhite: '#ffffff',
},
});
const fitAddon = new FitAddon();
terminal.loadAddon(fitAddon);
terminal.open(terminalRef.current);
fitAddon.fit();
xtermRef.current = terminal;
fitAddonRef.current = fitAddon;
// Handle user input
terminal.onData((data) => {
send('shell.input', { task_id: taskId, session_id: sessionId, data });
});
// Handle resize
const resizeObserver = new ResizeObserver(() => {
fitAddon.fit();
});
resizeObserver.observe(terminalRef.current);
return () => {
resizeObserver.disconnect();
terminal.dispose();
xtermRef.current = null;
fitAddonRef.current = null;
};
}, [taskId, sessionId, send]);
// Write new output to terminal
useEffect(() => {
if (!xtermRef.current) return;
// Only write new data since last update
const newData = shellOutput.slice(lastOutputLengthRef.current);
if (newData) {
xtermRef.current.write(newData);
lastOutputLengthRef.current = shellOutput.length;
}
}, [shellOutput]);
// Subscribe to shell on mount to start the shell stream
// Uses retry logic to handle cases where agent isn't ready yet (e.g., session resumption)
useEffect(() => {
// Increment subscription ID to invalidate any pending requests
const currentSubscriptionId = ++subscriptionIdRef.current;
let retryCount = 0;
const maxRetries = 10;
const retryDelay = 1000; // 1 second between retries
let retryTimeout: ReturnType<typeof setTimeout> | null = null;
// Clear any stale output before subscribing to get fresh buffer
storeApi.getState().clearShellOutput(taskId);
lastOutputLengthRef.current = 0;
// Also clear the terminal display
if (xtermRef.current) {
xtermRef.current.clear();
}
const attemptSubscribe = () => {
const client = getWebSocketClient();
if (!client) return;
// Check if this subscription is still valid
if (subscriptionIdRef.current !== currentSubscriptionId) return;
client
.request<{ success: boolean; buffer?: string }>('shell.subscribe', { task_id: taskId, session_id: sessionId })
.then((response) => {
// Only process if this is still the current subscription (handles React Strict Mode)
if (subscriptionIdRef.current !== currentSubscriptionId) return;
// Write buffered output from response
if (response.buffer) {
storeApi.getState().appendShellOutput(taskId, response.buffer);
}
})
.catch((err) => {
if (subscriptionIdRef.current !== currentSubscriptionId) return;
// Retry if agent not ready yet (common during session resumption)
if (retryCount < maxRetries) {
retryCount++;
console.log(`[ShellTerminal] Retrying shell subscription (${retryCount}/${maxRetries})...`);
retryTimeout = setTimeout(attemptSubscribe, retryDelay);
} else {
console.error('Failed to subscribe to shell after retries:', err);
}
});
};
attemptSubscribe();
return () => {
if (retryTimeout) {
clearTimeout(retryTimeout);
}
};
}, [taskId, sessionId, storeApi]);
return (
<div
ref={terminalRef}
className="h-full w-full overflow-hidden rounded-md border border-border bg-[#1e1e1e]"
/>
);
}