@yancyyu/openhermit 1.6.42 → 1.6.43

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

@@ -8,12 +8,24 @@ import type {
   SystemManagerStatus,
 } from '@shared/types/systemManager';
 
+import { getGlobalHermitWorkflowDir } from './BuiltinWorkflowSeeder';
+
 const CONFIG_FILE = 'system-manager.json';
 
 function hermitHome(): string {
   return process.env.HERMIT_HOME || path.join(os.homedir(), '.hermit');
 }
 
+/**
+ * Canonical, isolated runtime path for the Helm Loop. Dedicated (never shared
+ * with another team/project) so the admin agent can bootstrap its own CLAUDE.md
+ * here without colliding with project work. Single source of truth — reused by
+ * `getSystemManagerWorkDir` (runtime) and `getStatus` (UI scope display).
+ */
+export function adminWorkDir(): string {
+  return path.join(hermitHome(), 'admin-workspace');
+}
+
 function expandHome(input: string): string {
   const normalized = input.trim().replace(/^～/, '~');
   if (normalized === '~') return os.homedir();
@@ -62,6 +74,7 @@ export class SystemManagerConfigService {
         schemaVersion: 1,
         selectedWorkDir,
         ...(workflowFolder ? { workflowFolder } : {}),
+        ...(parsed.adminInitialized ? { adminInitialized: true } : {}),
         updatedAt:
           typeof parsed.updatedAt === 'string' ? parsed.updatedAt : new Date().toISOString(),
       };
@@ -92,6 +105,9 @@ export class SystemManagerConfigService {
     } else if (typeof patch.workflowFolder === 'string') {
       next.workflowFolder = await this.normalizeDirectory(patch.workflowFolder, 'workflowFolder');
     }
+    if (typeof patch.adminInitialized === 'boolean') {
+      next.adminInitialized = patch.adminInitialized;
+    }
 
     await mkdir(path.dirname(this.configPath), { recursive: true });
     await writeFile(this.configPath, JSON.stringify(next, null, 2), 'utf-8');
@@ -102,10 +118,12 @@ export class SystemManagerConfigService {
     const config = await this.getConfig();
     const hasClaude = await commandExists('claude');
     return {
-      displayName: '控制台',
+      displayName: 'Helm Loop',
+      adminWorkDir: adminWorkDir(),
       defaultWorkDir: this.defaultWorkDir,
       selectedWorkDir: config.selectedWorkDir,
       ...(config.workflowFolder ? { workflowFolder: config.workflowFolder } : {}),
+      globalHermitWorkflowFolder: getGlobalHermitWorkflowDir(),
       claudeCommand: 'claude',
       localStatus: hasClaude ? 'ready' : 'missing-claude',
       ...(hasClaude ? {} : { error: '未在 PATH 中找到 claude 命令' }),

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

@@ -9,6 +9,11 @@ import type {
   WorkflowPromptSummary,
 } from '@shared/types/systemManager';
 
+import {
+  getBuiltinWorkflowByFilename,
+  type BuiltinWorkflowDefinition,
+} from './BuiltinWorkflowSeeder';
+
 const SUPPORTED_EXTENSIONS = new Set(['.md', '.txt', '.prompt', '.workflow']);
 const MAX_PROMPT_BYTES = 256 * 1024;
 
@@ -27,17 +32,49 @@ function labelFromFilename(filename: string): string {
   return path.basename(filename, path.extname(filename)).replace(/[-_]+/g, ' ').trim() || filename;
 }
 
+function getClaudeCommandRoot(folder: string): string | null {
+  const normalized = path.normalize(folder);
+  const commandsSuffix = path.join('.claude', 'commands');
+  if (normalized.endsWith(commandsSuffix)) return normalized;
+  const parent = path.dirname(normalized);
+  return parent.endsWith(commandsSuffix) ? parent : null;
+}
+
+function commandNameFromRelativePath(relativePath: string): `/${string}` {
+  const withoutExt = relativePath.slice(0, -path.extname(relativePath).length);
+  const commandName = withoutExt.split(path.sep).filter(Boolean).join(':');
+  return `/${commandName}`;
+}
+
+function applyBuiltinMetadata(
+  summary: WorkflowPromptSummary,
+  builtin: BuiltinWorkflowDefinition | undefined
+): WorkflowPromptSummary {
+  if (!builtin) return summary;
+  return {
+    ...summary,
+    label: builtin.label,
+    commandName: summary.commandName ?? builtin.commandName,
+    description: builtin.description,
+    category: builtin.category,
+    safety: builtin.safety,
+    builtin: true,
+    order: builtin.order,
+  };
+}
+
 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}`);
+      throw new Error(`Loop command folder 不是有效目录: ${folder}`);
     }
 
     const warnings: string[] = [];
     const prompts: WorkflowPromptSummary[] = [];
     const entries = await readdir(folder, { withFileTypes: true });
+    const commandRoot = getClaudeCommandRoot(folder);
 
     for (const entry of entries) {
       if (!entry.isFile() || entry.name.startsWith('.')) continue;
@@ -49,17 +86,33 @@ export class WorkflowPromptService {
         warnings.push(`${entry.name} 超过 256 KiB，已跳过`);
         continue;
       }
-      prompts.push({
+
+      const relativeCommandPath = commandRoot ? path.relative(commandRoot, filePath) : entry.name;
+      const commandName = commandRoot
+        ? commandNameFromRelativePath(relativeCommandPath)
+        : undefined;
+      const builtin = commandRoot ? getBuiltinWorkflowByFilename(entry.name) : undefined;
+      const summary: WorkflowPromptSummary = {
         id: promptId(filePath),
         label: labelFromFilename(entry.name),
         filename: entry.name,
         path: filePath,
+        folder,
         sizeBytes: fileStat.size,
         updatedAt: fileStat.mtime.toISOString(),
-      });
+        source: commandRoot ? 'claude-command' : 'workflow-folder',
+        commandName,
+        safety: commandRoot ? 'unknown' : undefined,
+      };
+      prompts.push(applyBuiltinMetadata(summary, builtin));
     }
 
-    prompts.sort((a, b) => a.filename.localeCompare(b.filename));
+    prompts.sort((a, b) => {
+      const orderA = a.order ?? Number.MAX_SAFE_INTEGER;
+      const orderB = b.order ?? Number.MAX_SAFE_INTEGER;
+      if (orderA !== orderB) return orderA - orderB;
+      return a.filename.localeCompare(b.filename);
+    });
     return { folder, prompts, warnings };
   }
 
@@ -67,7 +120,7 @@ export class WorkflowPromptService {
     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}`);
+      throw new Error(`未找到 Loop workflow: ${id}`);
     }
     const content = await readFile(prompt.path, 'utf-8');
     return { prompt, content };

