@poolzin/pool-bot 2026.3.13 → 2026.3.14

package/extensions/xyops/node_modules/.bin/yaml

@@ -0,0 +1,21 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -z "$NODE_PATH" ]; then
+  export NODE_PATH="/Users/pool/Documents/GitHub/pool-bot/node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/node_modules:/Users/pool/Documents/GitHub/pool-bot/node_modules/.pnpm/yaml@2.8.2/node_modules:/Users/pool/Documents/GitHub/pool-bot/node_modules/.pnpm/node_modules"
+else
+  export NODE_PATH="/Users/pool/Documents/GitHub/pool-bot/node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/node_modules:/Users/pool/Documents/GitHub/pool-bot/node_modules/.pnpm/yaml@2.8.2/node_modules:/Users/pool/Documents/GitHub/pool-bot/node_modules/.pnpm/node_modules:$NODE_PATH"
+fi
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../../../../node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/bin.mjs" "$@"
+else
+  exec node  "$basedir/../../../../node_modules/.pnpm/yaml@2.8.2/node_modules/yaml/bin.mjs" "$@"
+fi

package/extensions/xyops/node_modules/.vite/vitest/da39a3ee5e6b4b0d3255bfef95601890afd80709/results.json

@@ -0,0 +1 @@
+{"version":"4.0.18","results":[[":src/client.test.ts",{"duration":29.100499999999982,"failed":false}]]}

package/extensions/xyops/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@poolbot/xyops",
+  "version": "2026.3.13",
+  "description": "XYOps integration for PoolBot - Workflow automation and job scheduling",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./client": "./dist/client.js",
+    "./types": "./dist/types.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@sinclair/typebox": "^0.34.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^3.0.0"
+  },
+  "peerDependencies": {
+    "poolbot": "workspace:*"
+  },
+  "poolbot": {
+    "plugin": true,
+    "config": {
+      "schema": "./dist/config/schema.js"
+    }
+  },
+  "keywords": ["xyops", "workflow", "automation", "scheduler", "jobs"],
+  "author": "PoolBot Team",
+  "license": "MIT"
+}

package/extensions/xyops/src/client.test.ts

