@choiceopen/automation-plugin-cli 0.1.2 → 0.2.0

package/README.md

@@ -20,7 +20,7 @@ $ npm install -g @choiceopen/automation-plugin-cli
 $ automation COMMAND
 running command...
 $ automation (--version)
-@choiceopen/automation-plugin-cli/0.1.2 darwin-arm64 node-v24.12.0
+@choiceopen/automation-plugin-cli/0.2.0 darwin-arm64 node-v24.13.0
 $ automation --help [COMMAND]
 USAGE
   $ automation COMMAND
@@ -30,9 +30,15 @@ USAGE
 # Commands
 <!-- commands -->
 * [`automation auth login`](#automation-auth-login)
+* [`automation auth status`](#automation-auth-status)
 * [`automation autocomplete [SHELL]`](#automation-autocomplete-shell)
 * [`automation help [COMMAND]`](#automation-help-command)
+* [`automation plugin checksum [FILE]`](#automation-plugin-checksum-file)
+* [`automation plugin init`](#automation-plugin-init)
+* [`automation plugin pack [FILE]`](#automation-plugin-pack-file)
+* [`automation plugin permission [FILE]`](#automation-plugin-permission-file)
 * [`automation plugin refresh-key`](#automation-plugin-refresh-key)
+* [`automation plugin run [FILE]`](#automation-plugin-run-file)
 * [`automation version`](#automation-version)
 
 ## `automation auth login`
@@ -57,7 +63,29 @@ EXAMPLES
     $ automation auth login
 ```
 
-_See code: [src/commands/auth/login.ts](https://github.com/choice-open/automation-plugin-cli/blob/v0.1.2/src/commands/auth/login.ts)_
+_See code: [src/commands/auth/login.ts](https://github.com/choice-open/automation-plugin-cli/blob/v0.2.0/src/commands/auth/login.ts)_
+
+## `automation auth status`
+
+Display the current authentication status.
+
+```
+USAGE
+  $ automation auth status
+
+DESCRIPTION
+  Display the current authentication status.
+
+  Shows user information and session details if authenticated,
+  or prompts to login if not yet authenticated.
+
+EXAMPLES
+  Check current authentication status
+
+    $ automation auth status
+```
+
+_See code: [src/commands/auth/status.ts](https://github.com/choice-open/automation-plugin-cli/blob/v0.2.0/src/commands/auth/status.ts)_
 
 ## `automation autocomplete [SHELL]`
 
@@ -110,6 +138,115 @@ DESCRIPTION
 
 _See code: [@oclif/plugin-help](https://github.com/oclif/plugin-help/blob/v6.2.36/src/commands/help.ts)_
 
+## `automation plugin checksum [FILE]`
+
+describe the command here
+
+```
+USAGE
+  $ automation plugin checksum [FILE] [-f] [-n <value>]
+
+ARGUMENTS
+  [FILE]  file to read
+
+FLAGS
+  -f, --force
+  -n, --name=<value>  name to print
+
+DESCRIPTION
+  describe the command here
+
+EXAMPLES
+  $ automation plugin checksum
+```
+
+_See code: [src/commands/plugin/checksum.ts](https://github.com/choice-open/automation-plugin-cli/blob/v0.2.0/src/commands/plugin/checksum.ts)_
+
+## `automation plugin init`
+
+Initialize a new plugin with step-by-step interactive instructions.
+
+```
+USAGE
+  $ automation plugin init [-i] [-n my-awesome-plugin] [-d Descriptive
+    text...] [-a John Doe] [-e john.doe@example.com] [-u <value>] [--locales en_US|zh_Hans|ja_JP...] [-l
+    elixir|python|typescript] [-t extension|llm|tool|trigger]
+
+FLAGS
+  -a, --author=John Doe                  Author name
+  -d, --description=Descriptive text...  Short description
+  -e, --email=john.doe@example.com       Author email address
+  -i, --[no-]interactive                 Use interactive mode (by default)
+  -l, --language=<option>                Programming language to use for plugin development
+                                         <options: elixir|python|typescript>
+  -n, --name=my-awesome-plugin           Plugin name
+  -t, --type=<option>                    Plugin type
+                                         <options: extension|llm|tool|trigger>
+  -u, --url=<value>                      Repository URL
+      --locales=<option>...              Provide READMEs in which languages
+                                         <options: en_US|zh_Hans|ja_JP>
+
+DESCRIPTION
+  Initialize a new plugin with step-by-step interactive instructions.
+
+  Providing required flags skips interactive flow and completes initialization in one go.
+
+EXAMPLES
+  Start with interactive initialization:
+
+    $ automation plugin init
+```
+
+_See code: [src/commands/plugin/init.ts](https://github.com/choice-open/automation-plugin-cli/blob/v0.2.0/src/commands/plugin/init.ts)_
+
+## `automation plugin pack [FILE]`
+
+describe the command here
+
+```
+USAGE
+  $ automation plugin pack [FILE] [-f] [-n <value>]
+
+ARGUMENTS
+  [FILE]  file to read
+
+FLAGS
+  -f, --force
+  -n, --name=<value>  name to print
+
+DESCRIPTION
+  describe the command here
+
+EXAMPLES
+  $ automation plugin pack
+```
+
+_See code: [src/commands/plugin/pack.ts](https://github.com/choice-open/automation-plugin-cli/blob/v0.2.0/src/commands/plugin/pack.ts)_
+
+## `automation plugin permission [FILE]`
+
+describe the command here
+
+```
+USAGE
+  $ automation plugin permission [FILE] [-f] [-n <value>]
+
+ARGUMENTS
+  [FILE]  file to read
+
+FLAGS
+  -f, --force
+  -n, --name=<value>  name to print
+
+DESCRIPTION
+  describe the command here
+
+EXAMPLES
+  $ automation plugin permission
+```
+
+_See code: [src/commands/plugin/permission.ts](https://github.com/choice-open/automation-plugin-cli/blob/v0.2.0/src/commands/plugin/permission.ts)_
+
 ## `automation plugin refresh-key`
 
 Refresh or create API Key for plugin debugging in development stage.
@@ -125,7 +262,31 @@ EXAMPLES
   $ automation plugin refresh-key
 ```
 
-_See code: [src/commands/plugin/refresh-key.ts](https://github.com/choice-open/automation-plugin-cli/blob/v0.1.2/src/commands/plugin/refresh-key.ts)_
+_See code: [src/commands/plugin/refresh-key.ts](https://github.com/choice-open/automation-plugin-cli/blob/v0.2.0/src/commands/plugin/refresh-key.ts)_
+
+## `automation plugin run [FILE]`
+
+describe the command here
+
+```
+USAGE
+  $ automation plugin run [FILE] [-f] [-n <value>]
+
+ARGUMENTS
+  [FILE]  file to read
+
+FLAGS
+  -f, --force
+  -n, --name=<value>  name to print
+
+DESCRIPTION
+  describe the command here
+
+EXAMPLES
+  $ automation plugin run
+```
+
+_See code: [src/commands/plugin/run.ts](https://github.com/choice-open/automation-plugin-cli/blob/v0.2.0/src/commands/plugin/run.ts)_
 
 ## `automation version`
 

package/dist/commands/auth/index.d.ts

@@ -0,0 +1,11 @@
+import { Command } from "@oclif/core";
+export default class Auth extends Command {
+    static description: string;
+    static enableJsonFlag: boolean;
+    static examples: {
+        command: string;
+        description: string;
+    }[];
+    static hidden: boolean;
+    run(): Promise<void>;
+}

package/dist/commands/auth/index.js

@@ -0,0 +1,15 @@
+import { Command } from "@oclif/core";
+export default class Auth extends Command {
+    static description = "Manages your plugin via subcommands";
+    static enableJsonFlag = true;
+    static examples = [
+        {
+            command: "<%= config.bin %> help <%= command.id %> [COMMAND]",
+            description: "Check help for each individual sub-command",
+        },
+    ];
+    static hidden = true;
+    async run() {
+        await this.config.runCommand("help", ["auth"]);
+    }
+}

package/dist/commands/auth/login.d.ts

@@ -0,0 +1,16 @@
+import { Command } from "@oclif/core";
+export default class AuthLogin extends Command {
+    static description: string;
+    static examples: {
+        command: string;
+        description: string;
+    }[];
+    static flags: {};
+    private pollingInterval;
+    private client_id;
+    private grant_type;
+    private endpoint;
+    run(): Promise<void>;
+    private requestDeviceCode;
+    private pollForToken;
+}

package/dist/commands/auth/status.d.ts

@@ -0,0 +1,11 @@
+import { Command } from "@oclif/core";
+export default class AuthStatus extends Command {
+    static description: string;
+    static examples: {
+        command: string;
+        description: string;
+    }[];
+    run(): Promise<void>;
+    private fetchSession;
+    private formatDate;
+}

package/dist/commands/auth/status.js

@@ -0,0 +1,61 @@
+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 AuthStatus extends Command {
+    static description = dedent `
+    Display the current authentication status.
+
+    Shows user information and session details if authenticated,
+    or prompts to login if not yet authenticated.
+  `;
+    static examples = [
+        {
+            command: "<%= config.bin %> <%= command.id %>",
+            description: "Check current authentication status",
+        },
+    ];
+    async run() {
+        await this.parse(AuthStatus);
+        const config = await configStore.load();
+        if (!config.auth?.access_token) {
+            this.log(colorize("yellow", "Your device has not been authenticated yet. Please execute `automation auth login`."));
+            return;
+        }
+        assert(config.auth?.endpoint, "Auth endpoint is required");
+        try {
+            const session = await this.fetchSession(config.auth.endpoint, config.auth.access_token);
+            this.log(colorize("greenBright", "✓ Authenticated\n"));
+            this.log(colorize("bold", colorize("gray", "Name    : ")), session.user.name);
+            this.log(colorize("bold", colorize("gray", "Email   : ")), session.user.email);
+            this.log(colorize("bold", colorize("gray", "Updated : ")), this.formatDate(session.session.updatedAt));
+            this.log(colorize("bold", colorize("gray", "Expires : ")), this.formatDate(session.session.expiresAt));
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "Unknown error";
+            this.log(colorize("red", `✗ Failed to fetch session: ${message}`));
+            process.exit(1);
+        }
+    }
+    async fetchSession(endpoint, accessToken) {
+        const response = await fetch(`${endpoint}/v1/auth/get-session`, {
+            headers: {
+                "Content-Type": "application/json",
+                "User-Agent": "Choiceform (Automation 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}`);
+        }
+        return (await response.json());
+    }
+    formatDate(isoDate) {
+        const date = new Date(isoDate);
+        return date.toLocaleString();
+    }
+}

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

@@ -0,0 +1,13 @@
+import { Command } from "@oclif/core";
+export default class PluginChecksum 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/checksum.js

@@ -0,0 +1,22 @@
+import { Args, Command, Flags } from "@oclif/core";
+export default class PluginChecksum 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(PluginChecksum);
+        const name = flags.name ?? "world";
+        this.log(`hello ${name} from /Users/nightire/Code/github.com/choice-open/automation-plugin-cli/src/commands/plugin/checksum.ts`);
+        if (args.file && flags.force) {
+            this.log(`you input --force and --file: ${args.file}`);
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+import { Command } from "@oclif/core";
+export default class Plugin extends Command {
+    static description: string;
+    static enableJsonFlag: boolean;
+    static examples: {
+        command: string;
+        description: string;
+    }[];
+    static hidden: boolean;
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,31 @@
+import { Command } from "@oclif/core";
+export default class PluginInit extends Command {
+    static description: string;
+    static examples: {
+        command: string;
+        description: string;
+    }[];
+    static flags: {
+        interactive: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        description: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        author: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        email: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        url: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        locales: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        language: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        type: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    private nameIsValid;
+    private reconcileInteractiveFlag;
+    private runInteractiveMode;
+    private collectName;
+    private collectDescription;
+    private collectAuthor;
+    private collectEmail;
+    private collectURL;
+    private collectLocales;
+    private collectLanguage;
+    private collectType;
+}

package/dist/commands/plugin/init.js

@@ -0,0 +1,284 @@
+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() },
+            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", "automation 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,
+        });
+    }
+}