agentcn 0.1.0

package/dist/lib/deps.js

@@ -0,0 +1,105 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExecErrorOutput = getExecErrorOutput;
+exports.detectPackageManager = detectPackageManager;
+exports.installDependencies = installDependencies;
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const path_exists_1 = require("path-exists");
+const logger_js_1 = require("../utils/logger.js");
+function getExecErrorOutput(error) {
+    if (!error || typeof error !== "object") {
+        return String(error ?? "");
+    }
+    const execError = error;
+    const message = String(execError.message ?? "");
+    const stdout = String(execError.stdout ?? "");
+    const stderr = String(execError.stderr ?? "");
+    return [message, stdout, stderr].filter(Boolean).join("\n");
+}
+function detectPackageManager(cwd) {
+    if ((0, path_exists_1.pathExistsSync)(path.join(cwd, "pnpm-lock.yaml")))
+        return "pnpm";
+    if ((0, path_exists_1.pathExistsSync)(path.join(cwd, "yarn.lock")))
+        return "yarn";
+    return "npm";
+}
+function installDependencies(cwd, dependencies, options) {
+    const deps = dependencies ?? [];
+    if (deps.length === 0)
+        return [];
+    if (options.dryRun)
+        return deps;
+    const pm = detectPackageManager(cwd);
+    const depString = deps.join(" ");
+    const cmd = pm === "pnpm"
+        ? `pnpm add ${depString}`
+        : pm === "yarn"
+            ? `yarn add ${depString}`
+            : `npm install ${depString}`;
+    const runInstall = (installCmd) => (0, child_process_1.execSync)(installCmd, {
+        cwd,
+        stdio: options.verbose ? "inherit" : "pipe",
+        encoding: options.verbose ? undefined : "utf-8",
+    });
+    try {
+        runInstall(cmd);
+    }
+    catch (error) {
+        const message = getExecErrorOutput(error);
+        if (pm === "pnpm" && message.includes("ERR_PNPM_ADDING_TO_ROOT")) {
+            // When target cwd is a workspace root, pnpm requires explicit -w.
+            try {
+                runInstall(`pnpm add -w ${depString}`);
+            }
+            catch (fallbackError) {
+                if (!options.verbose) {
+                    const fallbackMsg = getExecErrorOutput(fallbackError);
+                    if (fallbackMsg.trim().length > 0)
+                        logger_js_1.logger.error(fallbackMsg);
+                }
+                throw fallbackError;
+            }
+        }
+        else {
+            if (!options.verbose && message.trim().length > 0) {
+                logger_js_1.logger.error(message);
+            }
+            throw error;
+        }
+    }
+    return deps;
+}

package/dist/lib/install-plan.d.ts

@@ -0,0 +1,9 @@
+import type { PlannedFileAction, RegistryItem } from "../types.js";
+export declare function planInstall(item: RegistryItem, cwd: string, options: {
+    overwrite: boolean;
+}): PlannedFileAction[];
+export declare function applyInstallPlan(actions: PlannedFileAction[]): {
+    created: string[];
+    updated: string[];
+    skipped: string[];
+};

package/dist/lib/install-plan.js

@@ -0,0 +1,76 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planInstall = planInstall;
+exports.applyInstallPlan = applyInstallPlan;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function planInstall(item, cwd, options) {
+    return item.files.map((file) => {
+        const targetPath = file.target ?? file.path;
+        const absoluteTargetPath = path.join(cwd, targetPath);
+        const exists = fs.existsSync(absoluteTargetPath);
+        const action = exists
+            ? options.overwrite
+                ? "update"
+                : "skip"
+            : "create";
+        return {
+            sourcePath: file.path,
+            targetPath,
+            absoluteTargetPath,
+            content: file.content,
+            action,
+        };
+    });
+}
+function applyInstallPlan(actions) {
+    const created = [];
+    const updated = [];
+    const skipped = [];
+    for (const action of actions) {
+        if (action.action === "skip") {
+            skipped.push(action.targetPath);
+            continue;
+        }
+        fs.mkdirSync(path.dirname(action.absoluteTargetPath), { recursive: true });
+        fs.writeFileSync(action.absoluteTargetPath, action.content, "utf-8");
+        if (action.action === "create")
+            created.push(action.targetPath);
+        if (action.action === "update")
+            updated.push(action.targetPath);
+    }
+    return { created, updated, skipped };
+}

package/dist/lib/registry.d.ts

@@ -0,0 +1,5 @@
+import type { AddOptions, AddOptionsInput, RegistryIndex, RegistryItem } from "../types.js";
+export declare function parseAddOptions(input: AddOptionsInput, cwd: string): AddOptions;
+export declare function resolveRegistrySource(registryPath: string | undefined, cwd: string): string;
+export declare function loadRegistryItem(agentName: string, registryBase: string): Promise<RegistryItem>;
+export declare function loadRegistryIndex(registryBase: string): Promise<RegistryIndex>;

