bopodev-api 0.1.34 → 0.1.35

package/src/services/plugin-jobs-service.ts

@@ -0,0 +1,74 @@
+import type { PluginManifestV2 } from "bopodev-contracts";
+import { PluginInvocationResultSchema, PluginManifestV2Schema } from "bopodev-contracts";
+import type { BopoDb } from "bopodev-db";
+import { appendPluginRun, listCompanyPluginConfigs } from "bopodev-db";
+import { pluginWorkerHost } from "./plugin-worker-host";
+
+const lastJobRun = new Map<string, number>();
+
+function shouldRunJob(companyId: string, pluginId: string, jobKey: string) {
+  const key = `${companyId}:${pluginId}:${jobKey}`;
+  const now = Date.now();
+  const previous = lastJobRun.get(key) ?? 0;
+  if (now - previous < 55_000) {
+    return false;
+  }
+  lastJobRun.set(key, now);
+  return true;
+}
+
+export async function runPluginJobSweep(db: BopoDb, companyId: string) {
+  const rows = await listCompanyPluginConfigs(db, companyId);
+  for (const row of rows) {
+    if (!row.enabled) continue;
+    const manifest = parseManifest(row.manifestJson);
+    if (!manifest || manifest.jobs.length === 0) continue;
+    for (const job of manifest.jobs) {
+      if (!shouldRunJob(companyId, row.pluginId, job.jobKey)) continue;
+      const startedAt = Date.now();
+      try {
+        const result = await pluginWorkerHost.invoke(manifest, {
+          method: "plugin.job",
+          params: {
+            companyId,
+            pluginId: row.pluginId,
+            jobKey: job.jobKey,
+            schedule: job.schedule
+          }
+        });
+        const validated = PluginInvocationResultSchema.parse(result);
+        await appendPluginRun(db, {
+          companyId,
+          runId: null,
+          pluginId: row.pluginId,
+          hook: `job:${job.jobKey}`,
+          status: validated.status,
+          durationMs: Date.now() - startedAt,
+          diagnosticsJson: JSON.stringify(validated.diagnostics ?? {}),
+          error: validated.status === "failed" || validated.status === "blocked" ? validated.summary : null
+        });
+      } catch (error) {
+        await appendPluginRun(db, {
+          companyId,
+          runId: null,
+          pluginId: row.pluginId,
+          hook: `job:${job.jobKey}`,
+          status: "failed",
+          durationMs: Date.now() - startedAt,
+          error: String(error)
+        });
+      }
+    }
+  }
+}
+
+function parseManifest(value: string | null | undefined): PluginManifestV2 | null {
+  if (!value) return null;
+  try {
+    const parsed = JSON.parse(value) as unknown;
+    const result = PluginManifestV2Schema.safeParse(parsed);
+    return result.success ? result.data : null;
+  } catch {
+    return null;
+  }
+}

package/src/services/plugin-manifest-loader.ts

