@yancyyu/openhermit 1.6.38 → 1.6.39

package/src/main/services/system-manager/SystemManagerPtyService.ts

@@ -0,0 +1,233 @@
+import { spawn as spawnChild } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { EventEmitter } from 'node:events';
+import { stat } from 'node:fs/promises';
+
+import type { PtySpawnOptions } from '@shared/types/terminal';
+import * as pty from 'node-pty';
+
+const PYTHON_PTY_BRIDGE = String.raw`
+import errno
+import os
+import pty
+import select
+import signal
+import sys
+
+cmd = sys.argv[1:]
+child_pid = None
+
+
+def terminate(signum, _frame):
+    if child_pid:
+        try:
+            os.kill(child_pid, signum)
+        except OSError:
+            pass
+    sys.exit(128 + signum)
+
+
+signal.signal(signal.SIGTERM, terminate)
+signal.signal(signal.SIGINT, terminate)
+
+child_pid, fd = pty.fork()
+if child_pid == 0:
+    os.execvpe(cmd[0], cmd, os.environ)
+
+while True:
+    try:
+        readable, _, _ = select.select([fd, sys.stdin.fileno()], [], [])
+    except OSError:
+        break
+
+    if fd in readable:
+        try:
+            data = os.read(fd, 4096)
+        except OSError:
+            break
+        if not data:
+            break
+        os.write(sys.stdout.fileno(), data)
+
+    if sys.stdin.fileno() in readable:
+        try:
+            data = os.read(sys.stdin.fileno(), 4096)
+        except OSError as err:
+            if err.errno == errno.EIO:
+                data = b''
+            else:
+                raise
+        if data:
+            os.write(fd, data)
+
+try:
+    _, status = os.waitpid(child_pid, 0)
+except ChildProcessError:
+    sys.exit(0)
+sys.exit(os.waitstatus_to_exitcode(status))
+`;
+
+interface ManagedProcess {
+  id: string;
+  pid: number;
+  command: string;
+  args: string[];
+  cwd: string;
+  createdAt: string;
+  write(data: string): void;
+  resize(cols: number, rows: number): void;
+  kill(signal?: NodeJS.Signals): void;
+}
+
+const TERMINAL_KILL_TIMEOUT_MS = 1_500;
+const TERMINAL_FORCE_KILL_TIMEOUT_MS = 1_500;
+
+export type TerminalDataEvent = { ptyId: string; data: string };
+export type TerminalExitEvent = { ptyId: string; exitCode: number };
+
+export class SystemManagerPtyService extends EventEmitter {
+  private readonly sessions = new Map<string, ManagedProcess>();
+
+  async spawn(options: PtySpawnOptions = {}): Promise<string> {
+    const command = options.command || 'claude';
+    const args = options.args ?? [];
+    const cwd = options.cwd || process.cwd();
+    const cwdStat = await stat(cwd);
+    if (!cwdStat.isDirectory()) {
+      throw new Error(`cwd 不是有效目录: ${cwd}`);
+    }
+
+    const id = `pty-${randomUUID()}`;
+    const env = {
+      ...process.env,
+      TERM: 'xterm-256color',
+      COLORTERM: 'truecolor',
+      ...(options.env ?? {}),
+    } as Record<string, string>;
+
+    try {
+      const proc = pty.spawn(command, args, {
+        name: 'xterm-256color',
+        cols: options.cols ?? 120,
+        rows: options.rows ?? 34,
+        cwd,
+        env,
+      });
+
+      this.sessions.set(id, {
+        id,
+        pid: proc.pid,
+        command,
+        args,
+        cwd,
+        createdAt: new Date().toISOString(),
+        write: (data) => proc.write(data),
+        resize: (cols, rows) => proc.resize(Math.max(20, cols), Math.max(5, rows)),
+        kill: (signal) => proc.kill(signal),
+      });
+
+      proc.onData((data) => {
+        this.emit('data', { ptyId: id, data } satisfies TerminalDataEvent);
+      });
+      proc.onExit(({ exitCode }) => {
+        if (!this.sessions.delete(id)) return;
+        this.emit('exit', { ptyId: id, exitCode } satisfies TerminalExitEvent);
+      });
+    } catch (err) {
+      const child = spawnChild('python3', ['-u', '-c', PYTHON_PTY_BRIDGE, command, ...args], {
+        cwd,
+        env,
+        stdio: 'pipe',
+      });
+      this.sessions.set(id, {
+        id,
+        pid: child.pid ?? -1,
+        command,
+        args,
+        cwd,
+        createdAt: new Date().toISOString(),
+        write: (data) => child.stdin.write(data),
+        resize: () => {},
+        kill: (signal) => child.kill(signal),
+      });
+      this.emit('data', {
+        ptyId: id,
+        data: `[Hermit] node-pty unavailable (${err instanceof Error ? err.message : String(err)}); using python PTY fallback.\r\n`,
+      } satisfies TerminalDataEvent);
+      child.stdout.on('data', (data) => {
+        this.emit('data', { ptyId: id, data: data.toString() } satisfies TerminalDataEvent);
+      });
+      child.stderr.on('data', (data) => {
+        this.emit('data', { ptyId: id, data: data.toString() } satisfies TerminalDataEvent);
+      });
+      child.on('error', (error) => {
+        if (!this.sessions.delete(id)) return;
+        this.emit('data', {
+          ptyId: id,
+          data: `[Hermit] failed to start process: ${error.message}\r\n`,
+        } satisfies TerminalDataEvent);
+        this.emit('exit', { ptyId: id, exitCode: 1 } satisfies TerminalExitEvent);
+      });
+      child.on('exit', (exitCode) => {
+        if (!this.sessions.delete(id)) return;
+        this.emit('exit', { ptyId: id, exitCode: exitCode ?? 0 } satisfies TerminalExitEvent);
+      });
+    }
+
+    return id;
+  }
+
+  write(ptyId: string, data: string): void {
+    const session = this.sessions.get(ptyId);
+    if (!session) throw new Error(`PTY 不存在: ${ptyId}`);
+    session.write(data);
+  }
+
+  resize(ptyId: string, cols: number, rows: number): void {
+    const session = this.sessions.get(ptyId);
+    if (!session) return;
+    session.resize(cols, rows);
+  }
+
+  async kill(ptyId: string): Promise<void> {
+    const session = this.sessions.get(ptyId);
+    if (!session) return;
+
+    await new Promise<void>((resolve) => {
+      let settled = false;
+      let forceTimer: ReturnType<typeof setTimeout> | null = null;
+      const finish = (): void => {
+        if (settled) return;
+        settled = true;
+        if (forceTimer) clearTimeout(forceTimer);
+        this.off('exit', onExit);
+        resolve();
+      };
+      const onExit = (event: TerminalExitEvent): void => {
+        if (event.ptyId === ptyId) finish();
+      };
+
+      this.on('exit', onExit);
+      session.kill();
+      forceTimer = setTimeout(() => {
+        if (!this.sessions.has(ptyId)) {
+          finish();
+          return;
+        }
+        session.kill('SIGKILL');
+      }, TERMINAL_KILL_TIMEOUT_MS);
+      setTimeout(() => {
+        if (this.sessions.delete(ptyId)) {
+          this.emit('exit', { ptyId, exitCode: 0 } satisfies TerminalExitEvent);
+        }
+        finish();
+      }, TERMINAL_KILL_TIMEOUT_MS + TERMINAL_FORCE_KILL_TIMEOUT_MS);
+    });
+  }
+
+  killAll(): void {
+    for (const id of [...this.sessions.keys()]) {
+      void this.kill(id);
+    }
+  }
+}

