@yancyyu/openhermit 1.6.28 → 1.6.30

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

@@ -24,6 +24,26 @@ import {
 } from './TeamWorkspaceService';
 
 const logger = createLogger('TeamProvisioningService');
+const TEAM_INSTRUCTIONS_BEGIN = '<!-- hermit:team-collaboration:start -->';
+const TEAM_INSTRUCTIONS_END = '<!-- hermit:team-collaboration:end -->';
+
+function removeSectionByHeading(content: string, heading: string): string {
+  const escapedHeading = heading.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return content.replace(
+    new RegExp(`\\n{0,2}## ${escapedHeading}\\n[\\s\\S]*?(?=\\n## |\\s*$)`, 'g'),
+    ''
+  );
+}
+
+function removeManagedTeamInstructions(content: string): string {
+  let next = content.replace(
+    new RegExp(`\\n{0,2}${TEAM_INSTRUCTIONS_BEGIN}[\\s\\S]*?${TEAM_INSTRUCTIONS_END}\\n?`, 'g'),
+    '\n'
+  );
+  next = removeSectionByHeading(next, 'Agent Collaboration (Hermit)');
+  next = removeSectionByHeading(next, 'Cross-Team Task Dispatch (Hermit)');
+  return next.replace(/\n{3,}/g, '\n\n').trimEnd();
+}
 
 export class TeamProvisioningService {
   private readonly workspace: TeamWorkspaceService;
@@ -77,8 +97,6 @@ export class TeamProvisioningService {
       }
     }
 
-    await this.injectTeamInstructions(manifest.workDir, slug);
-
     return { slug, manifest };
   }
 
@@ -244,25 +262,33 @@ export class TeamProvisioningService {
 
   async injectTeamInstructions(workDir: string, teamSlug: string): Promise<void> {
     const mdPath = path.join(workDir, 'CLAUDE.md');
+    const teams = await this.workspace.listTeams().catch(() => []);
+    const availableTeams = teams
+      .filter((team) => team.slug !== teamSlug)
+      .map((team) => {
+        const label =
+          team.displayName && team.displayName !== team.slug
+            ? `${team.slug} (${team.displayName})`
+            : team.slug;
+        return team.description ? `- ${label}: ${team.description}` : `- ${label}`;
+      });
     const section = `
 
-## Cross-Team Task Dispatch (Hermit)
+${TEAM_INSTRUCTIONS_BEGIN}
 
-You can dispatch tasks to other teams via the Hermit local API:
-
-- **List available teams**: \`curl -s http://127.0.0.1:5680/api/cross-team/targets\`
-- **Dispatch a task**: \`curl -s -X POST http://127.0.0.1:5680/api/cross-team/send -H 'Content-Type: application/json' -d '{"fromTeam":"${teamSlug}","toTeam":"TARGET_TEAM","subject":"Task title","description":"Optional description"}'\`
+## Hermit Team Context
 
 Current team slug: \`${teamSlug}\`
 
-When to dispatch:
-- Task requires access to a different codebase/project
-- Task explicitly mentions another team's domain
-- Task is blocked by work owned by another team
+Available teams:
+${availableTeams.length > 0 ? availableTeams.join('\n') : '- No other teams currently registered.'}
+
+Cross-team work is routed by Hermit itself. If the user mentions another team with \`@team\`,
+Hermit will create and track the cross-team collaboration task automatically.
 
-Do NOT dispatch:
-- Task is within current team's project scope
-- Task can be completed with available tools
+Do not call cross-team dispatch APIs yourself and do not invent dispatch IDs.
+You may use the team list only to understand which teams exist and when a user is referring to one.
+${TEAM_INSTRUCTIONS_END}
 `;
 
     try {
@@ -273,11 +299,8 @@ Do NOT dispatch:
         // File doesn't exist yet
       }
 
-      if (existing.includes('Cross-Team Task Dispatch (Hermit)')) {
-        return;
-      }
-
-      await fs.promises.writeFile(mdPath, existing + section, 'utf8');
+      const cleaned = removeManagedTeamInstructions(existing);
+      await fs.promises.writeFile(mdPath, `${cleaned}${section}`, 'utf8');
       logger.info(`injected team instructions → ${mdPath}`);
     } catch (err) {
       logger.warn(
@@ -285,4 +308,20 @@ Do NOT dispatch:
       );
     }
   }
