@yancyyu/openhermit 1.6.29 → 1.6.31

package/src/features/recent-projects/main/adapters/input/http/registerRecentProjectsHttp.ts

@@ -1,30 +0,0 @@
-import {
-  DASHBOARD_RECENT_PROJECTS_ROUTE,
-  type DashboardRecentProjectsPayload,
-  normalizeDashboardRecentProjectsPayload,
-} from '@features/recent-projects/contracts';
-import { createLogger } from '@shared/utils/logger';
-
-import type { RecentProjectsFeatureFacade } from '@features/recent-projects/main/composition/createRecentProjectsFeature';
-import type { FastifyInstance } from 'fastify';
-
-const logger = createLogger('Feature:RecentProjects:HTTP');
-
-export function registerRecentProjectsHttp(
-  app: FastifyInstance,
-  feature: RecentProjectsFeatureFacade
-): void {
-  app.get(DASHBOARD_RECENT_PROJECTS_ROUTE, async (): Promise<DashboardRecentProjectsPayload> => {
-    try {
-      return (
-        normalizeDashboardRecentProjectsPayload(await feature.listDashboardRecentProjects()) ?? {
-          projects: [],
-          degraded: true,
-        }
-      );
-    } catch (error) {
-      logger.error('Failed to load dashboard recent projects via HTTP', error);
-      return { projects: [], degraded: true };
-    }
-  });
-}

package/src/features/recent-projects/main/adapters/output/presenters/DashboardRecentProjectsPresenter.ts

@@ -1,27 +0,0 @@
-import type {
-  DashboardRecentProject,
-  DashboardRecentProjectsPayload,
-} from '@features/recent-projects/contracts';
-import type { ListDashboardRecentProjectsResponse } from '@features/recent-projects/core/application/models/ListDashboardRecentProjectsResponse';
-import type { ListDashboardRecentProjectsOutputPort } from '@features/recent-projects/core/application/ports/ListDashboardRecentProjectsOutputPort';
-
-export class DashboardRecentProjectsPresenter implements ListDashboardRecentProjectsOutputPort<DashboardRecentProjectsPayload> {
-  present(response: ListDashboardRecentProjectsResponse): DashboardRecentProjectsPayload {
-    return {
-      degraded: response.degraded,
-      projects: response.projects.map(
-        (aggregate): DashboardRecentProject => ({
-          id: aggregate.identity,
-          name: aggregate.displayName,
-          primaryPath: aggregate.primaryPath,
-          associatedPaths: aggregate.associatedPaths,
-          mostRecentActivity: aggregate.lastActivityAt,
-          providerIds: aggregate.providerIds,
-          source: aggregate.source,
-          openTarget: aggregate.openTarget,
-          primaryBranch: aggregate.branchName,
-        })
-      ),
-    };
-  }
-}

package/src/features/recent-projects/main/adapters/output/sources/ClaudeRecentProjectsSourceAdapter.ts

