@shawnstack/quickforge 1.3.24 → 1.3.26

package/server/plugins/registry.mjs

@@ -0,0 +1,304 @@
+import { promises as fs } from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+import { fileURLToPath } from 'node:url'
+import { dataDir, readStore, atomicUpdate } from '../storage.mjs'
+import { logger } from '../utils/logger.mjs'
+import { loadPlugin } from './loader.mjs'
+import {
+  isPluginToolName,
+  normalizePluginManifest,
+  parseQuickForgePluginToolName,
+  quickForgePluginToolName,
+} from './manifest.mjs'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const bundledPluginDir = path.resolve(__dirname, '..', '..', 'plugins')
+const globalPluginDir = path.join(dataDir, 'plugins')
+const legacyGlobalPluginDir = path.join(os.homedir(), '.agents', 'plugins')
+let cachedCatalog = null
+let cachedCatalogKey = null
+let refreshPromise = null
+
+function catalogKey(projectContext = null) {
+  return projectContext?.workspaceRoot ? path.resolve(projectContext.workspaceRoot) : ''
+}
+
+function isPlainObject(value) {
+  return Boolean(value && typeof value === 'object' && !Array.isArray(value))
+}
+
+async function exists(filePath) {
+  try {
+    await fs.access(filePath)
+    return true
+  } catch {
+    return false
+  }
+}
+
+async function readJsonFile(filePath) {
+  const text = await fs.readFile(filePath, 'utf8')
+  return JSON.parse(text.trimStart())
+}
+
+async function listPluginDirs(root) {
+  let entries = []
+  try {
+    entries = await fs.readdir(root, { withFileTypes: true })
+  } catch (error) {
+    if (error?.code === 'ENOENT') return []
+    throw error
+  }
+  return entries.filter((entry) => entry.isDirectory()).map((entry) => path.join(root, entry.name))
+}
+
+function normalizePluginStore(store) {
+  const source = isPlainObject(store) ? store : {}
+  return {
+    enabled: isPlainObject(source.enabled) ? source.enabled : {},
+    config: isPlainObject(source.config) ? source.config : {},
+  }
+}
+
+async function readPluginStore() {
+  return normalizePluginStore(await readStore('plugins'))
+}
+
+function contributionSummary(contribution) {
+  return {
+    path: contribution.path,
+    resolvedPath: contribution.resolvedPath,
+  }
+}
+
+async function discoverManifests(projectContext) {
+  const roots = [bundledPluginDir, globalPluginDir, legacyGlobalPluginDir]
+  if (projectContext?.workspaceRoot) roots.push(path.join(projectContext.workspaceRoot, '.quickforge', 'plugins'))
+
+  const manifests = new Map()
+  const errors = []
+  for (const root of roots) {
+    const dirs = await listPluginDirs(root)
+    for (const dir of dirs) {
+      const manifestPath = path.join(dir, 'plugin.json')
+      if (!(await exists(manifestPath))) continue
+      try {
+        const manifest = normalizePluginManifest(await readJsonFile(manifestPath), dir)
+        if (!manifests.has(manifest.name) || root !== legacyGlobalPluginDir) {
+          manifests.set(manifest.name, { manifest, sourceRoot: root })
+        }
+      } catch (error) {
+        errors.push({ dir, sourceRoot: root, error: error?.message || 'Failed to read plugin manifest' })
+      }
+    }
+  }
+  return { manifests, errors, roots }
+}
+
+async function loadEnabledPlugins(projectContext) {
+  const store = await readPluginStore()
+  const { manifests, errors, roots } = await discoverManifests(projectContext)
+  const plugins = []
+  const handlers = new Map()
+
+  for (const { manifest, sourceRoot } of manifests.values()) {
+    const enabled = store.enabled[manifest.name] === true || (manifest.enabledByDefault && store.enabled[manifest.name] !== false)
+    const config = isPlainObject(store.config[manifest.name]) ? store.config[manifest.name] : {}
+    const entry = {
+      ...manifest,
+      enabled,
+      config,
+      sourceRoot,
+      status: enabled ? 'loaded' : 'disabled',
+      error: null,
+      tools: manifest.contributes.tools.map((tool) => ({
+        ...tool,
+        quickForgeName: quickForgePluginToolName(manifest.name, tool.name),
+      })),
+      skills: manifest.contributes.skills.map(contributionSummary),
+      commands: manifest.contributes.commands.map(contributionSummary),
+    }
+
+    if (enabled && entry.tools.length > 0) {
+      try {
+        const loaded = await loadPlugin(manifest, { config, projectContext })
+        handlers.set(manifest.name, loaded)
+      } catch (error) {
+        logger.error(`Failed to load plugin ${manifest.name}:`, error)
+        entry.status = 'error'
+        entry.error = error?.message || 'Failed to load plugin'
+      }
+    }
+
+    plugins.push(entry)
+  }
+
+  plugins.sort((a, b) => a.name.localeCompare(b.name))
+  return { plugins, handlers, errors, roots }
+}
+
+export async function refreshPlugins(projectContext = null) {
+  const key = catalogKey(projectContext)
+  if (!refreshPromise) {
+    refreshPromise = loadEnabledPlugins(projectContext).then((catalog) => {
+      cachedCatalog = catalog
+      cachedCatalogKey = key
+      return catalog
+    }).finally(() => {
+      refreshPromise = null
+    })
+  }
+  return refreshPromise
+}
+
+async function getCatalog(projectContext = null) {
+  const key = catalogKey(projectContext)
+  if (!cachedCatalog || cachedCatalogKey !== key) return refreshPlugins(projectContext)
+  return cachedCatalog
+}
+
+function enabledLoadedPlugins(catalog) {
+  return catalog.plugins.filter((plugin) => plugin.enabled && plugin.status === 'loaded')
+}
+
+export async function getEnabledPluginSkillSources(projectContext = null) {
+  const catalog = await getCatalog(projectContext)
+  return enabledLoadedPlugins(catalog).flatMap((plugin) => plugin.skills.map((skill) => ({
+    pluginName: plugin.name,
+    source: `plugin:${plugin.name}`,
+    dir: skill.resolvedPath,
+    path: skill.path,
+  })))
+}
+
+export async function getEnabledPluginCommandSources(projectContext = null) {
+  const catalog = await getCatalog(projectContext)
+  return enabledLoadedPlugins(catalog).flatMap((plugin) => plugin.commands.map((command) => ({
+    pluginName: plugin.name,
+    source: `plugin:${plugin.name}`,
+    path: command.resolvedPath,
+    relativePath: command.path,
+  })))
+}
+
+export async function getPluginStatus(projectContext = null) {
+  const catalog = await refreshPlugins(projectContext)
+  return {
+    searchPaths: catalog.roots,
+    errors: catalog.errors,
+    plugins: catalog.plugins.map((plugin) => ({
+      name: plugin.name,
+      displayName: plugin.displayName,
+      version: plugin.version,
+      description: plugin.description,
+      apiVersion: plugin.apiVersion,
+      quickforgeVersion: plugin.quickforgeVersion,
+      enabledByDefault: plugin.enabledByDefault,
+      dir: plugin.dir,
+      sourceRoot: plugin.sourceRoot,
+      enabled: plugin.enabled,
+      status: plugin.status,
+      error: plugin.error,
+      permissions: plugin.permissions,
+      tools: plugin.tools.map((tool) => ({
+        name: tool.name,
+        quickForgeName: tool.quickForgeName,
+        label: tool.label,
+        description: tool.description,
+      })),
+      skills: plugin.skills.map((skill) => ({ path: skill.path })),
+      commands: plugin.commands.map((command) => ({ path: command.path })),
+      settings: plugin.contributes.settings,
+      config: plugin.config,
+    })),
+  }
+}
+
+export async function setPluginEnabled(name, enabled) {
+  await atomicUpdate('plugins', (store) => {
+    const next = normalizePluginStore(store)
+    next.enabled[name] = enabled === true
+    return next
+  })
+  cachedCatalog = null
+  cachedCatalogKey = null
+}
+
+export async function setPluginConfig(name, config) {
+  await atomicUpdate('plugins', (store) => {
+    const next = normalizePluginStore(store)
+    next.config[name] = isPlainObject(config) ? config : {}
+    return next
+  })
+  cachedCatalog = null
+  cachedCatalogKey = null
+}
+
+export async function createPluginToolDefinitions(projectContext = null) {
+  const catalog = await getCatalog(projectContext)
+  const definitions = []
+  for (const plugin of catalog.plugins) {
+    if (!plugin.enabled || plugin.status !== 'loaded') continue
+    for (const tool of plugin.tools) {
+      definitions.push({
+        name: tool.quickForgeName,
+        label: tool.label,
+        description: `[Plugin:${plugin.name}] ${tool.description || tool.name}`,
+        parameters: tool.parameters,
+        executionMode: tool.executionMode,
+        plugin: { name: plugin.name, toolName: tool.name },
+      })
+    }
+  }
+  return definitions
+}
+
+export { isPluginToolName }
+
+export async function callPluginTool(toolName, params = {}, toolContext = {}) {
+  const parsed = parseQuickForgePluginToolName(toolName)
+  if (!parsed) {
+    const error = new Error(`Invalid plugin tool name: ${toolName}`)
+    error.statusCode = 400
+    throw error
+  }
+
+  const catalog = await getCatalog(toolContext)
+  const plugin = catalog.plugins.find((item) => item.name === parsed.pluginName)
+  if (!plugin || !plugin.enabled || plugin.status !== 'loaded') {
+    const error = new Error(`Plugin is not loaded: ${parsed.pluginName}`)
+    error.statusCode = 503
+    throw error
+  }
+
+  const tool = plugin.tools.find((item) => item.name === parsed.toolName || item.quickForgeName === toolName)
+  if (!tool) {
+    const error = new Error(`Unknown plugin tool: ${toolName}`)
+    error.statusCode = 404
+    throw error
+  }
+
+  const handler = catalog.handlers.get(parsed.pluginName)
+  if (!handler) {
+    const error = new Error(`Missing plugin handler: ${parsed.pluginName}`)
+    error.statusCode = 503
+    throw error
+  }
+
+  const result = await handler.callTool(tool.name, params, {
+    ...toolContext,
+    plugin: { name: plugin.name, dir: plugin.dir, config: plugin.config },
+  })
+
+  return {
+    isError: Boolean(result.isError),
+    content: result.content,
+    details: {
+      ...(isPlainObject(result.details) ? result.details : {}),
+      plugin: true,
+      pluginName: plugin.name,
+      tool: tool.name,
+    },
+  }
+}