+
+  async removeTeamInstructions(workDir: string): Promise<void> {
+    const mdPath = path.join(workDir, 'CLAUDE.md');
+    try {
+      const existing = await fs.promises.readFile(mdPath, 'utf8');
+      const cleaned = removeManagedTeamInstructions(existing);
+      if (cleaned === existing.trimEnd()) return;
+      await fs.promises.writeFile(mdPath, cleaned ? `${cleaned}\n` : '', 'utf8');
+      logger.info(`removed team instructions → ${mdPath}`);
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code === 'ENOENT') return;
+      logger.warn(
+        `Team instructions removal failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
 }

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

@@ -224,7 +224,23 @@ export class TeamWorkspaceService {
   async readTeamManifest(teamSlug: string): Promise<TeamManifest> {
     const root = teamRoot(teamSlug);
     const manifest = await readJson<TeamManifest | null>(path.join(root, 'team.json'), null);
-    if (!manifest) throw new Error(`团队 "${teamSlug}" 不存在 (${root})`);
+    if (!manifest) {
+      if (!(await pathExists(root))) {
+        throw new Error(`团队 "${teamSlug}" 不存在 (${root})`);
+      }
+      const stat = await fs.promises.stat(root).catch(() => null);
+      return {
+        schemaVersion: 2,
+        slug: teamSlug,
+        displayName: teamSlug,
+        bindProject: teamSlug,
+        harness: 'claudecode',
+        workDir: '',
+        collaboration: true,
+        rootPath: root,
+        createdAt: (stat?.birthtime ?? stat?.mtime ?? new Date()).toISOString(),
+      };
+    }
     return manifest;
   }
 
@@ -359,7 +375,13 @@ export class TeamWorkspaceService {
 
   async createTask(
     teamSlug: string,
-    payload: { title: string; description?: string; assignee?: string | null; status?: TaskStatus }
+    payload: {
+      title: string;
+      description?: string;
+      assignee?: string | null;
+      status?: TaskStatus;
+      dispatchMeta?: import('@shared/types/team').DispatchMeta;
+    }
   ): Promise<Task> {
     if (!payload?.title) throw new Error('title is required');
     const board = await this.readBoard(teamSlug);
@@ -378,6 +400,7 @@ export class TeamWorkspaceService {
       createdAt: now,
       updatedAt: now,
       order,
+      dispatchMeta: payload.dispatchMeta,
     };
     board.tasks = [...(board.tasks || []), task];
     await this.writeBoard(teamSlug, board);

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

@@ -4,6 +4,7 @@
  * 设计：一个 Team = 一个 cc-connect project，无 Member 子层级。
  * - TeamWorkspaceService: 本地目录管理（team.json / messages / tasks/board.json）
  * - TeamProvisioningService: 组合 cc-connect，含 Task Dispatcher
+ * - CollaborationBoardService: 全局协作看板数据管理
  */
 
 export {
@@ -24,3 +25,5 @@ export type {
 } from './TeamWorkspaceService';
 
 export { TeamProvisioningService } from './TeamProvisioningService';
+
+export { CollaborationBoardService } from './CollaborationBoardService';

package/src/main/utils/atomicWrite.ts

@@ -0,0 +1,72 @@
+import { randomUUID } from 'crypto';
+import * as fs from 'fs';
+import * as path from 'path';
+
+const RENAME_MAX_ATTEMPTS = 8;
+const RENAME_RETRY_BASE_DELAY_MS = 40;
+const RENAME_RETRY_MAX_DELAY_MS = 250;
+const RENAME_RETRY_JITTER_MS = 25;
+const RETRYABLE_RENAME_CODES = new Set(['EPERM', 'EACCES', 'EBUSY']);
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function getRenameRetryDelayMs(attempt: number): number {
+  const backoff = Math.min(RENAME_RETRY_BASE_DELAY_MS * attempt, RENAME_RETRY_MAX_DELAY_MS);
+  return backoff + Math.floor(Math.random() * (RENAME_RETRY_JITTER_MS + 1));
+}
+
+async function renameWithRetry(src: string, dest: string): Promise<void> {
+  for (let attempt = 1; attempt <= RENAME_MAX_ATTEMPTS; attempt++) {
+    try {
+      await fs.promises.rename(src, dest);
+      return;
+    } catch (error) {
+      const code = (error as NodeJS.ErrnoException).code;
+      if (code === 'EXDEV') {
+        await fs.promises.copyFile(src, dest);
+        await fs.promises.unlink(src).catch(() => undefined);
+        return;
+      }
+      if (code && RETRYABLE_RENAME_CODES.has(code) && attempt < RENAME_MAX_ATTEMPTS) {
+        await sleep(getRenameRetryDelayMs(attempt));
+        continue;
+      }
+      throw error;
+    }
+  }
+}
+
+/**
+ * Async atomic write: write tmp file then rename over target.
+ * Uses best-effort fsync and bounded Windows transient rename retries for safety.
+ */
+export async function atomicWriteAsync(targetPath: string, data: string | Buffer): Promise<void> {
+  const dir = path.dirname(targetPath);
+  const tmpPath = path.join(dir, `.tmp.${randomUUID()}`);
+
+  try {
+    await fs.promises.mkdir(dir, { recursive: true });
+    await fs.promises.writeFile(tmpPath, data, typeof data === 'string' ? 'utf8' : undefined);
+
+    let fd: fs.promises.FileHandle | null = null;
+    try {
+      fd = await fs.promises.open(tmpPath, 'r+');
+      await fd.sync();
+    } catch {
+      // fsync is best-effort.
+    } finally {
+      try {
+        await fd?.close();
+      } catch {
+        // close is best-effort after a best-effort fsync.
+      }
+    }
+
+    await renameWithRetry(tmpPath, targetPath);
+  } catch (error) {
+    await fs.promises.unlink(tmpPath).catch(() => undefined);
+    throw error;
+  }
+}