@@ -1,91 +0,0 @@
-import { normalizeIdentityPath } from '@features/recent-projects/main/infrastructure/identity/normalizeIdentityPath';
-import { WorktreeGrouper } from '@main/services/discovery/WorktreeGrouper';
-import { getProjectsBasePath } from '@main/utils/pathDecoder';
-import { isEphemeralProjectPath } from '@shared/utils/ephemeralProjectPath';
-
-import type { LoggerPort } from '@features/recent-projects/core/application/ports/LoggerPort';
-import type {
-  RecentProjectsSourcePort,
-  RecentProjectsSourceResult,
-} from '@features/recent-projects/core/application/ports/RecentProjectsSourcePort';
-import type { RecentProjectCandidate } from '@features/recent-projects/core/domain/models/RecentProjectCandidate';
-import type { ServiceContext } from '@main/services';
-import type { RepositoryGroup, Worktree } from '@main/types';
-
-function selectPreferredWorktree(worktrees: readonly Worktree[]): Worktree | undefined {
-  return worktrees.find((worktree) => worktree.isMainWorktree) ?? worktrees[0];
-}
-
-function toCandidate(repo: RepositoryGroup): RecentProjectCandidate | null {
-  const selectableWorktrees = repo.worktrees.filter(
-    (worktree) => !isEphemeralProjectPath(worktree.path)
-  );
-
-  if (!selectableWorktrees.length || !repo.mostRecentSession) {
-    return null;
-  }
-
-  const preferredWorktree = selectPreferredWorktree(selectableWorktrees);
-  if (!preferredWorktree) {
-    return null;
-  }
-
-  return {
-    identity: repo.identity?.id ?? `path:${normalizeIdentityPath(preferredWorktree.path)}`,
-    displayName: repo.name,
-    primaryPath: preferredWorktree.path,
-    associatedPaths: selectableWorktrees.map((worktree) => worktree.path),
-    lastActivityAt: repo.mostRecentSession,
-    providerIds: ['anthropic'],
-    sourceKind: 'claude',
-    openTarget: {
-      type: 'existing-worktree',
-      repositoryId: repo.id,
-      worktreeId: preferredWorktree.id,
-    },
-    branchName: preferredWorktree.gitBranch,
-  };
-}
-
-export class ClaudeRecentProjectsSourceAdapter implements RecentProjectsSourcePort {
-  readonly #localWorktreeGrouper = new WorktreeGrouper(getProjectsBasePath());
-
-  constructor(
-    private readonly getActiveContext: () => ServiceContext,
-    private readonly logger: LoggerPort
-  ) {}
-
-  async list(): Promise<RecentProjectsSourceResult> {
-    const activeContext = this.getActiveContext();
-    const groups =
-      activeContext.type === 'local'
-        ? await this.#groupLocalProjects(activeContext)
-        : await activeContext.projectScanner.scanWithWorktreeGrouping();
-
-    const candidates = groups
-      .map((group) => toCandidate(group))
-      .filter((candidate): candidate is RecentProjectCandidate => candidate !== null);
-
-    this.logger.info('claude recent-projects source loaded', {
-      count: candidates.length,
-      contextId: activeContext.id,
-    });
-
-    return {
-      candidates,
-      degraded: false,
-    };
-  }
-
-  async #groupLocalProjects(activeContext: ServiceContext): Promise<RepositoryGroup[]> {
-    try {
-      const projects = await activeContext.projectScanner.scan();
-      return await this.#localWorktreeGrouper.groupByRepository(projects);
-    } catch (error) {
-      this.logger.warn('claude recent-projects fell back to simplified grouping', {
-        error: error instanceof Error ? error.message : String(error),
-      });
-      return activeContext.projectScanner.scanWithWorktreeGrouping();
-    }
-  }
-}

package/src/features/recent-projects/main/adapters/output/sources/CodexRecentProjectsSourceAdapter.ts

