@choiceopen/automation-plugin-cli 0.1.3 → 0.2.2

package/dist/commands/plugin/init.js

@@ -0,0 +1,289 @@
+import path from "node:path";
+import checkbox from "@inquirer/checkbox";
+import input from "@inquirer/input";
+import select from "@inquirer/select";
+import { Command, Flags } from "@oclif/core";
+import { colorize } from "@oclif/core/ux";
+import { assert, isString } from "es-toolkit";
+import { dedent } from "ts-dedent";
+import z from "zod";
+import { createPluginGenerator } from "../../utils/generator.js";
+import { checkboxTheme, selectTheme } from "../../utils/theme.js";
+const LOCALES = ["en_US", "zh_Hans", "ja_JP"];
+const LANGUAGES = ["elixir", "python", "typescript"];
+export default class PluginInit extends Command {
+    static description = dedent `
+    Initialize a new plugin with step-by-step interactive instructions.
+
+    Providing required flags skips interactive flow and completes initialization in one go.
+  `;
+    static examples = [
+        {
+            command: "<%= config.bin %> <%= command.id %>",
+            description: "Start with interactive initialization:",
+        },
+    ];
+    static flags = {
+        interactive: Flags.boolean({
+            allowNo: true,
+            char: "i",
+            default: true,
+            summary: "Use interactive mode (by default)",
+        }),
+        name: Flags.string({
+            char: "n",
+            helpValue: "my-awesome-plugin",
+            summary: "Plugin name",
+        }),
+        description: Flags.string({
+            char: "d",
+            default: "",
+            helpValue: "Descriptive text...",
+            summary: "Short description",
+        }),
+        author: Flags.string({
+            char: "a",
+            default: "",
+            helpValue: "John Doe",
+            summary: "Author name",
+        }),
+        email: Flags.string({
+            char: "e",
+            default: "",
+            helpValue: "john.doe@example.com",
+            summary: "Author email address",
+        }),
+        url: Flags.string({
+            char: "u",
+            default: "",
+            summary: "Repository URL",
+        }),
+        locales: Flags.option({
+            multiple: true,
+            options: LOCALES,
+        })({
+            delimiter: ",",
+            summary: "Provide READMEs in which languages",
+        }),
+        language: Flags.option({
+            multiple: false,
+            options: LANGUAGES,
+        })({
+            char: "l",
+            summary: "Programming language to use for plugin development",
+        }),
+        type: Flags.option({
+            multiple: false,
+            options: ["extension", "llm", "tool", "trigger"],
+        })({
+            char: "t",
+            summary: "Plugin type",
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(PluginInit);
+        this.reconcileInteractiveFlag(flags);
+        if (flags.interactive) {
+            await this.runInteractiveMode(flags);
+        }
+        assert(flags.name, "flags.name should be valid here...");
+        assert(flags.language, "flags.language should be valid here...");
+        const generator = createPluginGenerator(flags.language, {
+            props: {
+                ...flags,
+                createdAt: new Date().toISOString(),
+                date: new Date().toISOString().slice(0, 10),
+                year: new Date().getFullYear().toString(),
+            },
+            target: path.join(process.cwd(), flags.name),
+        });
+        await generator.generate();
+    }
+    nameIsValid(name) {
+        return isString(name) && /^[a-z][a-z0-9_-]{2,62}[a-z0-9]$/.test(name);
+    }
+    reconcileInteractiveFlag(flags) {
+        if (flags.interactive && this.nameIsValid(flags.name)) {
+            flags.interactive = false;
+        }
+        if (!flags.interactive && !this.nameIsValid(flags.name)) {
+            this.log(colorize("redBright", dedent `
+            Without interactive mode, you should provide initial information manually.
+            Use ${colorize("blue", "atomemo help plugin init")} to see all available options.
+          `));
+            this.exit(0);
+        }
+    }
+    async runInteractiveMode(flags) {
+        this.log(dedent `
+      Guiding you through creating a new plugin in interactive mode
+      Please follow the instructions below to complete the process:\n
+    `);
+        try {
+            flags.name = await this.collectName();
+            flags.description = await this.collectDescription();
+            flags.author = await this.collectAuthor();
+            flags.email = await this.collectEmail();
+            flags.url = await this.collectURL();
+            flags.locales = await this.collectLocales(flags);
+            flags.language = await this.collectLanguage();
+            flags.type = await this.collectType();
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === "ExitPromptError") {
+                process.exit(0);
+            }
+            throw error;
+        }
+    }
+    async collectName() {
+        return await input({
+            message: "What's the name of this new plugin:",
+            pattern: /^[a-z][a-z0-9_-]{2,62}[a-z0-9]$/,
+            patternError: dedent `
+        You must provide a name for the new plugin:
+          - Only lowercase letters, digits, underscores, and hyphens are allowed
+          - Minimum length of 4 and maximum length of 64
+          - Starts with a lowercase letter (not a digit)
+          - Ends with a lowercase letter or digit (not underscore or hyphen)
+      `,
+        });
+    }
+    async collectDescription() {
+        return await input({
+            message: "How do you describe this new plugin:",
+            default: "A brief description of the plugin's functionality",
+            prefill: "tab",
+            pattern: /^.{16,256}$/,
+            patternError: dedent `
+        You must provide a description for the new plugin:
+          - Allows any characters, minimum 16 characters, maximum 256 characters
+      `,
+        });
+    }
+    async collectAuthor() {
+        return await input({
+            message: "Who is the author of the new plugin:",
+            default: "John Doe",
+            prefill: "tab",
+            pattern: /^.{2,64}$/,
+            patternError: dedent `
+        You must provide the author name:
+          - Allows any characters, minimum 2 characters, maximum 64 characters
+      `,
+        });
+    }
+    async collectEmail() {
+        return await input({
+            message: "What is the email address of the author:",
+            default: "john.doe@example.com",
+            prefill: "tab",
+            pattern: /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}(?:\.[a-zA-Z]{2,})*$/,
+            patternError: dedent `You must provide the author email`,
+        });
+    }
+    async collectURL() {
+        return await input({
+            message: "What is the repository URL address (Optional):",
+            default: "https://github.com/[user]/[repo]",
+            prefill: "tab",
+            validate: (value) => {
+                const { success } = z
+                    .url({ normalize: true, protocol: /https?|git/ })
+                    .optional()
+                    .safeParse(value);
+                return success || "You must provide a valid URL";
+            },
+        });
+    }
+    async collectLocales(flags) {
+        const values = await checkbox({
+            choices: [
+                {
+                    checked: flags.locales?.includes("en_US"),
+                    disabled: "(required)",
+                    name: "English",
+                    description: "English (United States)",
+                    value: "en_US",
+                },
+                {
+                    checked: flags.locales?.includes("zh_Hans"),
+                    disabled: false,
+                    name: "简体中文",
+                    description: "Simplified Chinese (China)",
+                    value: "zh_Hans",
+                },
+                {
+                    checked: flags.locales?.includes("ja_JP"),
+                    disabled: false,
+                    name: "日本語",
+                    description: "Japanese (Japan)",
+                    value: "ja_JP",
+                },
+            ],
+            message: "Provide READMEs in which language(s)?",
+            theme: checkboxTheme,
+        });
+        return ["en_US", ...values];
+    }
+    async collectLanguage() {
+        return await select({
+            choices: [
+                {
+                    name: "Elixir",
+                    value: "elixir",
+                },
+                {
+                    name: "Python",
+                    value: "python",
+                },
+                {
+                    name: "TypeScript",
+                    value: "typescript",
+                },
+            ],
+            message: "What programming language do you prefer for developing this plugin?",
+            theme: selectTheme,
+        });
+    }
+    async collectType() {
+        return await select({
+            choices: [
+                {
+                    name: "Extension",
+                    value: "extension",
+                    description: "Extend capabilities by integrating with external APIs.",
+                },
+                {
+                    name: "Model",
+                    value: "llm",
+                    description: "Introduce more LLMs to enhance AI capabilities.",
+                },
+                {
+                    name: "Tool",
+                    value: "tool",
+                    description: "Complete specific tasks, typically invoked by LLMs.",
+                },
+                {
+                    name: "Trigger",
+                    value: "trigger",
+                    description: "Run workflows by receiving events through webhooks.",
+                },
+            ],
+            message: dedent `
+        ${colorize("blue", "Choose the type of the new plugin")}
+
+        Plugins can extend the platform's capabilities in multiple ways, making workflows more flexible and powerful.
+        Based on your specific requirement, plugins can be categorized into the following types:
+
+          - ${colorize("yellowBright", "Extension")}: Provide more functionality to workflows by integrating external service APIs
+          - ${colorize("yellowBright", "Model")}:     Access more large language models to enrich the AI capabilities of workflows
+          - ${colorize("yellowBright", "Tool")}:      Customized logic to perform specific tasks, typically invoked by LLMs and/or Agents
+          - ${colorize("yellowBright", "Trigger")}:   Receive external events through webhooks to start workflows with initial input data
+
+        Please select the matching type from the following options:
+      `,
+            theme: selectTheme,
+        });
+    }
+}