package/src/main/services/system-manager/__tests__/AdminLoopInitializer.test.ts

@@ -0,0 +1,129 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import {
+  ADMIN_INIT_MESSAGE_ID,
+  buildAdminInitMessage,
+  ensureAdminLoopInitialized,
+  htmlToPlainText,
+  type AdminLoopInitDeps,
+} from '../AdminLoopInitializer';
+import type { SystemManagerConfig, SystemManagerConfigPatch } from '@shared/types/systemManager';
+
+interface Recorder {
+  getConfig: ReturnType<typeof vi.fn>;
+  updateConfig: ReturnType<typeof vi.fn>;
+  fetchGuide: ReturnType<typeof vi.fn>;
+  dispatch: ReturnType<typeof vi.fn>;
+  log: ReturnType<typeof vi.fn>;
+}
+
+function makeDeps(overrides?: Partial<Recorder>): Recorder & AdminLoopInitDeps {
+  const r: Recorder = {
+    getConfig: vi.fn(async () => ({ schemaVersion: 1, selectedWorkDir: '/x', updatedAt: 't' })),
+    updateConfig: vi.fn(
+      async (patch: SystemManagerConfigPatch) =>
+        ({
+          schemaVersion: 1,
+          selectedWorkDir: '/x',
+          updatedAt: 't',
+          ...patch,
+        }) as SystemManagerConfig
+    ),
+    fetchGuide: vi.fn(async () => ({ statusCode: 200, body: '<p>hello manual</p>' })),
+    dispatch: vi.fn(async () => undefined),
+    log: vi.fn(),
+    ...overrides,
+  };
+  return r as Recorder & AdminLoopInitDeps;
+}
+
+describe('htmlToPlainText', () => {
+  it('strips script/style and tags, decodes entities, collapses whitespace', () => {
+    const html =
+      '<style>.x{}</style><script>alert(1)</script><h1>Title</h1><p>a&nbsp;&amp;b</p><!--c-->';
+    expect(htmlToPlainText(html)).toBe('Title\na &b');
+  });
+
+  it('returns empty string for whitespace-only input', () => {
+    expect(htmlToPlainText('   \n  ')).toBe('');
+  });
+});
+
+describe('buildAdminInitMessage', () => {
+  it('wraps the guide text with the bootstrap instructions', () => {
+    const msg = buildAdminInitMessage('MANUAL_BODY');
+    expect(msg).toContain('Helm Loop 初始化');
+    expect(msg).toContain('MANUAL_BODY');
+    expect(msg).toContain('/workers');
+  });
+});
+
+describe('ensureAdminLoopInitialized', () => {
+  afterEach(() => vi.clearAllMocks());
+
+  it('is idempotent: skips fetch + dispatch + updateConfig when already initialized', async () => {
+    const deps = makeDeps({
+      getConfig: vi.fn(async () => ({
+        schemaVersion: 1,
+        selectedWorkDir: '/x',
+        updatedAt: 't',
+        adminInitialized: true,
+      })),
+    });
+
+    await ensureAdminLoopInitialized(deps);
+
+    expect(deps.fetchGuide).not.toHaveBeenCalled();
+    expect(deps.dispatch).not.toHaveBeenCalled();
+    expect(deps.updateConfig).not.toHaveBeenCalled();
+  });
+
+  it('does NOT set the marker when the guide fetch rejects', async () => {
+    const deps = makeDeps({
+      fetchGuide: vi.fn(async () => {
+        throw new Error('network down');
+      }),
+    });
+
+    await ensureAdminLoopInitialized(deps);
+
+    expect(deps.dispatch).not.toHaveBeenCalled();
+    expect(deps.updateConfig).not.toHaveBeenCalled();
+    expect(deps.log).toHaveBeenCalled();
+  });
+
+  it('does NOT set the marker on non-2xx status', async () => {
+    const deps = makeDeps({
+      fetchGuide: vi.fn(async () => ({ statusCode: 503, body: 'unavailable' })),
+    });
+
+    await ensureAdminLoopInitialized(deps);
+
+    expect(deps.dispatch).not.toHaveBeenCalled();
+    expect(deps.updateConfig).not.toHaveBeenCalled();
+  });
+
+  it('does NOT set the marker when the body is empty', async () => {
+    const deps = makeDeps({
+      fetchGuide: vi.fn(async () => ({ statusCode: 200, body: '<script>x</script>' })),
+    });
+
+    await ensureAdminLoopInitialized(deps);
+
+    expect(deps.dispatch).not.toHaveBeenCalled();
+    expect(deps.updateConfig).not.toHaveBeenCalled();
+  });
+
+  it('on success dispatches the wrapped guide and sets adminInitialized=true', async () => {
+    const deps = makeDeps();
+
+    await ensureAdminLoopInitialized(deps);
+
+    expect(deps.fetchGuide).toHaveBeenCalledTimes(1);
+    expect(deps.dispatch).toHaveBeenCalledWith({
+      text: buildAdminInitMessage('hello manual'),
+      messageId: ADMIN_INIT_MESSAGE_ID,
+    });
+    expect(deps.updateConfig).toHaveBeenCalledWith({ adminInitialized: true });
+  });
+});

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