package/dist/lib/registry.js

@@ -0,0 +1,116 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAddOptions = parseAddOptions;
+exports.resolveRegistrySource = resolveRegistrySource;
+exports.loadRegistryItem = loadRegistryItem;
+exports.loadRegistryIndex = loadRegistryIndex;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const path_exists_1 = require("path-exists");
+const schemas_js_1 = require("../schemas.js");
+const constants_js_1 = require("../constants.js");
+function isHttpUrl(value) {
+    return value.startsWith("http://") || value.startsWith("https://");
+}
+function parseAddOptions(input, cwd) {
+    const parsed = schemas_js_1.addOptionsSchema.parse(input);
+    return {
+        registry: parsed.registry,
+        dryRun: parsed.dryRun,
+        overwrite: parsed.overwrite,
+        yes: parsed.yes,
+        verbose: parsed.verbose,
+        cwd: parsed.cwd ? path.resolve(cwd, parsed.cwd) : cwd,
+    };
+}
+function resolveRegistrySource(registryPath, cwd) {
+    if (registryPath) {
+        if (isHttpUrl(registryPath))
+            return registryPath;
+        const resolved = path.resolve(cwd, registryPath);
+        if ((0, path_exists_1.pathExistsSync)(resolved))
+            return resolved;
+    }
+    const envRegistry = process.env.AGENTCN_REGISTRY_URL?.trim();
+    if (envRegistry) {
+        if (isHttpUrl(envRegistry))
+            return envRegistry;
+        const resolved = path.resolve(cwd, envRegistry);
+        if ((0, path_exists_1.pathExistsSync)(resolved))
+            return resolved;
+    }
+    const scriptDir = path.dirname(process.argv[1] || cwd);
+    const localRegistry = path.resolve(scriptDir, "../../../../apps/web/public/r");
+    if ((0, path_exists_1.pathExistsSync)(localRegistry))
+        return localRegistry;
+    return "https://agentcn.dev/r";
+}
+async function loadJson(source) {
+    if (isHttpUrl(source)) {
+        const res = await fetch(source);
+        if (!res.ok) {
+            throw new Error(`Failed to fetch ${source} (${res.status})`);
+        }
+        return res.json();
+    }
+    if (!(0, path_exists_1.pathExistsSync)(source)) {
+        throw new Error(`File not found: ${source}`);
+    }
+    return JSON.parse(fs.readFileSync(source, "utf-8"));
+}
+function assertSchemaVersion(schemaVersion) {
+    if (schemaVersion !== constants_js_1.REGISTRY_SCHEMA_VERSION) {
+        throw new Error(`Registry schema mismatch. Expected ${constants_js_1.REGISTRY_SCHEMA_VERSION}, got ${schemaVersion}.`);
+    }
+}
+async function loadRegistryItem(agentName, registryBase) {
+    const source = isHttpUrl(registryBase)
+        ? `${registryBase.replace(/\/$/, "")}/${agentName}.json`
+        : path.join(registryBase, `${agentName}.json`);
+    const json = await loadJson(source);
+    const item = schemas_js_1.registryItemSchema.parse(json);
+    assertSchemaVersion(item.schemaVersion);
+    return item;
+}
+async function loadRegistryIndex(registryBase) {
+    const source = isHttpUrl(registryBase)
+        ? `${registryBase.replace(/\/$/, "")}/index.json`
+        : path.join(registryBase, "index.json");
+    const json = await loadJson(source);
+    const index = schemas_js_1.registryIndexSchema.parse(json);
+    assertSchemaVersion(index.schemaVersion);
+    return index;
+}

package/dist/schemas.d.ts