@@ -1,326 +0,0 @@
-import { normalizeIdentityPath } from '@features/recent-projects/main/infrastructure/identity/normalizeIdentityPath';
-import { isEphemeralProjectPath } from '@shared/utils/ephemeralProjectPath';
-import path from 'path';
-
-import type { LoggerPort } from '@features/recent-projects/core/application/ports/LoggerPort';
-import type {
-  RecentProjectsSourcePort,
-  RecentProjectsSourceResult,
-} from '@features/recent-projects/core/application/ports/RecentProjectsSourcePort';
-import type { RecentProjectCandidate } from '@features/recent-projects/core/domain/models/RecentProjectCandidate';
-import type {
-  CodexAppServerClient,
-  CodexRecentThreadsResult,
-  CodexThreadSummary,
-} from '@features/recent-projects/main/infrastructure/codex/CodexAppServerClient';
-import type { RecentProjectIdentityResolver } from '@features/recent-projects/main/infrastructure/identity/RecentProjectIdentityResolver';
-import type { ServiceContext } from '@main/services';
-
-const CODEX_THREAD_LIMIT = 20;
-const CODEX_INITIALIZE_TIMEOUT_MS = 6_000;
-const CODEX_LIVE_FETCH_TIMEOUT_MS = 18_000;
-const CODEX_ARCHIVED_FETCH_TIMEOUT_MS = 6_000;
-const CODEX_SESSION_OVERHEAD_TIMEOUT_MS = 1_500;
-const CODEX_TOTAL_FETCH_TIMEOUT_MS =
-  CODEX_INITIALIZE_TIMEOUT_MS +
-  CODEX_ARCHIVED_FETCH_TIMEOUT_MS +
-  CODEX_LIVE_FETCH_TIMEOUT_MS +
-  CODEX_SESSION_OVERHEAD_TIMEOUT_MS;
-const CODEX_SOURCE_TIMEOUT_MS = CODEX_TOTAL_FETCH_TIMEOUT_MS + 500;
-const CODEX_LIVE_ONLY_FALLBACK_TOTAL_TIMEOUT_MS =
-  CODEX_INITIALIZE_TIMEOUT_MS + CODEX_LIVE_FETCH_TIMEOUT_MS + CODEX_SESSION_OVERHEAD_TIMEOUT_MS;
-const CODEX_STALE_CANDIDATES_TTL_MS = 5 * 60_000;
-const CODEX_FULL_FAILURE_COOLDOWN_MS = 30_000;
-
-interface StaleCodexCandidatesSnapshot {
-  candidates: RecentProjectCandidate[];
-  capturedAt: number;
-}
-
-function isInteractiveSource(source: unknown): boolean {
-  return source === 'vscode' || source === 'cli';
-}
-
-function normalizeTimestamp(value: number | undefined): number {
-  if (!value) {
-    return 0;
-  }
-  return value < 1_000_000_000_000 ? value * 1000 : value;
-}
-
-function isDegradedThreadResult(result: CodexRecentThreadsResult): boolean {
-  return Boolean(result.live.error || result.archived.error);
-}
-
-function getFullFailureReason(result: CodexRecentThreadsResult): string | null {
-  if (!result.live.error || !result.archived.error) {
-    return null;
-  }
-
-  if (result.live.error === result.archived.error) {
-    return result.live.error;
-  }
-
-  if (result.archived.skipped) {
-    return result.live.error;
-  }
-
-  return `live: ${result.live.error}; archived: ${result.archived.error}`;
-}
-
-export class CodexRecentProjectsSourceAdapter implements RecentProjectsSourcePort {
-  readonly sourceId = 'codex';
-  readonly timeoutMs = CODEX_SOURCE_TIMEOUT_MS;
-  #staleCandidatesSnapshot: StaleCodexCandidatesSnapshot | null = null;
-  #fullFailureCooldownUntil = 0;
-  #fullFailureCooldownReason: string | null = null;
-
-  constructor(
-    private readonly deps: {
-      getActiveContext: () => ServiceContext;
-      getLocalContext: () => ServiceContext | undefined;
-      resolveBinary: () => Promise<string | null>;
-      appServerClient: CodexAppServerClient;
-      identityResolver: RecentProjectIdentityResolver;
-      logger: LoggerPort;
-    }
-  ) {}
-
-  async list(): Promise<RecentProjectsSourceResult> {
-    const activeContext = this.deps.getActiveContext();
-    const localContext = this.deps.getLocalContext();
-
-    if (activeContext.type !== 'local' || activeContext.id !== localContext?.id) {
-      return {
-        candidates: [],
-        degraded: false,
-      };
-    }
-
-    const binaryPath = await this.deps.resolveBinary();
-    if (!binaryPath) {
-      this.deps.logger.info('codex recent-projects source skipped - binary unavailable');
-      return {
-        candidates: [],
-        degraded: false,
-      };
-    }
-
-    const cooldown = this.#getActiveCooldown();
-    if (cooldown) {
-      this.deps.logger.info('codex recent-projects source cooldown active', cooldown);
-      return {
-        candidates: this.#getFreshStaleCandidates() ?? [],
-        degraded: true,
-      };
-    }
-
-    const threadSegments = await this.#listRecentThreadsSafe(binaryPath);
-    const degraded = isDegradedThreadResult(threadSegments);
-    const fullFailureReason = getFullFailureReason(threadSegments);
-    this.#updateFullFailureCooldown(fullFailureReason);
-    this.#logSegmentFailure(threadSegments, 'live');
-    this.#logSegmentFailure(threadSegments, 'archived');
-    const liveThreads = threadSegments.live.threads;
-    const archivedThreads = threadSegments.archived.threads;
-
-    const interactiveThreads = [...liveThreads, ...archivedThreads].filter(
-      (thread) => Boolean(thread.cwd) && isInteractiveSource(thread.source)
-    );
-
-    const candidates = (
-      await Promise.all(interactiveThreads.map((thread) => this.#toCandidate(thread)))
-    ).filter((candidate): candidate is RecentProjectCandidate => candidate !== null);
-
-    if (!degraded) {
-      this.#rememberHealthyCandidates(candidates);
-    }
-
-    if (degraded && candidates.length === 0) {
-      const staleCandidates = this.#getFreshStaleCandidates();
-      if (staleCandidates) {
-        this.deps.logger.info('codex recent-projects served stale candidates', {
-          count: staleCandidates.length,
-          reason: fullFailureReason ?? 'degraded-empty-result',
-        });
-
-        return {
-          candidates: staleCandidates,
-          degraded: true,
-        };
-      }
-    }
-
-    this.deps.logger.info('codex recent-projects source loaded', {
-      count: candidates.length,
-      degraded,
-    });
-
-    return {
-      candidates,
-      degraded,
-    };
-  }
-
-  #getActiveCooldown(): { retryAfterMs: number; reason: string | null } | null {
-    const retryAfterMs = this.#fullFailureCooldownUntil - Date.now();
-    if (retryAfterMs <= 0) {
-      return null;
-    }
-
-    return {
-      retryAfterMs,
-      reason: this.#fullFailureCooldownReason,
-    };
-  }
-
-  #updateFullFailureCooldown(reason: string | null): void {
-    if (!reason) {
-      this.#fullFailureCooldownUntil = 0;
-      this.#fullFailureCooldownReason = null;
-      return;
-    }
-
-    this.#fullFailureCooldownUntil = Date.now() + CODEX_FULL_FAILURE_COOLDOWN_MS;
-    this.#fullFailureCooldownReason = reason;
-  }
-
-  #rememberHealthyCandidates(candidates: RecentProjectCandidate[]): void {
-    this.#staleCandidatesSnapshot =
-      candidates.length > 0
-        ? {
-            candidates,
-            capturedAt: Date.now(),
-          }
-        : null;
-  }
-
-  #getFreshStaleCandidates(): RecentProjectCandidate[] | null {
-    const snapshot = this.#staleCandidatesSnapshot;
-    if (!snapshot) {
-      return null;
-    }
-
-    if (Date.now() - snapshot.capturedAt > CODEX_STALE_CANDIDATES_TTL_MS) {
-      this.#staleCandidatesSnapshot = null;
-      return null;
-    }
-
-    return [...snapshot.candidates];
-  }
-
-  async #listRecentThreads(binaryPath: string): Promise<CodexRecentThreadsResult> {
-    const result = await this.deps.appServerClient.listRecentThreads(binaryPath, {
-      limit: CODEX_THREAD_LIMIT,
-      liveRequestTimeoutMs: CODEX_LIVE_FETCH_TIMEOUT_MS,
-      archivedRequestTimeoutMs: CODEX_ARCHIVED_FETCH_TIMEOUT_MS,
-      initializeTimeoutMs: CODEX_INITIALIZE_TIMEOUT_MS,
-      totalTimeoutMs: CODEX_TOTAL_FETCH_TIMEOUT_MS,
-    });
-
-    this.deps.logger.info('codex recent-projects thread lists loaded', {
-      liveCount: result.live.threads.length,
-      archivedCount: result.archived.threads.length,
-    });
-    return result;
-  }
-
-  #logSegmentFailure(result: CodexRecentThreadsResult, segment: 'live' | 'archived'): void {
-    const error = result[segment].error;
-    if (!error) {
-      return;
-    }
-
-    if (result[segment].skipped) {
-      this.deps.logger.info('codex recent-projects thread list skipped', {
-        segment,
-        reason: error,
-      });
-      return;
-    }
-
-    if (segment === 'archived' && !result.live.error) {
-      this.deps.logger.info('codex recent-projects archived thread list degraded', {
-        error,
-      });
-      return;
-    }
-
-    this.deps.logger.warn('codex recent-projects thread list failed', {
-      segment,
-      error,
-    });
-  }
-
-  async #listRecentThreadsSafe(binaryPath: string): Promise<CodexRecentThreadsResult> {
-    try {
-      return await this.#listRecentThreads(binaryPath);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      this.deps.logger.warn('codex recent-projects thread list session failed', {
-        error: message,
-      });
-
-      if (message.toLowerCase().includes('timed out')) {
-        return {
-          live: { threads: [], error: message },
-          archived: { threads: [], error: message },
-        };
-      }
-
-      try {
-        const liveFallback = await this.deps.appServerClient.listRecentLiveThreads(binaryPath, {
-          limit: CODEX_THREAD_LIMIT,
-          requestTimeoutMs: CODEX_LIVE_FETCH_TIMEOUT_MS,
-          initializeTimeoutMs: CODEX_INITIALIZE_TIMEOUT_MS,
-          totalTimeoutMs: CODEX_LIVE_ONLY_FALLBACK_TOTAL_TIMEOUT_MS,
-        });
-
-        this.deps.logger.info('codex recent-projects recovered with live-only fallback', {
-          liveCount: liveFallback.threads.length,
-        });
-
-        return {
-          live: liveFallback,
-          archived: { threads: [], error: message },
-        };
-      } catch (fallbackError) {
-        const fallbackMessage =
-          fallbackError instanceof Error ? fallbackError.message : String(fallbackError);
-        this.deps.logger.warn('codex recent-projects live-only fallback failed', {
-          error: fallbackMessage,
-        });
-      }
-
-      return {
-        live: { threads: [], error: message },
-        archived: { threads: [], error: message },
-      };
-    }
-  }
-
-  async #toCandidate(thread: CodexThreadSummary): Promise<RecentProjectCandidate | null> {
-    const cwd = thread.cwd?.trim();
-    if (!cwd || isEphemeralProjectPath(cwd)) {
-      return null;
-    }
-
-    const identity = await this.deps.identityResolver.resolve(cwd);
-    const displayName = identity?.name ?? path.basename(cwd) ?? thread.name?.trim() ?? cwd;
-
-    return {
-      identity: identity?.id ?? `path:${normalizeIdentityPath(cwd)}`,
-      displayName,
-      primaryPath: cwd,
-      associatedPaths: [cwd],
-      lastActivityAt: normalizeTimestamp(thread.updatedAt ?? thread.createdAt),
-      providerIds: ['codex'],
-      sourceKind: 'codex',
-      openTarget: {
-        type: 'synthetic-path',
-        path: cwd,
-      },
-      branchName: thread.gitInfo?.branch ?? undefined,
-    };
-  }
-}