package/src/main/services/system-manager/WorkflowPromptService.ts

@@ -0,0 +1,75 @@
+import { createHash } from 'node:crypto';
+import { readFile, readdir, stat } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+import type {
+  WorkflowPromptContentResponse,
+  WorkflowPromptListResponse,
+  WorkflowPromptSummary,
+} from '@shared/types/systemManager';
+
+const SUPPORTED_EXTENSIONS = new Set(['.md', '.txt', '.prompt', '.workflow']);
+const MAX_PROMPT_BYTES = 256 * 1024;
+
+function expandHome(input: string): string {
+  const normalized = input.trim().replace(/^～/, '~');
+  if (normalized === '~') return os.homedir();
+  if (normalized.startsWith('~/')) return path.join(os.homedir(), normalized.slice(2));
+  return normalized;
+}
+
+function promptId(filePath: string): string {
+  return createHash('sha256').update(filePath).digest('hex').slice(0, 16);
+}
+
+function labelFromFilename(filename: string): string {
+  return path.basename(filename, path.extname(filename)).replace(/[-_]+/g, ' ').trim() || filename;
+}
+
+export class WorkflowPromptService {
+  async list(folderInput: string): Promise<WorkflowPromptListResponse> {
+    const folder = path.resolve(expandHome(folderInput));
+    const folderStat = await stat(folder);
+    if (!folderStat.isDirectory()) {
+      throw new Error(`workflow folder 不是有效目录: ${folder}`);
+    }
+
+    const warnings: string[] = [];
+    const prompts: WorkflowPromptSummary[] = [];
+    const entries = await readdir(folder, { withFileTypes: true });
+
+    for (const entry of entries) {
+      if (!entry.isFile() || entry.name.startsWith('.')) continue;
+      const ext = path.extname(entry.name).toLowerCase();
+      if (!SUPPORTED_EXTENSIONS.has(ext)) continue;
+      const filePath = path.join(folder, entry.name);
+      const fileStat = await stat(filePath);
+      if (fileStat.size > MAX_PROMPT_BYTES) {
+        warnings.push(`${entry.name} 超过 256 KiB，已跳过`);
+        continue;
+      }
+      prompts.push({
+        id: promptId(filePath),
+        label: labelFromFilename(entry.name),
+        filename: entry.name,
+        path: filePath,
+        sizeBytes: fileStat.size,
+        updatedAt: fileStat.mtime.toISOString(),
+      });
+    }
+
+    prompts.sort((a, b) => a.filename.localeCompare(b.filename));
+    return { folder, prompts, warnings };
+  }
+
+  async read(folderInput: string, id: string): Promise<WorkflowPromptContentResponse> {
+    const list = await this.list(folderInput);
+    const prompt = list.prompts.find((item) => item.id === id || item.filename === id);
+    if (!prompt) {
+      throw new Error(`未找到 workflow: ${id}`);
+    }
+    const content = await readFile(prompt.path, 'utf-8');
+    return { prompt, content };
+  }
+}

