agentikit 0.0.8 → 0.0.12

package/src/init.ts

@@ -1,7 +1,7 @@
 /**
  * Agentikit initialization logic.
  *
- * Creates the stash directory structure, sets the AGENTIKIT_STASH_DIR
+ * Creates the working stash directory structure, sets the AKM_STASH_DIR
  * environment variable, and ensures ripgrep is available.
  */
 
@@ -25,7 +25,7 @@ export interface InitResponse {
   }
 }
 
-export function agentikitInit(): InitResponse {
+export async function agentikitInit(): Promise<InitResponse> {
   let stashDir: string
   if (IS_WINDOWS) {
     const userProfile = process.env.USERPROFILE?.trim()
@@ -59,7 +59,7 @@ export function agentikitInit(): InitResponse {
   let profileUpdated: string | undefined
 
   if (IS_WINDOWS) {
-    const result = spawnSync("setx", ["AGENTIKIT_STASH_DIR", stashDir], {
+    const result = spawnSync("setx", ["AKM_STASH_DIR", stashDir], {
       encoding: "utf8",
       timeout: 10_000,
     })
@@ -76,22 +76,30 @@ export function agentikitInit(): InitResponse {
       profile = path.join(homeDir, ".profile")
     }
 
-    const exportLine = `export AGENTIKIT_STASH_DIR="${stashDir}"`
+    const exportLine = `export AKM_STASH_DIR="${stashDir}"`
     const existing = fs.existsSync(profile) ? fs.readFileSync(profile, "utf8") : ""
-    if (!existing.includes("AGENTIKIT_STASH_DIR")) {
-      fs.appendFileSync(profile, `\n# Agentikit stash directory\n${exportLine}\n`)
+    if (!existing.includes("AKM_STASH_DIR")) {
+      const updated = existing + `\n# Agentikit working stash directory\n${exportLine}\n`
+      const tmpPath = profile + `.tmp.${process.pid}`
+      try {
+        fs.writeFileSync(tmpPath, updated, "utf8")
+        fs.renameSync(tmpPath, profile)
+      } catch (err) {
+        try { fs.unlinkSync(tmpPath) } catch { /* ignore */ }
+        throw err
+      }
       envSet = true
       profileUpdated = profile
     }
   }
 
   // Create default config.json if it doesn't exist
-  const configPath = getConfigPath(stashDir)
+  const configPath = getConfigPath()
   if (!fs.existsSync(configPath)) {
-    saveConfig(DEFAULT_CONFIG, stashDir)
+    saveConfig(DEFAULT_CONFIG)
   }
 
-  process.env.AGENTIKIT_STASH_DIR = stashDir
+  process.env.AKM_STASH_DIR = stashDir
 
   // Ensure ripgrep is available (install to stash/bin if needed)
   let ripgrep: InitResponse["ripgrep"]

package/src/llm.ts

@@ -1,4 +1,5 @@
 import type { LlmConnectionConfig } from "./config"
+import { fetchWithTimeout } from "./common"
 import type { StashEntry } from "./metadata"
 
 // ── OpenAI-compatible chat completions ──────────────────────────────────────
@@ -21,14 +22,14 @@ async function chatCompletion(
     headers["Authorization"] = `Bearer ${config.apiKey}`
   }
 
-  const response = await fetch(config.endpoint, {
+  const response = await fetchWithTimeout(config.endpoint, {
     method: "POST",
     headers,
     body: JSON.stringify({
       model: config.model,
       messages,
-      temperature: 0.3,
-      max_tokens: 512,
+      temperature: config.temperature ?? 0.3,
+      max_tokens: config.maxTokens ?? 512,
     }),
   })
 

package/src/metadata.ts

@@ -4,6 +4,7 @@ import { type AgentikitAssetType, isAssetType } from "./common"
 import { SCRIPT_EXTENSIONS, isRelevantAssetFile, deriveCanonicalAssetName } from "./asset-spec"
 import { parseFrontmatter, toStringOrUndefined } from "./frontmatter"
 import { parseMarkdownToc, type TocHeading } from "./markdown"
+import { tryGetHandler } from "./asset-type-handler"
 
 // ── Schema ──────────────────────────────────────────────────────────────────
 
@@ -28,6 +29,7 @@ export interface StashEntry {
   source?: "package" | "frontmatter" | "comments" | "filename" | "manual" | "llm"
   aliases?: string[]
   toc?: TocHeading[]
+  usage?: string[]
 }
 
 export interface StashFile {
@@ -111,10 +113,25 @@ export function validateStashEntry(entry: unknown): StashEntry | null {
     )
     if (validated.length > 0) result.toc = validated
   }
+  const usage = normalizeNonEmptyStringList(e.usage)
+  if (usage) result.usage = usage
 
   return result
 }
 
+function normalizeNonEmptyStringList(value: unknown): string[] | undefined {
+  if (typeof value === "string") {
+    const trimmed = value.trim()
+    return trimmed ? [trimmed] : undefined
+  }
+  if (!Array.isArray(value)) return undefined
+  const filtered = value
+    .filter((item): item is string => typeof item === "string")
+    .map((item) => item.trim())
+    .filter((item) => item.length > 0)
+  return filtered.length > 0 ? filtered : undefined
+}
+
 // ── Metadata Generation ─────────────────────────────────────────────────────
 
 export function generateMetadata(
@@ -167,25 +184,10 @@ export function generateMetadata(
       }
     }
 
-    // Knowledge entries: generate TOC from headings
-    if (assetType === "knowledge") {
-      try {
-        const mdContent = fs.readFileSync(file, "utf8")
-        const toc = parseMarkdownToc(mdContent)
-        if (toc.headings.length > 0) entry.toc = toc.headings
-      } catch {
-        // Non-fatal: skip TOC if file can't be read
-      }
-    }
-
-    // Priority 3: Code comments (for script files)
-    if (SCRIPT_EXTENSIONS.has(ext) && ext !== ".md") {
-      const commentDesc = extractDescriptionFromComments(file)
-      if (commentDesc && !entry.description) {
-        entry.description = commentDesc
-        entry.source = "comments"
-        entry.confidence = 0.7
-      }
+    // Type-specific metadata extraction (e.g. TOC for knowledge, comments for tools/scripts)
+    const handler = tryGetHandler(assetType)
+    if (handler?.extractTypeMetadata) {
+      handler.extractTypeMetadata(entry, file, ext)
     }
 
     // Priority 4: Filename heuristics (fallback)
@@ -233,52 +235,6 @@ function buildAliases(name: string, tags: string[]): string[] {
   return Array.from(aliases)
 }
 
-// ── Intent Generation ────────────────────────────────────────────────────────
-
-export function generateIntents(description: string, tags: string[], name: string): string[] {
-  const intents = new Set<string>()
-
-  // Split name on separators to extract tokens and potential verb
-  const nameTokens = name
-    .replace(/[-_]+/g, " ")
-    .replace(/([a-z])([A-Z])/g, "$1 $2")
-    .toLowerCase()
-    .trim()
-    .split(/\s+/)
-    .filter((t) => t.length > 1)
-
-  // Intent from name as phrase (e.g. "summarize diff")
-  const namePhrase = nameTokens.join(" ")
-  if (namePhrase.length > 2) intents.add(namePhrase)
-
-  // Intent from description (lowercased)
-  const desc = description.toLowerCase().trim()
-  if (desc.length > 2) intents.add(desc)
-
-  // Combine first name token (potential verb) with tags
-  // e.g. name "summarize-diff", tags ["git"] → "summarize git diff"
-  if (nameTokens.length >= 1 && tags.length > 0) {
-    const verb = nameTokens[0]
-    const rest = nameTokens.slice(1).join(" ")
-    for (const tag of tags) {
-      const tagLower = tag.toLowerCase()
-      // verb + tag + rest (e.g. "summarize git diff")
-      const parts = [verb, tagLower, rest].filter((p) => p.length > 0)
-      const phrase = parts.join(" ")
-      if (phrase !== namePhrase && phrase.length > 2) intents.add(phrase)
-    }
-  }
-
-  // Join tag pairs (e.g. ["git", "diff"] → "git diff")
-  if (tags.length >= 2) {
-    const tagPhrase = tags.map((t) => t.toLowerCase()).join(" ")
-    if (tagPhrase.length > 2) intents.add(tagPhrase)
-  }
-
-  // Cap at 8 intents
-  return Array.from(intents).slice(0, 8)
-}
-
 export function extractDescriptionFromComments(filePath: string): string | null {
   let content: string
   try {

package/src/origin-resolve.ts

@@ -0,0 +1,67 @@
+import path from "node:path"
+import type { StashSource } from "./stash-source"
+import { parseRegistryRef } from "./registry-resolve"
+
+/**
+ * Given an origin string (from an AssetRef) and the full list of stash
+ * sources, return the subset of sources to search.
+ *
+ * Resolution order:
+ *   1. undefined   → all sources (working → mounted → installed)
+ *   2. "local"     → working stash only
+ *   3. exact match → installed source whose registryId matches verbatim
+ *   4. parsed match → parse origin as a registry ref, match by parsed ID
+ *   5. path match  → mounted source whose path matches
+ *   6. empty       → indicates a remote/uninstalled origin (caller decides)
+ */
+export function resolveSourcesForOrigin(
+  origin: string | undefined,
+  allSources: StashSource[],
+): StashSource[] {
+  if (!origin) return allSources
+
+  if (origin === "local") {
+    return allSources.filter((s) => s.kind === "working")
+  }
+
+  // Exact registryId match (e.g. origin is "npm:@scope/pkg")
+  const byExactId = allSources.filter(
+    (s) => s.kind === "installed" && s.registryId === origin,
+  )
+  if (byExactId.length > 0) return byExactId
+
+  // Parse origin as a registry ref and match by parsed ID.
+  // Allows shorthand: "owner/repo" matches "github:owner/repo",
+  // "@scope/pkg" matches "npm:@scope/pkg".
+  try {
+    const parsed = parseRegistryRef(origin)
+    const byParsedId = allSources.filter(
+      (s) => s.kind === "installed" && s.registryId === parsed.id,
+    )
+    if (byParsedId.length > 0) return byParsedId
+  } catch {
+    // Not a valid registry ref — continue to path matching
+  }
+
+  // Mounted stash by resolved path
+  const resolvedOrigin = path.resolve(origin)
+  const byPath = allSources.filter(
+    (s) => s.kind === "mounted" && path.resolve(s.path) === resolvedOrigin,
+  )
+  if (byPath.length > 0) return byPath
+
+  // No match — origin may be remote/uninstalled
+  return []
+}
+
+/**
+ * Check whether an origin refers to something that could be fetched remotely
+ * (i.e. it looks like a registry ref but isn't installed locally).
+ */
+export function isRemoteOrigin(
+  origin: string,
+  allSources: StashSource[],
+): boolean {
+  if (origin === "local") return false
+  return resolveSourcesForOrigin(origin, allSources).length === 0
+}

package/src/registry-install.ts

@@ -0,0 +1,361 @@
+import { spawnSync } from "node:child_process"
+import fs from "node:fs"
+import path from "node:path"
+import { fetchWithTimeout, isWithin, TYPE_DIRS } from "./common"
+import { loadConfig, saveConfig, type AgentikitConfig } from "./config"
+import { parseRegistryRef, resolveRegistryArtifact } from "./registry-resolve"
+import type { ParsedGitRef, RegistryInstallResult, RegistryInstalledEntry, RegistrySource } from "./registry-types"
+
+const REGISTRY_STASH_DIR_NAMES = new Set<string>(Object.values(TYPE_DIRS))
+
+export interface InstallRegistryRefOptions {
+  cacheRootDir?: string
+  now?: Date
+}
+
+export async function installRegistryRef(ref: string, options?: InstallRegistryRefOptions): Promise<RegistryInstallResult> {
+  const parsed = parseRegistryRef(ref)
+  if (parsed.source === "git") {
+    return installGitRegistryRef(parsed, options)
+  }
+  const resolved = await resolveRegistryArtifact(parsed)
+
+  const installedAt = (options?.now ?? new Date()).toISOString()
+  const cacheRootDir = options?.cacheRootDir ?? getRegistryCacheRootDir()
+  const cacheDir = buildInstallCacheDir(cacheRootDir, resolved.source, resolved.id)
+  const archivePath = path.join(cacheDir, "artifact.tar.gz")
+  const extractedDir = path.join(cacheDir, "extracted")
+
+  fs.mkdirSync(cacheDir, { recursive: true })
+
+  await downloadArchive(resolved.artifactUrl, archivePath)
+  extractTarGzSecure(archivePath, extractedDir)
+
+  const provisionalKitRoot = detectStashRoot(extractedDir)
+  const installRoot = applyAgentikitIncludeConfig(provisionalKitRoot, cacheDir, extractedDir) ?? provisionalKitRoot
+  const stashRoot = detectStashRoot(installRoot)
+
+  return {
+    id: resolved.id,
+    source: resolved.source,
+    ref: resolved.ref,
+    artifactUrl: resolved.artifactUrl,
+    resolvedVersion: resolved.resolvedVersion,
+    resolvedRevision: resolved.resolvedRevision,
+    installedAt,
+    cacheDir,
+    extractedDir,
+    stashRoot,
+  }
+}
+
+async function installGitRegistryRef(parsed: ParsedGitRef, options?: InstallRegistryRefOptions): Promise<RegistryInstallResult> {
+  const resolved = await resolveRegistryArtifact(parsed)
+  const installedAt = (options?.now ?? new Date()).toISOString()
+  const cacheRootDir = options?.cacheRootDir ?? getRegistryCacheRootDir()
+  const cacheDir = buildInstallCacheDir(cacheRootDir, parsed.source, parsed.id)
+  const extractedDir = path.join(cacheDir, "extracted")
+
+  fs.mkdirSync(cacheDir, { recursive: true })
+  fs.rmSync(extractedDir, { recursive: true, force: true })
+  fs.mkdirSync(extractedDir, { recursive: true })
+
+  const includeConfig = findNearestAgentikitIncludeConfig(parsed.sourcePath, parsed.repoRoot)
+  if (includeConfig) {
+    copyIncludedPaths(includeConfig.baseDir, includeConfig.include, extractedDir)
+  } else {
+    copyDirectoryContents(parsed.sourcePath, extractedDir)
+  }
+
+  const stashRoot = detectStashRoot(extractedDir)
+
+  return {
+    id: resolved.id,
+    source: resolved.source,
+    ref: resolved.ref,
+    artifactUrl: resolved.artifactUrl,
+    resolvedVersion: resolved.resolvedVersion,
+    resolvedRevision: resolved.resolvedRevision,
+    installedAt,
+    cacheDir,
+    extractedDir,
+    stashRoot,
+  }
+}
+
+export function upsertInstalledRegistryEntry(entry: RegistryInstalledEntry): AgentikitConfig {
+  const current = loadConfig()
+  const currentInstalled = current.registry?.installed ?? []
+  const withoutExisting = currentInstalled.filter((item) => item.id !== entry.id)
+  const nextInstalled = [...withoutExisting, normalizeInstalledEntry(entry)]
+
+  const nextConfig: AgentikitConfig = {
+    ...current,
+    registry: { installed: nextInstalled },
+  }
+  saveConfig(nextConfig)
+  return nextConfig
+}
+
+export function removeInstalledRegistryEntry(id: string): AgentikitConfig {
+  const current = loadConfig()
+  const currentInstalled = current.registry?.installed ?? []
+  const nextInstalled = currentInstalled.filter((item) => item.id !== id)
+
+  const nextConfig: AgentikitConfig = {
+    ...current,
+    registry: nextInstalled.length > 0 ? { installed: nextInstalled } : undefined,
+  }
+  saveConfig(nextConfig)
+  return nextConfig
+}
+
+export function getRegistryCacheRootDir(): string {
+  const xdgCache = process.env.XDG_CACHE_HOME?.trim()
+  if (xdgCache) {
+    return path.join(path.resolve(xdgCache), "agentikit", "registry")
+  }
+  const home = process.env.HOME?.trim()
+  if (!home) {
+    throw new Error("Unable to determine cache directory. Set XDG_CACHE_HOME or HOME.")
+  }
+  return path.join(path.resolve(home), ".cache", "agentikit", "registry")
+}
+
+export function detectStashRoot(extractedDir: string): string {
+  const root = path.resolve(extractedDir)
+
+  const rootDotStash = path.join(root, ".stash")
+  if (isDirectory(rootDotStash)) {
+    return root
+  }
+
+  if (hasStashDirs(root)) {
+    return root
+  }
+
+  const opencodeDir = path.join(root, "opencode")
+  if (hasStashDirs(opencodeDir)) {
+    return opencodeDir
+  }
+
+  const shallowest = findShallowestDotStashRoot(root)
+  if (shallowest) return shallowest
+
+  return root
+}
+
+function buildInstallCacheDir(cacheRootDir: string, source: RegistrySource, id: string): string {
+  const slug = `${source}-${id.replace(/[^a-zA-Z0-9_.-]+/g, "-").replace(/^-+|-+$/g, "")}`
+  const stamp = `${Date.now()}-${Math.random().toString(36).slice(2, 10)}`
+  return path.join(cacheRootDir, slug || source, stamp)
+}
+
+function applyAgentikitIncludeConfig(
+  sourceRoot: string,
+  cacheDir: string,
+  searchRoot: string = sourceRoot,
+): string | undefined {
+  const includeConfig = findNearestAgentikitIncludeConfig(sourceRoot, searchRoot)
+  if (!includeConfig) return undefined
+
+  const selectedDir = path.join(cacheDir, "selected")
+  fs.rmSync(selectedDir, { recursive: true, force: true })
+  fs.mkdirSync(selectedDir, { recursive: true })
+  copyIncludedPaths(includeConfig.baseDir, includeConfig.include, selectedDir)
+  return selectedDir
+}
+
+async function downloadArchive(url: string, destination: string): Promise<void> {
+  const response = await fetchWithTimeout(url, undefined, 120_000)
+  if (!response.ok) {
+    throw new Error(`Failed to download archive (${response.status}) from ${url}`)
+  }
+  // Stream response to disk instead of buffering the entire archive in memory.
+  // Uses Bun.write which handles Response streaming natively.
+  const BunRuntime: { write(path: string, body: Response): Promise<number> } =
+    (globalThis as Record<string, unknown>).Bun as typeof BunRuntime
+  if (BunRuntime?.write) {
+    await BunRuntime.write(destination, response)
+  } else {
+    // Fallback for non-Bun environments (e.g., tests)
+    const arrayBuffer = await response.arrayBuffer()
+    fs.writeFileSync(destination, Buffer.from(arrayBuffer))
+  }
+}
+
+function extractTarGzSecure(archivePath: string, destinationDir: string): void {
+  const listResult = spawnSync("tar", ["tzf", archivePath], { encoding: "utf8" })
+  if (listResult.status !== 0) {
+    const err = listResult.stderr?.trim() || listResult.error?.message || "unknown error"
+    throw new Error(`Failed to inspect archive ${archivePath}: ${err}`)
+  }
+
+  validateTarEntries(listResult.stdout)
+
+  fs.rmSync(destinationDir, { recursive: true, force: true })
+  fs.mkdirSync(destinationDir, { recursive: true })
+
+  const extractResult = spawnSync("tar", ["xzf", archivePath, "--strip-components=1", "-C", destinationDir], {
+    encoding: "utf8",
+  })
+  if (extractResult.status !== 0) {
+    const err = extractResult.stderr?.trim() || extractResult.error?.message || "unknown error"
+    throw new Error(`Failed to extract archive ${archivePath}: ${err}`)
+  }
+}
+
+function validateTarEntries(listOutput: string): void {
+  const lines = listOutput.split(/\r?\n/).filter(Boolean)
+  for (const rawLine of lines) {
+    const entry = rawLine.trim()
+    if (!entry || entry.includes("\0")) {
+      throw new Error(`Archive contains an invalid entry: ${JSON.stringify(rawLine)}`)
+    }
+    if (entry.startsWith("/")) {
+      throw new Error(`Archive contains an absolute path entry: ${entry}`)
+    }
+
+    const normalized = path.posix.normalize(entry)
+    if (normalized === ".." || normalized.startsWith("../")) {
+      throw new Error(`Archive contains a path traversal entry: ${entry}`)
+    }
+
+    const parts = normalized.split("/").filter(Boolean)
+    const stripped = parts.slice(1).join("/")
+    if (!stripped) continue
+    const normalizedStripped = path.posix.normalize(stripped)
+    if (normalizedStripped === ".." || normalizedStripped.startsWith("../") || path.posix.isAbsolute(normalizedStripped)) {
+      throw new Error(`Archive contains an unsafe entry after strip-components: ${entry}`)
+    }
+  }
+}
+
+function isDirectory(target: string): boolean {
+  try {
+    return fs.statSync(target).isDirectory()
+  } catch {
+    return false
+  }
+}
+
+function readAgentikitIncludeConfigAtDir(dirPath: string): { baseDir: string; include: string[] } | undefined {
+  const packageJsonPath = path.join(dirPath, "package.json")
+  if (!fs.existsSync(packageJsonPath)) return undefined
+
+  let pkg: unknown
+  try {
+    pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"))
+  } catch {
+    return undefined
+  }
+  if (typeof pkg !== "object" || pkg === null || Array.isArray(pkg)) return undefined
+
+  const agentikit = (pkg as Record<string, unknown>).agentikit
+  if (typeof agentikit !== "object" || agentikit === null || Array.isArray(agentikit)) return undefined
+
+  const include = (agentikit as Record<string, unknown>).include
+  if (!Array.isArray(include)) return undefined
+
+  const parsedInclude = include
+    .filter((value): value is string => typeof value === "string")
+    .map((value) => value.trim())
+    .filter(Boolean)
+
+  return parsedInclude.length > 0 ? { baseDir: dirPath, include: parsedInclude } : undefined
+}
+
+function findNearestAgentikitIncludeConfig(
+  startDir: string,
+  stopDir: string,
+): { baseDir: string; include: string[] } | undefined {
+  let current = path.resolve(startDir)
+  const boundary = path.resolve(stopDir)
+
+  while (isWithin(current, boundary)) {
+    const config = readAgentikitIncludeConfigAtDir(current)
+    if (config) return config
+    if (current === boundary) break
+    const parent = path.dirname(current)
+    if (parent === current) break
+    current = parent
+  }
+
+  return undefined
+}
+
+function copyIncludedPaths(baseDir: string, include: string[], destinationDir: string): void {
+  for (const entry of include) {
+    const resolvedSource = path.resolve(baseDir, entry)
+    if (!isWithin(resolvedSource, baseDir)) {
+      throw new Error(`Path in agentikit.include escapes the package root: ${entry}`)
+    }
+    if (!fs.existsSync(resolvedSource)) {
+      throw new Error(`Path in agentikit.include does not exist: ${entry}`)
+    }
+    if (path.basename(resolvedSource) === ".git") {
+      continue
+    }
+    const relativePath = path.relative(baseDir, resolvedSource)
+    if (!relativePath || relativePath === ".") {
+      copyDirectoryContents(baseDir, destinationDir)
+      continue
+    }
+    copyPath(resolvedSource, path.join(destinationDir, relativePath))
+  }
+}
+
+function copyDirectoryContents(sourceDir: string, destinationDir: string): void {
+  for (const entry of fs.readdirSync(sourceDir, { withFileTypes: true })) {
+    if (entry.name === ".git") continue
+    copyPath(path.join(sourceDir, entry.name), path.join(destinationDir, entry.name))
+  }
+}
+
+function copyPath(sourcePath: string, destinationPath: string): void {
+  const stat = fs.statSync(sourcePath)
+  fs.mkdirSync(path.dirname(destinationPath), { recursive: true })
+  if (stat.isDirectory()) {
+    fs.cpSync(sourcePath, destinationPath, { recursive: true, force: true })
+    return
+  }
+  fs.copyFileSync(sourcePath, destinationPath)
+}
+
+function hasStashDirs(dirPath: string): boolean {
+  if (!isDirectory(dirPath)) return false
+  const entries = fs.readdirSync(dirPath, { withFileTypes: true })
+  return entries.some((entry) => entry.isDirectory() && REGISTRY_STASH_DIR_NAMES.has(entry.name))
+}
+
+function findShallowestDotStashRoot(root: string): string | undefined {
+  const queue: string[] = [root]
+  while (queue.length > 0) {
+    const current = queue.shift()!
+    const dotStash = path.join(current, ".stash")
+    if (isDirectory(dotStash)) {
+      return current
+    }
+    let children: fs.Dirent[]
+    try {
+      children = fs.readdirSync(current, { withFileTypes: true })
+    } catch {
+      continue
+    }
+    for (const child of children) {
+      if (!child.isDirectory()) continue
+      if (child.name === ".git" || child.name === "node_modules") continue
+      queue.push(path.join(current, child.name))
+    }
+  }
+  return undefined
+}
+
+function normalizeInstalledEntry(entry: RegistryInstalledEntry): RegistryInstalledEntry {
+  return {
+    ...entry,
+    stashRoot: path.resolve(entry.stashRoot),
+    cacheDir: path.resolve(entry.cacheDir),
+  }
+}
+