@yancyyu/openhermit 1.6.28 → 1.6.30

package/src/main/services/extensions/state/PluginInstallationStateService.ts

@@ -0,0 +1,281 @@
+/**
+ * Reads plugin installed state and install counts from the filesystem.
+ *
+ * Sources:
+ * - Installed state: ~/.claude/plugins/installed_plugins.json
+ * - Install counts:  ~/.claude/plugins/install-counts-cache.json
+ *
+ * Both files are managed by the Claude CLI. This service is read-only.
+ */
+
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+
+import { getClaudeBasePath } from '@main/utils/pathDecoder';
+import { createLogger } from '@shared/utils/logger';
+
+import type { InstalledPluginEntry } from '@shared/types/extensions';
+import type { InstallScope } from '@shared/types/extensions';
+
+const logger = createLogger('Extensions:PluginState');
+
+// ── Constants ──────────────────────────────────────────────────────────────
+
+const INSTALLED_STATE_TTL_MS = 10_000; // 10 seconds
+const INSTALL_COUNTS_TTL_MS = 5 * 60_000; // 5 minutes
+
+// ── Raw file shapes ────────────────────────────────────────────────────────
+
+interface InstalledPluginsJson {
+  version: number;
+  plugins: Record<
+    string, // qualifiedName
+    {
+      scope: string;
+      installPath?: string;
+      version?: string;
+      installedAt?: string;
+      lastUpdated?: string;
+      gitCommitSha?: string;
+    }[]
+  >;
+}
+
+interface InstallCountsJson {
+  version: number;
+  fetchedAt: string;
+  counts: {
+    plugin: string; // qualifiedName format
+    unique_installs: number;
+  }[];
+}
+
+// ── Cache ──────────────────────────────────────────────────────────────────
+
+interface TimedCache<T> {
+  data: T;
+  fetchedAt: number;
+}
+
+// ── Service ────────────────────────────────────────────────────────────────
+
+export class PluginInstallationStateService {
+  private installedCache = new Map<string, TimedCache<InstalledPluginEntry[]>>();
+  private countsCache: TimedCache<Map<string, number>> | null = null;
+
+  /**
+   * Get installed plugins relevant to the active context.
+   * Always includes user scope. Project/local entries are only included when
+   * they are enabled for the active project.
+   */
+  async getInstalledPlugins(projectPath?: string): Promise<InstalledPluginEntry[]> {
+    const normalizedProjectPath =
+      typeof projectPath === 'string' && path.isAbsolute(projectPath) ? projectPath : undefined;
+    const cacheKey = this.getInstalledCacheKey(normalizedProjectPath);
+    const cached = this.installedCache.get(cacheKey);
+
+    if (cached && Date.now() - cached.fetchedAt < INSTALLED_STATE_TTL_MS) {
+      return cached.data;
+    }
+
+    const entries = await this.buildInstalledEntriesForContext(normalizedProjectPath);
+    this.installedCache.set(cacheKey, { data: entries, fetchedAt: Date.now() });
+    return entries;
+  }
+
+  /**
+   * Get install counts keyed by pluginId (qualifiedName).
+   */
+  async getInstallCounts(): Promise<Map<string, number>> {
+    if (this.countsCache && Date.now() - this.countsCache.fetchedAt < INSTALL_COUNTS_TTL_MS) {
+      return this.countsCache.data;
+    }
+
+    const counts = await this.readInstallCounts();
+    this.countsCache = { data: counts, fetchedAt: Date.now() };
+    return counts;
+  }
+
+  /**
+   * Invalidate all caches. Call after install/uninstall operations.
+   */
+  invalidateCache(): void {
+    this.installedCache.clear();
+    this.countsCache = null;
+  }
+
+  // ── Private ────────────────────────────────────────────────────────────
+
+  private getPluginsDir(): string {
+    return path.join(getClaudeBasePath(), 'plugins');
+  }
+
+  private getInstalledCacheKey(projectPath?: string): string {
+    return projectPath ?? '__user__';
+  }
+
+  private async buildInstalledEntriesForContext(
+    projectPath?: string
+  ): Promise<InstalledPluginEntry[]> {
+    const installedMetadata = await this.readInstalledPluginMetadata();
+    const metadataByKey = new Map<string, InstalledPluginEntry[]>();
+
+    for (const entry of installedMetadata) {
+      const key = this.getPluginScopeKey(entry.pluginId, entry.scope);
+      const matches = metadataByKey.get(key) ?? [];
+      matches.push(entry);
+      metadataByKey.set(key, matches);
+    }
+
+    const userEnabled = await this.readEnabledPlugins(
+      path.join(getClaudeBasePath(), 'settings.json')
+    );
+    const projectEnabled = projectPath
+      ? await this.readEnabledPlugins(path.join(projectPath, '.claude', 'settings.json'))
+      : new Set<string>();
+    const localEnabled = projectPath
+      ? await this.readEnabledPlugins(path.join(projectPath, '.claude', 'settings.local.json'))
+      : new Set<string>();
+
+    return [
+      ...this.buildScopedEntries('user', userEnabled, metadataByKey),
+      ...this.buildScopedEntries('project', projectEnabled, metadataByKey),
+      ...this.buildScopedEntries('local', localEnabled, metadataByKey),
+    ];
+  }
+
+  private buildScopedEntries(
+    scope: InstallScope,
+    enabledPlugins: Set<string>,
+    metadataByKey: Map<string, InstalledPluginEntry[]>
+  ): InstalledPluginEntry[] {
+    return Array.from(enabledPlugins).map((pluginId) => {
+      const key = this.getPluginScopeKey(pluginId, scope);
+      const bestMatch = this.pickBestInstallationEntry(metadataByKey.get(key) ?? []);
+
+      return bestMatch
+        ? {
+            ...bestMatch,
+            pluginId,
+            scope,
+          }
+        : {
+            pluginId,
+            scope,
+          };
+    });
+  }
+
+  private getPluginScopeKey(pluginId: string, scope: InstallScope): string {
+    return `${pluginId}::${scope}`;
+  }
+
+  private pickBestInstallationEntry(entries: InstalledPluginEntry[]): InstalledPluginEntry | null {
+    if (entries.length === 0) {
+      return null;
+    }
+
+    return [...entries].sort((left, right) => {
+      const leftInstalledAt = Date.parse(left.installedAt ?? '');
+      const rightInstalledAt = Date.parse(right.installedAt ?? '');
+      const normalizedLeft = Number.isFinite(leftInstalledAt) ? leftInstalledAt : 0;
+      const normalizedRight = Number.isFinite(rightInstalledAt) ? rightInstalledAt : 0;
+      return normalizedRight - normalizedLeft;
+    })[0];
+  }
+
+  private async readInstalledPluginMetadata(): Promise<InstalledPluginEntry[]> {
+    const filePath = path.join(this.getPluginsDir(), 'installed_plugins.json');
+
+    try {
+      const raw = await fs.readFile(filePath, 'utf-8');
+      const json = JSON.parse(raw) as InstalledPluginsJson;
+
+      if (json.version !== 2 || !json.plugins) {
+        logger.warn(`Unexpected installed_plugins.json version: ${json.version}`);
+        return [];
+      }
+
+      const entries: InstalledPluginEntry[] = [];
+
+      for (const [qualifiedName, installations] of Object.entries(json.plugins)) {
+        for (const inst of installations) {
+          entries.push({
+            pluginId: qualifiedName,
+            scope: this.normalizeScope(inst.scope),
+            version: inst.version,
+            installedAt: inst.installedAt,
+            installPath: inst.installPath,
+          });
+        }
+      }
+
+      return entries;
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
+        return []; // No plugins installed yet
+      }
+      logger.error('Failed to read installed_plugins.json:', err);
+      return [];
+    }
+  }
+
+  private async readEnabledPlugins(filePath: string): Promise<Set<string>> {
+    try {
+      const raw = await fs.readFile(filePath, 'utf-8');
+      const json = JSON.parse(raw) as {
+        enabledPlugins?: Record<string, boolean> | null;
+      };
+
+      if (!json.enabledPlugins || typeof json.enabledPlugins !== 'object') {
+        return new Set<string>();
+      }
+
+      return new Set(
+        Object.entries(json.enabledPlugins)
+          .filter(([, enabled]) => enabled === true)
+          .map(([pluginId]) => pluginId)
+      );
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
+        return new Set<string>();
+      }
+      logger.error(`Failed to read plugin settings from ${filePath}:`, err);
+      return new Set<string>();
+    }
+  }
+
+  private async readInstallCounts(): Promise<Map<string, number>> {
+    const filePath = path.join(this.getPluginsDir(), 'install-counts-cache.json');
+
+    try {
+      const raw = await fs.readFile(filePath, 'utf-8');
+      const json = JSON.parse(raw) as InstallCountsJson;
+
+      const map = new Map<string, number>();
+
+      if (json.counts && Array.isArray(json.counts)) {
+        for (const entry of json.counts) {
+          // Install counts use qualifiedName format (name@marketplace)
+          map.set(entry.plugin, entry.unique_installs);
+        }
+      }
+
+      return map;
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
+        return new Map();
+      }
+      logger.error('Failed to read install-counts-cache.json:', err);
+      return new Map();
+    }
+  }
+
+  private normalizeScope(raw: string): InstallScope {
+    const lower = raw.toLowerCase();
+    if (lower === 'user' || lower === 'project' || lower === 'local') {
+      return lower;
+    }
+    return 'user'; // safe default
+  }
+}