@@ -0,0 +1,467 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { XYOpsClient } from './client.js'
+import type { XYOpsConfig, XYOpsJob, XYOpsSchedule, XYOpsEvent, XYOpsStatus, XYOpsPlugin } from './types.js'
+
+describe('XYOpsClient', () => {
+  let client: XYOpsClient
+  let mockFetch: ReturnType<typeof vi.fn>
+
+  const config: XYOpsConfig = {
+    baseUrl: 'http://localhost:8080',
+    apiKey: 'test-api-key',
+    timeout: 5000,
+  }
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    client = new XYOpsClient(config)
+    mockFetch = vi.fn()
+    global.fetch = mockFetch as unknown as typeof fetch
+  })
+
+  describe('constructor', () => {
+    it('should create client with config', () => {
+      expect(client).toBeDefined()
+    })
+
+    it('should remove trailing slash from baseUrl', () => {
+      const clientWithSlash = new XYOpsClient({
+        ...config,
+        baseUrl: 'http://localhost:8080/',
+      })
+      expect(clientWithSlash).toBeDefined()
+    })
+
+    it('should use default timeout', () => {
+      const clientWithoutTimeout = new XYOpsClient({
+        baseUrl: 'http://localhost:8080',
+      })
+      expect(clientWithoutTimeout).toBeDefined()
+    })
+  })
+
+  describe('request', () => {
+    it('should make GET request with auth header', async () => {
+      const mockJob: XYOpsJob = {
+        id: 'job-1',
+        title: 'Test Job',
+        category: 'test',
+        plugin: 'shell',
+        params: { command: 'echo test' },
+        enabled: true,
+        created: Date.now(),
+        modified: Date.now(),
+      }
+
+      mockFetch.mockResolvedValue({
+        ok: true,
+        headers: new Headers({ 'content-type': 'application/json' }),
+        json: () => Promise.resolve(mockJob),
+      })
+
+      const result = await client.getJob('job-1')
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://localhost:8080/api/jobs/job-1',
+        expect.objectContaining({
+          method: 'GET',
+          headers: expect.objectContaining({
+            'Authorization': 'Bearer test-api-key',
+            'Content-Type': 'application/json',
+          }),
+        })
+      )
+      expect(result).toEqual(mockJob)
+    })
+
+    it('should make POST request with body', async () => {
+      const newJob = {
+        title: 'New Job',
+        category: 'test',
+        plugin: 'shell',
+        params: { command: 'echo hello' },
+        enabled: true,
+      }
+
+      const mockResponse: XYOpsJob = {
+        id: 'job-2',
+        ...newJob,
+        created: Date.now(),
+        modified: Date.now(),
+      }
+
+      mockFetch.mockResolvedValue({
+        ok: true,
+        headers: new Headers({ 'content-type': 'application/json' }),
+        json: () => Promise.resolve(mockResponse),
+      })
+
+      const result = await client.createJob(newJob)
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://localhost:8080/api/jobs',
+        expect.objectContaining({
+          method: 'POST',
+          body: JSON.stringify(newJob),
+        })
+      )
+      expect(result).toEqual(mockResponse)
+    })
+
+    it('should handle API errors', async () => {
+      mockFetch.mockResolvedValue({
+        ok: false,
+        status: 404,
+        statusText: 'Not Found',
+        text: () => Promise.resolve('Job not found'),
+      })
+
+      await expect(client.getJob('nonexistent')).rejects.toThrow('XYOps API error')
+    })
+
+    it('should handle timeout', async () => {
+      mockFetch.mockImplementation(() => {
+        const error = new Error('AbortError')
+        error.name = 'AbortError'
+        return Promise.reject(error)
+      })
+
+      await expect(client.getJob('job-1')).rejects.toThrow('timeout')
+    })
+
+    it('should handle non-JSON responses', async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        headers: new Headers({ 'content-type': 'text/plain' }),
+      })
+
+      const result = await client.deleteJob('job-1')
+      expect(result).toBeUndefined()
+    })
+
+    it('should work without API key', async () => {
+      const clientNoAuth = new XYOpsClient({
+        baseUrl: 'http://localhost:8080',
+      })
+
+      mockFetch.mockResolvedValue({
+        ok: true,
+        headers: new Headers({ 'content-type': 'application/json' }),
+        json: () => Promise.resolve([]),
+      })
+
+      await clientNoAuth.listJobs()
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.objectContaining({
+          headers: expect.not.objectContaining({
+            'Authorization': expect.any(String),
+          }),
+        })
+      )
+    })
+  })
+
+  describe('Jobs', () => {
+    const mockJob: XYOpsJob = {
+      id: 'job-1',
+      title: 'Test Job',
+      category: 'test',
+      plugin: 'shell',
+      params: { command: 'echo test' },
+      enabled: true,
+      created: Date.now(),
+      modified: Date.now(),
+    }
+
+    it('should list jobs', async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        headers: new Headers({ 'content-type': 'application/json' }),
+        json: () => Promise.resolve([mockJob]),
+      })
+
+      const result = await client.listJobs(0, 50)
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://localhost:8080/api/jobs?offset=0&limit=50',
+        expect.any(Object)
+      )
+      expect(result).toEqual([mockJob])
+    })
+
+    it('should get job by id', async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        headers: new Headers({ 'content-type': 'application/json' }),
+        json: () => Promise.resolve(mockJob),
+      })
+
+      const result = await client.getJob('job-1')
+
+      expect(result).toEqual(mockJob)
+    })
+
+    it('should create job', async () => {
+      const jobData = {
+        title: 'New Job',
+        category: 'test',
+        plugin: 'shell',
+        params: { command: 'echo hello' },
+        enabled: true,
+      }
+
+      mockFetch.mockResolvedValue({
+        ok: true,
+        headers: new Headers({ 'content-type': 'application/json' }),
+        json: () => Promise.resolve({ id: 'job-2', ...jobData, created: Date.now(), modified: Date.now() }),
+      })
+
+      const result = await client.createJob(jobData)
+
+      expect(result.title).toBe('New Job')
+    })
+
+    it('should update job', async () => {
+      const updates = { title: 'Updated Job' }
+
+      mockFetch.mockResolvedValue({
+        ok: true,
+        headers: new Headers({ 'content-type': 'application/json' }),
+        json: () => Promise.resolve({ ...mockJob, ...updates }),
+      })
+
+      const result = await client.updateJob('job-1', updates)
+
+      expect(result.title).toBe('Updated Job')
+    })
+
+    it('should delete job', async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        headers: new Headers({ 'content-type': 'application/json' }),
+        json: () => Promise.resolve(undefined),
+      })
+
+      await client.deleteJob('job-1')
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://localhost:8080/api/jobs/job-1',
+        expect.objectContaining({ method: 'DELETE' })
+      )
+    })
+
+    it('should run job', async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        headers: new Headers({ 'content-type': 'application/json' }),
+        json: () => Promise.resolve({ eventId: 'event-1' }),
+      })
+
+      const result = await client.runJob('job-1', { param1: 'value1' })
+
+      expect(result.eventId).toBe('event-1')
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://localhost:8080/api/jobs/job-1/run',
+        expect.objectContaining({
+          method: 'POST',
+          body: JSON.stringify({ params: { param1: 'value1' } }),
+        })
+      )
+    })
+
+    it('should run job without params', async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        headers: new Headers({ 'content-type': 'application/json' }),
+        json: () => Promise.resolve({ eventId: 'event-1' }),
+      })
+
+      await client.runJob('job-1')
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.objectContaining({
+          body: undefined,
+        })
+      )
+    })
+  })
+
+  describe('Schedules', () => {
+    const mockSchedule: XYOpsSchedule = {
+      id: 'schedule-1',
+      jobId: 'job-1',
+      cron: '0 0 * * *',
+      enabled: true,
+      created: Date.now(),
+    }
+
+    it('should list schedules', async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        headers: new Headers({ 'content-type': 'application/json' }),
+        json: () => Promise.resolve([mockSchedule]),
+      })
+
+      const result = await client.listSchedules()
+
+      expect(result).toEqual([mockSchedule])
+    })
+
+    it('should list schedules for specific job', async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        headers: new Headers({ 'content-type': 'application/json' }),
+        json: () => Promise.resolve([mockSchedule]),
+      })
+
+      await client.listSchedules('job-1')
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://localhost:8080/api/schedules?jobId=job-1',
+        expect.any(Object)
+      )
+    })
+
+    it('should create schedule', async () => {
+      const scheduleData = {
+        jobId: 'job-1',
+        cron: '0 0 * * *',
+        enabled: true,
+      }
+
+      mockFetch.mockResolvedValue({
+        ok: true,
+        headers: new Headers({ 'content-type': 'application/json' }),
+        json: () => Promise.resolve({ id: 'schedule-2', ...scheduleData, created: Date.now() }),
+      })
+
+      const result = await client.createSchedule(scheduleData)
+
+      expect(result.jobId).toBe('job-1')
+    })
+
+    it('should delete schedule', async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        headers: new Headers({ 'content-type': 'application/json' }),
+        json: () => Promise.resolve(undefined),
+      })
+
+      await client.deleteSchedule('schedule-1')
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://localhost:8080/api/schedules/schedule-1',
+        expect.objectContaining({ method: 'DELETE' })
+      )
+    })
+  })
+
+  describe('Events', () => {
+    const mockEvent: XYOpsEvent = {
+      id: 'event-1',
+      jobId: 'job-1',
+      status: 'running',
+      startTime: Date.now(),
+    }
+
+    it('should list events', async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        headers: new Headers({ 'content-type': 'application/json' }),
+        json: () => Promise.resolve([mockEvent]),
+      })
+
+      const result = await client.listEvents()
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://localhost:8080/api/events?limit=50&offset=0',
+        expect.any(Object)
+      )
+      expect(result).toEqual([mockEvent])
+    })
+
+    it('should list events with filters', async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        headers: new Headers({ 'content-type': 'application/json' }),
+        json: () => Promise.resolve([mockEvent]),
+      })
+
+      await client.listEvents('job-1', 10, 20)
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://localhost:8080/api/events?jobId=job-1&limit=10&offset=20',
+        expect.any(Object)
+      )
+    })
+
+    it('should get event by id', async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        headers: new Headers({ 'content-type': 'application/json' }),
+        json: () => Promise.resolve(mockEvent),
+      })
+
+      const result = await client.getEvent('event-1')
+
+      expect(result).toEqual(mockEvent)
+    })
+
+    it('should abort event', async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        headers: new Headers({ 'content-type': 'application/json' }),
+        json: () => Promise.resolve(undefined),
+      })
+
+      await client.abortEvent('event-1')
+
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://localhost:8080/api/events/event-1/abort',
+        expect.objectContaining({ method: 'POST' })
+      )
+    })
+  })
+
+  describe('System', () => {
+    it('should get status', async () => {
+      const mockStatus: XYOpsStatus = {
+        version: '1.0.0',
+        uptime: 3600,
+        jobCount: 5,
+        scheduleCount: 3,
+        activeEvents: 1,
+      }
+
+      mockFetch.mockResolvedValue({
+        ok: true,
+        headers: new Headers({ 'content-type': 'application/json' }),
+        json: () => Promise.resolve(mockStatus),
+      })
+
+      const result = await client.getStatus()
+
+      expect(result).toEqual(mockStatus)
+    })
+
+    it('should list plugins', async () => {
+      const mockPlugins: XYOpsPlugin[] = [
+        { name: 'plugin-1', title: 'Plugin 1', description: 'Test plugin 1' },
+        { name: 'plugin-2', title: 'Plugin 2', description: 'Test plugin 2' },
+      ]
+
+      mockFetch.mockResolvedValue({
+        ok: true,
+        headers: new Headers({ 'content-type': 'application/json' }),
+        json: () => Promise.resolve(mockPlugins),
+      })
+
+      const result = await client.listPlugins()
+
+      expect(result).toEqual(mockPlugins)
+    })
+  })
+})

