create-donobu-plugin 1.0.0

package/index.js

@@ -0,0 +1,307 @@
+#!/usr/bin/env node
+
+import { mkdir, writeFile, readFile } from "fs/promises";
+import { join, dirname } from "path";
+import { createRequire } from "module";
+
+async function getDonobuVersions() {
+  try {
+    // Find the donobu package.json by resolving the module path
+    const require = createRequire(import.meta.url);
+    const donobuPath = require.resolve("donobu");
+    // Navigate up to find package.json (donobu path might point to dist/main.js)
+    const donobuDir = dirname(donobuPath);
+    let packageJsonPath = join(donobuDir, "package.json");
+
+    try {
+      await readFile(packageJsonPath, "utf8");
+    } catch {
+      // If not found, try going up one more directory
+      packageJsonPath = join(dirname(donobuDir), "package.json");
+    }
+
+    const packageJsonContent = await readFile(packageJsonPath, "utf8");
+    const donobuPackageJson = JSON.parse(packageJsonContent);
+
+    return {
+      donobuVersion: donobuPackageJson.version,
+      playwrightVersion:
+        donobuPackageJson.devDependencies?.playwright ||
+        donobuPackageJson.dependencies?.playwright ||
+        donobuPackageJson.peerDependencies?.playwright?.replace(/^>=/, "") ||
+        "1.53.2",
+      playwrightTestVersion:
+        donobuPackageJson.devDependencies?.["@playwright/test"] ||
+        donobuPackageJson.dependencies?.["@playwright/test"] ||
+        donobuPackageJson.peerDependencies?.["@playwright/test"]?.replace(
+          /^>=/,
+          ""
+        ) ||
+        "1.53.2",
+    };
+  } catch (error) {
+    console.error("Could not read the Donobu package.json file!");
+    throw error;
+  }
+}
+
+async function createPluginStructure(pluginName) {
+  const pluginDir = join(process.cwd(), pluginName);
+  console.log(`Creating plugin directory: ${pluginDir}`);
+  // Get current donobu and playwright versions
+  const versions = await getDonobuVersions();
+  console.log(`Using Donobu version: ${versions.donobuVersion}`);
+  console.log(`Using Playwright version: ${versions.playwrightVersion}`);
+  // Create directory structure
+  await mkdir(pluginDir, { recursive: true });
+  await mkdir(join(pluginDir, "src"), { recursive: true });
+  console.log("Creating files...");
+  await createTemplateFiles(pluginDir, pluginName, versions);
+  console.log(`\nPlugin "${pluginName}" created successfully!`);
+  console.log(`\nNext steps:`);
+  console.log(`  cd ${pluginName}`);
+  console.log(`  npm install`);
+  console.log(`  # Edit src/index.ts to add your custom tools`);
+  console.log(`  npx install-donobu-plugin`);
+}
+
+async function createTemplateFiles(pluginDir, pluginName, versions) {
+  // Create package.json
+  const packageJson = {
+    name: pluginName,
+    version: "1.0.0",
+    private: true,
+    type: "module",
+    description: "Custom tools for use by Donobu.",
+    main: "./dist/index.mjs",
+    types: "./dist/index.d.ts",
+    exports: {
+      ".": "./dist/index.mjs",
+    },
+    files: ["dist"],
+    scripts: {
+      clean: "rm -rf dist",
+      build:
+        "npm run clean && npm install && tsc -p tsconfig.json && node esbuild.config.mjs",
+    },
+    license: "UNLICENSED",
+    devDependencies: {
+      donobu: `^${versions.donobuVersion}`,
+      playwright: versions.playwrightVersion,
+      "@playwright/test": versions.playwrightTestVersion,
+      typescript: "^5.8.3",
+      esbuild: "^0.25.6",
+    },
+    peerDependencies: {
+      donobu: `>=${versions.donobuVersion}`,
+      playwright: `>=${versions.playwrightVersion}`,
+      "@playwright/test": `>=${versions.playwrightTestVersion}`,
+    },
+    peerDependenciesMeta: {
+      playwright: {
+        optional: false,
+      },
+      "@playwright/test": {
+        optional: false,
+      },
+    },
+    dependencies: {
+      zod: "^3.24.1",
+    },
+  };
+
+  await writeFile(
+    join(pluginDir, "package.json"),
+    JSON.stringify(packageJson, null, 2)
+  );
+
+  // Create tsconfig.json
+  const tsConfig = {
+    compilerOptions: {
+      target: "ES2020",
+      module: "NodeNext",
+      moduleResolution: "NodeNext",
+      rootDir: "./src",
+      outDir: "./dist",
+      declaration: true,
+      strict: true,
+      esModuleInterop: true,
+      skipLibCheck: true,
+      forceConsistentCasingInFileNames: true,
+    },
+    include: ["src/**/*"],
+  };
+
+  await writeFile(
+    join(pluginDir, "tsconfig.json"),
+    JSON.stringify(tsConfig, null, 2)
+  );
+
+  // Create esbuild.config.mjs
+  const esbuildConfig = `import { build } from 'esbuild';
+
+await build({
+  entryPoints: ['dist/index.js'],
+  outfile: 'dist/index.mjs',
+  bundle: true,
+  format: 'esm',
+  platform: 'node',
+  external: ['donobu', 'playwright'],
+  minify: true,
+});
+`;
+
+  await writeFile(join(pluginDir, "esbuild.config.mjs"), esbuildConfig);
+
+  // Create src/index.ts
+  const indexTs = `import type { Tool } from "donobu";
+import { PluginDependencies } from "./PluginDependencies.js";
+
+export async function loadCustomTools(
+  dependencies: PluginDependencies
+): Promise<Tool<any, any>[]> {
+  // Register your custom tools here.
+  return [];
+}
+`;
+
+  await writeFile(join(pluginDir, "src", "index.ts"), indexTs);
+
+  // Create src/createTool.ts
+  const createToolTs = `import { z } from "zod";
+import type { ToolCallContext, ToolCallResult, Tool } from "donobu";
+import { PluginDependencies } from "./PluginDependencies.js";
+
+/**
+ * Factory function to create a Donobu Tool instance.
+ */
+export function createTool<
+  CallSchema extends z.ZodObject<any>,
+  CallFromGptSchema extends z.ZodObject<any> = CallSchema,
+>(
+  dependencies: PluginDependencies,
+  options: CreateToolOptions<CallSchema, CallFromGptSchema>
+): Tool<CallSchema, CallFromGptSchema> {
+  class AnonymousTool extends dependencies.donobu.Tool<
+    CallSchema,
+    CallFromGptSchema
+  > {
+    public constructor() {
+      super(
+        options.name,
+        options.description,
+        options.schema,
+        (options.gptSchema ?? options.schema) as CallFromGptSchema,
+        options.requiresGpt
+      );
+    }
+    public override async call(
+      ctx: ToolCallContext,
+      params: z.infer<CallSchema>
+    ): Promise<ToolCallResult> {
+      return options.call(ctx, params);
+    }
+    public override async callFromGpt(
+      ctx: ToolCallContext,
+      params: z.infer<CallFromGptSchema>
+    ): Promise<ToolCallResult> {
+      return options.callFromGpt
+        ? options.callFromGpt(ctx, params)
+        : this.call(ctx, params);
+    }
+  }
+
+  return new AnonymousTool();
+}
+
+export interface CreateToolOptions<
+  CallSchema extends z.ZodObject<any>,
+  CallFromGptSchema extends z.ZodObject<any> = CallSchema,
+> {
+  /**
+   * @param name This is the name for the tool that will be shared with the LLM when making requests.
+   * @param description This is the description that will be shared with the LLM when making requests.
+   * @param inputSchema This is the JSON-schema for the tool when it is invoked by a non-LLM.
+   * @param inputSchemaForGpt This is the JSON-schema that will be shared with the LLM when making
+   *                          requests during autonomous flows.
+   * @param requiresGpt Set to true if this tool requires the usage of a GPT.
+   * @param call This is the function that will be invoked when the tool is called by a non-LLM.
+   * @param callFromGpt This is the function that will be invoked when the tool is called by an LLM.
+   */
+  name: string;
+  description: string;
+  requiresGpt: boolean;
+  schema: CallSchema;
+  gptSchema?: CallFromGptSchema;
+  call(
+    ctx: ToolCallContext,
+    params: z.infer<CallSchema>
+  ): Promise<ToolCallResult> | ToolCallResult;
+  callFromGpt?(
+    ctx: ToolCallContext,
+    params: z.infer<CallFromGptSchema>
+  ): Promise<ToolCallResult> | ToolCallResult;
+}
+`;
+
+  await writeFile(join(pluginDir, "src", "createTool.ts"), createToolTs);
+
+  // Create src/PluginDependencies.ts
+  const pluginDepsTs = `export interface PluginDependencies {
+  donobu: typeof import("donobu");
+  playwright: typeof import("playwright");
+}
+`;
+
+  await writeFile(
+    join(pluginDir, "src", "PluginDependencies.ts"),
+    pluginDepsTs
+  );
+
+  // Create a basic README
+  const readme = `# ${pluginName}
+
+A custom Donobu plugin with tools for browser automation.
+
+## Development
+
+1. Edit \`src/index.ts\` to add your custom tools
+2. Build and install the plugin:
+   \`\`\`bash
+   npm run build
+   npm exec install-donobu-plugin
+   \`\`\`
+3. Restart Donobu to see your tools
+`;
+
+  await writeFile(join(pluginDir, "README.md"), readme);
+}
+
+async function main() {
+  const pluginName = process.argv[2];
+
+  if (!pluginName) {
+    console.error("Usage: create-donobu-plugin <plugin-name>");
+    console.error("");
+    console.error("Example:");
+    console.error("  npm create donobu-plugin my-awesome-plugin");
+    process.exit(1);
+  }
+
+  // Validate plugin name
+  if (!/^[a-z0-9-_]+$/.test(pluginName)) {
+    console.error(
+      "Plugin name must contain only lowercase letters, numbers, hyphens, and underscores"
+    );
+    process.exit(1);
+  }
+
+  try {
+    await createPluginStructure(pluginName);
+  } catch (error) {
+    console.error("Failed to create plugin:", error.message);
+    process.exit(1);
+  }
+}
+
+main();

package/package.json

@@ -0,0 +1,24 @@
+{
+    "name": "create-donobu-plugin",
+    "version": "1.0.0",
+    "type": "module",
+    "description": "Create a new Donobu plugin",
+    "author": "Donobu",
+    "homepage": "https://donobu.com",
+    "main": "index.js",
+    "bin": {
+        "create-donobu-plugin": "./index.js"
+    },
+    "files": [
+        "index.js"
+    ],
+    "dependencies": {
+        "donobu": "^2.30.1"
+    },
+    "keywords": [
+        "donobu",
+        "plugin",
+        "create"
+    ],
+    "license": "UNLICENSED"
+}