package/src/main/services/identity/AgentTeamsIdentityStore.ts

@@ -0,0 +1,218 @@
+import { atomicWriteAsync } from '@main/utils/atomicWrite';
+import {
+  getAppDataPath,
+  getAutoDetectedClaudeBasePath,
+  getClaudeBasePath,
+  getHomeDir,
+} from '@main/utils/pathDecoder';
+import { createHash, randomUUID } from 'crypto';
+import * as fs from 'fs';
+import * as path from 'path';
+
+export const AGENT_TEAMS_IDENTITY_STORE_PATH_ENV = 'AGENT_TEAMS_IDENTITY_STORE_PATH';
+export const AGENT_TEAMS_IDENTITY_SCHEMA_VERSION = 1;
+const SENTRY_ANONYMOUS_USER_PREFIX = 'agent-teams-sentry-v1:';
+const IDENTITY_DIR_MODE = 0o700;
+const IDENTITY_FILE_MODE = 0o600;
+
+type ParsedJson = null | boolean | number | string | ParsedJson[] | { [key: string]: ParsedJson };
+
+export type AgentTeamsIdentitySource = 'app-data' | 'legacy-global-config' | 'created';
+
+export interface AgentTeamsIdentityStoreV1 {
+  schemaVersion: typeof AGENT_TEAMS_IDENTITY_SCHEMA_VERSION;
+  clientId: string;
+  session?: Record<string, unknown>;
+  capabilities?: Record<string, unknown>;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface AgentTeamsClientIdentity {
+  clientId: string;
+  source: AgentTeamsIdentitySource;
+  storePath: string;
+}
+
+interface LegacyAgentTeamsState {
+  clientId: string;
+  session?: Record<string, unknown>;
+  capabilities?: Record<string, unknown>;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+export function isValidAgentTeamsClientId(value: unknown): value is string {
+  return (
+    typeof value === 'string' &&
+    /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value)
+  );
+}
+
+function isNonEmptyString(value: unknown): value is string {
+  return typeof value === 'string' && value.trim().length > 0;
+}
+
+function pickObjectField(
+  record: Record<string, unknown>,
+  key: string
+): Record<string, unknown> | undefined {
+  const value = record[key];
+  return isRecord(value) ? value : undefined;
+}
+
+export function getAgentTeamsIdentityStorePath(): string {
+  return path.join(getAppDataPath(), 'identity', 'agent-teams-client.json');
+}
+
+export function applyAgentTeamsIdentityEnv(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv {
+  const existing = env[AGENT_TEAMS_IDENTITY_STORE_PATH_ENV];
+  if (!isNonEmptyString(existing)) {
+    env[AGENT_TEAMS_IDENTITY_STORE_PATH_ENV] = getAgentTeamsIdentityStorePath();
+  }
+  return env;
+}
+
+export function getSentryAnonymousUserId(clientId: string): string {
+  if (!isValidAgentTeamsClientId(clientId)) {
+    throw new Error('Invalid Agent Teams clientId');
+  }
+  return createHash('sha256').update(`${SENTRY_ANONYMOUS_USER_PREFIX}${clientId}`).digest('hex');
+}
+
+function getLegacyGlobalConfigPath(): string {
+  const claudeBasePath = getClaudeBasePath();
+  return claudeBasePath !== getAutoDetectedClaudeBasePath()
+    ? path.join(claudeBasePath, '.claude.json')
+    : path.join(getHomeDir(), '.claude.json');
+}
+
+async function readJsonFile(filePath: string): Promise<ParsedJson | undefined> {
+  try {
+    const raw = await fs.promises.readFile(filePath, 'utf8');
+    return JSON.parse(raw) as ParsedJson;
+  } catch (error) {
+    const code = (error as NodeJS.ErrnoException).code;
+    if (code === 'ENOENT') {
+      return undefined;
+    }
+    return undefined;
+  }
+}
+
+async function pathExists(filePath: string): Promise<boolean> {
+  try {
+    await fs.promises.stat(filePath);
+    return true;
+  } catch (error) {
+    return (error as NodeJS.ErrnoException).code !== 'ENOENT';
+  }
+}
+
+function normalizeStoreRecord(value: unknown): AgentTeamsIdentityStoreV1 | null {
+  if (!isRecord(value)) {
+    return null;
+  }
+
+  if (value.schemaVersion !== AGENT_TEAMS_IDENTITY_SCHEMA_VERSION) {
+    return null;
+  }
+
+  if (!isValidAgentTeamsClientId(value.clientId)) {
+    return null;
+  }
+
+  const createdAt = isNonEmptyString(value.createdAt) ? value.createdAt : new Date().toISOString();
+  const updatedAt = isNonEmptyString(value.updatedAt) ? value.updatedAt : createdAt;
+  return {
+    schemaVersion: AGENT_TEAMS_IDENTITY_SCHEMA_VERSION,
+    clientId: value.clientId,
+    session: pickObjectField(value, 'session'),
+    capabilities: pickObjectField(value, 'capabilities'),
+    createdAt,
+    updatedAt,
+  };
+}
+
+function normalizeLegacyAgentTeams(value: unknown): LegacyAgentTeamsState | null {
+  if (!isRecord(value) || !isValidAgentTeamsClientId(value.clientId)) {
+    return null;
+  }
+
+  return {
+    clientId: value.clientId,
+    session: pickObjectField(value, 'session'),
+    capabilities: pickObjectField(value, 'capabilities'),
+  };
+}
+
+async function readLegacyAgentTeamsState(): Promise<LegacyAgentTeamsState | null> {
+  const legacyConfig = await readJsonFile(getLegacyGlobalConfigPath());
+  if (!isRecord(legacyConfig)) {
+    return null;
+  }
+
+  return normalizeLegacyAgentTeams(legacyConfig.agentTeams);
+}
+
+function buildStoreRecord(
+  source: LegacyAgentTeamsState | null,
+  options?: { existingCreatedAt?: string }
+): AgentTeamsIdentityStoreV1 {
+  const now = new Date().toISOString();
+  return {
+    schemaVersion: AGENT_TEAMS_IDENTITY_SCHEMA_VERSION,
+    clientId: source?.clientId ?? randomUUID(),
+    session: source?.session,
+    capabilities: source?.capabilities,
+    createdAt: options?.existingCreatedAt ?? now,
+    updatedAt: now,
+  };
+}
+
+async function writeStoreRecord(
+  storePath: string,
+  record: AgentTeamsIdentityStoreV1
+): Promise<void> {
+  const dir = path.dirname(storePath);
+  await fs.promises.mkdir(dir, { recursive: true, mode: IDENTITY_DIR_MODE });
+  await fs.promises.chmod(dir, IDENTITY_DIR_MODE).catch(() => undefined);
+  await atomicWriteAsync(storePath, `${JSON.stringify(record, null, 2)}\n`);
+  await fs.promises.chmod(storePath, IDENTITY_FILE_MODE).catch(() => undefined);
+}
+
+async function loadAppDataIdentity(storePath: string): Promise<AgentTeamsIdentityStoreV1 | null> {
+  return normalizeStoreRecord(await readJsonFile(storePath));
+}
+
+export async function ensureAgentTeamsClientIdentity(options?: {
+  storePath?: string;
+}): Promise<AgentTeamsClientIdentity> {
+  const storePath = options?.storePath ?? getAgentTeamsIdentityStorePath();
+  const existing = await loadAppDataIdentity(storePath);
+  if (existing) {
+    return {
+      clientId: existing.clientId,
+      source: 'app-data',
+      storePath,
+    };
+  }
+
+  const legacy = !(await pathExists(storePath)) ? await readLegacyAgentTeamsState() : null;
+  const record = buildStoreRecord(legacy);
+  await writeStoreRecord(storePath, record);
+
+  return {
+    clientId: record.clientId,
+    source: legacy ? 'legacy-global-config' : 'created',
+    storePath,
+  };
+}
+
+export async function readAgentTeamsIdentityStore(options?: {
+  storePath?: string;
+}): Promise<AgentTeamsIdentityStoreV1 | null> {
+  return loadAppDataIdentity(options?.storePath ?? getAgentTeamsIdentityStorePath());
+}

package/src/main/services/runtime/providerAwareCliEnv.ts

@@ -0,0 +1,60 @@
+/**
+ * Provider-aware CLI environment builder.
+ *
+ * Builds an enriched environment for CLI processes that accounts for
+ * provider-specific configuration (API keys, base URLs, etc.).
+ *
+ * NOTE: The full source in claude_agent_teams_ui depends on several services
+ * not yet available in this project (ProviderConnectionService, OpenCodeRuntime,
+ * codex-runtime-installer). This module provides the core interface and
+ * environment building, falling back gracefully when those services are absent.
+ */
+
+import { buildEnrichedEnv } from '@main/utils/cliEnv';
+
+export interface ProviderAwareCliEnvOptions {
+  binaryPath?: string | null;
+  providerId?: string;
+  providerBackendId?: string | null;
+  shellEnv?: NodeJS.ProcessEnv | null;
+  env?: NodeJS.ProcessEnv;
+  connectionMode?: 'strict' | 'augment';
+  allowStoredApiKeyDecryption?: boolean;
+  allowedStoredApiKeyEnvVarNames?: readonly string[];
+  projectPath?: string;
+}
+
+export interface ProviderAwareCliEnvResult {
+  env: NodeJS.ProcessEnv;
+  connectionIssues: Record<string, string>;
+  providerArgs: string[];
+}
+
+export async function buildProviderAwareCliEnv(
+  options: ProviderAwareCliEnvOptions = {}
+): Promise<ProviderAwareCliEnvResult> {
+  const env = buildEnrichedEnv(options.binaryPath);
+
+  // Remove ELECTRON_RUN_AS_NODE to prevent child processes from thinking
+  // they are running in Node.js mode instead of Electron mode.
+  delete env.ELECTRON_RUN_AS_NODE;
+
+  // Inject project-level env vars (from CredentialService) when a projectPath is provided
+  if (options.projectPath) {
+    try {
+      const { CredentialService } =
+        await import('@main/services/extensions/credentials/CredentialService');
+      const credentials = new CredentialService();
+      const projectEnv = await credentials.resolveAgentEnv(options.projectPath);
+      Object.assign(env, projectEnv);
+    } catch {
+      // Non-critical — CLI will use system env as fallback
+    }
+  }
+
+  return {
+    env,
+    connectionIssues: {},
+    providerArgs: [],
+  };
+}

package/src/main/services/session-intelligence/UsageTelemetryService.ts

@@ -17,6 +17,7 @@ const KEY_WORK_SECONDS = (slug: string) => `hermit:usage:${slug}:workSeconds`;
 const KEY_PROJECTS = (slug: string) => `hermit:usage:${slug}:projects`;
 
 let scanInterval: ReturnType<typeof setInterval> | null = null;
+let lastLocalScan: TelemetryStatusResult | null = null;
 
 function redisConfig(cfg: TaskBusConfig) {
   return {
@@ -103,12 +104,19 @@ async function uploadMetrics(client: Redis, slug: string, result: ParseResult):
 async function doScan(cfg: TaskBusConfig): Promise<ParseResult | null> {
   if (!cfg.telemetry?.enabled) return null;
 
+  const result = await scanSessions();
+  lastLocalScan = statusFromParseResult(result, false);
+
+  if (!cfg.telemetry.uploadEnabled) {
+    return result;
+  }
+
   const client = await getRedis(cfg);
-  if (!client) return null;
+  if (!client) return result;
 
   try {
-    const result = await scanSessions();
     await uploadMetrics(client, 'global', result);
+    lastLocalScan = statusFromParseResult(result, true);
     return result;
   } finally {
     try {
@@ -171,15 +179,35 @@ interface TelemetryStatusResult {
   workSecondsByDay: Record<string, number>;
 }
 
+function statusFromParseResult(result: ParseResult, connected: boolean): TelemetryStatusResult {
+  const { aggregate } = result;
+  return {
+    connected,
+    lastScan: new Date().toISOString(),
+    sessions: aggregate.sessions,
+    messages: aggregate.messages,
+    tokensIn: aggregate.tokens.input,
+    tokensOut: aggregate.tokens.output,
+    cacheRead: aggregate.tokens.cacheRead,
+    cacheCreation: aggregate.tokens.cacheCreation,
+    activeDays: aggregate.activeDays,
+    hourly: aggregate.hourly,
+    projects: aggregate.projects,
+    workSecondsByDay: aggregate.workSecondsByDay,
+  };
+}
+
 export async function getTelemetryStatus(
-  redisCfg: TaskBusConfig['redis']
+  redisCfg?: TaskBusConfig['redis']
 ): Promise<TelemetryStatusResult | null> {
+  if (!redisCfg) return lastLocalScan;
+
   let Redis: typeof import('ioredis').default;
   try {
     const mod = await import('ioredis');
     Redis = mod.default;
   } catch {
-    return null;
+    return lastLocalScan;
   }
 
   const cfg = { redis: redisCfg };
@@ -188,20 +216,7 @@ export async function getTelemetryStatus(
     await client.connect();
     await client.ping();
   } catch {
-    return {
-      connected: false,
-      lastScan: null,
-      sessions: 0,
-      messages: 0,
-      tokensIn: 0,
-      tokensOut: 0,
-      cacheRead: 0,
-      cacheCreation: 0,
-      activeDays: 0,
-      hourly: [],
-      projects: [],
-      workSecondsByDay: {},
-    };
+    return lastLocalScan;
   }
 
   try {