package/server/project-config.mjs

@@ -298,24 +298,71 @@ export async function readInstructionsFile(filePath) {
   return null
 }
 
+async function readInstructionSources(candidates) {
+  const sources = []
+  const seen = new Set()
+
+  for (const candidate of candidates) {
+    const file = path.resolve(candidate.file)
+    if (seen.has(file)) continue
+    seen.add(file)
+
+    try {
+      const content = await fs.readFile(file, 'utf8')
+      const trimmed = content.trim()
+      if (trimmed) sources.push({ source: candidate.source, content: trimmed })
+    } catch {
+      // optional compatibility source
+    }
+  }
+
+  return sources
+}
+
+function combineInstructionSources(sources) {
+  return sources.map((source) => source.content).join('\n\n') || null
+}
+
+function globalInstructionCandidates() {
+  const home = os.homedir()
+  return [
+    { file: path.join(home, '.claude', 'CLAUDE.md'), source: '~/.claude/CLAUDE.md' },
+    { file: path.join(home, '.opencode', 'AGENTS.md'), source: '~/.opencode/AGENTS.md' },
+    { file: path.join(dataDir, 'AGENTS.md'), source: '~/.quickforge/AGENTS.md' },
+    { file: path.join(dataDir, 'agents.md'), source: '~/.quickforge/agents.md' },
+  ]
+}
+
+function projectInstructionCandidates(workspaceRoot) {
+  return [
+    { file: path.join(workspaceRoot, 'CLAUDE.md'), source: 'CLAUDE.md' },
+    { file: path.join(workspaceRoot, 'AGENTS.md'), source: 'AGENTS.md' },
+    { file: path.join(workspaceRoot, 'agents.md'), source: 'agents.md' },
+    { file: path.join(workspaceRoot, '.opencode', 'AGENTS.md'), source: '.opencode/AGENTS.md' },
+    { file: path.join(workspaceRoot, '.quickforge', 'AGENTS.md'), source: '.quickforge/AGENTS.md' },
+  ]
+}
+
 export async function buildInstructionsPayload(projectId) {
   const config = await readProjectConfig()
-  let projectInstructions = null
+  let projectInstructionSources = []
   let project = projectId ? config.projects.find((item) => item.id === projectId) ?? null : null
 
   if (projectId) {
     try {
       const context = await projectContextFromId(projectId)
       project = context.project
-      projectInstructions = await readInstructionsFile(path.join(context.workspaceRoot, 'AGENTS.md'))
+      projectInstructionSources = await readInstructionSources(projectInstructionCandidates(context.workspaceRoot))
     } catch {
       // project not found or inaccessible — leave projectInstructions null
     }
   }
 
-  const globalInstructions = await readInstructionsFile(path.join(dataDir, 'AGENTS.md'))
+  const globalInstructionSources = await readInstructionSources(globalInstructionCandidates())
+  const globalInstructions = combineInstructionSources(globalInstructionSources)
+  const projectInstructions = combineInstructionSources(projectInstructionSources)
   const globalSkills = await loadSelectedGlobalSkills(config.globalSkills)
-  const projectSkills = project?.skills && project?.path
+  const projectSkills = project?.path
     ? await loadSelectedProjectSkills(project.skills, project.path)
     : []
   const activeSkills = mergeSkills(globalSkills, projectSkills)
@@ -331,6 +378,8 @@ export async function buildInstructionsPayload(projectId) {
       : null,
     global: globalInstructions,
     project: projectInstructions,
+    globalSources: globalInstructionSources,
+    projectSources: projectInstructionSources,
     globalSkills: globalSkills.map(stripRuntimeFields),
     projectSkills: projectSkills.map(stripRuntimeFields),
     skills: activeSkills.map(stripRuntimeFields),

package/server/routes/agent-profiles.mjs

@@ -1,4 +1,4 @@
-import { streamSimple } from '@mariozechner/pi-ai'
+import { streamSimple } from '@earendil-works/pi-ai'
 import { sendJson, readJsonBody, decodeSegment } from '../utils/response.mjs'
 import { readStore } from '../storage.mjs'
 import { logger } from '../utils/logger.mjs'

package/server/routes/agent.mjs

@@ -23,7 +23,6 @@ import {
   approveAutoCompact,
   rejectAutoCompact,
   abortToolCall,
-  replaceSessionMessages,
   rollbackSessionMessages,
   continueSession,
   agentEvents,
@@ -83,7 +82,7 @@ export async function handleAgentApi(req, res, url) {
       error.statusCode = 400
       throw error
     }
-    const result = await runPrompt(sessionId, message)
+    const result = await runPrompt(sessionId, message, body?.selectedCapabilities)
     sendJson(res, 200, result)
     return
   }
@@ -169,20 +168,6 @@ export async function handleAgentApi(req, res, url) {
     return
   }
 
-  // POST /api/agents/:sessionId/messages — replace session messages (legacy rollback/sync)
-  if (req.method === 'POST' && subPath === 'messages') {
-    const body = await readJsonBody(req)
-    const messages = body?.messages
-    if (!Array.isArray(messages)) {
-      const error = new Error('Missing messages array in request body')
-      error.statusCode = 400
-      throw error
-    }
-    const state = await replaceSessionMessages(sessionId, messages)
-    sendJson(res, 200, { ok: true, messages: state?.messages })
-    return
-  }
-
   // POST /api/agents/:sessionId/rollback — roll back from a message index on the authoritative server state
   if (req.method === 'POST' && subPath === 'rollback') {
     const body = await readJsonBody(req)

package/server/routes/filesystem.mjs

@@ -50,9 +50,21 @@ async function getFilesystemRoots() {
   return roots
 }
 
-async function listFilesystemDirectories(inputPath) {
+async function listFilesystemDirectories(inputPath, allowedRoots) {
   const requestedPath = String(inputPath || os.homedir())
   const resolved = path.resolve(requestedPath)
+
+  // Only allow browsing within or at known filesystem roots
+  const isAllowed = allowedRoots.some((root) => {
+    const rel = path.relative(root, resolved)
+    return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel))
+  })
+  if (!isAllowed) {
+    const error = new Error('Access denied: path is outside allowed roots')
+    error.statusCode = 403
+    throw error
+  }
+
   await assertDirectory(resolved)
 
   const entries = await fs.readdir(resolved, { withFileTypes: true }).catch((error) => {
@@ -77,7 +89,11 @@ export async function handleFilesystemApi(req, res, url) {
   }
 
   if (req.method === 'GET' && url.pathname === '/api/filesystem/directories') {
-    sendJson(res, 200, await listFilesystemDirectories(url.searchParams.get('path')))
+    const roots = await getFilesystemRoots()
+    const allowedRootPaths = roots.map((r) => path.resolve(r.path))
+    // Always allow browsing from home directory as a fallback
+    allowedRootPaths.push(os.homedir())
+    sendJson(res, 200, await listFilesystemDirectories(url.searchParams.get('path'), allowedRootPaths))
     return
   }
 

package/server/routes/plugins.mjs

@@ -0,0 +1,63 @@
+import { sendJson, readJsonBody, decodeSegment } from '../utils/response.mjs'
+import { refreshAllSessionTools } from '../agent-manager.mjs'
+import { projectContextFromId, readProjectConfig } from '../project-config.mjs'
+import { getPluginStatus, refreshPlugins, setPluginConfig, setPluginEnabled } from '../plugins/registry.mjs'
+
+async function activeProjectContext() {
+  const config = await readProjectConfig()
+  const activeProject = config.projects.find((project) => project.id === config.activeProjectId) || config.projects[0]
+  if (!activeProject?.id) return null
+  return projectContextFromId(activeProject.id)
+}
+
+async function refreshPluginsAndAgentTools() {
+  const projectContext = await activeProjectContext()
+  await refreshPlugins(projectContext)
+  const refreshedSessions = await refreshAllSessionTools()
+  return { ...(await getPluginStatus(projectContext)), refreshedSessions }
+}
+
+export async function handlePluginsApi(req, res, url) {
+  const parts = url.pathname.split('/').filter(Boolean)
+
+  if (req.method === 'GET' && url.pathname === '/api/plugins') {
+    sendJson(res, 200, await getPluginStatus(await activeProjectContext()))
+    return
+  }
+
+  if (req.method === 'POST' && url.pathname === '/api/plugins/reload') {
+    sendJson(res, 200, await refreshPluginsAndAgentTools())
+    return
+  }
+
+  if (req.method === 'GET' && parts[0] === 'api' && parts[1] === 'plugins' && parts[2]) {
+    const name = decodeSegment(parts[2])
+    const status = await getPluginStatus(await activeProjectContext())
+    const plugin = status.plugins.find((item) => item.name === name)
+    if (!plugin) {
+      const error = new Error(`Unknown plugin: ${name}`)
+      error.statusCode = 404
+      throw error
+    }
+    sendJson(res, 200, { ...status, plugin })
+    return
+  }
+
+  if (req.method === 'PUT' && parts[0] === 'api' && parts[1] === 'plugins' && parts[2] && parts[3] === 'enabled') {
+    const body = await readJsonBody(req)
+    await setPluginEnabled(decodeSegment(parts[2]), body?.enabled === true)
+    sendJson(res, 200, await refreshPluginsAndAgentTools())
+    return
+  }
+
+  if (req.method === 'PUT' && parts[0] === 'api' && parts[1] === 'plugins' && parts[2] && parts[3] === 'config') {
+    const body = await readJsonBody(req)
+    await setPluginConfig(decodeSegment(parts[2]), body?.config || body || {})
+    sendJson(res, 200, await refreshPluginsAndAgentTools())
+    return
+  }
+
+  const error = new Error('Not found')
+  error.statusCode = 404
+  throw error
+}

package/server/routes/project.mjs

@@ -29,6 +29,8 @@ export async function handleProjectApi(req, res, url) {
         allowEdit: command.allowEdit,
         allowCommands: command.allowCommands,
         relativePath: command.relativePath,
+        source: command.source,
+        pluginName: command.pluginName,
       })),
     })
     return

package/server/routes/scheduled-tasks.mjs

@@ -1,4 +1,4 @@
-import { streamSimple } from '@mariozechner/pi-ai'
+import { streamSimple } from '@earendil-works/pi-ai'
 import { readJsonBody, sendJson, decodeSegment } from '../utils/response.mjs'
 import { readStore, atomicUpdate } from '../storage.mjs'
 import { createAgent, getSessionEventBus, agentEvents, persistSessionState } from '../agent-manager.mjs'

package/server/routes/storage.mjs

@@ -1,8 +1,72 @@
 import path from 'node:path'
 import { sendJson, readJsonBody, decodeSegment } from '../utils/response.mjs'
-import { readStore, writeStore, atomicUpdate, getComparable, readSessionStoreScoped, readSessionValue, writeSessionValue, deleteSessionValue, ensureStorage, dataDir, configDir, storageDir, cacheDir, logsDir } from '../storage.mjs'
+import { readStore, writeStore, atomicUpdate, getComparable, getStoreRevision, readSessionStoreScoped, readSessionValue, writeSessionValue, deleteSessionValue, ensureStorage, dataDir, configDir, storageDir, cacheDir, logsDir } from '../storage.mjs'
 import { directorySize } from '../utils/workspace.mjs'
 
+const metadataIndexCache = new Map()
+const MAX_METADATA_INDEX_CACHE_ENTRIES = 50
+
+function metadataIndexCacheKey({ scope, projectId, indexName, direction }) {
+  return JSON.stringify({ scope: scope || '', projectId: projectId || '', indexName, direction })
+}
+
+function sortIndexedValues(values, store, indexName, direction) {
+  values.sort((a, b) => {
+    if (store === 'sessions-metadata' && indexName === 'lastModified') {
+      const leftPinned = getComparable(a, 'pinnedAt')
+      const rightPinned = getComparable(b, 'pinnedAt')
+      if (leftPinned !== rightPinned) {
+        if (leftPinned === undefined || leftPinned === null) return 1
+        if (rightPinned === undefined || rightPinned === null) return -1
+        return -String(leftPinned).localeCompare(String(rightPinned))
+      }
+    }
+
+    const left = getComparable(a, indexName)
+    const right = getComparable(b, indexName)
+    if (left === right) return 0
+    if (left === undefined || left === null) return direction === 'desc' ? 1 : -1
+    if (right === undefined || right === null) return direction === 'desc' ? -1 : 1
+    const result = String(left).localeCompare(String(right))
+    return direction === 'desc' ? -result : result
+  })
+  return values
+}
+
+async function readIndexedValues(store, indexName, direction, scope, projectId) {
+  if (store !== 'sessions-metadata') {
+    let data
+    if (scope && store === 'sessions') {
+      data = await readSessionStoreScoped(store, scope, scope === 'project' ? projectId : undefined)
+    } else {
+      data = await readStore(store)
+    }
+    return sortIndexedValues(Object.values(data), store, indexName, direction)
+  }
+
+  const revision = getStoreRevision(store)
+  const key = metadataIndexCacheKey({ scope, projectId, indexName, direction })
+  const cached = metadataIndexCache.get(key)
+  if (cached && cached.revision === revision) return cached.values
+
+  const data = scope
+    ? await readSessionStoreScoped(store, scope, scope === 'project' ? projectId : undefined)
+    : await readStore(store)
+  const values = sortIndexedValues(
+    Object.values(data).filter((value) => value?.messageCount !== 0),
+    store,
+    indexName,
+    direction,
+  )
+
+  metadataIndexCache.set(key, { revision, values })
+  if (metadataIndexCache.size > MAX_METADATA_INDEX_CACHE_ENTRIES) {
+    const firstKey = metadataIndexCache.keys().next().value
+    if (firstKey) metadataIndexCache.delete(firstKey)
+  }
+  return values
+}
+
 export async function handleStorageApi(req, res, url) {
   const parts = url.pathname.split('/').filter(Boolean)
 
@@ -44,36 +108,7 @@ export async function handleStorageApi(req, res, url) {
 
     await ensureStorage()
 
-    let data
-    if (scope && (store === 'sessions' || store === 'sessions-metadata')) {
-      data = await readSessionStoreScoped(store, scope, scope === 'project' ? projectId : undefined)
-    } else {
-      data = await readStore(store)
-    }
-
-    let values = Object.values(data)
-    if (store === 'sessions-metadata') {
-      values = values.filter((value) => value?.messageCount !== 0)
-    }
-    values.sort((a, b) => {
-      if (store === 'sessions-metadata' && indexName === 'lastModified') {
-        const leftPinned = getComparable(a, 'pinnedAt')
-        const rightPinned = getComparable(b, 'pinnedAt')
-        if (leftPinned !== rightPinned) {
-          if (leftPinned === undefined || leftPinned === null) return 1
-          if (rightPinned === undefined || rightPinned === null) return -1
-          return -String(leftPinned).localeCompare(String(rightPinned))
-        }
-      }
-
-      const left = getComparable(a, indexName)
-      const right = getComparable(b, indexName)
-      if (left === right) return 0
-      if (left === undefined || left === null) return direction === 'desc' ? 1 : -1
-      if (right === undefined || right === null) return direction === 'desc' ? -1 : 1
-      const result = String(left).localeCompare(String(right))
-      return direction === 'desc' ? -result : result
-    })
+    const values = await readIndexedValues(store, indexName, direction, scope, projectId)
 
     const total = values.length
     const limit = limitParam ? parseInt(limitParam, 10) : undefined