chatccc 0.2.203 → 0.2.205

package/src/agent-activity.ts

@@ -0,0 +1,170 @@
+import type { UnifiedBlock } from "./adapters/adapter-interface.ts";
+
+export type AgentActivityKind =
+  | "starting"
+  | "thinking"
+  | "tool"
+  | "processing"
+  | "responding"
+  | "searching"
+  | "compacting";
+
+/** The user-visible activity of a running Agent turn. */
+export interface AgentActivity {
+  kind: AgentActivityKind;
+  /** Time when the current activity began, used for truthful elapsed time. */
+  startedAt: number;
+  toolName?: string;
+  toolCount?: number;
+}
+
+interface ActiveTool {
+  id: string;
+  name: string;
+  startedAt: number;
+}
+
+export interface AgentActivityTracker {
+  activity: AgentActivity;
+  activeTools: Map<string, ActiveTool>;
+  nextAnonymousToolId: number;
+}
+
+export function createAgentActivityTracker(now = Date.now()): AgentActivityTracker {
+  return {
+    activity: { kind: "starting", startedAt: now },
+    activeTools: new Map(),
+    nextAnonymousToolId: 1,
+  };
+}
+
+function sameVisibleActivity(left: AgentActivity, right: AgentActivity): boolean {
+  return left.kind === right.kind
+    && left.toolName === right.toolName
+    && left.toolCount === right.toolCount;
+}
+
+function setActivity(tracker: AgentActivityTracker, next: AgentActivity): boolean {
+  if (sameVisibleActivity(tracker.activity, next)) return false;
+  tracker.activity = next;
+  return true;
+}
+
+function refreshToolActivity(tracker: AgentActivityTracker): boolean {
+  const tools = [...tracker.activeTools.values()];
+  const first = tools[0];
+  if (!first) return false;
+  return setActivity(tracker, {
+    kind: "tool",
+    startedAt: first.startedAt,
+    toolName: first.name,
+    toolCount: tools.length,
+  });
+}
+
+function removeCompletedTool(tracker: AgentActivityTracker, toolUseId: string): void {
+  if (toolUseId && tracker.activeTools.delete(toolUseId)) return;
+
+  // Older adapters did not always include a tool ID. Prefer an anonymous entry;
+  // if there is only one active call, it is still safe to match that result.
+  const anonymousId = [...tracker.activeTools.keys()].find((id) => id.startsWith("anonymous:"));
+  if (anonymousId) {
+    tracker.activeTools.delete(anonymousId);
+  } else if (tracker.activeTools.size === 1) {
+    const onlyId = tracker.activeTools.keys().next().value as string | undefined;
+    if (onlyId) tracker.activeTools.delete(onlyId);
+  }
+}
+
+/**
+ * Applies one normalized Agent event and returns whether the persisted activity
+ * changed. Tool activity takes precedence while a tool call is still active.
+ */
+export function updateAgentActivity(
+  tracker: AgentActivityTracker,
+  block: UnifiedBlock,
+  now = Date.now(),
+): boolean {
+  if (block.type === "tool_use") {
+    const id = block.id || `anonymous:${tracker.nextAnonymousToolId++}`;
+    const existing = tracker.activeTools.get(id);
+    tracker.activeTools.set(id, {
+      id,
+      name: block.name || "未知工具",
+      startedAt: existing?.startedAt ?? now,
+    });
+    return refreshToolActivity(tracker);
+  }
+
+  if (block.type === "tool_result") {
+    removeCompletedTool(tracker, block.tool_use_id);
+    if (tracker.activeTools.size > 0) return refreshToolActivity(tracker);
+    return setActivity(tracker, { kind: "processing", startedAt: now });
+  }
+
+  if (tracker.activeTools.size > 0) return false;
+
+  switch (block.type) {
+    case "thinking":
+    case "redacted_thinking":
+      return setActivity(tracker, { kind: "thinking", startedAt: now });
+    case "text":
+    case "text_final":
+      return setActivity(tracker, { kind: "responding", startedAt: now });
+    case "search_result":
+      return setActivity(tracker, { kind: "searching", startedAt: now });
+    case "compact_boundary":
+      return setActivity(tracker, { kind: "compacting", startedAt: now });
+  }
+}
+
+function formatElapsed(startedAt: number, now: number): string {
+  const totalSeconds = Math.max(0, Math.floor((now - startedAt) / 1000));
+  if (totalSeconds < 60) return `${totalSeconds}秒`;
+  const totalMinutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  if (totalMinutes < 60) return `${totalMinutes}分${seconds}秒`;
+  const hours = Math.floor(totalMinutes / 60);
+  const minutes = totalMinutes % 60;
+  return `${hours}小时${minutes}分`;
+}
+
+function displayToolName(name: string | undefined): string {
+  const normalized = (name || "未知工具").replace(/\s+/g, " ").trim();
+  return normalized.length > 24 ? `${normalized.slice(0, 23)}…` : normalized;
+}
+
+export function formatAgentActivityTitle(
+  activity: AgentActivity | undefined,
+  now = Date.now(),
+): string {
+  if (!activity) return "正在处理";
+
+  let label: string;
+  switch (activity.kind) {
+    case "starting":
+      label = "正在启动 Agent";
+      break;
+    case "thinking":
+      label = "思考中";
+      break;
+    case "tool": {
+      const count = Math.max(1, activity.toolCount ?? 1);
+      label = `正在执行 ${displayToolName(activity.toolName)}${count > 1 ? ` 等 ${count} 项` : ""}`;
+      break;
+    }
+    case "processing":
+      label = "正在处理工具结果";
+      break;
+    case "responding":
+      label = "正在生成回复";
+      break;
+    case "searching":
+      label = "正在处理搜索结果";
+      break;
+    case "compacting":
+      label = "正在整理上下文";
+      break;
+  }
+  return `${label} · ${formatElapsed(activity.startedAt, now)}`;
+}