@@ -0,0 +1,144 @@
+import { z } from "zod";
+export declare const registryFileSchema: z.ZodObject<{
+    path: z.ZodString;
+    type: z.ZodString;
+    target: z.ZodOptional<z.ZodString>;
+    content: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    content: string;
+    path: string;
+    type: string;
+    target?: string | undefined;
+}, {
+    content: string;
+    path: string;
+    type: string;
+    target?: string | undefined;
+}>;
+export declare const registryItemSchema: z.ZodObject<{
+    schemaVersion: z.ZodNumber;
+    name: z.ZodString;
+    type: z.ZodString;
+    description: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    categories: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    dependencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    envVars: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        type: z.ZodString;
+        target: z.ZodOptional<z.ZodString>;
+        content: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        content: string;
+        path: string;
+        type: string;
+        target?: string | undefined;
+    }, {
+        content: string;
+        path: string;
+        type: string;
+        target?: string | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    schemaVersion: number;
+    name: string;
+    description: string;
+    files: {
+        content: string;
+        path: string;
+        type: string;
+        target?: string | undefined;
+    }[];
+    title?: string | undefined;
+    categories?: string[] | undefined;
+    dependencies?: string[] | undefined;
+    envVars?: Record<string, string> | undefined;
+}, {
+    type: string;
+    schemaVersion: number;
+    name: string;
+    description: string;
+    files: {
+        content: string;
+        path: string;
+        type: string;
+        target?: string | undefined;
+    }[];
+    title?: string | undefined;
+    categories?: string[] | undefined;
+    dependencies?: string[] | undefined;
+    envVars?: Record<string, string> | undefined;
+}>;
+export declare const registryIndexItemSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    categories: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    description: string;
+    categories?: string[] | undefined;
+}, {
+    name: string;
+    description: string;
+    categories?: string[] | undefined;
+}>;
+export declare const registryIndexSchema: z.ZodObject<{
+    schemaVersion: z.ZodNumber;
+    name: z.ZodString;
+    homepage: z.ZodOptional<z.ZodString>;
+    items: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        categories: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        description: string;
+        categories?: string[] | undefined;
+    }, {
+        name: string;
+        description: string;
+        categories?: string[] | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    schemaVersion: number;
+    name: string;
+    items: {
+        name: string;
+        description: string;
+        categories?: string[] | undefined;
+    }[];
+    homepage?: string | undefined;
+}, {
+    schemaVersion: number;
+    name: string;
+    items: {
+        name: string;
+        description: string;
+        categories?: string[] | undefined;
+    }[];
+    homepage?: string | undefined;
+}>;
+export declare const addOptionsSchema: z.ZodObject<{
+    registry: z.ZodOptional<z.ZodString>;
+    dryRun: z.ZodDefault<z.ZodBoolean>;
+    overwrite: z.ZodDefault<z.ZodBoolean>;
+    yes: z.ZodDefault<z.ZodBoolean>;
+    verbose: z.ZodDefault<z.ZodBoolean>;
+    cwd: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    dryRun: boolean;
+    overwrite: boolean;
+    yes: boolean;
+    verbose: boolean;
+    cwd?: string | undefined;
+    registry?: string | undefined;
+}, {
+    cwd?: string | undefined;
+    registry?: string | undefined;
+    dryRun?: boolean | undefined;
+    overwrite?: boolean | undefined;
+    yes?: boolean | undefined;
+    verbose?: boolean | undefined;
+}>;

package/dist/schemas.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addOptionsSchema = exports.registryIndexSchema = exports.registryIndexItemSchema = exports.registryItemSchema = exports.registryFileSchema = void 0;
+const zod_1 = require("zod");
+exports.registryFileSchema = zod_1.z.object({
+    path: zod_1.z.string().min(1),
+    type: zod_1.z.string().min(1),
+    target: zod_1.z.string().min(1).optional(),
+    content: zod_1.z.string(),
+});
+exports.registryItemSchema = zod_1.z.object({
+    schemaVersion: zod_1.z.number().int(),
+    name: zod_1.z.string().min(1),
+    type: zod_1.z.string().min(1),
+    description: zod_1.z.string().min(1),
+    title: zod_1.z.string().optional(),
+    categories: zod_1.z.array(zod_1.z.string()).optional(),
+    dependencies: zod_1.z.array(zod_1.z.string()).optional(),
+    envVars: zod_1.z.record(zod_1.z.string()).optional(),
+    files: zod_1.z.array(exports.registryFileSchema),
+});
+exports.registryIndexItemSchema = zod_1.z.object({
+    name: zod_1.z.string().min(1),
+    description: zod_1.z.string().min(1),
+    categories: zod_1.z.array(zod_1.z.string()).optional(),
+});
+exports.registryIndexSchema = zod_1.z.object({
+    schemaVersion: zod_1.z.number().int(),
+    name: zod_1.z.string().min(1),
+    homepage: zod_1.z.string().optional(),
+    items: zod_1.z.array(exports.registryIndexItemSchema),
+});
+exports.addOptionsSchema = zod_1.z.object({
+    registry: zod_1.z.string().optional(),
+    dryRun: zod_1.z.boolean().default(false),
+    overwrite: zod_1.z.boolean().default(false),
+    yes: zod_1.z.boolean().default(false),
+    verbose: zod_1.z.boolean().default(false),
+    cwd: zod_1.z.string().optional(),
+});

package/dist/tests/add.integration.test.d.ts

@@ -0,0 +1 @@
+export {};