@@ -1,6 +1,7 @@
 import { mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
+import { existsSync, readdirSync } from "node:fs";
 import { resolve } from "node:path";
-import { PluginManifestSchema, type PluginManifest } from "bopodev-contracts";
+import { PluginManifestSchema, PluginManifestV2Schema, type PluginManifest } from "bopodev-contracts";
 
 export type FilesystemPluginManifestLoadResult = {
   manifests: PluginManifest[];
@@ -29,7 +30,7 @@ export async function loadFilesystemPluginManifests(): Promise<FilesystemPluginM
     }
     try {
       const parsed = JSON.parse(raw) as unknown;
-      const manifest = PluginManifestSchema.parse(parsed);
+      const manifest = normalizeFilesystemManifest(manifestPath, PluginManifestSchema.parse(parsed));
       manifests.push(manifest);
     } catch (error) {
       warnings.push(`Invalid plugin manifest at '${manifestPath}': ${String(error)}`);
@@ -40,7 +41,24 @@ export async function loadFilesystemPluginManifests(): Promise<FilesystemPluginM
 }
 
 export function resolvePluginManifestsDir() {
-  return process.env.BOPO_PLUGIN_MANIFESTS_DIR || resolve(process.cwd(), "plugins");
+  if (process.env.BOPO_PLUGIN_MANIFESTS_DIR) {
+    return process.env.BOPO_PLUGIN_MANIFESTS_DIR;
+  }
+  const localPlugins = resolve(process.cwd(), "plugins");
+  if (directoryHasPluginManifests(localPlugins)) {
+    return localPlugins;
+  }
+  const repoRootPlugins = resolve(process.cwd(), "..", "..", "plugins");
+  if (directoryHasPluginManifests(repoRootPlugins)) {
+    return repoRootPlugins;
+  }
+  if (existsSync(localPlugins)) {
+    return localPlugins;
+  }
+  if (existsSync(repoRootPlugins)) {
+    return repoRootPlugins;
+  }
+  return localPlugins;
 }
 
 export async function writePluginManifestToFilesystem(manifest: PluginManifest) {
@@ -53,6 +71,29 @@ export async function writePluginManifestToFilesystem(manifest: PluginManifest)
   return manifestPath;
 }
 
+export async function writePackagedPluginManifestToFilesystem(
+  manifest: PluginManifest,
+  input: {
+    sourceType: "builtin" | "registry" | "local_path" | "archive_url";
+    sourceRef?: string;
+    integrity?: string;
+    buildHash?: string;
+  }
+) {
+  const nextManifest = {
+    ...manifest,
+    apiVersion: "2",
+    install: {
+      sourceType: input.sourceType,
+      sourceRef: input.sourceRef,
+      integrity: input.integrity,
+      buildHash: input.buildHash,
+      installedAt: new Date().toISOString()
+    }
+  } as PluginManifest;
+  return writePluginManifestToFilesystem(nextManifest);
+}
+
 export async function deletePluginManifestFromFilesystem(pluginId: string) {
   const pluginRoot = resolvePluginManifestsDir();
   const safeDirName = sanitizePluginDirectoryName(pluginId);
@@ -63,3 +104,37 @@ export async function deletePluginManifestFromFilesystem(pluginId: string) {
 function sanitizePluginDirectoryName(pluginId: string) {
   return pluginId.replace(/[^a-zA-Z0-9._-]/g, "-");
 }
+
+function directoryHasPluginManifests(dir: string) {
+  if (!existsSync(dir)) {
+    return false;
+  }
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    return entries.some((entry) => entry.isDirectory() && existsSync(resolve(dir, entry.name, "plugin.json")));
+  } catch {
+    return false;
+  }
+}
+
+function normalizeFilesystemManifest(manifestPath: string, manifest: PluginManifest): PluginManifest {
+  const pluginDir = resolve(manifestPath, "..");
+  const parsedV2 = PluginManifestV2Schema.safeParse(manifest);
+  if (!parsedV2.success) {
+    return manifest;
+  }
+  const v2 = parsedV2.data;
+  const worker = resolve(pluginDir, v2.entrypoints.worker);
+  const ui = v2.entrypoints.ui ? resolve(pluginDir, v2.entrypoints.ui) : undefined;
+  return {
+    ...v2,
+    runtime: {
+      ...v2.runtime,
+      entrypoint: v2.runtime.type === "stdio" || v2.runtime.type === "http" ? resolve(pluginDir, v2.runtime.entrypoint) : v2.runtime.entrypoint
+    },
+    entrypoints: {
+      worker,
+      ui
+    }
+  };
+}

package/src/services/plugin-rpc.ts

@@ -0,0 +1,102 @@
+import { EventEmitter } from "node:events";
+
+export type PluginRpcRequest = {
+  jsonrpc: "2.0";
+  id: string;
+  method: string;
+  params?: unknown;
+};
+
+export type PluginRpcSuccess = {
+  jsonrpc: "2.0";
+  id: string;
+  result: unknown;
+};
+
+export type PluginRpcFailure = {
+  jsonrpc: "2.0";
+  id: string;
+  error: {
+    code: number;
+    message: string;
+    data?: unknown;
+  };
+};
+
+export type PluginRpcResponse = PluginRpcSuccess | PluginRpcFailure;
+
+export function createPluginRpcRequest(method: string, params: unknown, id: string): PluginRpcRequest {
+  return {
+    jsonrpc: "2.0",
+    id,
+    method,
+    params
+  };
+}
+
+export function encodePluginRpcMessage(value: PluginRpcRequest | PluginRpcResponse): string {
+  return `${JSON.stringify(value)}\n`;
+}
+
+export function decodePluginRpcMessage(line: string): PluginRpcResponse | null {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(line) as unknown;
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object") {
+    return null;
+  }
+  const obj = parsed as Record<string, unknown>;
+  if (obj.jsonrpc !== "2.0" || typeof obj.id !== "string") {
+    return null;
+  }
+  if ("result" in obj) {
+    return {
+      jsonrpc: "2.0",
+      id: obj.id,
+      result: obj.result
+    };
+  }
+  if ("error" in obj && obj.error && typeof obj.error === "object") {
+    const err = obj.error as Record<string, unknown>;
+    if (typeof err.code === "number" && typeof err.message === "string") {
+      return {
+        jsonrpc: "2.0",
+        id: obj.id,
+        error: {
+          code: err.code,
+          message: err.message,
+          data: err.data
+        }
+      };
+    }
+  }
+  return null;
+}
+
+export class PluginRpcLineBuffer extends EventEmitter<{
+  message: [PluginRpcResponse];
+}> {
+  private buffer = "";
+
+  push(chunk: string) {
+    this.buffer += chunk;
+    while (true) {
+      const idx = this.buffer.indexOf("\n");
+      if (idx === -1) {
+        break;
+      }
+      const line = this.buffer.slice(0, idx).trim();
+      this.buffer = this.buffer.slice(idx + 1);
+      if (!line) {
+        continue;
+      }
+      const parsed = decodePluginRpcMessage(line);
+      if (parsed) {
+        this.emit("message", parsed);
+      }
+    }
+  }
+}