agentikit 0.0.9 → 0.0.13

package/dist/src/registry-install.js

@@ -1,12 +1,15 @@
 import { spawnSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
-import { TYPE_DIRS } from "./common";
+import { fetchWithTimeout, isWithin, TYPE_DIRS } from "./common";
 import { loadConfig, saveConfig } from "./config";
 import { parseRegistryRef, resolveRegistryArtifact } from "./registry-resolve";
 const REGISTRY_STASH_DIR_NAMES = new Set(Object.values(TYPE_DIRS));
 export async function installRegistryRef(ref, options) {
     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();
@@ -16,6 +19,38 @@ export async function installRegistryRef(ref, options) {
     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, options) {
+    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,
@@ -30,39 +65,27 @@ export async function installRegistryRef(ref, options) {
         stashRoot,
     };
 }
-export function upsertInstalledRegistryEntry(entry, stashDir) {
-    const current = loadConfig(stashDir);
+export function upsertInstalledRegistryEntry(entry) {
+    const current = loadConfig();
     const currentInstalled = current.registry?.installed ?? [];
-    const previousRegistryRoots = new Set(currentInstalled.map((item) => path.resolve(item.stashRoot)));
     const withoutExisting = currentInstalled.filter((item) => item.id !== entry.id);
     const nextInstalled = [...withoutExisting, normalizeInstalledEntry(entry)];
-    const nextRegistryRoots = new Set(nextInstalled.map((item) => path.resolve(item.stashRoot)));
-    const preservedAdditional = current.additionalStashDirs.filter((dir) => !previousRegistryRoots.has(path.resolve(dir)));
-    const syncedAdditional = uniquePaths([...preservedAdditional, ...nextRegistryRoots]);
     const nextConfig = {
         ...current,
-        additionalStashDirs: syncedAdditional,
-        registry: {
-            installed: nextInstalled,
-        },
+        registry: { installed: nextInstalled },
     };
-    saveConfig(nextConfig, stashDir);
+    saveConfig(nextConfig);
     return nextConfig;
 }
-export function removeInstalledRegistryEntry(id, stashDir) {
-    const current = loadConfig(stashDir);
+export function removeInstalledRegistryEntry(id) {
+    const current = loadConfig();
     const currentInstalled = current.registry?.installed ?? [];
-    const previousRegistryRoots = new Set(currentInstalled.map((item) => path.resolve(item.stashRoot)));
     const nextInstalled = currentInstalled.filter((item) => item.id !== id);
-    const nextRegistryRoots = new Set(nextInstalled.map((item) => path.resolve(item.stashRoot)));
-    const preservedAdditional = current.additionalStashDirs.filter((dir) => !previousRegistryRoots.has(path.resolve(dir)));
-    const syncedAdditional = uniquePaths([...preservedAdditional, ...nextRegistryRoots]);
     const nextConfig = {
         ...current,
-        additionalStashDirs: syncedAdditional,
         registry: nextInstalled.length > 0 ? { installed: nextInstalled } : undefined,
     };
-    saveConfig(nextConfig, stashDir);
+    saveConfig(nextConfig);
     return nextConfig;
 }
 export function getRegistryCacheRootDir() {
@@ -99,13 +122,32 @@ function buildInstallCacheDir(cacheRootDir, source, id) {
     const stamp = `${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
     return path.join(cacheRootDir, slug || source, stamp);
 }
+function applyAgentikitIncludeConfig(sourceRoot, cacheDir, searchRoot = sourceRoot) {
+    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, destination) {
-    const response = await fetch(url);
+    const response = await fetchWithTimeout(url, undefined, 120_000);
     if (!response.ok) {
         throw new Error(`Failed to download archive (${response.status}) from ${url}`);
     }
-    const arrayBuffer = await response.arrayBuffer();
-    fs.writeFileSync(destination, Buffer.from(arrayBuffer));
+    // Stream response to disk instead of buffering the entire archive in memory.
+    // Uses Bun.write which handles Response streaming natively.
+    const BunRuntime = globalThis.Bun;
+    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, destinationDir) {
     const listResult = spawnSync("tar", ["tzf", archivePath], { encoding: "utf8" });
@@ -156,6 +198,83 @@ function isDirectory(target) {
         return false;
     }
 }
+function readAgentikitIncludeConfigAtDir(dirPath) {
+    const packageJsonPath = path.join(dirPath, "package.json");
+    if (!fs.existsSync(packageJsonPath))
+        return undefined;
+    let pkg;
+    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.agentikit;
+    if (typeof agentikit !== "object" || agentikit === null || Array.isArray(agentikit))
+        return undefined;
+    const include = agentikit.include;
+    if (!Array.isArray(include))
+        return undefined;
+    const parsedInclude = include
+        .filter((value) => typeof value === "string")
+        .map((value) => value.trim())
+        .filter(Boolean);
+    return parsedInclude.length > 0 ? { baseDir: dirPath, include: parsedInclude } : undefined;
+}
+function findNearestAgentikitIncludeConfig(startDir, stopDir) {
+    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, include, destinationDir) {
+    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, destinationDir) {
+    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, destinationPath) {
+    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) {
     if (!isDirectory(dirPath))
         return false;
@@ -194,15 +313,3 @@ function normalizeInstalledEntry(entry) {
         cacheDir: path.resolve(entry.cacheDir),
     };
 }
-function uniquePaths(paths) {
-    const seen = new Set();
-    const result = [];
-    for (const candidate of paths) {
-        const normalized = path.resolve(candidate);
-        if (seen.has(normalized))
-            continue;
-        seen.add(normalized);
-        result.push(normalized);
-    }
-    return result;
-}

package/dist/src/registry-resolve.js

@@ -1,4 +1,9 @@
-const GITHUB_API_BASE = "https://api.github.com";
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { fetchWithTimeout } from "./common";
+import { GITHUB_API_BASE, githubHeaders, asRecord, asString } from "./github";
 export function parseRegistryRef(rawRef) {
     const ref = rawRef.trim();
     if (!ref)
@@ -12,6 +17,10 @@ export function parseRegistryRef(rawRef) {
     if (ref.startsWith("http://") || ref.startsWith("https://")) {
         return parseGithubUrl(ref);
     }
+    const localGitRef = tryParseLocalGitRef(ref, isPathLikeRef(ref));
+    if (localGitRef) {
+        return localGitRef;
+    }
     if (ref.startsWith("@") || !looksLikeGithubOwnerRepo(ref)) {
         return parseNpmRef(ref, ref);
     }
@@ -21,6 +30,9 @@ export async function resolveRegistryArtifact(parsed) {
     if (parsed.source === "npm") {
         return resolveNpmArtifact(parsed);
     }
+    if (parsed.source === "git") {
+        return resolveGitArtifact(parsed);
+    }
     return resolveGithubArtifact(parsed);
 }
 function parseNpmRef(input, originalRef) {
@@ -84,6 +96,41 @@ function parseGithubUrl(rawUrl) {
         requestedRef,
     };
 }
+function tryParseLocalGitRef(rawRef, explicitPath) {
+    if (!explicitPath) {
+        return undefined;
+    }
+    const resolvedPath = path.resolve(rawRef);
+    let stat;
+    try {
+        stat = fs.statSync(resolvedPath);
+    }
+    catch {
+        throw new Error(`Local path not found: ${resolvedPath}`);
+    }
+    if (!stat.isDirectory()) {
+        throw new Error("Local add path must be a directory, but the provided path is not one.");
+    }
+    const repoRoot = findGitRepoRoot(resolvedPath);
+    if (!repoRoot) {
+        throw new Error("Local add path must be inside a git repository.");
+    }
+    return {
+        source: "git",
+        ref: rawRef,
+        id: `git:${encodeURIComponent(resolvedPath)}`,
+        repoRoot,
+        sourcePath: resolvedPath,
+    };
+}
+function isPathLikeRef(ref) {
+    if (path.isAbsolute(ref))
+        return true;
+    if (ref.startsWith("./") || ref.startsWith("../") || ref.startsWith(".\\") || ref.startsWith("..\\")) {
+        return true;
+    }
+    return ref.includes("/") || ref.includes("\\");
+}
 async function resolveNpmArtifact(parsed) {
     const encodedName = encodeURIComponent(parsed.packageName);
     const metadata = await fetchJson(`https://registry.npmjs.org/${encodedName}`);
@@ -162,6 +209,16 @@ async function resolveGithubArtifact(parsed) {
         resolvedRevision: asString(commit?.sha) ?? defaultBranch,
     };
 }
+async function resolveGitArtifact(parsed) {
+    return {
+        id: parsed.id,
+        source: parsed.source,
+        ref: parsed.ref,
+        artifactUrl: pathToFileURL(parsed.sourcePath).toString(),
+        resolvedRevision: readGitValue(parsed.repoRoot, "rev-parse", "HEAD"),
+        resolvedVersion: readGitValue(parsed.repoRoot, "rev-parse", "--abbrev-ref", "HEAD"),
+    };
+}
 function splitNpmNameAndVersion(input) {
     if (input.startsWith("@")) {
         const secondAt = input.indexOf("@", 1);
@@ -183,8 +240,18 @@ function splitNpmNameAndVersion(input) {
     return { packageName: input };
 }
 function validateNpmPackageName(name) {
-    if (!name || name.includes(" ")) {
-        throw new Error(`Invalid npm package name: \"${name}\".`);
+    if (!name)
+        throw new Error('Invalid npm package name: name is required.');
+    if (name.length > 214)
+        throw new Error(`Invalid npm package name: "${name}" exceeds 214 characters.`);
+    if (name !== name.toLowerCase() && !name.startsWith('@')) {
+        throw new Error(`Invalid npm package name: "${name}" must be lowercase.`);
+    }
+    if (name.startsWith('.') || name.startsWith('_')) {
+        throw new Error(`Invalid npm package name: "${name}" cannot start with . or _.`);
+    }
+    if (/[~'!()*]/.test(name) || name.includes(' ') || encodeURIComponent(name).replace(/%40/g, '@').replace(/%2[Ff]/g, '/') !== name) {
+        throw new Error(`Invalid npm package name: "${name}" contains invalid characters.`);
     }
 }
 function looksLikeGithubOwnerRepo(ref) {
@@ -198,34 +265,35 @@ function splitRefSuffix(value) {
         return [value, undefined];
     return [value.slice(0, hash), value.slice(hash + 1) || undefined];
 }
-function githubHeaders() {
-    const token = process.env.GITHUB_TOKEN?.trim();
-    const headers = {
-        Accept: "application/vnd.github+json",
-        "User-Agent": "agentikit-registry",
-    };
-    if (token)
-        headers.Authorization = `Bearer ${token}`;
-    return headers;
+function findGitRepoRoot(startDir) {
+    let current = path.resolve(startDir);
+    while (true) {
+        if (fs.existsSync(path.join(current, ".git"))) {
+            return current;
+        }
+        const parent = path.dirname(current);
+        if (parent === current)
+            return undefined;
+        current = parent;
+    }
+}
+function readGitValue(repoRoot, ...args) {
+    const result = spawnSync("git", ["-C", repoRoot, ...args], { encoding: "utf8" });
+    if (result.status !== 0)
+        return undefined;
+    const value = result.stdout.trim();
+    return value || undefined;
 }
 async function fetchJson(url, headers) {
-    const response = await fetch(url, { headers });
+    const response = await fetchWithTimeout(url, { headers });
     if (!response.ok) {
         throw new Error(`Request failed (${response.status}) for ${url}`);
     }
     return await response.json();
 }
 async function tryFetchJson(url, headers) {
-    const response = await fetch(url, { headers });
+    const response = await fetchWithTimeout(url, { headers });
     if (!response.ok)
         return null;
     return await response.json();
 }
-function asRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value)
-        ? value
-        : {};
-}
-function asString(value) {
-    return typeof value === "string" && value ? value : undefined;
-}

package/dist/src/registry-search.d.ts

@@ -1,5 +1,27 @@
 import type { RegistrySearchResponse } from "./registry-types";
+export interface RegistryIndex {
+    version: number;
+    updatedAt: string;
+    kits: RegistryKitEntry[];
+}
+export interface RegistryKitEntry {
+    id: string;
+    name: string;
+    description?: string;
+    ref: string;
+    source: "npm" | "github" | "git";
+    homepage?: string;
+    tags?: string[];
+    assetTypes?: string[];
+    author?: string;
+    license?: string;
+    latestVersion?: string;
+    /** Whether this entry was manually reviewed and approved */
+    curated?: boolean;
+}
 export interface RegistrySearchOptions {
     limit?: number;
+    /** Override registry URL(s). Accepts a single URL or an array. */
+    registryUrls?: string | string[];
 }
 export declare function searchRegistry(query: string, options?: RegistrySearchOptions): Promise<RegistrySearchResponse>;