@downcity/city 1.1.32 → 1.1.47

package/src/cli/agent/AgentChat.ts

@@ -5,24 +5,25 @@
  * - 统一覆盖交互式持续对话与一次性消息模式，不再保留独立 `quest` 命令。
  * - 目标 agent 始终按 managed agent registry 名称解析，不依赖当前工作目录。
  * - 默认使用独立 local-cli 主会话：`local-cli-chat-main`。
+ * - 远程访问统一走 `RemoteAgent({ url })`，不再在 CLI 侧维护第二套 HTTP SDK transport。
  */
 
 import { createInterface } from "node:readline/promises";
 import chalk from "chalk";
 import prompts from "prompts";
-import type { AgentSessionEvent } from "@downcity/agent";
+import {
+  RemoteAgent,
+  type AgentSessionEvent,
+  type RemoteAgentSession,
+} from "@downcity/agent";
 import { emitCliBlock } from "../shared/CliReporter.js";
 import { printResult } from "@/utils/cli/CliOutput.js";
 import {
-  resolveProjectRootByAgentName,
+  resolveProjectRootByAgentId,
   validateAgentProjectRoot,
 } from "../shared/PluginTargetSupport.js";
 import { listRegisteredAgentsForCli } from "./AgentSelection.js";
-import {
-  formatCliBearerHeaderValue,
-  resolveCliAuthToken,
-} from "@/http/auth/CliAuthStateStore.js";
-import { resolveDaemonEndpoint } from "@/process/daemon/Client.js";
+import { resolveDaemonRpcEndpoint } from "@/process/daemon/Client.js";
 import type {
   AgentChatCliOptions,
   AgentChatExecutionOutcome,
@@ -31,13 +32,11 @@ import type {
 } from "./AgentChatTypes.js";
 import { AGENT_CHAT_DEFAULT_SESSION_ID } from "./AgentChatTypes.js";
 
-const SDK_EVENTS_READY_TYPE = "sdk-events-ready";
-
 type ResolvedAgentChatTarget = {
   /**
-   * 目标 agent 名称。
+   * 目标 agent id。
    */
-  agentName: string;
+  agentId: string;
   /**
    * 目标项目根目录。
    */
@@ -69,15 +68,15 @@ function buildAgentChatFailureText(error?: string): string {
   );
 }
 
-async function resolveChatTargetAgentName(inputName?: string): Promise<string | null> {
-  const explicit = String(inputName || "").trim();
+async function resolveChatTargetAgentId(inputId?: string): Promise<string | null> {
+  const explicit = String(inputId || "").trim();
   if (explicit) return explicit;
 
   if (!process.stdin.isTTY || !process.stdout.isTTY) {
     emitCliBlock({
       tone: "error",
-      title: "Agent name is required",
-      note: "Use `city agent chat --to <agentName>` or run this command in an interactive terminal.",
+      title: "Agent id is required",
+      note: "Use `city agent chat --to <id>` or run this command in an interactive terminal.",
     });
     return null;
   }
@@ -96,28 +95,28 @@ async function resolveChatTargetAgentName(inputName?: string): Promise<string |
 
   const response = (await prompts({
     type: "select",
-    name: "agentName",
+    name: "agentId",
     message: "选择要聊天的 Agent",
     choices: runningAgents.map((agent) => ({
-      title: agent.name,
+      title: agent.id,
       description: agent.projectRoot,
-      value: agent.name,
+      value: agent.id,
     })),
     initial: 0,
-  })) as { agentName?: string };
-  const agentName = String(response.agentName || "").trim();
-  if (!agentName) {
+  })) as { agentId?: string };
+  const agentId = String(response.agentId || "").trim();
+  if (!agentId) {
     emitCliBlock({
       tone: "info",
       title: "Agent chat cancelled",
     });
     return null;
   }
-  return agentName;
+  return agentId;
 }
 
 async function resolveAgentChatTarget(
-  agentNameInput: string,
+  agentIdInput: string,
 ): Promise<
   | {
       success: true;
@@ -128,26 +127,26 @@ async function resolveAgentChatTarget(
       outcome: AgentChatExecutionOutcome;
     }
 > {
-  const agentName = String(agentNameInput || "").trim();
+  const agentId = String(agentIdInput || "").trim();
   const sessionId = AGENT_CHAT_DEFAULT_SESSION_ID;
-  if (!agentName) {
+  if (!agentId) {
     return {
       success: false,
       outcome: {
-        agentName: "",
+        agentId: "",
         sessionId,
         success: false,
-        error: "Missing target agent name.",
+        error: "Missing target agent id.",
       },
     };
   }
 
-  const resolved = await resolveProjectRootByAgentName(agentName);
+  const resolved = await resolveProjectRootByAgentId(agentId);
   if (!resolved.projectRoot) {
     return {
       success: false,
       outcome: {
-        agentName,
+        agentId,
         sessionId,
         success: false,
         error: resolved.error || "Failed to resolve agent project path",
@@ -160,7 +159,7 @@ async function resolveAgentChatTarget(
     return {
       success: false,
       outcome: {
-        agentName,
+        agentId,
         projectRoot: resolved.projectRoot,
         sessionId,
         success: false,
@@ -172,7 +171,7 @@ async function resolveAgentChatTarget(
   return {
     success: true,
     target: {
-      agentName,
+      agentId,
       projectRoot: resolved.projectRoot,
       sessionId,
     },
@@ -193,7 +192,7 @@ function printAssistantReply(replyText: string): void {
 }
 
 function printAgentChatFailure(params: {
-  agentName: string;
+  agentId: string;
   error?: string;
 }): void {
   emitCliBlock({
@@ -202,7 +201,7 @@ function printAgentChatFailure(params: {
     facts: [
       {
         label: "agent",
-        value: params.agentName,
+        value: params.agentId,
       },
       {
         label: "error",
@@ -212,93 +211,35 @@ function printAgentChatFailure(params: {
   });
 }
 
-async function readHttpFailure(response: Response): Promise<string> {
-  const contentType = String(response.headers.get("content-type") || "").toLowerCase();
-  const text = await response.text().catch(() => "");
-  if (contentType.includes("application/json")) {
-    try {
-      const payload = JSON.parse(text) as {
-        error?: string;
-        message?: string;
-      };
-      return (
-        String(payload.error || payload.message || "").trim() ||
-        `HTTP ${response.status}`
-      );
-    } catch {
-      // ignore malformed json payloads
-    }
-  }
-  return String(text || "").trim() || `HTTP ${response.status}`;
-}
-
-function isSdkEventsReadyFrame(value: unknown): boolean {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    "type" in value &&
-    String((value as { type?: unknown }).type || "") === SDK_EVENTS_READY_TYPE
-  );
-}
-
-async function postSdkPrompt(params: {
-  endpointBaseUrl: string;
-  sessionId: string;
-  message: string;
-  authHeaderValue?: string;
-}): Promise<
-  | {
-      success: true;
-      turnId: string;
-    }
-  | {
-      success: false;
-      error: string;
-    }
-> {
-  const response = await fetch(
-    new URL(
-      `/api/sdk/sessions/${encodeURIComponent(params.sessionId)}/prompt`,
-      params.endpointBaseUrl,
-    ).toString(),
-    {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        ...(params.authHeaderValue ? { Authorization: params.authHeaderValue } : {}),
-      },
-      body: JSON.stringify({
-        query: params.message,
-      }),
-    },
-  ).catch((error) => {
-    throw new Error(`Failed to call ${params.endpointBaseUrl}: ${String(error)}`);
+function createRemoteAgent(params: {
+  projectRoot: string;
+  transport?: AgentChatTransportOptions;
+}): RemoteAgent {
+  const endpoint = resolveDaemonRpcEndpoint({
+    projectRoot: params.projectRoot,
+    host: params.transport?.host,
+    port: params.transport?.port,
+  });
+  return new RemoteAgent({
+    url: `rpc://${endpoint.host}:${endpoint.port}`,
   });
+}
 
-  const payload = (await response.json().catch(() => ({}))) as {
-    success?: boolean;
-    error?: string;
-    turn?: {
-      id?: string;
-    };
-  };
-  const turnId = String(payload.turn?.id || "").trim();
-  if (!response.ok || payload.success !== true || !turnId) {
-    return {
-      success: false,
-      error:
-        String(payload.error || "").trim() ||
-        `SDK prompt failed with HTTP ${response.status}`,
-    };
+async function getOrCreateRemoteSession(params: {
+  remote_agent: RemoteAgent;
+  session_id: string;
+}): Promise<RemoteAgentSession> {
+  try {
+    return await params.remote_agent.getSession(params.session_id);
+  } catch {
+    return await params.remote_agent.createSession({
+      sessionId: params.session_id,
+    });
   }
-  return {
-    success: true,
-    turnId,
-  };
 }
 
 async function runSdkPromptTurn(params: {
-  agentName: string;
+  agentId: string;
   message: string;
   transport?: AgentChatTransportOptions;
   renderText?: boolean;
@@ -318,7 +259,7 @@ async function runSdkPromptTurn(params: {
     };
   }
 
-  const resolved = await resolveAgentChatTarget(params.agentName);
+  const resolved = await resolveAgentChatTarget(params.agentId);
   if (!resolved.success) {
     return {
       success: false,
@@ -328,188 +269,76 @@ async function runSdkPromptTurn(params: {
     };
   }
 
-  const { target } = resolved;
-  const abortController = new AbortController();
-  const endpoint = resolveDaemonEndpoint({
-    projectRoot: target.projectRoot,
-    host: params.transport?.host,
-    port: params.transport?.port,
+  const remote_agent = createRemoteAgent({
+    projectRoot: resolved.target.projectRoot,
+    transport: params.transport,
   });
-  const authHeaderValue = formatCliBearerHeaderValue(
-    resolveCliAuthToken({
-      explicitToken: params.transport?.token,
-    }),
-  );
-  const response = await fetch(
-    new URL(
-      `/api/sdk/sessions/${encodeURIComponent(target.sessionId)}/events`,
-      endpoint.baseUrl,
-    ).toString(),
-    {
-      headers: {
-        ...(authHeaderValue ? { Authorization: authHeaderValue } : {}),
-      },
-      signal: abortController.signal,
-    },
-  ).catch((error) => {
-    throw new Error(`Failed to call ${endpoint.baseUrl}: ${String(error)}`);
+  const session = await getOrCreateRemoteSession({
+    remote_agent,
+    session_id: resolved.target.sessionId,
   });
 
-  if (!response.ok || !response.body) {
-    return {
-      success: false,
-      error: await readHttpFailure(response),
-      emittedVisibleText: false,
-      text: "",
-    };
-  }
-
-  const decoder = new TextDecoder();
-  const reader = response.body.getReader();
-  let buffered = "";
-  let printedLeadingNewline = false;
-  let emittedVisibleText = false;
-  let promptTurnId = "";
-  let promptPosted = false;
-  let finalText = "";
+  let printed_leading_newline = false;
+  let emitted_visible_text = false;
+  let final_text = "";
+  let target_turn_id = "";
 
   const renderEvent = (event: AgentSessionEvent): void => {
-    if (event.type !== "text-delta" || event.turnId !== promptTurnId || !event.text) return;
+    if (event.type !== "text-delta" || event.turnId !== target_turn_id || !event.text) {
+      return;
+    }
     if (params.renderText === false) return;
-    if (!printedLeadingNewline) {
+    if (!printed_leading_newline) {
       process.stdout.write("\n");
-      printedLeadingNewline = true;
+      printed_leading_newline = true;
     }
     process.stdout.write(event.text);
-    emittedVisibleText = true;
+    emitted_visible_text = true;
   };
 
-  const handleLine = async (line: string): Promise<
-    | {
-        done: true;
-        error?: string;
-      }
-    | {
-        done: false;
-      }
-  > => {
-    const value = JSON.parse(line) as unknown;
-    if (isSdkEventsReadyFrame(value)) {
-      if (!promptPosted) {
-        promptPosted = true;
-        const promptResult = await postSdkPrompt({
-          endpointBaseUrl: endpoint.baseUrl,
-          sessionId: target.sessionId,
-          message,
-          authHeaderValue,
-        });
-        if (!promptResult.success) {
-          return {
-            done: true,
-            error: promptResult.error,
-          };
-        }
-        promptTurnId = promptResult.turnId;
-      }
-      return { done: false };
-    }
-
-    const event = value as AgentSessionEvent;
-    if (event.type === "error") {
-      return {
-        done: true,
-        error: event.message,
-      };
-    }
+  const unsubscribe = session.subscribe((event) => {
     renderEvent(event);
-    if (event.type === "turn-finish" && event.turnId === promptTurnId) {
-      finalText = event.text;
-      return {
-        done: true,
-        ...(event.success ? {} : { error: event.error || "Agent turn failed" }),
-      };
+    if (event.type === "turn-finish" && event.turnId === target_turn_id) {
+      final_text = event.text;
     }
-    return { done: false };
-  };
+  });
+
+  try {
+    const turn = await session.prompt({ query: message });
+    target_turn_id = turn.id;
+    const result = await turn.finished;
+    final_text = result.text;
 
-  const finishTurn = (result: {
-    success: boolean;
-    error?: string;
-  }): {
-    success: boolean;
-    error?: string;
-    emittedVisibleText: boolean;
-    text: string;
-  } => {
-    if (printedLeadingNewline) {
+    if (printed_leading_newline) {
       process.stdout.write("\n\n");
     }
+
     return {
       success: result.success,
       ...(result.error ? { error: result.error } : {}),
-      emittedVisibleText,
-      text: finalText,
+      emittedVisibleText: emitted_visible_text,
+      text: final_text,
     };
-  };
-
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      buffered += decoder.decode(value, { stream: true });
-      let newlineIndex = buffered.indexOf("\n");
-      while (newlineIndex >= 0) {
-        const line = buffered.slice(0, newlineIndex).trim();
-        buffered = buffered.slice(newlineIndex + 1);
-        if (line) {
-          const result = await handleLine(line);
-          if (result.done) {
-            return finishTurn({
-              success: !result.error,
-              ...(result.error ? { error: result.error } : {}),
-            });
-          }
-        }
-        newlineIndex = buffered.indexOf("\n");
-      }
-    }
-
-    const tail = buffered.trim();
-    if (tail) {
-      const result = await handleLine(tail);
-      if (result.done) {
-        return finishTurn({
-          success: !result.error,
-          ...(result.error ? { error: result.error } : {}),
-        });
-      }
-    }
   } catch (error) {
-    return finishTurn({
+    if (printed_leading_newline) {
+      process.stdout.write("\n\n");
+    }
+    return {
       success: false,
       error: error instanceof Error ? error.message : String(error),
-    });
+      emittedVisibleText: emitted_visible_text,
+      text: final_text,
+    };
   } finally {
-    abortController.abort();
-    await reader.cancel().catch(() => undefined);
-    try {
-      reader.releaseLock();
-    } catch {
-      // ignore
-    }
+    unsubscribe();
   }
-
-  return finishTurn({
-    success: promptPosted && Boolean(promptTurnId),
-    ...(promptPosted && promptTurnId ? {} : { error: "SDK events connection closed before prompt was accepted." }),
-  });
 }
 
 /**
  * 向目标 agent 的 SDK actor session 发送一轮消息。
  */
 export async function executeAgentChatTurn(params: {
-  agentName: string;
+  agentId: string;
   message: string;
   transport?: AgentChatTransportOptions;
 }): Promise<AgentChatExecutionOutcome> {
@@ -518,25 +347,25 @@ export async function executeAgentChatTurn(params: {
 
   if (!message) {
     return {
-      agentName: String(params.agentName || "").trim(),
+      agentId: String(params.agentId || "").trim(),
       sessionId,
       success: false,
       error: "Chat message is required.",
     };
   }
 
-  const resolved = await resolveAgentChatTarget(params.agentName);
+  const resolved = await resolveAgentChatTarget(params.agentId);
   if (!resolved.success) return resolved.outcome;
 
   const outcome = await runSdkPromptTurn({
-    agentName: params.agentName,
+    agentId: params.agentId,
     message,
     transport: params.transport,
     renderText: false,
   });
 
   return {
-    agentName: params.agentName,
+    agentId: params.agentId,
     ...(resolved.target.projectRoot ? { projectRoot: resolved.target.projectRoot } : {}),
     sessionId,
     success: outcome.success,
@@ -555,18 +384,17 @@ export async function executeAgentChatTurn(params: {
 }
 
 async function runOneShotChat(params: {
-  agentName: string;
+  agentId: string;
   message: string;
   options: AgentChatCliOptions;
 }): Promise<void> {
   if (params.options.json === true) {
     const outcome = await executeAgentChatTurn({
-      agentName: params.agentName,
+      agentId: params.agentId,
       message: params.message,
       transport: {
         host: params.options.host,
         port: params.options.port,
-        token: params.options.token,
       },
     });
     printResult({
@@ -574,7 +402,7 @@ async function runOneShotChat(params: {
       success: outcome.success,
       title: "agent chat",
       payload: {
-        agent: params.agentName,
+        agent: params.agentId,
         ...(outcome.projectRoot ? { projectRoot: outcome.projectRoot } : {}),
         sessionId: outcome.sessionId,
         ...(outcome.payload?.result ? { result: outcome.payload.result } : {}),
@@ -585,18 +413,17 @@ async function runOneShotChat(params: {
   }
 
   const outcome = await runSdkPromptTurn({
-    agentName: params.agentName,
+    agentId: params.agentId,
     message: params.message,
     transport: {
       host: params.options.host,
       port: params.options.port,
-      token: params.options.token,
     },
   });
 
   if (!outcome.success) {
     printAgentChatFailure({
-      agentName: params.agentName,
+      agentId: params.agentId,
       error: outcome.error,
     });
     return;
@@ -609,10 +436,10 @@ async function runOneShotChat(params: {
  * 启动交互式持续对话。
  */
 async function runInteractiveChat(params: {
-  agentName: string;
+  agentId: string;
   options: AgentChatCliOptions;
 }): Promise<void> {
-  const prompt = `${chalk.cyan(params.agentName)} ${chalk.dim("›")} `;
+  const prompt = `${chalk.cyan(params.agentId)} ${chalk.dim("›")} `;
   const helpText = [
     `${chalk.dim("/exit, /quit  — 退出对话")}`,
     `${chalk.dim("/clear       — 清屏")}`,
@@ -622,7 +449,7 @@ async function runInteractiveChat(params: {
 
   emitCliBlock({
     tone: "info",
-    title: `Agent chat · ${params.agentName}`,
+    title: `Agent chat · ${params.agentId}`,
     note: `Session: local-cli-chat-main · ${helpText[0].replace(chalk.dim(""), "").trim()}`,
   });
   console.log(helpText.join("\n"));
@@ -639,8 +466,6 @@ async function runInteractiveChat(params: {
       try {
         line = await rl.question(prompt);
       } catch (error) {
-        // 关键点（中文）：Node 24 下 Ctrl+C 会让 readline.question 以 AbortError 拒绝。
-        // 这里按正常退出处理，避免把交互式 chat 变成未捕获异常。
         if (isReadlineAbortError(error)) {
           console.log();
           break;
@@ -660,18 +485,17 @@ async function runInteractiveChat(params: {
       }
 
       const outcome = await runSdkPromptTurn({
-        agentName: params.agentName,
+        agentId: params.agentId,
         message: text,
         transport: {
           host: params.options.host,
           port: params.options.port,
-          token: params.options.token,
         },
       });
 
       if (!outcome.success) {
         printAgentChatFailure({
-          agentName: params.agentName,
+          agentId: params.agentId,
           error: outcome.error,
         });
         continue;
@@ -689,13 +513,13 @@ async function runInteractiveChat(params: {
  * `city agent chat` 统一入口。
  */
 export async function chatCommand(options: AgentChatCliOptions): Promise<void> {
-  const agentName = await resolveChatTargetAgentName(options.to);
-  if (!agentName) return;
+  const agentId = await resolveChatTargetAgentId(options.to);
+  if (!agentId) return;
 
   const oneShotMessage = normalizeChatMessage(String(options.message || ""));
   if (oneShotMessage) {
     await runOneShotChat({
-      agentName,
+      agentId,
       message: oneShotMessage,
       options,
     });
@@ -721,7 +545,7 @@ export async function chatCommand(options: AgentChatCliOptions): Promise<void> {
   }
 
   await runInteractiveChat({
-    agentName,
+    agentId,
     options,
   });
 }