@@ -0,0 +1,60 @@
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+
+import { SystemManagerConfigService, adminWorkDir } from '../SystemManagerConfigService';
+
+const PREV_HERMIT_HOME = process.env.HERMIT_HOME;
+let workdir: string;
+
+beforeAll(async () => {
+  workdir = await mkdtemp(path.join(tmpdir(), 'hermit-admin-cfg-'));
+  process.env.HERMIT_HOME = workdir;
+});
+
+afterAll(() => {
+  if (PREV_HERMIT_HOME === undefined) delete process.env.HERMIT_HOME;
+  else process.env.HERMIT_HOME = PREV_HERMIT_HOME;
+  void rm(workdir, { recursive: true, force: true });
+});
+
+describe('adminWorkDir', () => {
+  it('points at <hermit-home>/admin-workspace', () => {
+    expect(adminWorkDir()).toBe(path.join(workdir, 'admin-workspace'));
+  });
+});
+
+describe('SystemManagerConfigService.adminInitialized', () => {
+  it('round-trips the marker and persists it across instances', async () => {
+    const svc = new SystemManagerConfigService(workdir);
+
+    expect((await svc.getConfig()).adminInitialized).toBeUndefined();
+
+    await svc.updateConfig({ adminInitialized: true });
+    expect((await svc.getConfig()).adminInitialized).toBe(true);
+
+    // A fresh instance reads the same file → marker survives a restart.
+    const reopened = new SystemManagerConfigService(workdir);
+    expect((await reopened.getConfig()).adminInitialized).toBe(true);
+  });
+
+  it('preserves adminInitialized when patching an unrelated field', async () => {
+    const svc = new SystemManagerConfigService(workdir);
+    await svc.updateConfig({ adminInitialized: true });
+    await svc.updateConfig({ selectedWorkDir: workdir });
+
+    const config = await svc.getConfig();
+    expect(config.selectedWorkDir).toBe(workdir);
+    expect(config.adminInitialized).toBe(true);
+  });
+});
+
+describe('SystemManagerConfigService.getStatus', () => {
+  it('reports the Helm Loop identity and the admin workDir', async () => {
+    const svc = new SystemManagerConfigService(workdir);
+    const status = await svc.getStatus();
+    expect(status.displayName).toBe('Helm Loop');
+    expect(status.adminWorkDir).toBe(path.join(workdir, 'admin-workspace'));
+  });
+});

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