package/extensions/xyops/src/client.ts

@@ -0,0 +1,157 @@
+import type {
+  XYOpsConfig,
+  XYOpsJob,
+  XYOpsSchedule,
+  XYOpsEvent,
+  XYOpsPlugin,
+  XYOpsStatus,
+} from "./types.js";
+
+export class XYOpsClient {
+  private baseUrl: string;
+  private apiKey?: string;
+  private timeout: number;
+
+  constructor(config: XYOpsConfig) {
+    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+    this.apiKey = config.apiKey;
+    this.timeout = config.timeout ?? 30000;
+  }
+
+  private async request<T>(
+    method: string,
+    path: string,
+    body?: unknown
+  ): Promise<T> {
+    const url = `${this.baseUrl}/api${path}`;
+    const headers: Record<string, string> = {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+    };
+
+    if (this.apiKey) {
+      headers["Authorization"] = `Bearer ${this.apiKey}`;
+    }
+
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+
+    try {
+      const response = await fetch(url, {
+        method,
+        headers,
+        body: body ? JSON.stringify(body) : undefined,
+        signal: controller.signal,
+      });
+
+      clearTimeout(timeoutId);
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(
+          `XYOps API error: ${response.status} ${response.statusText} - ${errorText}`
+        );
+      }
+
+      // Handle empty responses
+      const contentType = response.headers.get("content-type");
+      if (!contentType?.includes("application/json")) {
+        return undefined as T;
+      }
+
+      return (await response.json()) as T;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new Error(`XYOps request timeout after ${this.timeout}ms`);
+      }
+      throw error;
+    }
+  }
+
+  // Jobs
+  async listJobs(offset = 0, limit = 50): Promise<XYOpsJob[]> {
+    return this.request<XYOpsJob[]>(
+      "GET",
+      `/jobs?offset=${offset}&limit=${limit}`
+    );
+  }
+
+  async getJob(jobId: string): Promise<XYOpsJob> {
+    return this.request<XYOpsJob>("GET", `/jobs/${jobId}`);
+  }
+
+  async createJob(
+    jobData: Omit<XYOpsJob, "id" | "created" | "modified">
+  ): Promise<XYOpsJob> {
+    return this.request<XYOpsJob>("POST", "/jobs", jobData);
+  }
+
+  async updateJob(
+    jobId: string,
+    updates: Partial<Omit<XYOpsJob, "id" | "created" | "modified">>
+  ): Promise<XYOpsJob> {
+    return this.request<XYOpsJob>("PUT", `/jobs/${jobId}`, updates);
+  }
+
+  async deleteJob(jobId: string): Promise<void> {
+    await this.request<void>("DELETE", `/jobs/${jobId}`);
+  }
+
+  async runJob(
+    jobId: string,
+    params?: Record<string, unknown>
+  ): Promise<{ eventId: string }> {
+    return this.request<{ eventId: string }>(
+      "POST",
+      `/jobs/${jobId}/run`,
+      params ? { params } : undefined
+    );
+  }
+
+  // Schedules
+  async listSchedules(jobId?: string): Promise<XYOpsSchedule[]> {
+    const query = jobId ? `?jobId=${jobId}` : "";
+    return this.request<XYOpsSchedule[]>("GET", `/schedules${query}`);
+  }
+
+  async createSchedule(
+    scheduleData: Omit<XYOpsSchedule, "id" | "created">
+  ): Promise<XYOpsSchedule> {
+    return this.request<XYOpsSchedule>("POST", "/schedules", scheduleData);
+  }
+
+  async deleteSchedule(scheduleId: string): Promise<void> {
+    await this.request<void>("DELETE", `/schedules/${scheduleId}`);
+  }
+
+  // Events
+  async listEvents(
+    jobId?: string,
+    limit = 50,
+    offset = 0
+  ): Promise<XYOpsEvent[]> {
+    const params = new URLSearchParams();
+    if (jobId) params.append("jobId", jobId);
+    params.append("limit", String(limit));
+    params.append("offset", String(offset));
+    return this.request<XYOpsEvent[]>("GET", `/events?${params.toString()}`);
+  }
+
+  async getEvent(eventId: string): Promise<XYOpsEvent> {
+    return this.request<XYOpsEvent>("GET", `/events/${eventId}`);
+  }
+
+  async abortEvent(eventId: string): Promise<void> {
+    await this.request<void>("POST", `/events/${eventId}/abort`);
+  }
+
+  // System
+  async getStatus(): Promise<XYOpsStatus> {
+    return this.request<XYOpsStatus>("GET", "/status");
+  }
+
+  async listPlugins(): Promise<XYOpsPlugin[]> {
+    return this.request<XYOpsPlugin[]>("GET", "/plugins");
+  }
+}