agentikit 0.0.7 → 0.0.9

package/src/stash-registry.ts

@@ -0,0 +1,259 @@
+import fs from "node:fs"
+import { resolveStashDir } from "./common"
+import { loadConfig } from "./config"
+import { agentikitIndex } from "./indexer"
+import {
+  installRegistryRef,
+  removeInstalledRegistryEntry,
+  upsertInstalledRegistryEntry,
+} from "./registry-install"
+import { parseRegistryRef } from "./registry-resolve"
+import type { RegistryInstalledEntry } from "./registry-types"
+import type {
+  ListResponse,
+  RegistryInstallStatus,
+  RemoveResponse,
+  ReinstallResponse,
+  UpdateResponse,
+} from "./stash-types"
+
+export async function agentikitList(input?: { stashDir?: string }): Promise<ListResponse> {
+  const stashDir = input?.stashDir ?? resolveStashDir()
+  const config = loadConfig(stashDir)
+  const installed = config.registry?.installed ?? []
+
+  return {
+    stashDir,
+    installed: installed.map((entry) => ({
+      ...entry,
+      status: {
+        cacheDirExists: directoryExists(entry.cacheDir),
+        stashRootExists: directoryExists(entry.stashRoot),
+      },
+    })),
+    totalInstalled: installed.length,
+  }
+}
+
+export async function agentikitRemove(input: { target: string; stashDir?: string }): Promise<RemoveResponse> {
+  const target = input.target.trim()
+  if (!target) throw new Error("Target is required.")
+
+  const stashDir = input.stashDir ?? resolveStashDir()
+  const config = loadConfig(stashDir)
+  const installed = config.registry?.installed ?? []
+  const entry = resolveInstalledTarget(installed, target)
+
+  const updatedConfig = removeInstalledRegistryEntry(entry.id, stashDir)
+  cleanupDirectoryBestEffort(entry.cacheDir)
+  const index = await agentikitIndex({ stashDir })
+
+  return {
+    stashDir,
+    target,
+    removed: {
+      id: entry.id,
+      source: entry.source,
+      ref: entry.ref,
+      cacheDir: entry.cacheDir,
+      stashRoot: entry.stashRoot,
+    },
+    config: {
+      additionalStashDirs: updatedConfig.additionalStashDirs,
+      installedRegistryCount: updatedConfig.registry?.installed.length ?? 0,
+    },
+    index: {
+      mode: index.mode,
+      totalEntries: index.totalEntries,
+      directoriesScanned: index.directoriesScanned,
+      directoriesSkipped: index.directoriesSkipped,
+    },
+  }
+}
+
+export async function agentikitReinstall(input?: {
+  target?: string
+  all?: boolean
+  stashDir?: string
+}): Promise<ReinstallResponse> {
+  const stashDir = input?.stashDir ?? resolveStashDir()
+  const target = input?.target?.trim()
+  const all = input?.all === true
+  const installedEntries = loadConfig(stashDir).registry?.installed ?? []
+  const selectedEntries = selectTargets(installedEntries, target, all)
+
+  const processed: ReinstallResponse["processed"] = []
+  for (const entry of selectedEntries) {
+    const installed = await installRegistryRef(entry.ref)
+    upsertInstalledRegistryEntry(toInstalledEntry(installed), stashDir)
+    if (entry.cacheDir !== installed.cacheDir) {
+      cleanupDirectoryBestEffort(entry.cacheDir)
+    }
+
+    processed.push({
+      id: entry.id,
+      source: entry.source,
+      ref: entry.ref,
+      previousCacheDir: entry.cacheDir,
+      installed: toInstallStatus(installed),
+    })
+  }
+
+  const index = await agentikitIndex({ stashDir })
+  const config = loadConfig(stashDir)
+
+  return {
+    stashDir,
+    target,
+    all,
+    processed,
+    config: {
+      additionalStashDirs: config.additionalStashDirs,
+      installedRegistryCount: config.registry?.installed.length ?? 0,
+    },
+    index: {
+      mode: index.mode,
+      totalEntries: index.totalEntries,
+      directoriesScanned: index.directoriesScanned,
+      directoriesSkipped: index.directoriesSkipped,
+    },
+  }
+}
+
+export async function agentikitUpdate(input?: {
+  target?: string
+  all?: boolean
+  stashDir?: string
+}): Promise<UpdateResponse> {
+  const stashDir = input?.stashDir ?? resolveStashDir()
+  const target = input?.target?.trim()
+  const all = input?.all === true
+  const installedEntries = loadConfig(stashDir).registry?.installed ?? []
+  const selectedEntries = selectTargets(installedEntries, target, all)
+
+  const processed: UpdateResponse["processed"] = []
+  for (const entry of selectedEntries) {
+    const installed = await installRegistryRef(entry.ref)
+    upsertInstalledRegistryEntry(toInstalledEntry(installed), stashDir)
+    if (entry.cacheDir !== installed.cacheDir) {
+      cleanupDirectoryBestEffort(entry.cacheDir)
+    }
+
+    const versionChanged = (entry.resolvedVersion ?? "") !== (installed.resolvedVersion ?? "")
+    const revisionChanged = (entry.resolvedRevision ?? "") !== (installed.resolvedRevision ?? "")
+
+    processed.push({
+      id: entry.id,
+      source: entry.source,
+      ref: entry.ref,
+      previous: {
+        resolvedVersion: entry.resolvedVersion,
+        resolvedRevision: entry.resolvedRevision,
+        cacheDir: entry.cacheDir,
+      },
+      installed: toInstallStatus(installed),
+      changed: {
+        version: versionChanged,
+        revision: revisionChanged,
+        any: versionChanged || revisionChanged,
+      },
+    })
+  }
+
+  const index = await agentikitIndex({ stashDir })
+  const config = loadConfig(stashDir)
+
+  return {
+    stashDir,
+    target,
+    all,
+    processed,
+    config: {
+      additionalStashDirs: config.additionalStashDirs,
+      installedRegistryCount: config.registry?.installed.length ?? 0,
+    },
+    index: {
+      mode: index.mode,
+      totalEntries: index.totalEntries,
+      directoriesScanned: index.directoriesScanned,
+      directoriesSkipped: index.directoriesSkipped,
+    },
+  }
+}
+
+function selectTargets(installed: RegistryInstalledEntry[], target: string | undefined, all: boolean): RegistryInstalledEntry[] {
+  if (all && target) {
+    throw new Error("Specify either <target> or --all, not both.")
+  }
+  if (all) return installed
+  if (!target) {
+    throw new Error("Either <target> or --all is required.")
+  }
+  return [resolveInstalledTarget(installed, target)]
+}
+
+function resolveInstalledTarget(installed: RegistryInstalledEntry[], target: string): RegistryInstalledEntry {
+  const byId = installed.find((entry) => entry.id === target)
+  if (byId) return byId
+
+  const byRef = installed.find((entry) => entry.ref === target)
+  if (byRef) return byRef
+
+  let parsedId: string | undefined
+  try {
+    parsedId = parseRegistryRef(target).id
+  } catch {
+    parsedId = undefined
+  }
+  if (parsedId) {
+    const byParsedId = installed.find((entry) => entry.id === parsedId)
+    if (byParsedId) return byParsedId
+  }
+
+  throw new Error(`No installed registry entry matched target: ${target}`)
+}
+
+function toInstalledEntry(status: RegistryInstallStatus): RegistryInstalledEntry {
+  return {
+    id: status.id,
+    source: status.source,
+    ref: status.ref,
+    artifactUrl: status.artifactUrl,
+    resolvedVersion: status.resolvedVersion,
+    resolvedRevision: status.resolvedRevision,
+    stashRoot: status.stashRoot,
+    cacheDir: status.cacheDir,
+    installedAt: status.installedAt,
+  }
+}
+
+function toInstallStatus(status: RegistryInstallStatus): RegistryInstallStatus {
+  return {
+    id: status.id,
+    source: status.source,
+    ref: status.ref,
+    artifactUrl: status.artifactUrl,
+    resolvedVersion: status.resolvedVersion,
+    resolvedRevision: status.resolvedRevision,
+    stashRoot: status.stashRoot,
+    cacheDir: status.cacheDir,
+    extractedDir: status.extractedDir,
+    installedAt: status.installedAt,
+  }
+}
+
+function cleanupDirectoryBestEffort(target: string): void {
+  try {
+    fs.rmSync(target, { recursive: true, force: true })
+  } catch {
+    // Best-effort cleanup only.
+  }
+}
+
+function directoryExists(target: string): boolean {
+  try {
+    return fs.statSync(target).isDirectory()
+  } catch {
+    return false
+  }
+}