package/src/features/recent-projects/main/composition/createRecentProjectsFeature.ts

@@ -1,43 +0,0 @@
-import {
-  type DashboardRecentProjectsPayload,
-  normalizeDashboardRecentProjectsPayload,
-} from '@features/recent-projects/contracts';
-
-import { ListDashboardRecentProjectsUseCase } from '../../core/application/use-cases/ListDashboardRecentProjectsUseCase';
-import { DashboardRecentProjectsPresenter } from '../adapters/output/presenters/DashboardRecentProjectsPresenter';
-import { ClaudeRecentProjectsSourceAdapter } from '../adapters/output/sources/ClaudeRecentProjectsSourceAdapter';
-import { InMemoryRecentProjectsCache } from '../infrastructure/cache/InMemoryRecentProjectsCache';
-
-import type { ClockPort } from '../../core/application/ports/ClockPort';
-import type { LoggerPort } from '../../core/application/ports/LoggerPort';
-import type { ServiceContext } from '@main/services';
-
-export interface RecentProjectsFeatureFacade {
-  listDashboardRecentProjects(): Promise<DashboardRecentProjectsPayload>;
-}
-
-export function createRecentProjectsFeature(deps: {
-  getActiveContext: () => ServiceContext;
-  getLocalContext: () => ServiceContext | undefined;
-  logger: LoggerPort;
-}): RecentProjectsFeatureFacade {
-  const cache = new InMemoryRecentProjectsCache<DashboardRecentProjectsPayload>();
-  const presenter = new DashboardRecentProjectsPresenter();
-  const clock: ClockPort = { now: () => Date.now() };
-  const sources = [new ClaudeRecentProjectsSourceAdapter(deps.getActiveContext, deps.logger)];
-  const useCase = new ListDashboardRecentProjectsUseCase({
-    sources,
-    cache,
-    output: presenter,
-    clock,
-    logger: deps.logger,
-  });
-
-  return {
-    listDashboardRecentProjects: async () => {
-      const activeContext = deps.getActiveContext();
-      const payload = await useCase.execute(`dashboard-recent-projects:${activeContext.id}`);
-      return normalizeDashboardRecentProjectsPayload(payload) ?? { projects: [], degraded: true };
-    },
-  };
-}

