@exelerus/openclaw-vexscan 1.0.0

package/src/cli-wrapper.ts

@@ -0,0 +1,177 @@
+import { spawn } from "child_process";
+import { existsSync } from "fs";
+import { homedir, platform, arch } from "os";
+import { join } from "path";
+import type { ExecResult } from "./types.js";
+
+const REPO = "edimuj/vexscan";
+const INSTALL_DIR = join(homedir(), ".local", "bin");
+
+/**
+ * Common locations to search for the vexscan binary
+ */
+const SEARCH_PATHS = [
+  join(INSTALL_DIR, "vexscan"),
+  join(homedir(), ".cargo", "bin", "vexscan"),
+  "/usr/local/bin/vexscan",
+  "/opt/homebrew/bin/vexscan",
+];
+
+/**
+ * Find vexscan binary in common locations
+ */
+export async function findVexscan(): Promise<string | null> {
+  // Check if in PATH
+  const inPath = await checkInPath("vexscan");
+  if (inPath) return "vexscan";
+
+  // Check common locations
+  for (const path of SEARCH_PATHS) {
+    if (existsSync(path)) {
+      return path;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Check if a command exists in PATH
+ */
+async function checkInPath(cmd: string): Promise<boolean> {
+  return new Promise((resolve) => {
+    const proc = spawn("which", [cmd], { stdio: "pipe" });
+    proc.on("close", (code) => resolve(code === 0));
+    proc.on("error", () => resolve(false));
+  });
+}
+
+/**
+ * Install vexscan from GitHub releases
+ */
+export async function installVexscan(): Promise<string | null> {
+  const os = platform();
+  const cpu = arch();
+
+  // Determine asset name
+  let osName: string;
+  switch (os) {
+    case "darwin":
+      osName = "macos";
+      break;
+    case "linux":
+      osName = "linux";
+      break;
+    default:
+      return null; // Windows not supported via this method
+  }
+
+  let archName: string;
+  switch (cpu) {
+    case "x64":
+      archName = "x86_64";
+      break;
+    case "arm64":
+      archName = "aarch64";
+      break;
+    default:
+      return null;
+  }
+
+  const assetName = `vexscan-${osName}-${archName}`;
+
+  try {
+    // Get latest version
+    const response = await fetch(`https://api.github.com/repos/${REPO}/releases/latest`);
+    if (!response.ok) return null;
+
+    const release = (await response.json()) as { tag_name: string };
+    const version = release.tag_name;
+
+    const downloadUrl = `https://github.com/${REPO}/releases/download/${version}/${assetName}`;
+
+    // Download binary
+    const binaryResponse = await fetch(downloadUrl);
+    if (!binaryResponse.ok) return null;
+
+    const binary = await binaryResponse.arrayBuffer();
+
+    // Write to install dir
+    const { mkdir, writeFile, chmod } = await import("fs/promises");
+    await mkdir(INSTALL_DIR, { recursive: true });
+
+    const binaryPath = join(INSTALL_DIR, "vexscan");
+    await writeFile(binaryPath, Buffer.from(binary));
+    await chmod(binaryPath, 0o755);
+
+    return binaryPath;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Execute an arbitrary command with arguments
+ */
+export async function execCommand(cmd: string, args: string[]): Promise<ExecResult> {
+  return new Promise((resolve, reject) => {
+    const proc = spawn(cmd, args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.env, NO_COLOR: "1" },
+    });
+
+    let stdout = "";
+    let stderr = "";
+
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+
+    proc.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+
+    proc.on("close", (code) => {
+      resolve({ stdout, stderr, exitCode: code ?? 0 });
+    });
+
+    proc.on("error", (err) => {
+      reject(err);
+    });
+  });
+}
+
+/**
+ * Execute vexscan CLI with arguments
+ */
+export async function execVexscan(cliPath: string, args: string[]): Promise<ExecResult> {
+  return new Promise((resolve, reject) => {
+    const proc = spawn(cliPath, args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.env, NO_COLOR: "1" },
+    });
+
+    let stdout = "";
+    let stderr = "";
+
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+
+    proc.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+
+    proc.on("close", (code) => {
+      resolve({
+        stdout,
+        stderr,
+        exitCode: code ?? 0,
+      });
+    });
+
+    proc.on("error", (err) => {
+      reject(err);
+    });
+  });
+}

package/src/openclaw-sdk.d.ts

@@ -0,0 +1,84 @@
+declare module "openclaw/plugin-sdk" {
+  import type { TSchema } from "@sinclair/typebox";
+
+  type OpenClawPluginConfigSchema = {
+    safeParse?: (value: unknown) => {
+      success: boolean;
+      data?: unknown;
+      error?: { issues?: Array<{ message: string }> };
+    };
+  };
+
+  type OpenClawPluginToolOptions = {
+    name?: string;
+    names?: string[];
+    optional?: boolean;
+  };
+
+  type OpenClawPluginToolContext = {
+    config: any;
+    sessionKey?: string;
+    sandboxed?: boolean;
+  };
+
+  type AgentTool = {
+    name: string;
+    description: string;
+    parameters: TSchema;
+    execute(toolCallId: string, params: Record<string, unknown>): Promise<{
+      content: { type: string; text: string }[];
+      details?: unknown;
+    }>;
+  };
+
+  type OpenClawPluginToolFactory = (
+    ctx: OpenClawPluginToolContext,
+  ) => AgentTool | AgentTool[] | null | undefined;
+
+  type OpenClawPluginService = {
+    id: string;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+  };
+
+  type OpenClawPluginApi = {
+    id: string;
+    name: string;
+    version?: string;
+    description?: string;
+    source: string;
+    config: any;
+    pluginConfig?: Record<string, unknown>;
+    runtime: any;
+    logger: {
+      info(msg: string): void;
+      warn(msg: string): void;
+      error(msg: string): void;
+    };
+    registerTool: (
+      tool: AgentTool | OpenClawPluginToolFactory,
+      opts?: OpenClawPluginToolOptions,
+    ) => void;
+    registerCli: (
+      registrar: (ctx: { program: any }) => void,
+      opts?: { commands?: string[] },
+    ) => void;
+    registerService: (service: OpenClawPluginService) => void;
+    registerHook: (events: string | string[], handler: (...args: any[]) => any, opts?: any) => void;
+    on: (hookName: string, handler: (...args: any[]) => any, opts?: { priority?: number }) => void;
+    resolvePath: (input: string) => string;
+  };
+
+  function emptyPluginConfigSchema(): OpenClawPluginConfigSchema;
+
+  export type {
+    OpenClawPluginApi,
+    OpenClawPluginConfigSchema,
+    OpenClawPluginToolOptions,
+    OpenClawPluginToolFactory,
+    OpenClawPluginToolContext,
+    OpenClawPluginService,
+    AgentTool,
+  };
+  export { emptyPluginConfigSchema };
+}

package/src/types.ts

@@ -0,0 +1,53 @@
+export interface VexscanConfig {
+  enabled: boolean;
+  scanOnInstall: boolean;
+  minSeverity: string;
+  thirdPartyOnly: boolean;
+  skipDeps: boolean;
+  cliPath?: string;
+}
+
+export interface ScanResult {
+  scan_root: string;
+  platform?: string;
+  total_findings?: number;
+  max_severity?: string;
+  findings_by_severity?: Record<string, number>;
+  total_time_ms: number;
+  results: FileResult[];
+}
+
+export interface FileResult {
+  path: string;
+  findings: Finding[];
+}
+
+export interface Finding {
+  rule_id: string;
+  title: string;
+  description: string;
+  severity: string;
+  category: string;
+  location: Location;
+  snippet: string;
+  remediation?: string;
+}
+
+export interface Location {
+  file: string;
+  start_line: number;
+  end_line: number;
+  start_column: number;
+  end_column: number;
+}
+
+export interface VetResult extends ScanResult {
+  source: string;
+  branch?: string;
+}
+
+export interface ExecResult {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+}

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "dist",
+    "rootDir": ".",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["index.ts", "src/**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}