@yancyyu/openhermit 1.6.37 → 1.6.39

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

@@ -0,0 +1,122 @@
+import { access, mkdir, readFile, stat, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+import type {
+  SystemManagerConfig,
+  SystemManagerConfigPatch,
+  SystemManagerStatus,
+} from '@shared/types/systemManager';
+
+const CONFIG_FILE = 'system-manager.json';
+
+function hermitHome(): string {
+  return process.env.HERMIT_HOME || path.join(os.homedir(), '.hermit');
+}
+
+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;
+}
+
+async function isDirectory(dirPath: string): Promise<boolean> {
+  try {
+    return (await stat(dirPath)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+async function commandExists(command: string): Promise<boolean> {
+  const paths = (process.env.PATH ?? '').split(path.delimiter).filter(Boolean);
+  for (const dir of paths) {
+    try {
+      await access(path.join(dir, command));
+      return true;
+    } catch {
+      // keep looking
+    }
+  }
+  return false;
+}
+
+export class SystemManagerConfigService {
+  private readonly configPath = path.join(hermitHome(), CONFIG_FILE);
+
+  constructor(private readonly defaultWorkDir: string) {}
+
+  async getConfig(): Promise<SystemManagerConfig> {
+    try {
+      const raw = await readFile(this.configPath, 'utf-8');
+      const parsed = JSON.parse(raw) as Partial<SystemManagerConfig>;
+      const selectedWorkDir = await this.normalizeDirectory(
+        parsed.selectedWorkDir || this.defaultWorkDir,
+        'selectedWorkDir'
+      );
+      const workflowFolder = parsed.workflowFolder
+        ? await this.normalizeDirectory(parsed.workflowFolder, 'workflowFolder')
+        : undefined;
+      return {
+        schemaVersion: 1,
+        selectedWorkDir,
+        ...(workflowFolder ? { workflowFolder } : {}),
+        updatedAt:
+          typeof parsed.updatedAt === 'string' ? parsed.updatedAt : new Date().toISOString(),
+      };
+    } catch {
+      return {
+        schemaVersion: 1,
+        selectedWorkDir: this.defaultWorkDir,
+        updatedAt: new Date().toISOString(),
+      };
+    }
+  }
+
+  async updateConfig(patch: SystemManagerConfigPatch): Promise<SystemManagerConfig> {
+    const current = await this.getConfig();
+    const next: SystemManagerConfig = {
+      ...current,
+      updatedAt: new Date().toISOString(),
+    };
+
+    if (typeof patch.selectedWorkDir === 'string') {
+      next.selectedWorkDir = await this.normalizeDirectory(
+        patch.selectedWorkDir,
+        'selectedWorkDir'
+      );
+    }
+    if (patch.workflowFolder === null) {
+      delete next.workflowFolder;
+    } else if (typeof patch.workflowFolder === 'string') {
+      next.workflowFolder = await this.normalizeDirectory(patch.workflowFolder, 'workflowFolder');
+    }
+
+    await mkdir(path.dirname(this.configPath), { recursive: true });
+    await writeFile(this.configPath, JSON.stringify(next, null, 2), 'utf-8');
+    return next;
+  }
+
+  async getStatus(): Promise<SystemManagerStatus> {
+    const config = await this.getConfig();
+    const hasClaude = await commandExists('claude');
+    return {
+      displayName: '控制台',
+      defaultWorkDir: this.defaultWorkDir,
+      selectedWorkDir: config.selectedWorkDir,
+      ...(config.workflowFolder ? { workflowFolder: config.workflowFolder } : {}),
+      claudeCommand: 'claude',
+      localStatus: hasClaude ? 'ready' : 'missing-claude',
+      ...(hasClaude ? {} : { error: '未在 PATH 中找到 claude 命令' }),
+    };
+  }
+
+  private async normalizeDirectory(input: string, fieldName: string): Promise<string> {
+    const resolved = path.resolve(expandHome(input));
+    if (!(await isDirectory(resolved))) {
+      throw new Error(`${fieldName} 不是有效目录: ${resolved}`);
+    }
+    return resolved;
+  }
+}

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

@@ -79,6 +79,7 @@ export class TaskDispatchService {
     this.stopHeartbeat();
     this.stopConsumers();
     this.stopResponseConsumers();
+    this.collabBoard.setRedis(null);
     this.redis?.disconnect();
     this.redisSub?.disconnect();
     this.redis = null;
@@ -757,27 +758,50 @@ export class TaskDispatchService {
 
   private async connectRedis(): Promise<void> {
     if (!this.config?.redis) return;
+    let redis: Redis | null = null;
+    let redisSub: Redis | null = null;
     try {
       const ioredis = await import('ioredis');
       const { host, port, password, db } = this.config.redis;
-      const opts = { host, port, password: password || undefined, db: db ?? 0 };
+      const opts = {
+        host,
+        port,
+        password: password || undefined,
+        db: db ?? 0,
+        lazyConnect: true,
+        maxRetriesPerRequest: 0,
+        retryStrategy: () => null,
+      };
 
-      this.redis = new ioredis.default(opts);
-      this.redisSub = new ioredis.default(opts);
+      redis = new ioredis.default(opts);
+      redisSub = new ioredis.default(opts);
 
-      this.redis.on('error', (err: Error) => {
-        console.error('[TaskDispatchService] Redis error:', err.message);
+      redis.on('error', () => {
+        /* handled by task bus connection status */
+      });
+      redisSub.on('error', () => {
+        /* handled by task bus connection status */
       });
 
-      await this.redis.ping();
+      await redis.connect();
+      await redisSub.connect();
+      await redis.ping();
 
+      this.redis = redis;
+      this.redisSub = redisSub;
+      redis = null;
+      redisSub = null;
       this.collabBoard.setRedis(this.redis);
       this.startHeartbeat();
       this.startConsumers();
       this.startResponseConsumers();
       this.subscribeStatus();
-    } catch (err) {
-      console.error('[TaskDispatchService] Redis connect failed:', err);
+    } catch {
+      this.collabBoard.setRedis(null);
+      redis?.disconnect();
+      redisSub?.disconnect();
+      this.redis?.disconnect();
+      this.redisSub?.disconnect();
       this.redis = null;
       this.redisSub = null;
     }

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;