package/src/features/recent-projects/main/index.ts

@@ -1,3 +0,0 @@
-export { registerRecentProjectsHttp } from './adapters/input/http/registerRecentProjectsHttp';
-export type { RecentProjectsFeatureFacade } from './composition/createRecentProjectsFeature';
-export { createRecentProjectsFeature } from './composition/createRecentProjectsFeature';

package/src/features/recent-projects/main/infrastructure/cache/InMemoryRecentProjectsCache.ts

@@ -1,34 +0,0 @@
-import type { RecentProjectsCachePort } from '../../../core/application/ports/RecentProjectsCachePort';
-
-interface CacheEntry<T> {
-  value: T;
-  expiresAt: number;
-}
-
-export class InMemoryRecentProjectsCache<T> implements RecentProjectsCachePort<T> {
-  readonly #entries = new Map<string, CacheEntry<T>>();
-
-  async get(key: string): Promise<T | null> {
-    const entry = this.#entries.get(key);
-    if (!entry) {
-      return null;
-    }
-
-    if (entry.expiresAt <= Date.now()) {
-      return null;
-    }
-
-    return entry.value;
-  }
-
-  async getStale(key: string): Promise<T | null> {
-    return this.#entries.get(key)?.value ?? null;
-  }
-
-  async set(key: string, value: T, ttlMs: number): Promise<void> {
-    this.#entries.set(key, {
-      value,
-      expiresAt: Date.now() + ttlMs,
-    });
-  }
-}

