@yancyyu/openhermit 1.6.41 → 1.6.43

package/src/renderer/utils/slashCommandRegistry.ts

@@ -0,0 +1,231 @@
+import { KNOWN_SLASH_COMMANDS, isSupportedSlashCommandName } from '@shared/utils/slashCommands';
+
+import type { MentionSuggestion } from '@renderer/types/mention';
+import type {
+  CapabilityCommand,
+  CapabilityScope,
+  LoadedCapabilityPack,
+  RegisteredSlashCommand,
+  SlashCommandResolveResult,
+  SlashCommandSource,
+} from '@shared/types/extensions';
+
+export const RESERVED_SLASH_COMMANDS = new Set([
+  ...KNOWN_SLASH_COMMANDS.map((command) => command.name.toLowerCase()),
+  'help',
+  'settings',
+  'permissions',
+  'login',
+  'logout',
+  'mcp',
+  'agents',
+  'hooks',
+  'memory',
+]);
+
+interface SlashRegistryInput {
+  packs?: readonly LoadedCapabilityPack[];
+  scope?: CapabilityScope;
+}
+
+function normalizeAlias(alias: string): string {
+  return alias.trim().replace(/^\//, '').toLowerCase();
+}
+
+function normalizeNamespace(namespace: string): string {
+  return namespace.trim().replace(/^\//, '').toLowerCase();
+}
+
+function isRegistryToken(value: string): boolean {
+  return isSupportedSlashCommandName(value) && !value.includes(':');
+}
+
+function commandAppliesToScope(command: CapabilityCommand, scope?: CapabilityScope): boolean {
+  if (!scope) return true;
+  return command.scope.includes(scope);
+}
+
+function commandSupportsSlash(command: CapabilityCommand): boolean {
+  return command.surfaces.includes('slash');
+}
+
+interface SlashCommandSuggestionOptions {
+  forceNamespacedAliases?: ReadonlySet<string>;
+}
+
+function shouldUseNamespacedSlash(
+  command: RegisteredSlashCommand,
+  options: SlashCommandSuggestionOptions = {}
+): boolean {
+  return (
+    RESERVED_SLASH_COMMANDS.has(command.alias) ||
+    options.forceNamespacedAliases?.has(command.alias) === true ||
+    Boolean(command.conflictsWith?.length)
+  );
+}
+
+export function collectSlashSuggestionAliases(
+  suggestions: readonly MentionSuggestion[]
+): Set<string> {
+  const aliases = new Set<string>();
+  for (const suggestion of suggestions) {
+    if (!suggestion.command) continue;
+    const commandName = suggestion.command.slice(1).split(/\s+/, 1)[0]?.toLowerCase();
+    if (commandName && !commandName.includes(':')) aliases.add(commandName);
+  }
+  return aliases;
+}
+
+export function buildSlashCommandRegistry({
+  packs = [],
+  scope,
+}: SlashRegistryInput): RegisteredSlashCommand[] {
+  const registered: RegisteredSlashCommand[] = [];
+
+  for (const pack of packs) {
+    if (!pack.enabled || pack.source === 'builtin') continue;
+
+    const packId = pack.manifest.id;
+    const namespace = normalizeNamespace(pack.manifest.namespace);
+    for (const command of pack.manifest.capabilities.commands ?? []) {
+      const alias = normalizeAlias(command.alias);
+      if (
+        !alias ||
+        !namespace ||
+        !isRegistryToken(alias) ||
+        !isRegistryToken(namespace) ||
+        !commandSupportsSlash(command) ||
+        !commandAppliesToScope(command, scope)
+      ) {
+        continue;
+      }
+
+      registered.push({
+        canonicalId: `${packId}.${command.id}`,
+        alias,
+        namespace,
+        slash: `/${alias}`,
+        namespacedSlash: `/${namespace}:${alias}`,
+        source: 'pack',
+        packId,
+        command: {
+          ...command,
+          alias,
+          execution: command.execution ?? {
+            type: scope === 'admin-loop' ? 'loop-session' : 'send-message',
+            reuse: true,
+          },
+        },
+      });
+    }
+  }
+
+  const byAlias = new Map<string, RegisteredSlashCommand[]>();
+  for (const command of registered) {
+    byAlias.set(command.alias, [...(byAlias.get(command.alias) ?? []), command]);
+  }
+
+  return registered
+    .map((command) => {
+      const aliasPeers = byAlias.get(command.alias) ?? [];
+      const conflictsWith = [
+        ...aliasPeers
+          .filter((peer) => peer.canonicalId !== command.canonicalId)
+          .map((peer) => peer.canonicalId),
+        ...(RESERVED_SLASH_COMMANDS.has(command.alias) ? [`official.${command.alias}`] : []),
+      ];
+      return conflictsWith.length ? { ...command, conflictsWith } : command;
+    })
+    .sort(
+      (a, b) =>
+        (a.command.order ?? 999) - (b.command.order ?? 999) || a.alias.localeCompare(b.alias)
+    );
+}
+
+export function resolveSlashCommand(
+  registry: readonly RegisteredSlashCommand[],
+  input: string,
+  commandRef?: string
+): SlashCommandResolveResult {
+  if (commandRef) {
+    const command = registry.find((entry) => entry.canonicalId === commandRef);
+    return command ? { status: 'resolved', command } : { status: 'not-found' };
+  }
+
+  const normalized = input.trim().replace(/^\//, '').toLowerCase();
+  if (!normalized) return { status: 'not-found' };
+
+  if (normalized.includes(':')) {
+    const parts = normalized.split(':');
+    if (parts.length !== 2 || !isRegistryToken(parts[0]) || !isRegistryToken(parts[1])) {
+      return { status: 'not-found' };
+    }
+    const [namespace, alias] = parts;
+    const command = registry.find(
+      (entry) => entry.namespace === namespace && entry.alias === alias
+    );
+    return command ? { status: 'resolved', command } : { status: 'not-found' };
+  }
+
+  const candidates = registry.filter((entry) => entry.alias === normalized);
+  if (candidates.length === 0) return { status: 'not-found' };
+  if (candidates.length > 1 || RESERVED_SLASH_COMMANDS.has(normalized)) {
+    return { status: 'conflict', candidates };
+  }
+  return { status: 'resolved', command: candidates[0] };
+}
+
+export function registeredSlashCommandToSuggestion(
+  registered: RegisteredSlashCommand,
+  options: SlashCommandSuggestionOptions = {}
+): MentionSuggestion {
+  const command = shouldUseNamespacedSlash(registered, options)
+    ? registered.namespacedSlash
+    : registered.slash;
+  const insertText = command.slice(1);
+  const conflictLabel = registered.conflictsWith?.length ? ' · use namespaced command' : '';
+
+  return {
+    id: `capability-command:${registered.canonicalId}`,
+    name: insertText,
+    type: 'command',
+    command,
+    commandRef: registered.canonicalId,
+    insertText,
+    description: registered.command.description ?? registered.command.title,
+    subtitle: `${registered.namespace} · ${registered.command.safety}${conflictLabel}`,
+    searchText: [
+      registered.command.title,
+      registered.command.description,
+      registered.alias,
+      registered.namespace,
+      registered.packId,
+      registered.command.safety,
+    ]
+      .filter(Boolean)
+      .join(' '),
+  };
+}
+
+export function buildCapabilityPackCommandSuggestions(
+  packs: readonly LoadedCapabilityPack[],
+  scope: CapabilityScope,
+  options: SlashCommandSuggestionOptions = {}
+): MentionSuggestion[] {
+  return buildSlashCommandRegistry({ packs, scope }).map((registered) =>
+    registeredSlashCommandToSuggestion(registered, options)
+  );
+}
+
+export function sourceLabel(source: SlashCommandSource): string {
+  switch (source) {
+    case 'builtin':
+      return 'Built-in';
+    case 'official':
+      return 'Official';
+    case 'project':
+      return 'Project';
+    case 'pack':
+      return 'Capability pack';
+  }
+}

package/src/renderer/utils/teamMentionDirective.ts

@@ -0,0 +1,31 @@
+/**
+ * Parses a leading "@team subject" directive from a message body.
+ *
+ * Accepts both the ASCII '@' (U+0040) and the full-width '＠' (U+FF20) so a
+ * mention typed under a CJK IME still routes cross-team. Without this, a
+ * full-width '＠' fails the dispatch regex, the message falls through to a
+ * local send, and the user's own team answers instead of the mentioned one.
+ *
+ * Only the trigger character is normalized here; case / slug resolution is left
+ * to each caller (MessageComposer vs loopSendIntent), which already differ.
+ *
+ * `\s` already covers the full-width space (U+3000), so no special separator
+ * handling is needed.
+ */
+const TEAM_MENTION_DIRECTIVE_RE = /^[@＠]([^\s]+)\s+([\s\S]+)$/;
+
+export interface TeamMentionDirective {
+  /** Token after the trigger, up to the first whitespace (team slug or display name). */
+  mentioned: string;
+  /** Everything after the separating whitespace, trimmed. */
+  subject: string;
+}
+
+export function parseTeamMentionDirective(text: string): TeamMentionDirective | null {
+  const match = text.match(TEAM_MENTION_DIRECTIVE_RE);
+  if (!match) return null;
+  const mentioned = match[1];
+  const subject = match[2]?.trim();
+  if (!mentioned || !subject) return null;
+  return { mentioned, subject };
+}

package/src/renderer/utils/workflowCommandExecution.ts

@@ -0,0 +1,96 @@
+import { api } from '@renderer/api';
+import { parseStandaloneSlashCommand } from '@shared/utils/slashCommands';
+
+import type { MentionSuggestion } from '@renderer/types/mention';
+import type { SlashCommandMeta } from '@shared/types/team';
+import type { WorkflowPromptSummary } from '@shared/types/systemManager';
+
+export interface ResolvedWorkflowCommand {
+  folder: string;
+  id: string;
+  command: `/${string}`;
+  args?: string;
+}
+
+export interface ExpandedWorkflowCommand {
+  text: string;
+  summary: string;
+  slashCommand: SlashCommandMeta;
+  prompt: WorkflowPromptSummary;
+}
+
+/**
+ * Append trailing user arguments to a prompt body. Mirrors the capability-pack
+ * expansion convention so workflow prompts and capability commands format args
+ * identically downstream.
+ */
+export function appendArgsToPrompt(prompt: string, args?: string): string {
+  const trimmedPrompt = prompt.trim();
+  const trimmedArgs = args?.trim();
+  if (!trimmedArgs) return trimmedPrompt;
+  return `${trimmedPrompt}\n\nUser arguments:\n${trimmedArgs}`;
+}
+
+/**
+ * Resolve a typed slash command against workflow-prompt suggestions.
+ *
+ * Workflow suggestions (built from `.claude/commands/*.md` via WorkflowPromptService)
+ * carry `workflowPromptId` + `workflowPromptFolder` but no `commandRef`, so they are
+ * invisible to the capability-pack resolver. This resolver finds the matching prompt
+ * so its full content can be loaded and injected — otherwise only the raw `/name`
+ * text is sent and the workflow never actually runs.
+ */
+export function resolveWorkflowCommandInput(
+  suggestions: readonly MentionSuggestion[],
+  text: string
+): ResolvedWorkflowCommand | null {
+  const parsed = parseStandaloneSlashCommand(text);
+  if (!parsed) return null;
+
+  const match = suggestions.find(
+    (suggestion) =>
+      suggestion.workflowPromptId &&
+      suggestion.workflowPromptFolder &&
+      typeof suggestion.command === 'string' &&
+      suggestion.command.toLowerCase() === parsed.command.toLowerCase()
+  );
+  if (!match || !match.workflowPromptFolder || !match.workflowPromptId) return null;
+
+  return {
+    folder: match.workflowPromptFolder,
+    id: match.workflowPromptId,
+    command: parsed.command,
+    args: parsed.args,
+  };
+}
+
+/**
+ * Load the full prompt content for a resolved workflow command and format it as
+ * an injectable message body. Parallel to `expandCapabilityCommand`.
+ */
+export async function expandWorkflowCommand(
+  resolved: ResolvedWorkflowCommand
+): Promise<ExpandedWorkflowCommand> {
+  if (!api.systemManager) {
+    throw new Error('System manager API is unavailable');
+  }
+
+  const { prompt, content } = await api.systemManager.readWorkflowPrompt(
+    resolved.folder,
+    resolved.id
+  );
+  const commandName = prompt.commandName ?? resolved.command;
+  const slashCommand: SlashCommandMeta = {
+    name: commandName.replace(/^\/+/, ''),
+    command: commandName.startsWith('/') ? (commandName as `/${string}`) : `/${commandName}`,
+    args: resolved.args,
+    knownDescription: prompt.description ?? prompt.label,
+  };
+
+  return {
+    text: appendArgsToPrompt(content, resolved.args),
+    summary: prompt.label,
+    slashCommand,
+    prompt,
+  };
+}

package/src/renderer/utils/workflowCommandSuggestions.ts

@@ -0,0 +1,49 @@
+/**
+ * Build command-list suggestions from workflow prompts (`.claude/commands/*.md`).
+ *
+ * Extracted from SystemManagerView so both the admin Loop console and each
+ * team's Loop console can surface workflow commands — the team console loads
+ * its own project's commands, so a digital worker's project-specific commands
+ * appear alongside the global ones.
+ */
+
+import type { MentionSuggestion } from '@renderer/types/mention';
+import type { WorkflowPromptSummary } from '@shared/types/systemManager';
+
+function formatWorkflowCommand(prompt: WorkflowPromptSummary): string {
+  return prompt.commandName ?? `/${prompt.filename.replace(/\.[^.]+$/, '')}`;
+}
+
+/**
+ * Convert a workflow prompt into a command suggestion carrying the
+ * `workflowPromptId` / `workflowPromptFolder` metadata that the submit path
+ * uses to inject the prompt's full body (instead of sending the raw `/name`).
+ */
+export function buildWorkflowCommandSuggestion(
+  prompt: WorkflowPromptSummary,
+  idPrefix = 'workflow'
+): MentionSuggestion {
+  const command = formatWorkflowCommand(prompt) as `/${string}`;
+  const commandName = command.slice(1);
+  return {
+    id: `${idPrefix}:${prompt.id}`,
+    name: commandName,
+    type: 'command',
+    command,
+    insertText: commandName,
+    workflowPromptId: prompt.id,
+    workflowPromptFolder: prompt.folder,
+    description: prompt.description ?? `运行 ${prompt.label}`,
+    subtitle: prompt.safety ? `${prompt.label} · ${prompt.safety}` : prompt.label,
+    searchText: [
+      prompt.label,
+      prompt.description,
+      prompt.category,
+      prompt.safety,
+      prompt.filename,
+      command,
+    ]
+      .filter(Boolean)
+      .join(' '),
+  };
+}

package/src/shared/types/api.ts

@@ -10,7 +10,13 @@
 import type { CliArgsValidationResult } from '../utils/cliArgsParser';
 import type { CliInstallerAPI } from './cliInstaller';
 import type { EditorAPI, EditorFileChangeEvent, ProjectAPI, WorkspaceListResponse } from './editor';
-import type { ApiKeysAPI, McpCatalogAPI, PluginCatalogAPI, SkillsCatalogAPI } from './extensions';
+import type {
+  ApiKeysAPI,
+  CapabilityPacksAPI,
+  McpCatalogAPI,
+  PluginCatalogAPI,
+  SkillsCatalogAPI,
+} from './extensions';
 import type {
   AppConfig,
   DetectedError,
@@ -94,8 +100,10 @@ import type {
   ToolApprovalSettings,
   UpdateKanbanPatch,
 } from './team';
+import type { LoopAssetsSnapshot } from './loopAssets';
 import type { SystemManagerAPI } from './systemManager';
 import type { TerminalAPI } from './terminal';
+import type { DiscoverableWorker } from './worker';
 import type { WaterfallData } from './visualization';
 import type { RecentProjectsElectronApi } from '@features/recent-projects/contracts';
 import type {
@@ -501,6 +509,14 @@ export interface CcSession {
   createdAt: string;
   updatedAt: string;
   lastMessage: { role: string; content: string; timestamp: string } | null;
+  /**
+   * Whether this list entry is backed by a local Claude JSONL file. cc-only
+   * sessions (e.g. a Feishu listening session with no local file yet) are
+   * `false` — expanding them must not attempt a local detail read, which 404s
+   * and surfaces a misleading "会话文件已不存在" (#20). Defaults to true when
+   * unset, so construction sites that predate the flag keep current behavior.
+   */
+  hasLocalFile?: boolean;
 }
 
 export interface CcSessionMessage {
@@ -524,6 +540,18 @@ export interface CcSessionDetail {
   history: CcSessionMessage[];
 }
 
+export interface LoopSessionRequest {
+  sessionName?: string;
+  message?: string;
+  reuse?: boolean;
+}
+
+export interface LoopSessionResponse {
+  session: CcSession;
+  reused: boolean;
+  messageSent: boolean;
+}
+
 export type ConversationTelemetryExportFormat = 'csv' | 'json' | 'markdown' | 'plaintext';
 
 export type ConversationTelemetryIncludeContent = 'none' | 'summary' | 'full';
@@ -577,7 +605,12 @@ export interface ConversationTelemetryRow {
     endTime?: string;
     active?: boolean;
     live?: boolean;
-    matchStatus: 'matched' | 'missing-agent-session-id' | 'jsonl-not-found' | 'ambiguous' | 'local-only';
+    matchStatus:
+      | 'matched'
+      | 'missing-agent-session-id'
+      | 'jsonl-not-found'
+      | 'ambiguous'
+      | 'local-only';
   };
   identity: {
     platform: string;
@@ -641,6 +674,11 @@ export interface TeamsAPI {
   list: () => Promise<TeamSummary[]>;
   ensureSystemManager: () => Promise<SystemManagerSummary>;
   getData: (teamName: string) => Promise<TeamViewSnapshot>;
+  getLoopAssets: (teamName: string) => Promise<LoopAssetsSnapshot>;
+  createLoopSession: (
+    teamName: string,
+    request: LoopSessionRequest
+  ) => Promise<LoopSessionResponse>;
   getTaskChangePresence: (teamName: string) => Promise<Record<string, TaskChangePresenceState>>;
   setChangePresenceTracking: (teamName: string, enabled: boolean) => Promise<void>;
   setToolActivityTracking: (teamName: string, enabled: boolean) => Promise<void>;
@@ -840,6 +878,36 @@ export interface CrossTeamAPI {
   getOutbox: (teamName: string) => Promise<CrossTeamMessage[]>;
 }
 
+// =============================================================================
+// Digital Workers API
+// =============================================================================
+
+export interface WorkerListResponse {
+  workers: DiscoverableWorker[];
+}
+
+export interface WorkerInvokeRequest {
+  fromTeam?: string;
+  text: string;
+  summary?: string;
+  sessionName?: string;
+  reuse?: boolean;
+  sessionKey?: string;
+}
+
+export interface WorkerInvokeResponse {
+  ok: boolean;
+  worker: DiscoverableWorker;
+  session: CcSession;
+  reused: boolean;
+  messageSent: boolean;
+}
+
+export interface WorkersAPI {
+  list: () => Promise<WorkerListResponse>;
+  invoke: (workerId: string, request: WorkerInvokeRequest) => Promise<WorkerInvokeResponse>;
+}
+
 // =============================================================================
 // Collaboration Board API
 // =============================================================================
@@ -1199,11 +1267,15 @@ export interface ElectronAPI extends RecentProjectsElectronApi {
         work_dir?: string;
         agent_type?: string;
       }
-    ) => Promise<{ message: string; restart_required: boolean }>;
+    ) => Promise<{ message: string; restart_required: boolean; restart_handled?: boolean }>;
   };
 
   // Cross-Team Communication API
   crossTeam: CrossTeamAPI;
+
+  // Digital Workers API
+  workers: WorkersAPI;
+
   collab: CollabBoardAPI;
 
   // Review API
@@ -1215,7 +1287,7 @@ export interface ElectronAPI extends RecentProjectsElectronApi {
   // System Manager / Control Console API
   systemManager: SystemManagerAPI;
 
-  // Embedded Terminal API (xterm.js + node-pty)
+  // System terminal API
   terminal: TerminalAPI;
 
   // Project file operations (editor-independent)
@@ -1241,6 +1313,9 @@ export interface ElectronAPI extends RecentProjectsElectronApi {
   // Extension Store — Skills Catalog API (Electron-only, optional)
   skills?: SkillsCatalogAPI;
 
+  // Extension Store — Capability Packs API (Electron-only, optional)
+  capabilityPacks?: CapabilityPacksAPI;
+
   // Extension Store — Credentials (project env, MCP credentials)
   credentials?: {
     getStatus: () => Promise<{ encryption: string; storagePath: string } | null>;

package/src/shared/types/ccConnect.ts

@@ -118,6 +118,7 @@ export interface CcSessionListItem {
   id: string;
   name: string;
   session_key: string;
+  agent_session_id?: string;
   agent_type: CcAgentType;
   active: boolean;
   live: boolean;

package/src/shared/types/extensions/api.ts

@@ -23,6 +23,14 @@ import type {
   McpServerDiagnostic,
 } from './mcp';
 import type { EnrichedPlugin, PluginInstallRequest } from './plugin';
+import type {
+  CapabilityCommandPromptRequest,
+  CapabilityCommandPromptResult,
+  CapabilityPackExportRequest,
+  CapabilityPackImportRequest,
+  CapabilityPackListResult,
+  CapabilityPackMutationResult,
+} from './capabilityPack';
 import type {
   SkillCatalogItem,
   SkillDeleteRequest,
@@ -88,6 +96,17 @@ export interface SkillsCatalogAPI {
   onChanged: (callback: (event: SkillWatcherEvent) => void) => () => void;
 }
 
+// ── Capability Packs API ──────────────────────────────────────────────────
+
+export interface CapabilityPacksAPI {
+  list: () => Promise<CapabilityPackListResult>;
+  importPack: (request: CapabilityPackImportRequest) => Promise<CapabilityPackMutationResult>;
+  exportPack: (request: CapabilityPackExportRequest) => Promise<CapabilityPackMutationResult>;
+  getCommandPrompt: (
+    request: CapabilityCommandPromptRequest
+  ) => Promise<CapabilityCommandPromptResult>;
+}
+
 // ── API Keys API ──────────────────────────────────────────────────────────
 
 export interface ApiKeysAPI {