package/src/stash-resolve.ts

@@ -0,0 +1,47 @@
+import fs from "node:fs"
+import path from "node:path"
+import { type AgentikitAssetType, hasErrnoCode, isWithin } from "./common"
+import { TYPE_DIRS, isRelevantAssetFile, resolveAssetPathFromName } from "./asset-spec"
+
+export function resolveAssetPath(stashDir: string, type: AgentikitAssetType, name: string): string {
+  const root = path.join(stashDir, TYPE_DIRS[type])
+  const target = resolveAssetPathFromName(type, root, name)
+  const resolvedRoot = resolveAndValidateTypeRoot(root, type, name)
+  const resolvedTarget = path.resolve(target)
+  if (!isWithin(resolvedTarget, resolvedRoot)) {
+    throw new Error("Ref resolves outside the stash root.")
+  }
+  if (!fs.existsSync(resolvedTarget) || !fs.statSync(resolvedTarget).isFile()) {
+    throw new Error(`Stash asset not found for ref: ${type}:${name}`)
+  }
+  const realTarget = fs.realpathSync(resolvedTarget)
+  if (!isWithin(realTarget, resolvedRoot)) {
+    throw new Error("Ref resolves outside the stash root.")
+  }
+  if (!isRelevantAssetFile(type, path.basename(resolvedTarget))) {
+    if (type === "tool") {
+      throw new Error("Tool ref must resolve to a .sh, .ts, .js, .ps1, .cmd, or .bat file.")
+    }
+    throw new Error(`Stash asset not found for ref: ${type}:${name}`)
+  }
+  return realTarget
+}
+
+function resolveAndValidateTypeRoot(root: string, type: AgentikitAssetType, name: string): string {
+  const rootStat = readTypeRootStat(root, type, name)
+  if (!rootStat.isDirectory()) {
+    throw new Error(`Stash type root is not a directory for ref: ${type}:${name}`)
+  }
+  return fs.realpathSync(root)
+}
+
+function readTypeRootStat(root: string, type: AgentikitAssetType, name: string): fs.Stats {
+  try {
+    return fs.statSync(root)
+  } catch (error: unknown) {
+    if (hasErrnoCode(error, "ENOENT")) {
+      throw new Error(`Stash type root not found for ref: ${type}:${name}`)
+    }
+    throw error
+  }
+}