@cuongtran001/kanna 0.39.2

package/src/server/discovery.test.ts

@@ -0,0 +1,211 @@
+import { afterEach, describe, expect, test } from "bun:test"
+import { mkdtempSync, mkdirSync, rmSync, utimesSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import path from "node:path"
+import {
+  ClaudeProjectDiscoveryAdapter,
+  CodexProjectDiscoveryAdapter,
+  discoverProjects,
+  type ProjectDiscoveryAdapter,
+} from "./discovery"
+
+const tempDirs: string[] = []
+
+function makeTempDir() {
+  const directory = mkdtempSync(path.join(tmpdir(), "kanna-discovery-"))
+  tempDirs.push(directory)
+  return directory
+}
+
+function encodeClaudeProjectPath(localPath: string) {
+  return `-${localPath.replace(/\//g, "-")}`
+}
+
+afterEach(() => {
+  for (const directory of tempDirs.splice(0)) {
+    rmSync(directory, { recursive: true, force: true })
+  }
+})
+
+describe("project discovery", () => {
+  test("Claude adapter decodes saved project paths", () => {
+    const homeDir = makeTempDir()
+    const projectDir = path.join(homeDir, "workspace", "alpha-project")
+    const claudeProjectsDir = path.join(homeDir, ".claude", "projects")
+    const projectMarkerDir = path.join(claudeProjectsDir, encodeClaudeProjectPath(projectDir))
+
+    mkdirSync(projectDir, { recursive: true })
+    mkdirSync(projectMarkerDir, { recursive: true })
+    utimesSync(projectMarkerDir, new Date("2026-03-16T10:00:00.000Z"), new Date("2026-03-16T10:00:00.000Z"))
+
+    const projects = new ClaudeProjectDiscoveryAdapter().scan(homeDir)
+
+    expect(projects).toEqual([
+      {
+        provider: "claude",
+        localPath: projectDir,
+        title: "alpha-project",
+        modifiedAt: new Date("2026-03-16T10:00:00.000Z").getTime(),
+      },
+    ])
+  })
+
+  test("Codex adapter reads cwd from session metadata and ignores stale or invalid entries", () => {
+    const homeDir = makeTempDir()
+    const sessionsDir = path.join(homeDir, ".codex", "sessions", "2026", "03", "16")
+    const liveProjectDir = path.join(homeDir, "workspace", "kanna")
+    const missingProjectDir = path.join(homeDir, "workspace", "missing-project")
+    mkdirSync(liveProjectDir, { recursive: true })
+    mkdirSync(sessionsDir, { recursive: true })
+
+    writeFileSync(path.join(homeDir, ".codex", "session_index.jsonl"), [
+      JSON.stringify({
+        id: "session-live",
+        updated_at: "2026-03-16T23:05:58.940134Z",
+      }),
+      JSON.stringify({
+        id: "session-missing",
+        updated_at: "2026-03-16T20:05:58.940134Z",
+      }),
+      JSON.stringify({
+        id: "session-relative",
+        updated_at: "2026-03-16T21:05:58.940134Z",
+      }),
+    ].join("\n"))
+
+    writeFileSync(path.join(sessionsDir, "rollout-2026-03-16T23-05-52-session-live.jsonl"), [
+      JSON.stringify({
+        timestamp: "2026-03-16T23:05:52.000Z",
+        type: "session_meta",
+        payload: {
+          id: "session-live",
+          cwd: liveProjectDir,
+        },
+      }),
+    ].join("\n"))
+
+    writeFileSync(path.join(sessionsDir, "rollout-2026-03-16T20-05-52-session-missing.jsonl"), [
+      JSON.stringify({
+        timestamp: "2026-03-16T20:05:52.000Z",
+        type: "session_meta",
+        payload: {
+          id: "session-missing",
+          cwd: missingProjectDir,
+        },
+      }),
+    ].join("\n"))
+
+    writeFileSync(path.join(sessionsDir, "rollout-2026-03-16T21-05-52-session-relative.jsonl"), [
+      JSON.stringify({
+        timestamp: "2026-03-16T21:05:52.000Z",
+        type: "session_meta",
+        payload: {
+          id: "session-relative",
+          cwd: "./relative-path",
+        },
+      }),
+    ].join("\n"))
+
+    const projects = new CodexProjectDiscoveryAdapter().scan(homeDir)
+
+    expect(projects).toEqual([
+      {
+        provider: "codex",
+        localPath: liveProjectDir,
+        title: "kanna",
+        modifiedAt: Date.parse("2026-03-16T23:05:58.940134Z"),
+      },
+    ])
+  })
+
+  test("Codex adapter falls back to session timestamps and config projects when session index misses CLI entries", () => {
+    const homeDir = makeTempDir()
+    const sessionsDir = path.join(homeDir, ".codex", "sessions", "2026", "03", "16")
+    const cliProjectDir = path.join(homeDir, "workspace", "codex-test-2")
+    const configOnlyProjectDir = path.join(homeDir, "workspace", "config-only")
+    mkdirSync(cliProjectDir, { recursive: true })
+    mkdirSync(configOnlyProjectDir, { recursive: true })
+    mkdirSync(sessionsDir, { recursive: true })
+
+    writeFileSync(path.join(homeDir, ".codex", "session_index.jsonl"), "")
+    writeFileSync(path.join(homeDir, ".codex", "config.toml"), [
+      `personality = "pragmatic"`,
+      `[projects."${configOnlyProjectDir}"]`,
+      `trust_level = "trusted"`,
+    ].join("\n"))
+
+    writeFileSync(path.join(sessionsDir, "rollout-2026-03-16T23-42-24-cli-session.jsonl"), [
+      JSON.stringify({
+        timestamp: "2026-03-17T03:42:25.751Z",
+        type: "session_meta",
+        payload: {
+          id: "cli-session",
+          timestamp: "2026-03-17T03:42:24.578Z",
+          cwd: cliProjectDir,
+          originator: "codex-tui",
+          source: "cli",
+        },
+      }),
+    ].join("\n"))
+
+    const projects = new CodexProjectDiscoveryAdapter().scan(homeDir)
+
+    expect(projects.map((project) => project.localPath).sort()).toEqual([
+      cliProjectDir,
+      configOnlyProjectDir,
+    ].sort())
+    expect(projects.find((project) => project.localPath === cliProjectDir)?.modifiedAt).toBe(
+      Date.parse("2026-03-17T03:42:25.751Z")
+    )
+  })
+
+  test("discoverProjects de-dupes provider results by normalized path and keeps the newest timestamp", () => {
+    const adapters: ProjectDiscoveryAdapter[] = [
+      {
+        provider: "claude",
+        scan() {
+          return [
+            {
+              provider: "claude",
+              localPath: "/tmp/project",
+              title: "Claude Project",
+              modifiedAt: 10,
+            },
+          ]
+        },
+      },
+      {
+        provider: "codex",
+        scan() {
+          return [
+            {
+              provider: "codex",
+              localPath: "/tmp/project",
+              title: "Codex Project",
+              modifiedAt: 20,
+            },
+            {
+              provider: "codex",
+              localPath: "/tmp/other-project",
+              title: "Other Project",
+              modifiedAt: 15,
+            },
+          ]
+        },
+      },
+    ]
+
+    expect(discoverProjects("/unused-home", adapters)).toEqual([
+      {
+        localPath: "/tmp/project",
+        title: "Codex Project",
+        modifiedAt: 20,
+      },
+      {
+        localPath: "/tmp/other-project",
+        title: "Other Project",
+        modifiedAt: 15,
+      },
+    ])
+  })
+})

package/src/server/discovery.ts

@@ -0,0 +1,301 @@
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs"
+import { homedir } from "node:os"
+import path from "node:path"
+import type { AgentProvider } from "../shared/types"
+import { resolveLocalPath } from "./paths"
+
+export interface DiscoveredProject {
+  localPath: string
+  title: string
+  modifiedAt: number
+}
+
+export interface ProviderDiscoveredProject extends DiscoveredProject {
+  provider: AgentProvider
+}
+
+export interface ProjectDiscoveryAdapter {
+  provider: AgentProvider
+  scan(homeDir?: string): ProviderDiscoveredProject[]
+}
+
+function resolveEncodedClaudePath(folderName: string) {
+  const segments = folderName.replace(/^-/, "").split("-").filter(Boolean)
+  let currentPath = ""
+  let remainingSegments = [...segments]
+
+  while (remainingSegments.length > 0) {
+    let found = false
+
+    for (let index = remainingSegments.length; index >= 1; index -= 1) {
+      const segment = remainingSegments.slice(0, index).join("-")
+      const candidate = `${currentPath}/${segment}`
+
+      if (existsSync(candidate)) {
+        currentPath = candidate
+        remainingSegments = remainingSegments.slice(index)
+        found = true
+        break
+      }
+    }
+
+    if (!found) {
+      const [head, ...tail] = remainingSegments
+      currentPath = `${currentPath}/${head}`
+      remainingSegments = tail
+    }
+  }
+
+  return currentPath || "/"
+}
+
+function normalizeExistingDirectory(localPath: string) {
+  try {
+    const normalized = resolveLocalPath(localPath)
+    if (!statSync(normalized).isDirectory()) {
+      return null
+    }
+    return normalized
+  } catch {
+    return null
+  }
+}
+
+function mergeDiscoveredProjects(projects: Iterable<DiscoveredProject>): DiscoveredProject[] {
+  const merged = new Map<string, DiscoveredProject>()
+
+  for (const project of projects) {
+    const existing = merged.get(project.localPath)
+    if (!existing || project.modifiedAt > existing.modifiedAt) {
+      merged.set(project.localPath, {
+        localPath: project.localPath,
+        title: project.title || path.basename(project.localPath) || project.localPath,
+        modifiedAt: project.modifiedAt,
+      })
+      continue
+    }
+
+    if (!existing.title && project.title) {
+      existing.title = project.title
+    }
+  }
+
+  return [...merged.values()].sort((a, b) => b.modifiedAt - a.modifiedAt)
+}
+
+export class ClaudeProjectDiscoveryAdapter implements ProjectDiscoveryAdapter {
+  readonly provider = "claude" as const
+
+  scan(homeDir: string = homedir()): ProviderDiscoveredProject[] {
+    const projectsDir = path.join(homeDir, ".claude", "projects")
+    if (!existsSync(projectsDir)) {
+      return []
+    }
+
+    const entries = readdirSync(projectsDir, { withFileTypes: true })
+    const projects: ProviderDiscoveredProject[] = []
+
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue
+
+      const resolvedPath = resolveEncodedClaudePath(entry.name)
+      const normalizedPath = normalizeExistingDirectory(resolvedPath)
+      if (!normalizedPath) {
+        continue
+      }
+
+      const stat = statSync(path.join(projectsDir, entry.name))
+      projects.push({
+        provider: this.provider,
+        localPath: normalizedPath,
+        title: path.basename(normalizedPath) || normalizedPath,
+        modifiedAt: stat.mtimeMs,
+      })
+    }
+
+    const mergedProjects = mergeDiscoveredProjects(projects).map((project) => ({
+      provider: this.provider,
+      ...project,
+    }))
+
+    return mergedProjects
+  }
+}
+
+function parseJsonRecord(line: string): Record<string, unknown> | null {
+  try {
+    const parsed = JSON.parse(line)
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return null
+    }
+    return parsed as Record<string, unknown>
+  } catch {
+    return null
+  }
+}
+
+function readCodexSessionIndex(indexPath: string) {
+  const updatedAtById = new Map<string, number>()
+  if (!existsSync(indexPath)) {
+    return updatedAtById
+  }
+
+  for (const line of readFileSync(indexPath, "utf8").split("\n")) {
+    if (!line.trim()) continue
+    const record = parseJsonRecord(line)
+    if (!record) continue
+
+    const id = typeof record.id === "string" ? record.id : null
+    const updatedAt = typeof record.updated_at === "string" ? Date.parse(record.updated_at) : Number.NaN
+    if (!id || Number.isNaN(updatedAt)) continue
+
+    const existing = updatedAtById.get(id)
+    if (existing === undefined || updatedAt > existing) {
+      updatedAtById.set(id, updatedAt)
+    }
+  }
+
+  return updatedAtById
+}
+
+function collectCodexSessionFiles(directory: string): string[] {
+  if (!existsSync(directory)) {
+    return []
+  }
+
+  const files: string[] = []
+  for (const entry of readdirSync(directory, { withFileTypes: true })) {
+    const fullPath = path.join(directory, entry.name)
+    if (entry.isDirectory()) {
+      files.push(...collectCodexSessionFiles(fullPath))
+      continue
+    }
+    if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+      files.push(fullPath)
+    }
+  }
+  return files
+}
+
+function readCodexConfiguredProjects(configPath: string) {
+  const projects = new Map<string, number>()
+  if (!existsSync(configPath)) {
+    return projects
+  }
+
+  const configMtime = statSync(configPath).mtimeMs
+  for (const line of readFileSync(configPath, "utf8").split("\n")) {
+    const match = line.match(/^\[projects\."(.+)"\]$/)
+    if (!match?.[1]) continue
+    projects.set(match[1], configMtime)
+  }
+
+  return projects
+}
+
+function readCodexSessionMetadata(sessionsDir: string) {
+  const metadataById = new Map<string, { cwd: string; modifiedAt: number }>()
+
+  for (const sessionFile of collectCodexSessionFiles(sessionsDir)) {
+    const fileStat = statSync(sessionFile)
+    const firstLine = readFileSync(sessionFile, "utf8").split("\n", 1)[0]
+    if (!firstLine?.trim()) continue
+
+    const record = parseJsonRecord(firstLine)
+    if (!record || record.type !== "session_meta") continue
+
+    const payload = record.payload
+    if (!payload || typeof payload !== "object" || Array.isArray(payload)) continue
+
+    const payloadRecord = payload as Record<string, unknown>
+    const sessionId = typeof payloadRecord.id === "string" ? payloadRecord.id : null
+    const cwd = typeof payloadRecord.cwd === "string" ? payloadRecord.cwd : null
+    if (!sessionId || !cwd) continue
+
+    const recordTimestamp = typeof record.timestamp === "string" ? Date.parse(record.timestamp) : Number.NaN
+    const payloadTimestamp = typeof payloadRecord.timestamp === "string" ? Date.parse(payloadRecord.timestamp) : Number.NaN
+    const modifiedAt = [recordTimestamp, payloadTimestamp, fileStat.mtimeMs].find((value) => !Number.isNaN(value)) ?? fileStat.mtimeMs
+
+    metadataById.set(sessionId, { cwd, modifiedAt })
+  }
+
+  return metadataById
+}
+
+export class CodexProjectDiscoveryAdapter implements ProjectDiscoveryAdapter {
+  readonly provider = "codex" as const
+
+  scan(homeDir: string = homedir()): ProviderDiscoveredProject[] {
+    const indexPath = path.join(homeDir, ".codex", "session_index.jsonl")
+    const sessionsDir = path.join(homeDir, ".codex", "sessions")
+    const configPath = path.join(homeDir, ".codex", "config.toml")
+    const updatedAtById = readCodexSessionIndex(indexPath)
+    const metadataById = readCodexSessionMetadata(sessionsDir)
+    const configuredProjects = readCodexConfiguredProjects(configPath)
+    const projects: ProviderDiscoveredProject[] = []
+
+    for (const [sessionId, metadata] of metadataById.entries()) {
+      const modifiedAt = updatedAtById.get(sessionId) ?? metadata.modifiedAt
+      const cwd = metadata.cwd
+      if (!cwd) {
+        continue
+      }
+      if (!path.isAbsolute(cwd)) {
+        continue
+      }
+
+      const normalizedPath = normalizeExistingDirectory(cwd)
+      if (!normalizedPath) {
+        continue
+      }
+
+      projects.push({
+        provider: this.provider,
+        localPath: normalizedPath,
+        title: path.basename(normalizedPath) || normalizedPath,
+        modifiedAt,
+      })
+    }
+
+    for (const [configuredPath, modifiedAt] of configuredProjects.entries()) {
+      if (!path.isAbsolute(configuredPath)) {
+        continue
+      }
+
+      const normalizedPath = normalizeExistingDirectory(configuredPath)
+      if (!normalizedPath) {
+        continue
+      }
+
+      projects.push({
+        provider: this.provider,
+        localPath: normalizedPath,
+        title: path.basename(normalizedPath) || normalizedPath,
+        modifiedAt,
+      })
+    }
+
+    const mergedProjects = mergeDiscoveredProjects(projects).map((project) => ({
+      provider: this.provider,
+      ...project,
+    }))
+
+    return mergedProjects
+  }
+}
+
+export const DEFAULT_PROJECT_DISCOVERY_ADAPTERS: ProjectDiscoveryAdapter[] = [
+  new ClaudeProjectDiscoveryAdapter(),
+  new CodexProjectDiscoveryAdapter(),
+]
+
+export function discoverProjects(
+  homeDir: string = homedir(),
+  adapters: ProjectDiscoveryAdapter[] = DEFAULT_PROJECT_DISCOVERY_ADAPTERS
+): DiscoveredProject[] {
+  const mergedProjects = mergeDiscoveredProjects(
+    adapters.flatMap((adapter) => adapter.scan(homeDir).map(({ provider: _provider, ...project }) => project))
+  )
+
+  return mergedProjects
+}