package/dist/commands/plugin/pack.d.ts

@@ -0,0 +1,13 @@
+import { Command } from "@oclif/core";
+export default class PluginPack extends Command {
+    static args: {
+        file: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/plugin/pack.js

@@ -0,0 +1,22 @@
+import { Args, Command, Flags } from "@oclif/core";
+export default class PluginPack extends Command {
+    static args = {
+        file: Args.string({ description: "file to read" }),
+    };
+    static description = "describe the command here";
+    static examples = ["<%= config.bin %> <%= command.id %>"];
+    static flags = {
+        // flag with no value (-f, --force)
+        force: Flags.boolean({ char: "f" }),
+        // flag with a value (-n, --name=VALUE)
+        name: Flags.string({ char: "n", description: "name to print" }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(PluginPack);
+        const name = flags.name ?? "world";
+        this.log(`hello ${name} from /Users/nightire/Code/github.com/choice-open/automation-plugin-cli/src/commands/plugin/pack.ts`);
+        if (args.file && flags.force) {
+            this.log(`you input --force and --file: ${args.file}`);
+        }
+    }
+}

package/dist/commands/plugin/permission.d.ts

@@ -0,0 +1,13 @@
+import { Command } from "@oclif/core";
+export default class PluginPermission extends Command {
+    static args: {
+        file: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/plugin/permission.js

@@ -0,0 +1,22 @@
+import { Args, Command, Flags } from "@oclif/core";
+export default class PluginPermission extends Command {
+    static args = {
+        file: Args.string({ description: "file to read" }),
+    };
+    static description = "describe the command here";
+    static examples = ["<%= config.bin %> <%= command.id %>"];
+    static flags = {
+        // flag with no value (-f, --force)
+        force: Flags.boolean({ char: "f" }),
+        // flag with a value (-n, --name=VALUE)
+        name: Flags.string({ char: "n", description: "name to print" }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(PluginPermission);
+        const name = flags.name ?? "world";
+        this.log(`hello ${name} from /Users/nightire/Code/github.com/choice-open/automation-plugin-cli/src/commands/plugin/permission.ts`);
+        if (args.file && flags.force) {
+            this.log(`you input --force and --file: ${args.file}`);
+        }
+    }
+}

package/dist/commands/plugin/refresh-key.d.ts

@@ -0,0 +1,9 @@
+import { Command } from "@oclif/core";
+export default class PluginRefreshKey extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+    private fetchDebugApiKey;
+    private updateEnvFile;
+    private maskApiKey;
+}

package/dist/commands/plugin/refresh-key.js

@@ -0,0 +1,103 @@
+import { promises as fs } from "node:fs";
+import { join } from "node:path";
+import { Command } from "@oclif/core";
+import { colorize } from "@oclif/core/ux";
+import { assert } from "es-toolkit";
+import { dedent } from "ts-dedent";
+import * as configStore from "../../utils/config.js";
+export default class PluginRefreshKey extends Command {
+    static description = dedent `Refresh or create API Key for plugin debugging in development stage.`;
+    static examples = ["<%= config.bin %> <%= command.id %>"];
+    async run() {
+        await this.parse(PluginRefreshKey);
+        // Step 1: Check access token
+        const config = await configStore.load();
+        if (!config.auth?.access_token) {
+            this.log(colorize("red", "✗ You're not authenticated yet, please run 'atomemo auth login' first."));
+            return process.exit(1);
+        }
+        try {
+            // Step 2: Fetch debug API Key
+            const apiKey = await this.fetchDebugApiKey(config.auth.access_token);
+            // Step 3: Manage .env file
+            await this.updateEnvFile(apiKey);
+            // Display success message
+            this.log(colorize("green", "✓ Debug API Key refreshed successfully"));
+            this.log(colorize("green", "✓ DEBUG_API_KEY updated in .env file"));
+            this.log("");
+            this.log("Your debug API Key has been saved to .env file.");
+            this.log(`Key preview: ${this.maskApiKey(apiKey)}`);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "Unknown error";
+            this.log(colorize("red", `✗ Failed to refresh debug API Key: ${message}`));
+            return process.exit(1);
+        }
+    }
+    async fetchDebugApiKey(accessToken) {
+        // Get endpoint from config, use default if not available
+        const config = await configStore.load();
+        assert(config.hub?.endpoint, "Hub endpoint is required");
+        const response = await fetch(`${config.hub.endpoint}/api/v1/debug_api_key`, {
+            method: "GET",
+            headers: {
+                "Content-Type": "application/json",
+                "User-Agent": "Choiceform (Atomemo Plugin CLI)",
+                Authorization: `Bearer ${accessToken}`,
+            },
+        });
+        if (!response.ok) {
+            if (response.status === 401) {
+                throw new Error("Access token is invalid or expired, please login again");
+            }
+            throw new Error(`API request failed: ${response.status} ${response.statusText}`);
+        }
+        const data = (await response.json());
+        if (!data.api_key) {
+            throw new Error("API response format error: missing api_key field");
+        }
+        return data.api_key;
+    }
+    async updateEnvFile(apiKey) {
+        const envPath = join(process.cwd(), ".env");
+        try {
+            // Check if .env file exists
+            let envContent = "";
+            let existingKey = false;
+            try {
+                envContent = await fs.readFile(envPath, "utf-8");
+                existingKey = envContent.includes("DEBUG_API_KEY=");
+            }
+            catch (_error) {
+                // File doesn't exist, will create new file
+            }
+            let newContent;
+            if (existingKey) {
+                // Replace existing DEBUG_API_KEY
+                newContent = envContent.replace(/^DEBUG_API_KEY=.*$/m, `DEBUG_API_KEY=${apiKey}`);
+            }
+            else {
+                // Append new DEBUG_API_KEY
+                const separator = envContent && !envContent.endsWith("\n") ? "\n" : "";
+                newContent = `${envContent + separator}DEBUG_API_KEY=${apiKey}\n`;
+            }
+            await fs.writeFile(envPath, newContent, "utf-8");
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                "code" in error &&
+                error.code === "EACCES") {
+                throw new Error("Permission denied: cannot write .env file");
+            }
+            throw new Error(`Failed to update .env file: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
+    maskApiKey(apiKey) {
+        if (apiKey.length <= 8) {
+            return "***";
+        }
+        const start = apiKey.substring(0, 4);
+        const end = apiKey.substring(apiKey.length - 4);
+        return `${start}...${end}`;
+    }
+}

package/dist/commands/plugin/run.d.ts

@@ -0,0 +1,13 @@
+import { Command } from "@oclif/core";
+export default class PluginRun extends Command {
+    static args: {
+        file: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/plugin/run.js

@@ -0,0 +1,22 @@
+import { Args, Command, Flags } from "@oclif/core";
+export default class PluginRun extends Command {
+    static args = {
+        file: Args.string({ description: "file to read" }),
+    };
+    static description = "describe the command here";
+    static examples = ["<%= config.bin %> <%= command.id %>"];
+    static flags = {
+        // flag with no value (-f, --force)
+        force: Flags.boolean({ char: "f" }),
+        // flag with a value (-n, --name=VALUE)
+        name: Flags.string({ char: "n", description: "name to print" }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(PluginRun);
+        const name = flags.name ?? "world";
+        this.log(`hello ${name} from /Users/nightire/Code/github.com/choice-open/automation-plugin-cli/src/commands/plugin/run.ts`);
+        if (args.file && flags.force) {
+            this.log(`you input --force and --file: ${args.file}`);
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { run } from "@oclif/core";

package/dist/index.js

@@ -0,0 +1 @@
+export { run } from "@oclif/core";

package/dist/utils/config.d.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+declare const ConfigSchema: z.ZodObject<{
+    auth: z.ZodOptional<z.ZodObject<{
+        endpoint: z.ZodOptional<z.ZodURL>;
+        access_token: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    hub: z.ZodOptional<z.ZodObject<{
+        endpoint: z.ZodOptional<z.ZodURL>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Config = z.infer<typeof ConfigSchema>;
+export declare function save(config: Config): Promise<void>;
+export declare function load(): Promise<Config>;
+export declare function update(updates: Partial<Config>): Promise<void>;
+export {};

package/dist/utils/config.js

@@ -0,0 +1,65 @@
+import { promises as fs } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { toMerged } from "es-toolkit/object";
+import { z } from "zod";
+function getConfigDir() {
+    return process.env.CHOICEFORM_CONFIG_DIR ?? join(homedir(), ".choiceform");
+}
+function getConfigFile() {
+    return join(getConfigDir(), "atomemo.json");
+}
+const ConfigSchema = z.object({
+    auth: z
+        .object({
+        endpoint: z.url().optional(),
+        access_token: z.string().optional(),
+    })
+        .optional(),
+    hub: z
+        .object({
+        endpoint: z.url().optional(),
+    })
+        .optional(),
+});
+export async function save(config) {
+    const validated = ConfigSchema.parse(config);
+    const configDir = getConfigDir();
+    const configFile = getConfigFile();
+    await fs.mkdir(configDir, { recursive: true });
+    await fs.writeFile(configFile, JSON.stringify(validated, null, 2), "utf-8");
+}
+export async function load() {
+    const configFile = getConfigFile();
+    try {
+        await fs.access(configFile);
+    }
+    catch (error) {
+        if (error instanceof Error &&
+            ("code" in error ? error.code === "ENOENT" : false)) {
+            const defaultConfig = {
+                auth: {
+                    endpoint: process.env.NODE_ENV === "production"
+                        ? "https://oneauth.choiceform.io"
+                        : "https://oneauth.choiceform.io",
+                },
+                hub: {
+                    endpoint: process.env.NODE_ENV === "production"
+                        ? "https://automation-plugin-api.choiceform.io"
+                        : "https://automation-plugin-api.choiceform.io",
+                },
+            };
+            await save(defaultConfig);
+            return defaultConfig;
+        }
+        throw error;
+    }
+    const content = await fs.readFile(configFile, "utf-8");
+    const parsed = JSON.parse(content);
+    return ConfigSchema.parse(parsed);
+}
+export async function update(updates) {
+    const existing = await load();
+    const merged = toMerged(existing ?? {}, updates);
+    await save(merged);
+}

package/dist/utils/generator.d.ts

@@ -0,0 +1,20 @@
+import { Eta } from "eta";
+export interface PluginGenerator {
+    context: {
+        props: Record<string, unknown>;
+        target: string;
+    };
+    renderer: Eta;
+    type: string;
+    generate(): Promise<void>;
+}
+export declare function createPluginGenerator(type: PluginGenerator["type"], context: PluginGenerator["context"]): PluginGenerator;
+export declare class TypeScriptPluginGenerator implements PluginGenerator {
+    #private;
+    context: PluginGenerator["context"];
+    type: "typescript";
+    renderer: Eta;
+    constructor(context: PluginGenerator["context"]);
+    generate(): Promise<void>;
+    private groupPermissions;
+}