mirror of
https://github.com/wu736139669/hapi.git
synced 2026-08-05 06:24:37 +00:00
refactor: extract remote launcher base class for code reuse
This commit is contained in:
weishu
@@ -1,8 +1,6 @@
|
||||
import { render } from "ink";
|
||||
import { Session } from "./session";
|
||||
import { MessageBuffer } from "@/ui/ink/messageBuffer";
|
||||
import { RemoteModeDisplay } from "@/ui/ink/RemoteModeDisplay";
|
||||
import React from "react";
|
||||
import { Session } from "./session";
|
||||
import { RemoteModeDisplay } from "@/ui/ink/RemoteModeDisplay";
|
||||
import { claudeRemote } from "./claudeRemote";
|
||||
import { PermissionHandler } from "./utils/permissionHandler";
|
||||
import { Future } from "@/utils/future";
|
||||
@@ -12,11 +10,13 @@ import { logger } from "@/ui/logger";
|
||||
import { SDKToLogConverter } from "./utils/sdkToLogConverter";
|
||||
import { PLAN_FAKE_REJECT } from "./sdk/prompts";
|
||||
import { EnhancedMode } from "./loop";
|
||||
import { RawJSONLines } from "@/claude/types";
|
||||
import { OutgoingMessageQueue } from "./utils/OutgoingMessageQueue";
|
||||
import { getToolName } from "./utils/getToolName";
|
||||
import { restoreTerminalState } from "@/ui/terminalState";
|
||||
import type { ClaudePermissionMode } from "@hapi/protocol/types";
|
||||
import {
|
||||
RemoteLauncherBase,
|
||||
type RemoteLauncherDisplayContext,
|
||||
type RemoteLauncherExitReason
|
||||
} from "@/modules/common/remote/RemoteLauncherBase";
|
||||
|
||||
interface PermissionsField {
|
||||
date: number;
|
||||
@@ -25,439 +25,399 @@ interface PermissionsField {
|
||||
allowedTools?: string[];
|
||||
}
|
||||
|
||||
export async function claudeRemoteLauncher(session: Session): Promise<'switch' | 'exit'> {
|
||||
logger.debug('[claudeRemoteLauncher] Starting remote launcher');
|
||||
class ClaudeRemoteLauncher extends RemoteLauncherBase {
|
||||
private readonly session: Session;
|
||||
private abortController: AbortController | null = null;
|
||||
private abortFuture: Future<void> | null = null;
|
||||
private permissionHandler: PermissionHandler | null = null;
|
||||
private handleSessionFound: ((sessionId: string) => void) | null = null;
|
||||
|
||||
// Check if we have a TTY for UI rendering
|
||||
const hasTTY = process.stdout.isTTY && process.stdin.isTTY;
|
||||
logger.debug(`[claudeRemoteLauncher] TTY available: ${hasTTY}`);
|
||||
constructor(session: Session) {
|
||||
super(process.env.DEBUG ? session.logPath : undefined);
|
||||
this.session = session;
|
||||
}
|
||||
|
||||
// Configure terminal
|
||||
let messageBuffer = new MessageBuffer();
|
||||
let inkInstance: any = null;
|
||||
protected createDisplay(context: RemoteLauncherDisplayContext): React.ReactElement {
|
||||
return React.createElement(RemoteModeDisplay, context);
|
||||
}
|
||||
|
||||
if (hasTTY) {
|
||||
console.clear();
|
||||
inkInstance = render(React.createElement(RemoteModeDisplay, {
|
||||
messageBuffer,
|
||||
logPath: process.env.DEBUG ? session.logPath : undefined,
|
||||
onExit: async () => {
|
||||
// Exit the entire client
|
||||
logger.debug('[remote]: Exiting client via Ctrl-C');
|
||||
if (!exitReason) {
|
||||
exitReason = 'exit';
|
||||
}
|
||||
await abort();
|
||||
},
|
||||
onSwitchToLocal: () => {
|
||||
// Switch to local mode
|
||||
logger.debug('[remote]: Switching to local mode via double space');
|
||||
doSwitch();
|
||||
}
|
||||
}), {
|
||||
exitOnCtrlC: false,
|
||||
patchConsole: false
|
||||
private async abort(): Promise<void> {
|
||||
if (this.abortController && !this.abortController.signal.aborted) {
|
||||
this.abortController.abort();
|
||||
}
|
||||
await this.abortFuture?.promise;
|
||||
}
|
||||
|
||||
private async handleAbortRequest(): Promise<void> {
|
||||
logger.debug('[remote]: doAbort');
|
||||
await this.abort();
|
||||
}
|
||||
|
||||
private async handleSwitchRequest(): Promise<void> {
|
||||
logger.debug('[remote]: doSwitch');
|
||||
await this.requestExit('switch', async () => {
|
||||
await this.abort();
|
||||
});
|
||||
}
|
||||
|
||||
if (hasTTY) {
|
||||
process.stdin.resume();
|
||||
if (process.stdin.isTTY) {
|
||||
process.stdin.setRawMode(true);
|
||||
}
|
||||
process.stdin.setEncoding("utf8");
|
||||
private async handleExitFromUi(): Promise<void> {
|
||||
logger.debug('[remote]: Exiting client via Ctrl-C');
|
||||
await this.requestExit('exit', async () => {
|
||||
await this.abort();
|
||||
});
|
||||
}
|
||||
|
||||
// Handle abort
|
||||
let exitReason: 'switch' | 'exit' | null = null;
|
||||
let abortController: AbortController | null = null;
|
||||
let abortFuture: Future<void> | null = null;
|
||||
|
||||
async function abort() {
|
||||
if (abortController && !abortController.signal.aborted) {
|
||||
abortController.abort();
|
||||
}
|
||||
await abortFuture?.promise;
|
||||
private async handleSwitchFromUi(): Promise<void> {
|
||||
logger.debug('[remote]: Switching to local mode via double space');
|
||||
await this.handleSwitchRequest();
|
||||
}
|
||||
|
||||
async function doAbort() {
|
||||
logger.debug('[remote]: doAbort');
|
||||
await abort();
|
||||
public async launch(): Promise<RemoteLauncherExitReason> {
|
||||
return this.start({
|
||||
onExit: () => this.handleExitFromUi(),
|
||||
onSwitchToLocal: () => this.handleSwitchFromUi()
|
||||
});
|
||||
}
|
||||
|
||||
async function doSwitch() {
|
||||
logger.debug('[remote]: doSwitch');
|
||||
if (!exitReason) {
|
||||
exitReason = 'switch';
|
||||
}
|
||||
await abort();
|
||||
}
|
||||
protected async runMainLoop(): Promise<void> {
|
||||
logger.debug('[claudeRemoteLauncher] Starting remote launcher');
|
||||
logger.debug(`[claudeRemoteLauncher] TTY available: ${this.hasTTY}`);
|
||||
|
||||
// When to abort
|
||||
session.client.rpcHandlerManager.registerHandler('abort', doAbort); // When abort clicked
|
||||
session.client.rpcHandlerManager.registerHandler('switch', doSwitch); // When switch clicked
|
||||
// Removed catch-all stdin handler - now handled by RemoteModeDisplay keyboard handlers
|
||||
const session = this.session;
|
||||
const messageBuffer = this.messageBuffer;
|
||||
|
||||
// Create permission handler
|
||||
const permissionHandler = new PermissionHandler(session);
|
||||
this.setupAbortHandlers(session.client.rpcHandlerManager, {
|
||||
onAbort: () => this.handleAbortRequest(),
|
||||
onSwitch: () => this.handleSwitchRequest()
|
||||
});
|
||||
|
||||
// Create outgoing message queue
|
||||
const messageQueue = new OutgoingMessageQueue(
|
||||
(logMessage) => session.client.sendClaudeSessionMessage(logMessage)
|
||||
);
|
||||
const permissionHandler = new PermissionHandler(session);
|
||||
this.permissionHandler = permissionHandler;
|
||||
|
||||
// Set up callback to release delayed messages when permission is requested
|
||||
permissionHandler.setOnPermissionRequest((toolCallId: string) => {
|
||||
messageQueue.releaseToolCall(toolCallId);
|
||||
});
|
||||
const messageQueue = new OutgoingMessageQueue(
|
||||
(logMessage) => session.client.sendClaudeSessionMessage(logMessage)
|
||||
);
|
||||
|
||||
// Create SDK to Log converter (pass responses from permissions)
|
||||
const sdkToLogConverter = new SDKToLogConverter({
|
||||
sessionId: session.sessionId || 'unknown',
|
||||
cwd: session.path,
|
||||
version: process.env.npm_package_version
|
||||
}, permissionHandler.getResponses());
|
||||
permissionHandler.setOnPermissionRequest((toolCallId: string) => {
|
||||
messageQueue.releaseToolCall(toolCallId);
|
||||
});
|
||||
|
||||
const handleSessionFound = (sessionId: string) => {
|
||||
sdkToLogConverter.updateSessionId(sessionId);
|
||||
};
|
||||
session.addSessionFoundCallback(handleSessionFound);
|
||||
const sdkToLogConverter = new SDKToLogConverter({
|
||||
sessionId: session.sessionId || 'unknown',
|
||||
cwd: session.path,
|
||||
version: process.env.npm_package_version
|
||||
}, permissionHandler.getResponses());
|
||||
|
||||
const handleSessionFound = (sessionId: string) => {
|
||||
sdkToLogConverter.updateSessionId(sessionId);
|
||||
};
|
||||
this.handleSessionFound = handleSessionFound;
|
||||
session.addSessionFoundCallback(handleSessionFound);
|
||||
|
||||
// Handle messages
|
||||
let planModeToolCalls = new Set<string>();
|
||||
let ongoingToolCalls = new Map<string, { parentToolCallId: string | null }>();
|
||||
let planModeToolCalls = new Set<string>();
|
||||
let ongoingToolCalls = new Map<string, { parentToolCallId: string | null }>();
|
||||
|
||||
function onMessage(message: SDKMessage) {
|
||||
function onMessage(message: SDKMessage) {
|
||||
formatClaudeMessageForInk(message, messageBuffer);
|
||||
permissionHandler.onMessage(message);
|
||||
|
||||
// Write to message log
|
||||
formatClaudeMessageForInk(message, messageBuffer);
|
||||
|
||||
// Write to permission handler for tool id resolving
|
||||
permissionHandler.onMessage(message);
|
||||
|
||||
// Detect plan mode tool call
|
||||
if (message.type === 'assistant') {
|
||||
let umessage = message as SDKAssistantMessage;
|
||||
if (umessage.message.content && Array.isArray(umessage.message.content)) {
|
||||
for (let c of umessage.message.content) {
|
||||
if (c.type === 'tool_use' && (c.name === 'exit_plan_mode' || c.name === 'ExitPlanMode')) {
|
||||
logger.debug('[remote]: detected plan mode tool call ' + c.id!);
|
||||
planModeToolCalls.add(c.id! as string);
|
||||
if (message.type === 'assistant') {
|
||||
let umessage = message as SDKAssistantMessage;
|
||||
if (umessage.message.content && Array.isArray(umessage.message.content)) {
|
||||
for (let c of umessage.message.content) {
|
||||
if (c.type === 'tool_use' && (c.name === 'exit_plan_mode' || c.name === 'ExitPlanMode')) {
|
||||
logger.debug('[remote]: detected plan mode tool call ' + c.id!);
|
||||
planModeToolCalls.add(c.id! as string);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Track active tool calls
|
||||
if (message.type === 'assistant') {
|
||||
let umessage = message as SDKAssistantMessage;
|
||||
if (umessage.message.content && Array.isArray(umessage.message.content)) {
|
||||
for (let c of umessage.message.content) {
|
||||
if (c.type === 'tool_use') {
|
||||
logger.debug('[remote]: detected tool use ' + c.id! + ' parent: ' + umessage.parent_tool_use_id);
|
||||
ongoingToolCalls.set(c.id!, { parentToolCallId: umessage.parent_tool_use_id ?? null });
|
||||
if (message.type === 'assistant') {
|
||||
let umessage = message as SDKAssistantMessage;
|
||||
if (umessage.message.content && Array.isArray(umessage.message.content)) {
|
||||
for (let c of umessage.message.content) {
|
||||
if (c.type === 'tool_use') {
|
||||
logger.debug('[remote]: detected tool use ' + c.id! + ' parent: ' + umessage.parent_tool_use_id);
|
||||
ongoingToolCalls.set(c.id!, { parentToolCallId: umessage.parent_tool_use_id ?? null });
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (message.type === 'user') {
|
||||
let umessage = message as SDKUserMessage;
|
||||
if (umessage.message.content && Array.isArray(umessage.message.content)) {
|
||||
for (let c of umessage.message.content) {
|
||||
if (c.type === 'tool_result' && c.tool_use_id) {
|
||||
ongoingToolCalls.delete(c.tool_use_id);
|
||||
|
||||
// When tool result received, release any delayed messages for this tool call
|
||||
messageQueue.releaseToolCall(c.tool_use_id);
|
||||
if (message.type === 'user') {
|
||||
let umessage = message as SDKUserMessage;
|
||||
if (umessage.message.content && Array.isArray(umessage.message.content)) {
|
||||
for (let c of umessage.message.content) {
|
||||
if (c.type === 'tool_result' && c.tool_use_id) {
|
||||
ongoingToolCalls.delete(c.tool_use_id);
|
||||
messageQueue.releaseToolCall(c.tool_use_id);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Convert SDK message to log format and send to client
|
||||
let msg = message;
|
||||
let msg = message;
|
||||
|
||||
// Hack plan mode exit
|
||||
if (message.type === 'user') {
|
||||
let umessage = message as SDKUserMessage;
|
||||
if (umessage.message.content && Array.isArray(umessage.message.content)) {
|
||||
msg = {
|
||||
...umessage,
|
||||
message: {
|
||||
...umessage.message,
|
||||
content: umessage.message.content.map((c) => {
|
||||
if (c.type === 'tool_result' && c.tool_use_id && planModeToolCalls.has(c.tool_use_id!)) {
|
||||
if (c.content === PLAN_FAKE_REJECT) {
|
||||
logger.debug('[remote]: hack plan mode exit');
|
||||
logger.debugLargeJson('[remote]: hack plan mode exit', c);
|
||||
return {
|
||||
...c,
|
||||
is_error: false,
|
||||
content: 'Plan approved',
|
||||
mode: c.mode
|
||||
if (message.type === 'user') {
|
||||
let umessage = message as SDKUserMessage;
|
||||
if (umessage.message.content && Array.isArray(umessage.message.content)) {
|
||||
msg = {
|
||||
...umessage,
|
||||
message: {
|
||||
...umessage.message,
|
||||
content: umessage.message.content.map((c) => {
|
||||
if (c.type === 'tool_result' && c.tool_use_id && planModeToolCalls.has(c.tool_use_id!)) {
|
||||
if (c.content === PLAN_FAKE_REJECT) {
|
||||
logger.debug('[remote]: hack plan mode exit');
|
||||
logger.debugLargeJson('[remote]: hack plan mode exit', c);
|
||||
return {
|
||||
...c,
|
||||
is_error: false,
|
||||
content: 'Plan approved',
|
||||
mode: c.mode
|
||||
};
|
||||
} else {
|
||||
return c;
|
||||
}
|
||||
} else {
|
||||
return c;
|
||||
}
|
||||
return c;
|
||||
})
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
const logMessage = sdkToLogConverter.convert(msg);
|
||||
if (logMessage) {
|
||||
if (logMessage.type === 'user' && logMessage.message?.content) {
|
||||
const content = Array.isArray(logMessage.message.content)
|
||||
? logMessage.message.content
|
||||
: [];
|
||||
|
||||
for (let i = 0; i < content.length; i++) {
|
||||
const c = content[i];
|
||||
if (c.type === 'tool_result' && c.tool_use_id) {
|
||||
const responses = permissionHandler.getResponses();
|
||||
const response = responses.get(c.tool_use_id);
|
||||
|
||||
if (response) {
|
||||
const permissions: PermissionsField = {
|
||||
date: response.receivedAt || Date.now(),
|
||||
result: response.approved ? 'approved' : 'denied'
|
||||
};
|
||||
|
||||
if (response.mode) {
|
||||
permissions.mode = response.mode;
|
||||
}
|
||||
|
||||
if (response.allowTools && response.allowTools.length > 0) {
|
||||
permissions.allowedTools = response.allowTools;
|
||||
}
|
||||
|
||||
content[i] = {
|
||||
...c,
|
||||
permissions
|
||||
};
|
||||
}
|
||||
return c;
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (logMessage.type === 'assistant' && message.type === 'assistant') {
|
||||
const assistantMsg = message as SDKAssistantMessage;
|
||||
const toolCallIds: string[] = [];
|
||||
|
||||
if (assistantMsg.message.content && Array.isArray(assistantMsg.message.content)) {
|
||||
for (const block of assistantMsg.message.content) {
|
||||
if (block.type === 'tool_use' && block.id) {
|
||||
toolCallIds.push(block.id);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (toolCallIds.length > 0) {
|
||||
const isSidechain = assistantMsg.parent_tool_use_id !== undefined;
|
||||
|
||||
if (!isSidechain) {
|
||||
messageQueue.enqueue(logMessage, {
|
||||
delay: 250,
|
||||
toolCallIds
|
||||
});
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
messageQueue.enqueue(logMessage);
|
||||
}
|
||||
|
||||
if (message.type === 'assistant') {
|
||||
let umessage = message as SDKAssistantMessage;
|
||||
if (umessage.message.content && Array.isArray(umessage.message.content)) {
|
||||
for (let c of umessage.message.content) {
|
||||
if (c.type === 'tool_use' && c.name === 'Task' && c.input && typeof (c.input as any).prompt === 'string') {
|
||||
const logMessage2 = sdkToLogConverter.convertSidechainUserMessage(c.id!, (c.input as any).prompt);
|
||||
if (logMessage2) {
|
||||
messageQueue.enqueue(logMessage2);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const logMessage = sdkToLogConverter.convert(msg);
|
||||
if (logMessage) {
|
||||
// Add permissions field to tool result content
|
||||
if (logMessage.type === 'user' && logMessage.message?.content) {
|
||||
const content = Array.isArray(logMessage.message.content)
|
||||
? logMessage.message.content
|
||||
: [];
|
||||
try {
|
||||
let pending: {
|
||||
message: string;
|
||||
mode: EnhancedMode;
|
||||
} | null = null;
|
||||
|
||||
// Modify the content array to add permissions to each tool_result
|
||||
for (let i = 0; i < content.length; i++) {
|
||||
const c = content[i];
|
||||
if (c.type === 'tool_result' && c.tool_use_id) {
|
||||
const responses = permissionHandler.getResponses();
|
||||
const response = responses.get(c.tool_use_id);
|
||||
let previousSessionId: string | null = null;
|
||||
while (!this.exitReason) {
|
||||
logger.debug('[remote]: launch');
|
||||
messageBuffer.addMessage('═'.repeat(40), 'status');
|
||||
|
||||
if (response) {
|
||||
const permissions: PermissionsField = {
|
||||
date: response.receivedAt || Date.now(),
|
||||
result: response.approved ? 'approved' : 'denied'
|
||||
};
|
||||
const isNewSession = session.sessionId !== previousSessionId;
|
||||
if (isNewSession) {
|
||||
messageBuffer.addMessage('Starting new Claude session...', 'status');
|
||||
permissionHandler.reset();
|
||||
sdkToLogConverter.resetParentChain();
|
||||
logger.debug(`[remote]: New session detected (previous: ${previousSessionId}, current: ${session.sessionId})`);
|
||||
} else {
|
||||
messageBuffer.addMessage('Continuing Claude session...', 'status');
|
||||
logger.debug(`[remote]: Continuing existing session: ${session.sessionId}`);
|
||||
}
|
||||
|
||||
// Add optional fields if they exist
|
||||
if (response.mode) {
|
||||
permissions.mode = response.mode;
|
||||
previousSessionId = session.sessionId;
|
||||
const controller = new AbortController();
|
||||
this.abortController = controller;
|
||||
this.abortFuture = new Future<void>();
|
||||
let modeHash: string | null = null;
|
||||
let mode: EnhancedMode | null = null;
|
||||
try {
|
||||
await claudeRemote({
|
||||
sessionId: session.sessionId,
|
||||
path: session.path,
|
||||
allowedTools: session.allowedTools ?? [],
|
||||
mcpServers: session.mcpServers,
|
||||
hookSettingsPath: session.hookSettingsPath,
|
||||
canCallTool: permissionHandler.handleToolCall,
|
||||
isAborted: (toolCallId: string) => {
|
||||
return permissionHandler.isAborted(toolCallId);
|
||||
},
|
||||
nextMessage: async () => {
|
||||
if (pending) {
|
||||
let p = pending;
|
||||
pending = null;
|
||||
permissionHandler.handleModeChange(p.mode.permissionMode);
|
||||
return p;
|
||||
}
|
||||
|
||||
if (response.allowTools && response.allowTools.length > 0) {
|
||||
permissions.allowedTools = response.allowTools;
|
||||
let msg = await session.queue.waitForMessagesAndGetAsString(controller.signal);
|
||||
|
||||
if (msg) {
|
||||
if ((modeHash && msg.hash !== modeHash) || msg.isolate) {
|
||||
logger.debug('[remote]: mode has changed, pending message');
|
||||
pending = msg;
|
||||
return null;
|
||||
}
|
||||
modeHash = msg.hash;
|
||||
mode = msg.mode;
|
||||
permissionHandler.handleModeChange(mode.permissionMode);
|
||||
return {
|
||||
message: msg.message,
|
||||
mode: msg.mode
|
||||
};
|
||||
}
|
||||
|
||||
// Add permissions directly to the tool_result content object
|
||||
content[i] = {
|
||||
...c,
|
||||
permissions
|
||||
};
|
||||
return null;
|
||||
},
|
||||
onSessionFound: (sessionId) => {
|
||||
session.onSessionFound(sessionId);
|
||||
},
|
||||
onThinkingChange: session.onThinkingChange,
|
||||
claudeEnvVars: session.claudeEnvVars,
|
||||
claudeArgs: session.claudeArgs,
|
||||
onMessage,
|
||||
onCompletionEvent: (message: string) => {
|
||||
logger.debug(`[remote]: Completion event: ${message}`);
|
||||
session.client.sendSessionEvent({ type: 'message', message });
|
||||
},
|
||||
onSessionReset: () => {
|
||||
logger.debug('[remote]: Session reset');
|
||||
session.clearSessionId();
|
||||
},
|
||||
onReady: () => {
|
||||
if (!pending && session.queue.size() === 0) {
|
||||
session.client.sendSessionEvent({ type: 'ready' });
|
||||
}
|
||||
},
|
||||
signal: controller.signal,
|
||||
});
|
||||
|
||||
session.consumeOneTimeFlags();
|
||||
|
||||
if (!this.exitReason && controller.signal.aborted) {
|
||||
session.client.sendSessionEvent({ type: 'message', message: 'Aborted by user' });
|
||||
}
|
||||
} catch (e) {
|
||||
logger.debug('[remote]: launch error', e);
|
||||
if (!this.exitReason) {
|
||||
session.client.sendSessionEvent({ type: 'message', message: 'Process exited unexpectedly' });
|
||||
continue;
|
||||
}
|
||||
} finally {
|
||||
logger.debug('[remote]: launch finally');
|
||||
|
||||
for (let [toolCallId, { parentToolCallId }] of ongoingToolCalls) {
|
||||
const converted = sdkToLogConverter.generateInterruptedToolResult(toolCallId, parentToolCallId);
|
||||
if (converted) {
|
||||
logger.debug('[remote]: terminating tool call ' + toolCallId + ' parent: ' + parentToolCallId);
|
||||
session.client.sendClaudeSessionMessage(converted);
|
||||
}
|
||||
}
|
||||
ongoingToolCalls.clear();
|
||||
|
||||
logger.debug('[remote]: flushing message queue');
|
||||
await messageQueue.flush();
|
||||
messageQueue.destroy();
|
||||
logger.debug('[remote]: message queue flushed');
|
||||
|
||||
this.abortController = null;
|
||||
this.abortFuture?.resolve(undefined);
|
||||
this.abortFuture = null;
|
||||
logger.debug('[remote]: launch done');
|
||||
permissionHandler.reset();
|
||||
modeHash = null;
|
||||
mode = null;
|
||||
}
|
||||
}
|
||||
|
||||
// Queue message with optional delay for tool calls
|
||||
if (logMessage.type === 'assistant' && message.type === 'assistant') {
|
||||
const assistantMsg = message as SDKAssistantMessage;
|
||||
const toolCallIds: string[] = [];
|
||||
|
||||
if (assistantMsg.message.content && Array.isArray(assistantMsg.message.content)) {
|
||||
for (const block of assistantMsg.message.content) {
|
||||
if (block.type === 'tool_use' && block.id) {
|
||||
toolCallIds.push(block.id);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (toolCallIds.length > 0) {
|
||||
// Check if this is a sidechain tool call (has parent_tool_use_id)
|
||||
const isSidechain = assistantMsg.parent_tool_use_id !== undefined;
|
||||
|
||||
if (!isSidechain) {
|
||||
// Top-level tool call - queue with delay
|
||||
messageQueue.enqueue(logMessage, {
|
||||
delay: 250,
|
||||
toolCallIds
|
||||
});
|
||||
return; // Don't queue again below
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Queue all other messages immediately (no delay)
|
||||
messageQueue.enqueue(logMessage);
|
||||
}
|
||||
|
||||
// Insert a fake message to start the sidechain
|
||||
if (message.type === 'assistant') {
|
||||
let umessage = message as SDKAssistantMessage;
|
||||
if (umessage.message.content && Array.isArray(umessage.message.content)) {
|
||||
for (let c of umessage.message.content) {
|
||||
if (c.type === 'tool_use' && c.name === 'Task' && c.input && typeof (c.input as any).prompt === 'string') {
|
||||
const logMessage2 = sdkToLogConverter.convertSidechainUserMessage(c.id!, (c.input as any).prompt);
|
||||
if (logMessage2) {
|
||||
messageQueue.enqueue(logMessage2);
|
||||
}
|
||||
}
|
||||
}
|
||||
} finally {
|
||||
if (this.permissionHandler) {
|
||||
this.permissionHandler.reset();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
try {
|
||||
let pending: {
|
||||
message: string;
|
||||
mode: EnhancedMode;
|
||||
} | null = null;
|
||||
protected async cleanup(): Promise<void> {
|
||||
this.clearAbortHandlers(this.session.client.rpcHandlerManager);
|
||||
|
||||
// Track session ID to detect when it actually changes
|
||||
// This prevents context loss when mode changes (permission mode, model, etc.)
|
||||
// without starting a new session. Only reset parent chain when session ID
|
||||
// actually changes (e.g., new session started or /clear command used).
|
||||
// See: https://github.com/anthropics/happy-cli/issues/143
|
||||
let previousSessionId: string | null = null;
|
||||
while (!exitReason) {
|
||||
logger.debug('[remote]: launch');
|
||||
messageBuffer.addMessage('═'.repeat(40), 'status');
|
||||
|
||||
// Only reset parent chain and show "new session" message when session ID actually changes
|
||||
const isNewSession = session.sessionId !== previousSessionId;
|
||||
if (isNewSession) {
|
||||
messageBuffer.addMessage('Starting new Claude session...', 'status');
|
||||
permissionHandler.reset(); // Reset permissions before starting new session
|
||||
sdkToLogConverter.resetParentChain(); // Reset parent chain for new conversation
|
||||
logger.debug(`[remote]: New session detected (previous: ${previousSessionId}, current: ${session.sessionId})`);
|
||||
} else {
|
||||
messageBuffer.addMessage('Continuing Claude session...', 'status');
|
||||
logger.debug(`[remote]: Continuing existing session: ${session.sessionId}`);
|
||||
}
|
||||
|
||||
previousSessionId = session.sessionId;
|
||||
const controller = new AbortController();
|
||||
abortController = controller;
|
||||
abortFuture = new Future<void>();
|
||||
let modeHash: string | null = null;
|
||||
let mode: EnhancedMode | null = null;
|
||||
try {
|
||||
const remoteResult = await claudeRemote({
|
||||
sessionId: session.sessionId,
|
||||
path: session.path,
|
||||
allowedTools: session.allowedTools ?? [],
|
||||
mcpServers: session.mcpServers,
|
||||
hookSettingsPath: session.hookSettingsPath,
|
||||
canCallTool: permissionHandler.handleToolCall,
|
||||
isAborted: (toolCallId: string) => {
|
||||
return permissionHandler.isAborted(toolCallId);
|
||||
},
|
||||
nextMessage: async () => {
|
||||
if (pending) {
|
||||
let p = pending;
|
||||
pending = null;
|
||||
permissionHandler.handleModeChange(p.mode.permissionMode);
|
||||
return p;
|
||||
}
|
||||
|
||||
let msg = await session.queue.waitForMessagesAndGetAsString(controller.signal);
|
||||
|
||||
// Check if mode has changed
|
||||
if (msg) {
|
||||
if ((modeHash && msg.hash !== modeHash) || msg.isolate) {
|
||||
logger.debug('[remote]: mode has changed, pending message');
|
||||
pending = msg;
|
||||
return null;
|
||||
}
|
||||
modeHash = msg.hash;
|
||||
mode = msg.mode;
|
||||
permissionHandler.handleModeChange(mode.permissionMode);
|
||||
return {
|
||||
message: msg.message,
|
||||
mode: msg.mode
|
||||
}
|
||||
}
|
||||
|
||||
// Exit
|
||||
return null;
|
||||
},
|
||||
onSessionFound: (sessionId) => {
|
||||
session.onSessionFound(sessionId);
|
||||
},
|
||||
onThinkingChange: session.onThinkingChange,
|
||||
claudeEnvVars: session.claudeEnvVars,
|
||||
claudeArgs: session.claudeArgs,
|
||||
onMessage,
|
||||
onCompletionEvent: (message: string) => {
|
||||
logger.debug(`[remote]: Completion event: ${message}`);
|
||||
session.client.sendSessionEvent({ type: 'message', message });
|
||||
},
|
||||
onSessionReset: () => {
|
||||
logger.debug('[remote]: Session reset');
|
||||
session.clearSessionId();
|
||||
},
|
||||
onReady: () => {
|
||||
if (!pending && session.queue.size() === 0) {
|
||||
session.client.sendSessionEvent({ type: 'ready' });
|
||||
}
|
||||
},
|
||||
signal: abortController.signal,
|
||||
});
|
||||
|
||||
// Consume one-time Claude flags after spawn
|
||||
session.consumeOneTimeFlags();
|
||||
|
||||
if (!exitReason && abortController.signal.aborted) {
|
||||
session.client.sendSessionEvent({ type: 'message', message: 'Aborted by user' });
|
||||
}
|
||||
} catch (e) {
|
||||
logger.debug('[remote]: launch error', e);
|
||||
if (!exitReason) {
|
||||
session.client.sendSessionEvent({ type: 'message', message: 'Process exited unexpectedly' });
|
||||
continue;
|
||||
}
|
||||
} finally {
|
||||
|
||||
logger.debug('[remote]: launch finally');
|
||||
|
||||
// Terminate all ongoing tool calls
|
||||
for (let [toolCallId, { parentToolCallId }] of ongoingToolCalls) {
|
||||
const converted = sdkToLogConverter.generateInterruptedToolResult(toolCallId, parentToolCallId);
|
||||
if (converted) {
|
||||
logger.debug('[remote]: terminating tool call ' + toolCallId + ' parent: ' + parentToolCallId);
|
||||
session.client.sendClaudeSessionMessage(converted);
|
||||
}
|
||||
}
|
||||
ongoingToolCalls.clear();
|
||||
|
||||
// Flush any remaining messages in the queue
|
||||
logger.debug('[remote]: flushing message queue');
|
||||
await messageQueue.flush();
|
||||
messageQueue.destroy();
|
||||
logger.debug('[remote]: message queue flushed');
|
||||
|
||||
// Reset abort controller and future
|
||||
abortController = null;
|
||||
abortFuture?.resolve(undefined);
|
||||
abortFuture = null;
|
||||
logger.debug('[remote]: launch done');
|
||||
permissionHandler.reset();
|
||||
modeHash = null;
|
||||
mode = null;
|
||||
}
|
||||
if (this.handleSessionFound) {
|
||||
this.session.removeSessionFoundCallback(this.handleSessionFound);
|
||||
this.handleSessionFound = null;
|
||||
}
|
||||
} finally {
|
||||
|
||||
session.removeSessionFoundCallback(handleSessionFound);
|
||||
|
||||
// Clean up permission handler
|
||||
permissionHandler.reset();
|
||||
|
||||
// Reset Terminal
|
||||
process.stdin.off('data', abort);
|
||||
restoreTerminalState();
|
||||
if (hasTTY) {
|
||||
try { process.stdin.pause(); } catch {}
|
||||
if (this.permissionHandler) {
|
||||
this.permissionHandler.reset();
|
||||
}
|
||||
if (inkInstance) {
|
||||
inkInstance.unmount();
|
||||
}
|
||||
messageBuffer.clear();
|
||||
|
||||
// Resolve abort future
|
||||
if (abortFuture) { // Just in case of error
|
||||
abortFuture.resolve(undefined);
|
||||
if (this.abortFuture) {
|
||||
this.abortFuture.resolve(undefined);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return exitReason || 'exit';
|
||||
export async function claudeRemoteLauncher(session: Session): Promise<'switch' | 'exit'> {
|
||||
const launcher = new ClaudeRemoteLauncher(session);
|
||||
return launcher.launch();
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user