package/src/config.ts

@@ -150,10 +150,11 @@ export interface RawStreamLogsConfig {
   ccc: RawStreamAgentLogConfig;
 }
 
-export interface AppConfig {
-  feishu: FeishuConfig;
-  platforms: PlatformsConfig;
-  chromeDevtools: ChromeDevtoolsConfig;
+export interface AppConfig {
+  feishu: FeishuConfig;
+  platforms: PlatformsConfig;
+  webUi: { openOnStart: boolean };
+  chromeDevtools: ChromeDevtoolsConfig;
   port: number;
   gitTimeoutSeconds: number;
   /** 若为 false，AI 生成过程中用户发送消息不会打断，须先点「停止」再发送新消息 */
@@ -418,9 +419,10 @@ function normalizeRawStreamAgentLogConfig(raw: unknown): RawStreamAgentLogConfig
 
 function loadConfig(): AppConfig {
   const defaults: AppConfig = {
-    feishu: { appId: "", appSecret: "" },
-    platforms: { feishu: { enabled: true }, ilink: { enabled: true } },
-    chromeDevtools: { enabled: false, port: 15166, chromePath: "" },
+    feishu: { appId: "", appSecret: "" },
+    platforms: { feishu: { enabled: true }, ilink: { enabled: true } },
+    webUi: { openOnStart: true },
+    chromeDevtools: { enabled: false, port: 15166, chromePath: "" },
     port: 18080,
     gitTimeoutSeconds: 180,
     allowInterrupt: false,
@@ -495,6 +497,7 @@ function loadConfig(): AppConfig {
     };
     codex?: { enabled?: unknown; defaultAgent?: unknown; path?: unknown; command?: unknown; model?: unknown; alternativeModel?: unknown; effort?: unknown };
     ccc?: { DEEPSEEK_API_KEY?: unknown; DEEPSEEK_BASE_URL?: unknown; model?: unknown };
+    webUi?: { openOnStart?: unknown };
     chromeDevtools?: { enabled?: unknown; port?: unknown; chromePath?: unknown };
     rawStreamLogs?: unknown;
   };
@@ -510,6 +513,7 @@ function loadConfig(): AppConfig {
   const cursorRaw = (parsed.cursor ?? {}) as NonNullable<typeof parsed.cursor>;
   const codexRaw = (parsed.codex ?? {}) as NonNullable<typeof parsed.codex>;
   const cccRaw = (parsed.ccc ?? {}) as NonNullable<typeof parsed.ccc>;
+  const webUiRaw = (parsed.webUi ?? {}) as NonNullable<typeof parsed.webUi>;
   const chromeDevtoolsRaw = (parsed.chromeDevtools ?? {}) as NonNullable<typeof parsed.chromeDevtools>;
   const rawStreamLogsRaw = typeof parsed.rawStreamLogs === "object" && parsed.rawStreamLogs !== null
     ? parsed.rawStreamLogs as unknown as Record<string, unknown>
@@ -577,7 +581,7 @@ function loadConfig(): AppConfig {
       appId: feishu.appId ?? "",
       appSecret: feishu.appSecret ?? "",
     },
-    platforms: {
+    platforms: {
       feishu: {
         enabled: typeof (parsed.platforms as unknown as Record<string, unknown> | undefined)?.feishu === "object"
           ? Boolean(((parsed.platforms as unknown as Record<string, unknown>).feishu as Record<string, unknown>).enabled ?? true)
@@ -595,9 +599,13 @@ function loadConfig(): AppConfig {
         reuseTokenOnStart: typeof (parsed.platforms as unknown as Record<string, unknown> | undefined)?.ilink === "object"
           ? Boolean(((parsed.platforms as unknown as Record<string, unknown>).ilink as Record<string, unknown>).reuseTokenOnStart ?? true)
           : true,
-      },
-    },
-    chromeDevtools: {
+      },
+    },
+    webUi: {
+      // 兼容升级前没有 webUi 字段的 config.json：缺省仍按“自动打开”处理。
+      openOnStart: typeof webUiRaw.openOnStart === "boolean" ? webUiRaw.openOnStart : true,
+    },
+    chromeDevtools: {
       enabled: typeof chromeDevtoolsRaw.enabled === "boolean" ? chromeDevtoolsRaw.enabled : false,
       port: Number.isInteger(chromeDevtoolsPort) && chromeDevtoolsPort >= 1 && chromeDevtoolsPort <= 65535
         ? chromeDevtoolsPort

package/src/index.ts

@@ -28,12 +28,18 @@ import { WSClient, EventDispatcher, Domain } from "@larksuiteoapi/node-sdk";
 import WebSocket from "ws";
 
 import { appendStartupTrace, attachRelayWebSocket, ensureSingleInstance, freeRelayListenPort, installCrashLogging, waitForPortFree } from "./shared.ts";
-import { createUiRouter, setExtraApiHandler, setReloadConfigHook, startSetupMode } from "./web-ui.ts";
+import { createUiRouter, setExtraApiHandler, setReloadConfigHook, startSetupMode } from "./web-ui.ts";
+import {
+  buildWebUiUrl,
+  openWebUiInDefaultBrowser,
+  shouldAutoOpenWebUi,
+} from "./startup-lifecycle.ts";
 import { buildPlatformStartupPlan } from "./platform-startup.ts";
 import { makeTraceId, logTrace } from "./trace.ts";
 import {
-  CHATCCC_PORT,
-  APP_ID,
+  CHATCCC_PORT,
+  config,
+  APP_ID,
   APP_SECRET,
   FEISHU_ENABLED,
   FEISHU_PLATFORM_TYPE,
@@ -720,11 +726,17 @@ async function startConfiguredPlatforms(
 // Main
 // ---------------------------------------------------------------------------
 
-async function main(): Promise<void> {
-  appendStartupTrace("main: entered", {
-    argv: process.argv.join(" ").slice(0, 400),
-    CHATCCC_PORT,
-    PROJECT_ROOT,
+async function main(): Promise<void> {
+  // 用户直接运行 chatccc 时打开系统默认浏览器；由 `/restart`、`/update`
+  // 或 Web UI 拉起的替代进程会携带内部标记，不重复打扰用户。
+  const autoOpenWebUi = shouldAutoOpenWebUi({
+    openOnStart: config.webUi.openOnStart,
+  });
+  appendStartupTrace("main: entered", {
+    argv: process.argv.join(" ").slice(0, 400),
+    CHATCCC_PORT,
+    PROJECT_ROOT,
+    autoOpenWebUi,
   });
 
   // 黑匣子：所有未捕获异常 / 信号 / beforeExit 都同步写入 startup-trace.log（appendFileSync）。
@@ -780,9 +792,18 @@ async function main(): Promise<void> {
     console.log(`${"=".repeat(60)}`);
     console.log(`  发送消息: POST http://127.0.0.1:${SIM_PORT}/api/sim/inject-message`);
     console.log(`  消息日志: ~/.chatccc/sim/messages.jsonl`);
-    console.log(`${"=".repeat(60)}\n`);
-
-    installShutdownHandlers(simServer);
+    console.log(`${"=".repeat(60)}\n`);
+
+    if (autoOpenWebUi) {
+      const url = buildWebUiUrl(SIM_PORT);
+      const opened = openWebUiInDefaultBrowser(SIM_PORT);
+      appendStartupTrace(
+        opened ? "web-ui: opening simulate browser" : "web-ui: simulate browser unavailable",
+        { url },
+      );
+    }
+
+    installShutdownHandlers(simServer);
     return;
   }
 
@@ -830,8 +851,9 @@ async function main(): Promise<void> {
     if (!APP_ID.trim() || !APP_SECRET.trim()) {
       // 凭证不全：进 setup 向导。注入 onActivate 回调让用户点"保存并启动"
       // 时，原地（同进程）调用 startBotService，复用 setup HTTP server。
-      startSetupMode(CHATCCC_PORT, {
-        onActivate: async (httpServer: Server) => {
+      startSetupMode(CHATCCC_PORT, {
+        openBrowser: autoOpenWebUi,
+        onActivate: async (httpServer: Server) => {
           reloadRuntimeConfig("setup-activate");
           appendStartupTrace("setup-activate: reloaded config from disk", {
             appIdMaskAfterReload: maskAppId(APP_ID),
@@ -867,17 +889,35 @@ async function main(): Promise<void> {
     await waitForPortFree(CHATCCC_PORT);
     appendStartupTrace("main: port free confirmed", { CHATCCC_PORT });
   }
-  const httpServer = createServer(createUiRouter());
-  await listenWithRetry(httpServer, CHATCCC_PORT, "127.0.0.1").catch((err: NodeJS.ErrnoException) => {
+  const httpServer = createServer(createUiRouter());
+  await listenWithRetry(httpServer, CHATCCC_PORT, "127.0.0.1").catch((err: NodeJS.ErrnoException) => {
     console.error(`\n[启动] 本地中继 WebSocket 监听失败：端口 ${CHATCCC_PORT}（${err.code ?? "?"} — ${err.message}）`);
     console.error(
       "  处理建议: 关闭占用该端口的其它程序，或在 config.json 的 port 字段里改成其它未占用端口（如 18081）。"
     );
     printServiceDidNotStart(`本地中继端口 ${CHATCCC_PORT} 无法监听（${err.code ?? "?"} — ${err.message}）`);
-    process.exit(1);
-  });
-
-  await startConfiguredPlatforms(httpServer, { failOnFeishuError: false });
+    process.exit(1);
+  });
+
+  // 必须等 HTTP server 真正监听后再发起打开请求，避免浏览器先到一步看到
+  // ERR_CONNECTION_REFUSED。Chrome CDP 守护仍保持自己原有的独立行为。
+  if (autoOpenWebUi) {
+    const url = buildWebUiUrl(CHATCCC_PORT);
+    const opened = openWebUiInDefaultBrowser(CHATCCC_PORT);
+    if (opened) {
+      console.log(`[WEB-UI] 已请求系统默认浏览器打开: ${url}`);
+      appendStartupTrace("web-ui: opening default browser", { url });
+    } else {
+      appendStartupTrace("web-ui: default browser unavailable", { url });
+    }
+  } else {
+    appendStartupTrace("web-ui: default browser skipped by lifecycle or preference", {
+      url: buildWebUiUrl(CHATCCC_PORT),
+      openOnStart: config.webUi.openOnStart,
+    });
+  }
+
+  await startConfiguredPlatforms(httpServer, { failOnFeishuError: false });
 
   installShutdownHandlers(httpServer);
 }

package/src/orchestrator.ts

@@ -91,6 +91,7 @@ import { applySharedPrefix } from "./shared-prefix.ts";
 import { cwdDisplayName, sessionChatName } from "./session-name.ts";
 import { reloadRuntimeConfig } from "./runtime-reload.ts";
 import { acquireUpdateCommandGuard } from "./update-command-guard.ts";
+import { createInternalRestartEnv } from "./startup-lifecycle.ts";
 export { type PlatformAdapter } from "./platform-adapter.ts";
 import type { ChatAvatarUsageHints, PlatformAdapter } from "./platform-adapter.ts";
 import type { CodexUsageSummary } from "./feishu-api.ts";
@@ -480,7 +481,12 @@ function syncUpdateAndRestart(): void {
 
   // 3. spawn new chatccc
   try {
-    const child = spawn(binPath, [], { detached: true, stdio: "ignore", shell: true });
+    const child = spawn(binPath, [], {
+      detached: true,
+      stdio: "ignore",
+      shell: true,
+      env: createInternalRestartEnv(),
+    });
     child.unref();
     updLog(`spawn new chatccc OK, childPid=${child.pid}, bin=${binPath}`);
     appendStartupTrace("update: spawn OK", { childPid: child.pid, binPath });
@@ -545,9 +551,10 @@ export async function handleCommand(
     appendStartupTrace("restart: spawn begin", { fromPid: process.pid });
     const child = spawn("npx", ["tsx", "src/index.ts"], {
       cwd: PROJECT_ROOT,
-      detached: true,
-      stdio: "ignore",
-      shell: true,
+      detached: true,
+      stdio: "ignore",
+      shell: true,
+      env: createInternalRestartEnv(),
     });
 
     child.on("error", (err) => {

package/src/session-chat-binding.ts

@@ -139,8 +139,10 @@ export interface DisplayCardState {
   cardId: string;
   sequence: number;
   cardBusy: boolean;
-  cardCreatedAt: number;
-  lastSentContent: string;
+  cardCreatedAt: number;
+  lastSentContent: string;
+  /** Last rendered activity header; elapsed time can change without body output. */
+  lastSentHeaderTitle?: string;
   streamErrorNotified: boolean;
   /** 所属 session */
   sessionId: string;
@@ -153,8 +155,8 @@ export interface DisplayCardState {
   lastSentAccLen?: number;
   /** WeChat delta: 上次发送时的 finalReply */
   lastSentFinalReply?: string;
-  /** 点点点动画计数器（统一 display loop 每个卡片独立计数） */
-  dotCount: number;
+  /** Liveness animation counter; the explicit activity header conveys Agent state. */
+  dotCount: number;
 }
 
 export const displayCards = new Map<string, DisplayCardState>();