@@ -50,8 +50,10 @@ function normalizeTask(task: CollabTask): CollabTask {
 function eventTypeForStatus(status: CollabTaskStatus): CollabTaskEventType {
   switch (status) {
     case 'pending_accept':
+    case 'received':
       return 'task_sent';
     case 'accepted':
+    case 'in_progress':
       return 'task_accepted';
     case 'delivered':
       return 'task_delivered';

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

@@ -0,0 +1,60 @@
+/**
+ * Compact Hermit operations context injected into managed agent instructions.
+ *
+ * Keep this short: agents need the stable runbook boundary and pointers, not the
+ * full public guide copied into every session.
+ */
+
+export const HERMIT_OPS_GUIDE_URL = 'https://yancyuu.github.io/Hermit/';
+
+const OPS_CONTEXT_BEGIN = '<!-- hermit:ops-runbook-context:start -->';
+const OPS_CONTEXT_END = '<!-- hermit:ops-runbook-context:end -->';
+
+const OPS_RUNBOOK_CONTEXT = `## Hermit Ops Runbook Context
+
+Public operations guide: ${HERMIT_OPS_GUIDE_URL}
+Local canonical docs: README.md, docs/README.md, docs/team-management/README.md
+
+Hermit/openHermit is a local-first Loop Engineering control plane. Use /teams as the
+main operations surface and treat ~/.hermit/ as the default local data directory.
+Hermit coordinates teams, tasks, message routing, channel allowlists, audit trails,
+and Loop workflows; actual runtime execution is delegated to the local Agent CLI /
+cc-connect Bridge / Management API.
+
+Common ops workflows to suggest or use when appropriate. Hermit preinstalls them as
+user-level Claude commands under ~/.claude/commands/hermit/ so every team can run
+the same namespaced commands from its own cwd:
+- /hermit:doctor — diagnose install/runtime/config health.
+- /hermit:loop-scan — inspect Loop assets and recommended recurring loops.
+- /hermit:summary — summarize team/session status and next actions.
+- /hermit:daily-folder-hygiene — check temporary files, stale reports, and workspace clutter.
+- /hermit:daily-memory-conflict-check — check CLAUDE/AGENTS/memory/settings conflicts.
+- /hermit:daily-workflow-extraction — extract reusable prompts/workflows from recent work.
+- /hermit:worktree-scan — inspect dirty or stale worktrees before cleanup decisions.
+
+Safety boundary for operations workflows:
+- Default to read-only diagnosis. Do not modify, delete, move, format, commit, push,
+  publish, deploy, or run destructive commands unless the user explicitly approves.
+- Explain the purpose before commands; prefer read-only commands for diagnostics.
+- Do not expose secrets, tokens, cookies, private keys, or full sensitive paths.
+- If a fix is needed, report recommendations, verification steps, and an optional
+  patch plan before applying changes.
+- Treat the public guide and local docs as operational references; verify against
+  the current repository/config before making exact claims.`;
+
+export function buildHermitOpsRunbookContext(): string {
+  return `${OPS_CONTEXT_BEGIN}\n\n${OPS_RUNBOOK_CONTEXT}\n\n${OPS_CONTEXT_END}`;
+}
+
+export function removeHermitOpsRunbookContext(content: string): string {
+  return content
+    .replace(new RegExp(`\\n{0,2}${OPS_CONTEXT_BEGIN}[\\s\\S]*?${OPS_CONTEXT_END}\\n?`, 'g'), '\n')
+    .replace(/\n{3,}/g, '\n\n')
+    .trimEnd();
+}
+
+export function buildMemberWorkflowWithOpsContext(memberWorkflow?: string): string {
+  const workflow = removeHermitOpsRunbookContext(memberWorkflow ?? '').trim();
+  const context = buildHermitOpsRunbookContext();
+  return workflow ? `${workflow}\n\n${context}` : context;
+}