package/src/features/recent-projects/main/infrastructure/codex/CodexAppServerClient.ts

@@ -1,116 +0,0 @@
-// ---------------------------------------------------------------------------
-// Inline type stubs for deleted codexAppServer module
-// ---------------------------------------------------------------------------
-
-/** Minimal stub for the deleted JsonRpcSession interface */
-interface JsonRpcSession {
-  request<T>(method: string, params?: unknown, timeoutMs?: number): Promise<T>;
-  notify(method: string, params?: unknown): Promise<void>;
-}
-
-/** Minimal stub for the deleted JsonRpcStdioClient interface */
-interface JsonRpcStdioClient {
-  withSession<T>(
-    options: {
-      binaryPath: string;
-      args: string[];
-      requestTimeoutMs: number;
-      totalTimeoutMs: number;
-      label: string;
-    },
-    handler: (session: JsonRpcSession) => Promise<T>
-  ): Promise<T>;
-}
-
-const DEFAULT_REQUEST_TIMEOUT_MS = 3_000;
-const DEFAULT_TOTAL_TIMEOUT_MS = 8_000;
-const DEFAULT_INITIALIZE_TIMEOUT_MS = 6_000;
-const MIN_SESSION_OVERHEAD_TIMEOUT_MS = 1_500;
-const SUPPRESSED_NOTIFICATION_METHODS = [
-  'thread/started',
-  'thread/status/changed',
-  'thread/archived',
-  'thread/unarchived',
-  'thread/closed',
-  'thread/name/updated',
-  'turn/started',
-  'turn/completed',
-  'item/agentMessage/delta',
-  'item/agentReasoning/delta',
-  'item/execCommandOutputDelta',
-];
-
-interface ThreadListResponse {
-  data?: CodexThreadSummary[];
-}
-
-interface CodexGitInfo {
-  branch?: string | null;
-  originUrl?: string | null;
-  sha?: string | null;
-}
-
-export interface CodexThreadSummary {
-  id: string;
-  createdAt?: number;
-  updatedAt?: number;
-  cwd?: string | null;
-  source?: unknown;
-  modelProvider?: string | null;
-  gitInfo?: CodexGitInfo | null;
-  name?: string | null;
-  path?: string | null;
-}
-
-export interface CodexThreadSegmentResult {
-  threads: CodexThreadSummary[];
-  error?: string;
-  skipped?: boolean;
-}
-
-export interface CodexRecentThreadsResult {
-  live: CodexThreadSegmentResult;
-  archived: CodexThreadSegmentResult;
-}
-
-interface ThreadListSessionOptions {
-  binaryPath: string;
-  requestTimeoutMs: number;
-  initializeTimeoutMs: number;
-  totalTimeoutMs: number;
-  label: string;
-}
-
-export class CodexAppServerClient {
-  constructor(private readonly rpcClient: JsonRpcStdioClient) {}
-
-  async listRecentLiveThreads(
-    _binaryPath: string,
-    _options: {
-      limit: number;
-      requestTimeoutMs?: number;
-      initializeTimeoutMs?: number;
-      totalTimeoutMs?: number;
-    }
-  ): Promise<CodexThreadSegmentResult> {
-    // Codex app server module has been removed — return empty results
-    return { threads: [] };
-  }
-
-  async listRecentThreads(
-    _binaryPath: string,
-    _options: {
-      limit: number;
-      liveRequestTimeoutMs?: number;
-      archivedRequestTimeoutMs?: number;
-      initializeTimeoutMs?: number;
-      totalTimeoutMs?: number;
-    }
-  ): Promise<CodexRecentThreadsResult> {
-    // Codex app server module has been removed — return empty results
-    return {
-      live: { threads: [] },
-      archived: { threads: [] },
-    };
-  }
-}

package/src/features/recent-projects/main/infrastructure/identity/RecentProjectIdentityResolver.ts

@@ -1,20 +0,0 @@
-import { gitIdentityResolver } from '@main/services/parsing/GitIdentityResolver';
-
-export interface RecentProjectIdentity {
-  id: string;
-  name?: string;
-}
-
-export class RecentProjectIdentityResolver {
-  async resolve(projectPath: string): Promise<RecentProjectIdentity | null> {
-    const identity = await gitIdentityResolver.resolveIdentity(projectPath);
-    if (!identity) {
-      return null;
-    }
-
-    return {
-      id: identity.id,
-      name: identity.name,
-    };
-  }
-}