package/src/main/services/teams-mvp/TaskDispatchService.ts

@@ -776,11 +776,11 @@ export class TaskDispatchService {
       redis = new ioredis.default(opts);
       redisSub = new ioredis.default(opts);
 
-      redis.on('error', (err: Error) => {
-        console.warn('[TaskDispatchService] Redis error:', err.message);
+      redis.on('error', () => {
+        /* handled by task bus connection status */
       });
-      redisSub.on('error', (err: Error) => {
-        console.warn('[TaskDispatchService] Redis subscriber error:', err.message);
+      redisSub.on('error', () => {
+        /* handled by task bus connection status */
       });
 
       await redis.connect();
@@ -796,8 +796,7 @@ export class TaskDispatchService {
       this.startConsumers();
       this.startResponseConsumers();
       this.subscribeStatus();
-    } catch (err) {
-      console.warn('[TaskDispatchService] Redis connect failed:', err);
+    } catch {
       this.collabBoard.setRedis(null);
       redis?.disconnect();
       redisSub?.disconnect();

package/src/main/services/teams-mvp/TeamProvisioningService.ts

@@ -45,6 +45,35 @@ function removeManagedTeamInstructions(content: string): string {
   return next.replace(/\n{3,}/g, '\n\n').trimEnd();
 }
 
+async function injectHermitTasksMcpConfig(workDir: string): Promise<void> {
+  const settingsPath = path.join(workDir, '.claude', 'settings.json');
+  let settings: Record<string, unknown> = {};
+  try {
+    const raw = await fs.promises.readFile(settingsPath, 'utf8');
+    settings = JSON.parse(raw) as Record<string, unknown>;
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code !== 'ENOENT') {
+      throw err;
+    }
+  }
+
+  const existingMcpServers =
+    settings.mcpServers && typeof settings.mcpServers === 'object'
+      ? (settings.mcpServers as Record<string, unknown>)
+      : {};
+  const port = process.env.PORT ?? '5680';
+  settings.mcpServers = {
+    ...existingMcpServers,
+    'hermit-tasks': {
+      type: 'sse',
+      url: `http://127.0.0.1:${port}/mcp`,
+    },
+  };
+
+  await fs.promises.mkdir(path.dirname(settingsPath), { recursive: true });
+  await fs.promises.writeFile(settingsPath, JSON.stringify(settings, null, 2));
+}
+
 export class TeamProvisioningService {
   private readonly workspace: TeamWorkspaceService;
 
@@ -68,12 +97,16 @@ export class TeamProvisioningService {
    * 4. 触发 cc-connect restart 激活 project
    */
   async createTeam(
-    input: CreateTeamInput & { createCcProject?: boolean }
+    input: CreateTeamInput & { createCcProject?: boolean; injectInstructions?: boolean }
   ): Promise<{ slug: string; manifest: TeamManifest }> {
-    const { createCcProject = true, ...workspaceInput } = input;
+    const { createCcProject = true, injectInstructions = true, ...workspaceInput } = input;
 
     const { slug, manifest } = await this.workspace.createTeam(workspaceInput);
 
+    if (injectInstructions && manifest.harness === 'claudecode') {
+      await injectHermitTasksMcpConfig(manifest.workDir);
+    }
+
     if (createCcProject) {
       try {
         const platformType = manifest.platform ?? 'bridge';
@@ -118,6 +151,7 @@ export class TeamProvisioningService {
       Pick<
         TeamManifest,
         | 'displayName'
+        | 'bindProject'
         | 'color'
         | 'description'
         | 'collaboration'
@@ -130,7 +164,10 @@ export class TeamProvisioningService {
         | 'injectSender'
         | 'managedSources'
         | 'disabledCommands'
+        | 'platform'
+        | 'platformOptions'
         | 'platformAllowFrom'
+        | 'platformAllowChat'
       >
     >
   ): Promise<TeamManifest> {

package/src/main/services/teams-mvp/TeamWorkspaceService.ts

@@ -45,6 +45,8 @@ export interface TeamManifest {
   managedSources?: string;
   disabledCommands?: string[];
   platformAllowFrom?: Record<string, string>;
+  /** 群聊允许的 chat ID（按平台） */
+  platformAllowChat?: Record<string, string>;
   pendingDelete?: boolean;
   restartRequired?: boolean;
   /**
@@ -159,9 +161,9 @@ async function readJson<T>(p: string, fallback: T): Promise<T> {
   try {
     const raw = await fs.promises.readFile(p, 'utf8');
     return JSON.parse(raw) as T;
-  } catch (err) {
-    if ((err as NodeJS.ErrnoException).code === 'ENOENT') return fallback;
-    throw err;
+  } catch {
+    // File missing or corrupted JSON — return fallback silently
+    return fallback;
   }
 }
 
@@ -185,6 +187,17 @@ export class TeamWorkspaceService {
     return match?.slug ?? teamSlug;
   }
 
+  private async createUniqueStorageSlug(displayName: string): Promise<string> {
+    const baseSlug = toSlug(displayName);
+    let slug = baseSlug;
+    let suffix = 2;
+    while (await pathExists(path.join(teamRoot(slug), 'team.json'))) {
+      slug = `${baseSlug}-${suffix}`;
+      suffix += 1;
+    }
+    return slug;
+  }
+
   async createTeam(
     input: CreateTeamInput
   ): Promise<{ slug: string; root: string; manifest: TeamManifest }> {
@@ -192,7 +205,7 @@ export class TeamWorkspaceService {
     if (!input.bindProject) throw new Error('bindProject is required');
     if (!input.workDir) throw new Error('workDir is required');
 
-    const slug = toSlug(input.bindProject);
+    const slug = await this.createUniqueStorageSlug(input.displayName);
     const root = teamRoot(slug);
 
     await fs.promises.mkdir(root, { recursive: true });
@@ -263,6 +276,7 @@ export class TeamWorkspaceService {
     const out: TeamManifest[] = [];
     for (const e of entries) {
       if (!e.isDirectory()) continue;
+      if (e.name.startsWith('.')) continue;
       try {
         out.push(await this.readTeamManifest(e.name));
       } catch {
@@ -278,6 +292,7 @@ export class TeamWorkspaceService {
       Pick<
         TeamManifest,
         | 'displayName'
+        | 'bindProject'
         | 'color'
         | 'description'
         | 'collaboration'
@@ -290,7 +305,10 @@ export class TeamWorkspaceService {
         | 'injectSender'
         | 'managedSources'
         | 'disabledCommands'
+        | 'platform'
+        | 'platformOptions'
         | 'platformAllowFrom'
+        | 'platformAllowChat'
         | 'pendingDelete'
         | 'restartRequired'
       >

package/src/main/utils/teamProjectResolution.ts

@@ -0,0 +1,15 @@
+import type { TeamManifest } from '@main/services/teams-mvp/TeamWorkspaceService';
+
+export async function resolveCcProjectName(
+  routeTeamName: string,
+  readTeamManifest: (teamName: string) => Promise<TeamManifest>
+): Promise<string> {
+  try {
+    const manifest = await readTeamManifest(routeTeamName);
+    const bindProject = manifest.bindProject?.trim();
+    if (bindProject) return bindProject;
+  } catch {
+    // routeTeamName may already be a cc-connect project name.
+  }
+  return routeTeamName;
+}

package/src/renderer/App.tsx

@@ -41,6 +41,7 @@ function buildPathForTab(activeTab: Tab | null): string {
   }
   switch (activeTab.type) {
     case 'team':
+      if (activeTab.teamName === 'system-manager') return '/system-manager';
       return activeTab.teamName
         ? `/team/${encodeURIComponent(activeTab.teamName)}`
         : DEFAULT_APP_PATH;
@@ -142,6 +143,9 @@ function useTabPathPersistence() {
       case 'teams':
         state.openTeamsTab();
         break;
+      case 'system-manager':
+        void state.openSystemManager();
+        break;
       case 'settings':
         state.openSettingsTab();
         break;
@@ -208,11 +212,11 @@ declare global {
   }
 }
 
-const SPLASH_MIN_DURATION_MS = 1600;
-const SPLASH_ENHANCED_HOLD_MS = 600;
+const SPLASH_MIN_DURATION_MS = 2800;
+const SPLASH_ENHANCED_HOLD_MS = 800;
 const SPLASH_FADE_MS = 480;
-const SPLASH_REDUCED_MIN_DURATION_MS = 320;
-const SPLASH_REDUCED_HOLD_MS = 120;
+const SPLASH_REDUCED_MIN_DURATION_MS = 600;
+const SPLASH_REDUCED_HOLD_MS = 200;
 const SPLASH_REDUCED_FADE_MS = 180;
 const SPLASH_AVATAR_READY_MAX_WAIT_MS = 900;
 const SPLASH_REDUCED_AVATAR_READY_MAX_WAIT_MS = 160;

package/src/renderer/api/httpClient.ts

@@ -82,6 +82,7 @@ import type {
   TeamLaunchRequest,
   TeamLaunchResponse,
   TeamMemberActivityMeta,
+  SystemManagerSummary,
   TeamProvisioningModelVerificationMode,
   TeamProvisioningPrepareResult,
   TeamProvisioningProgress,
@@ -141,6 +142,7 @@ import type {
   TaskChangeSetV2,
 } from '@shared/types/review';
 import type { ApplyReviewRequest } from '@shared/types/review';
+import type { SystemManagerAPI } from '@shared/types/systemManager';
 import type { TerminalAPI } from '@shared/types/terminal';
 import type { CliArgsValidationResult } from '@shared/utils/cliArgsParser';
 
@@ -171,7 +173,6 @@ export class HttpAPIClient implements ElectronAPI {
     };
   }
 
-   
   // eslint-disable-next-line @typescript-eslint/no-explicit-any -- event callbacks have varying signatures
   private addEventListener(channel: string, callback: (...args: any[]) => void): () => void {
     this.initEventSource();
@@ -409,7 +410,7 @@ export class HttpAPIClient implements ElectronAPI {
       await this.patch('/api/cc-settings', patch);
     },
     restart: async (): Promise<void> => {
-      await this.post('/api/cc-restart', {});
+      await this.postLong('/api/cc-restart', {});
     },
     reload: async (): Promise<void> => {
       await this.post('/api/cc-reload', {});
@@ -1093,6 +1094,8 @@ export class HttpAPIClient implements ElectronAPI {
 
   teams: TeamsAPI = {
     list: async (): Promise<TeamSummary[]> => this.get<TeamSummary[]>('/api/teams'),
+    ensureSystemManager: async (): Promise<SystemManagerSummary> =>
+      this.post<SystemManagerSummary>('/api/system-manager/ensure'),
     getData: async (teamName: string): Promise<TeamViewSnapshot> =>
       this.get<TeamViewSnapshot>(`/api/teams/${encodeURIComponent(teamName)}/data`),
     getTaskChangePresence: async (): Promise<
@@ -1450,14 +1453,27 @@ export class HttpAPIClient implements ElectronAPI {
       return this.get(`/api/teams/${encodeURIComponent(teamName)}/lead-context`);
     },
     getMemberSpawnStatuses: async (teamName: string) => {
-      return this.get<MemberSpawnStatusesSnapshot>(
-        `/api/teams/${encodeURIComponent(teamName)}/member-spawn-statuses`
-      );
+      try {
+        return await this.get<MemberSpawnStatusesSnapshot>(
+          `/api/teams/${encodeURIComponent(teamName)}/member-spawn-statuses`
+        );
+      } catch {
+        return { statuses: {}, runId: null };
+      }
     },
     getTeamAgentRuntime: async (teamName: string) => {
-      return this.get<TeamAgentRuntimeSnapshot>(
-        `/api/teams/${encodeURIComponent(teamName)}/agent-runtime`
-      );
+      try {
+        return await this.get<TeamAgentRuntimeSnapshot>(
+          `/api/teams/${encodeURIComponent(teamName)}/agent-runtime`
+        );
+      } catch {
+        return {
+          teamName,
+          updatedAt: new Date().toISOString(),
+          runId: null,
+          members: {},
+        };
+      }
     },
     restartMember: async (teamName: string, memberName: string): Promise<void> => {
       await this.post(
@@ -1886,7 +1902,7 @@ export class HttpAPIClient implements ElectronAPI {
             p != null &&
             typeof p === 'object' &&
             !Array.isArray(p) &&
-            typeof (p).providerId === 'string'
+            typeof p.providerId === 'string'
         );
 
         // When the backend reports no provider capability data, fall back to a
@@ -2281,18 +2297,52 @@ export class HttpAPIClient implements ElectronAPI {
   };
 
   // ---------------------------------------------------------------------------
-  // Terminal (not available in browser mode)
+  // System Manager / Control Console
+  // ---------------------------------------------------------------------------
+
+  systemManager: SystemManagerAPI = {
+    getStatus: () => this.get('/api/system-manager/status'),
+    getConfig: () => this.get('/api/system-manager/config'),
+    updateConfig: (patch) => this.put('/api/system-manager/config', patch),
+    listWorkflowPrompts: (folder) => this.post('/api/system-manager/workflows/list', { folder }),
+    readWorkflowPrompt: (_folder, id) => this.post('/api/system-manager/workflows/read', { id }),
+  };
+
+  // ---------------------------------------------------------------------------
+  // Terminal (HTTP/SSE-backed browser mode)
   // ---------------------------------------------------------------------------
 
   terminal: TerminalAPI = {
-    spawn: async (): Promise<string> => {
-      throw new Error('Terminal not available in browser mode');
-    },
-    write: () => {},
-    resize: () => {},
-    kill: () => {},
-    onData: (): (() => void) => () => {},
-    onExit: (): (() => void) => () => {},
+    spawn: async (options = {}): Promise<string> => {
+      const result = await this.post<{ ptyId: string }>('/api/terminal/spawn', options);
+      return result.ptyId;
+    },
+    write: (ptyId: string, data: string): void => {
+      void this.post(`/api/terminal/${encodeURIComponent(ptyId)}/write`, { data });
+    },
+    resize: (ptyId: string, cols: number, rows: number): void => {
+      void this.post(`/api/terminal/${encodeURIComponent(ptyId)}/resize`, { cols, rows });
+    },
+    kill: async (ptyId: string): Promise<void> => {
+      await this.del(`/api/terminal/${encodeURIComponent(ptyId)}`);
+    },
+    openExternal: async (options: { command: string; args?: string[]; cwd?: string }): Promise<void> => {
+      await this.post('/api/terminal/open-external', options);
+    },
+    onData: (callback): (() => void) =>
+      this.addEventListener('terminal:data', (data: unknown) => {
+        const event = data as { ptyId?: string; data?: string };
+        if (event.ptyId && typeof event.data === 'string') {
+          callback(null, event.ptyId, event.data);
+        }
+      }),
+    onExit: (callback): (() => void) =>
+      this.addEventListener('terminal:exit', (data: unknown) => {
+        const event = data as { ptyId?: string; exitCode?: number };
+        if (event.ptyId && typeof event.exitCode === 'number') {
+          callback(null, event.ptyId, event.exitCode);
+        }
+      }),
   };
 
   // ---------------------------------------------------------------------------