@qodalis/cli-server-jobs 2.0.0-beta.3

package/public-api.mjs

@@ -0,0 +1,994 @@
+import { DefaultLibraryAuthor, CliIcon, CliForegroundColor, ICliCompletionProvider_TOKEN } from '@qodalis/cli-core';
+
+// src/lib/processors/cli-jobs-command-processor.ts
+
+// src/lib/services/cli-jobs-service.ts
+var CliJobsService = class {
+  constructor(baseUrl, headers = {}) {
+    this.baseUrl = baseUrl;
+    this.headers = headers;
+  }
+  async request(path, init) {
+    const url = `${this.baseUrl}/api/v1/qcli/jobs${path}`;
+    const response = await fetch(url, {
+      ...init,
+      headers: {
+        "Content-Type": "application/json",
+        ...this.headers,
+        ...init?.headers ?? {}
+      }
+    });
+    if (!response.ok) {
+      let errorMessage = `${response.status} ${response.statusText}`;
+      try {
+        const body = await response.json();
+        if (body.error) {
+          errorMessage = body.error;
+        }
+      } catch {
+      }
+      throw new Error(errorMessage);
+    }
+    const text = await response.text();
+    if (!text) {
+      return void 0;
+    }
+    return JSON.parse(text);
+  }
+  async listJobs() {
+    return this.request("");
+  }
+  async getJob(id) {
+    return this.request(`/${encodeURIComponent(id)}`);
+  }
+  async triggerJob(id) {
+    await this.request(`/${encodeURIComponent(id)}/trigger`, {
+      method: "POST"
+    });
+  }
+  async pauseJob(id) {
+    await this.request(`/${encodeURIComponent(id)}/pause`, {
+      method: "POST"
+    });
+  }
+  async resumeJob(id) {
+    await this.request(`/${encodeURIComponent(id)}/resume`, {
+      method: "POST"
+    });
+  }
+  async stopJob(id) {
+    await this.request(`/${encodeURIComponent(id)}/stop`, {
+      method: "POST"
+    });
+  }
+  async cancelJob(id) {
+    await this.request(`/${encodeURIComponent(id)}/cancel`, {
+      method: "POST"
+    });
+  }
+  async updateJob(id, request) {
+    await this.request(`/${encodeURIComponent(id)}`, {
+      method: "PUT",
+      body: JSON.stringify(request)
+    });
+  }
+  async getHistory(id, opts) {
+    const params = new URLSearchParams();
+    if (opts?.limit != null) params.set("limit", String(opts.limit));
+    if (opts?.offset != null) params.set("offset", String(opts.offset));
+    if (opts?.status) params.set("status", opts.status);
+    const qs = params.toString();
+    return this.request(
+      `/${encodeURIComponent(id)}/history${qs ? `?${qs}` : ""}`
+    );
+  }
+  async getExecution(jobId, execId) {
+    return this.request(
+      `/${encodeURIComponent(jobId)}/history/${encodeURIComponent(execId)}`
+    );
+  }
+};
+
+// src/lib/processors/cli-jobs-command-processor.ts
+function getServices(context, args) {
+  const manager = context.services.get("cli-server-manager");
+  if (!manager || !manager.connections) {
+    return [];
+  }
+  const targetServer = args["server"];
+  const results = [];
+  for (const [name, connection] of manager.connections) {
+    if (targetServer && name !== targetServer) continue;
+    if (!connection.connected) continue;
+    const config = connection.config;
+    const baseUrl = config.url.endsWith("/") ? config.url.slice(0, -1) : config.url;
+    const headers = config.headers ?? {};
+    results.push({ name, service: new CliJobsService(baseUrl, headers) });
+  }
+  return results;
+}
+async function resolveJobId(service, nameOrId) {
+  if (/^[0-9a-f-]{8,}$/i.test(nameOrId)) {
+    try {
+      return await service.getJob(nameOrId);
+    } catch {
+    }
+  }
+  const jobs = await service.listJobs();
+  const match = jobs.find(
+    (j) => j.name.toLowerCase() === nameOrId.toLowerCase() || j.id === nameOrId
+  );
+  return match ?? null;
+}
+function formatRelativeTime(isoString) {
+  if (!isoString) return "-";
+  const diff = Date.now() - new Date(isoString).getTime();
+  if (diff < 0) {
+    const absDiff = -diff;
+    if (absDiff < 6e4) return `in ${Math.round(absDiff / 1e3)}s`;
+    if (absDiff < 36e5) return `in ${Math.round(absDiff / 6e4)}m`;
+    if (absDiff < 864e5) return `in ${Math.round(absDiff / 36e5)}h`;
+    return `in ${Math.round(absDiff / 864e5)}d`;
+  }
+  if (diff < 6e4) return `${Math.round(diff / 1e3)}s ago`;
+  if (diff < 36e5) return `${Math.round(diff / 6e4)}m ago`;
+  if (diff < 864e5) return `${Math.round(diff / 36e5)}h ago`;
+  return `${Math.round(diff / 864e5)}d ago`;
+}
+function formatDuration(ms) {
+  if (ms == null) return "-";
+  if (ms < 1e3) return `${ms}ms`;
+  if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
+  return `${(ms / 6e4).toFixed(1)}m`;
+}
+function statusColor(status, writer) {
+  switch (status) {
+    case "active":
+    case "completed":
+    case "running":
+      return writer.wrapInColor(status, CliForegroundColor.Green);
+    case "paused":
+      return writer.wrapInColor(status, CliForegroundColor.Yellow);
+    case "stopped":
+    case "failed":
+    case "timed_out":
+    case "cancelled":
+      return writer.wrapInColor(status, CliForegroundColor.Red);
+    default:
+      return status;
+  }
+}
+function logLevelColor(level, writer) {
+  switch (level) {
+    case "debug":
+      return writer.wrapInColor(level, CliForegroundColor.Cyan);
+    case "info":
+      return writer.wrapInColor(level, CliForegroundColor.Green);
+    case "warning":
+      return writer.wrapInColor(level, CliForegroundColor.Yellow);
+    case "error":
+      return writer.wrapInColor(level, CliForegroundColor.Red);
+    default:
+      return level;
+  }
+}
+var serverParam = {
+  name: "server",
+  description: "Target a specific server by name",
+  required: false,
+  type: "string"
+};
+var CliJobsCommandProcessor = class {
+  constructor() {
+    this.command = "server";
+    this.extendsProcessor = true;
+    this.description = "Manage background jobs on connected servers";
+    this.author = DefaultLibraryAuthor;
+    this.metadata = {
+      icon: CliIcon.Gear,
+      module: "@qodalis/cli-server-jobs"
+    };
+    this.processors = [
+      {
+        command: "jobs",
+        description: "Manage background jobs on connected servers",
+        author: DefaultLibraryAuthor,
+        metadata: {
+          icon: CliIcon.Gear,
+          module: "@qodalis/cli-server-jobs"
+        },
+        parameters: [serverParam],
+        processors: [
+          // list
+          {
+            command: "list",
+            description: "List all jobs across connected servers",
+            aliases: ["ls"],
+            parameters: [
+              serverParam,
+              {
+                name: "group",
+                description: "Filter jobs by group",
+                required: false,
+                type: "string"
+              }
+            ],
+            processCommand: async (cmd, context) => {
+              await this.handleList(cmd, context);
+            }
+          },
+          // info
+          {
+            command: "info",
+            description: "Show detailed information about a job",
+            valueRequired: true,
+            parameters: [serverParam],
+            processCommand: async (cmd, context) => {
+              await this.handleInfo(cmd, context);
+            }
+          },
+          // trigger
+          {
+            command: "trigger",
+            description: "Trigger immediate execution of a job",
+            valueRequired: true,
+            parameters: [serverParam],
+            processCommand: async (cmd, context) => {
+              await this.handleAction(cmd, context, "trigger");
+            }
+          },
+          // pause
+          {
+            command: "pause",
+            description: "Pause scheduled execution of a job",
+            valueRequired: true,
+            parameters: [serverParam],
+            processCommand: async (cmd, context) => {
+              await this.handleAction(cmd, context, "pause");
+            }
+          },
+          // resume
+          {
+            command: "resume",
+            description: "Resume a paused job",
+            valueRequired: true,
+            parameters: [serverParam],
+            processCommand: async (cmd, context) => {
+              await this.handleAction(cmd, context, "resume");
+            }
+          },
+          // stop
+          {
+            command: "stop",
+            description: "Stop a job and cancel current execution if running",
+            valueRequired: true,
+            parameters: [serverParam],
+            processCommand: async (cmd, context) => {
+              await this.handleAction(cmd, context, "stop");
+            }
+          },
+          // cancel
+          {
+            command: "cancel",
+            description: "Cancel the current execution of a job",
+            valueRequired: true,
+            parameters: [serverParam],
+            processCommand: async (cmd, context) => {
+              await this.handleAction(cmd, context, "cancel");
+            }
+          },
+          // history
+          {
+            command: "history",
+            description: "Show execution history for a job",
+            valueRequired: true,
+            parameters: [
+              serverParam,
+              {
+                name: "limit",
+                description: "Number of entries to show (default 20)",
+                required: false,
+                type: "number",
+                defaultValue: 20
+              },
+              {
+                name: "offset",
+                description: "Offset for pagination",
+                required: false,
+                type: "number",
+                defaultValue: 0
+              },
+              {
+                name: "status",
+                description: "Filter by execution status",
+                required: false,
+                type: "string"
+              }
+            ],
+            processCommand: async (cmd, context) => {
+              await this.handleHistory(cmd, context);
+            }
+          },
+          // logs
+          {
+            command: "logs",
+            description: "Show logs from the latest or a specific execution",
+            valueRequired: true,
+            parameters: [
+              serverParam,
+              {
+                name: "exec",
+                description: "Specific execution ID to show logs for",
+                required: false,
+                type: "string"
+              }
+            ],
+            processCommand: async (cmd, context) => {
+              await this.handleLogs(cmd, context);
+            }
+          },
+          // edit
+          {
+            command: "edit",
+            description: "Interactively edit job settings",
+            valueRequired: true,
+            parameters: [serverParam],
+            processCommand: async (cmd, context) => {
+              await this.handleEdit(cmd, context);
+            }
+          },
+          // watch
+          {
+            command: "watch",
+            description: "Live view of job events via WebSocket",
+            parameters: [serverParam],
+            processCommand: async (cmd, context) => {
+              await this.handleWatch(cmd, context);
+            }
+          }
+        ],
+        processCommand: async (cmd, context) => {
+          await this.handleList(cmd, context);
+        }
+      }
+    ];
+  }
+  async processCommand(_cmd, _context) {
+  }
+  // ── List ──────────────────────────────────────────────────────────
+  async handleList(cmd, context) {
+    const services = getServices(context, cmd.args);
+    if (services.length === 0) {
+      context.writer.writeInfo(
+        'No connected servers. Use "server list" to check connections.'
+      );
+      return;
+    }
+    const groupFilter = cmd.args["group"];
+    const multiServer = services.length > 1;
+    for (const { name, service } of services) {
+      try {
+        let jobs = await service.listJobs();
+        if (groupFilter) {
+          jobs = jobs.filter(
+            (j) => j.group?.toLowerCase() === groupFilter.toLowerCase()
+          );
+        }
+        if (multiServer) {
+          context.writer.writeln(
+            context.writer.wrapInColor(
+              `Server: ${name}`,
+              CliForegroundColor.Cyan
+            )
+          );
+        }
+        if (jobs.length === 0) {
+          context.writer.writeInfo("  No jobs found.");
+          continue;
+        }
+        const headers = [
+          "Name",
+          "Group",
+          "Status",
+          "Schedule",
+          "Last Run",
+          "Next Run",
+          "Duration"
+        ];
+        const rows = jobs.map((j) => [
+          j.name,
+          j.group ?? "-",
+          statusColor(j.status, context.writer),
+          j.schedule ?? (j.interval ? `every ${j.interval}ms` : "-"),
+          formatRelativeTime(j.lastRunAt),
+          formatRelativeTime(j.nextRunAt),
+          formatDuration(j.lastRunDuration)
+        ]);
+        context.writer.writeTable(headers, rows);
+      } catch (e) {
+        context.writer.writeError(
+          `Failed to list jobs on ${name}: ${e.message}`
+        );
+      }
+    }
+  }
+  // ── Info ──────────────────────────────────────────────────────────
+  async handleInfo(cmd, context) {
+    const nameOrId = (cmd.value ?? "").trim();
+    if (!nameOrId) {
+      context.writer.writeError("Usage: jobs info <id|name>");
+      return;
+    }
+    const services = getServices(context, cmd.args);
+    if (services.length === 0) {
+      context.writer.writeInfo("No connected servers.");
+      return;
+    }
+    for (const { name, service } of services) {
+      try {
+        const job = await resolveJobId(service, nameOrId);
+        if (!job) {
+          if (services.length === 1) {
+            context.writer.writeError(
+              `Job "${nameOrId}" not found on server ${name}.`
+            );
+          }
+          continue;
+        }
+        if (services.length > 1) {
+          context.writer.writeln(
+            context.writer.wrapInColor(
+              `Server: ${name}`,
+              CliForegroundColor.Cyan
+            )
+          );
+        }
+        const lines = [
+          ["ID", job.id],
+          ["Name", job.name],
+          ["Description", job.description],
+          ["Group", job.group ?? "-"],
+          ["Status", statusColor(job.status, context.writer)],
+          [
+            "Schedule",
+            job.schedule ?? (job.interval ? `every ${job.interval}ms` : "-")
+          ],
+          ["Max Retries", String(job.maxRetries)],
+          [
+            "Timeout",
+            job.timeout ? `${job.timeout}ms` : "none"
+          ],
+          ["Overlap Policy", job.overlapPolicy],
+          [
+            "Current Execution",
+            job.currentExecutionId ?? "none"
+          ],
+          ["Next Run", formatRelativeTime(job.nextRunAt)],
+          ["Last Run", formatRelativeTime(job.lastRunAt)],
+          [
+            "Last Run Status",
+            job.lastRunStatus ? statusColor(job.lastRunStatus, context.writer) : "-"
+          ],
+          ["Last Run Duration", formatDuration(job.lastRunDuration)]
+        ];
+        for (const [label, value] of lines) {
+          context.writer.writeln(
+            `  ${context.writer.wrapInColor(
+              label.padEnd(20),
+              CliForegroundColor.Yellow
+            )} ${value}`
+          );
+        }
+        return;
+      } catch (e) {
+        context.writer.writeError(
+          `Error on server ${name}: ${e.message}`
+        );
+      }
+    }
+  }
+  // ── Action (trigger/pause/resume/stop/cancel) ────────────────────
+  async handleAction(cmd, context, action) {
+    const nameOrId = (cmd.value ?? "").trim();
+    if (!nameOrId) {
+      context.writer.writeError(`Usage: jobs ${action} <id|name>`);
+      return;
+    }
+    const services = getServices(context, cmd.args);
+    if (services.length === 0) {
+      context.writer.writeInfo("No connected servers.");
+      return;
+    }
+    for (const { name, service } of services) {
+      try {
+        const job = await resolveJobId(service, nameOrId);
+        if (!job) {
+          if (services.length === 1) {
+            context.writer.writeError(
+              `Job "${nameOrId}" not found on server ${name}.`
+            );
+          }
+          continue;
+        }
+        switch (action) {
+          case "trigger":
+            await service.triggerJob(job.id);
+            break;
+          case "pause":
+            await service.pauseJob(job.id);
+            break;
+          case "resume":
+            await service.resumeJob(job.id);
+            break;
+          case "stop":
+            await service.stopJob(job.id);
+            break;
+          case "cancel":
+            await service.cancelJob(job.id);
+            break;
+        }
+        const serverSuffix = services.length > 1 ? ` on server ${name}` : "";
+        context.writer.writeSuccess(
+          `Job "${job.name}" ${action}${action.endsWith("e") ? "d" : "ed"}${serverSuffix}.`
+        );
+        return;
+      } catch (e) {
+        context.writer.writeError(
+          `Failed to ${action} job on ${name}: ${e.message}`
+        );
+      }
+    }
+  }
+  // ── History ──────────────────────────────────────────────────────
+  async handleHistory(cmd, context) {
+    const nameOrId = (cmd.value ?? "").trim();
+    if (!nameOrId) {
+      context.writer.writeError("Usage: jobs history <id|name>");
+      return;
+    }
+    const services = getServices(context, cmd.args);
+    if (services.length === 0) {
+      context.writer.writeInfo("No connected servers.");
+      return;
+    }
+    const limit = cmd.args["limit"] ?? 20;
+    const offset = cmd.args["offset"] ?? 0;
+    const status = cmd.args["status"];
+    for (const { name, service } of services) {
+      try {
+        const job = await resolveJobId(service, nameOrId);
+        if (!job) {
+          if (services.length === 1) {
+            context.writer.writeError(
+              `Job "${nameOrId}" not found on server ${name}.`
+            );
+          }
+          continue;
+        }
+        if (services.length > 1) {
+          context.writer.writeln(
+            context.writer.wrapInColor(
+              `Server: ${name}`,
+              CliForegroundColor.Cyan
+            )
+          );
+        }
+        const history = await service.getHistory(job.id, {
+          limit,
+          offset,
+          status
+        });
+        if (history.items.length === 0) {
+          context.writer.writeInfo(
+            `No execution history for "${job.name}".`
+          );
+          return;
+        }
+        context.writer.writeln(
+          `Showing ${history.items.length} of ${history.total} executions for "${job.name}":`
+        );
+        const headers = [
+          "ID",
+          "Status",
+          "Started",
+          "Duration",
+          "Retry",
+          "Error"
+        ];
+        const rows = history.items.map((exec) => [
+          exec.id.substring(0, 8),
+          statusColor(exec.status, context.writer),
+          formatRelativeTime(exec.startedAt),
+          formatDuration(exec.duration),
+          String(exec.retryAttempt),
+          exec.error ? exec.error.substring(0, 40) : "-"
+        ]);
+        context.writer.writeTable(headers, rows);
+        return;
+      } catch (e) {
+        context.writer.writeError(
+          `Error on server ${name}: ${e.message}`
+        );
+      }
+    }
+  }
+  // ── Logs ─────────────────────────────────────────────────────────
+  async handleLogs(cmd, context) {
+    const nameOrId = (cmd.value ?? "").trim();
+    if (!nameOrId) {
+      context.writer.writeError("Usage: jobs logs <id|name>");
+      return;
+    }
+    const services = getServices(context, cmd.args);
+    if (services.length === 0) {
+      context.writer.writeInfo("No connected servers.");
+      return;
+    }
+    const execId = cmd.args["exec"];
+    for (const { name, service } of services) {
+      try {
+        const job = await resolveJobId(service, nameOrId);
+        if (!job) {
+          if (services.length === 1) {
+            context.writer.writeError(
+              `Job "${nameOrId}" not found on server ${name}.`
+            );
+          }
+          continue;
+        }
+        let execution;
+        if (execId) {
+          execution = await service.getExecution(job.id, execId);
+        } else {
+          const history = await service.getHistory(job.id, {
+            limit: 1
+          });
+          if (history.items.length === 0) {
+            context.writer.writeInfo(
+              `No executions found for "${job.name}".`
+            );
+            return;
+          }
+          execution = await service.getExecution(
+            job.id,
+            history.items[0].id
+          );
+        }
+        if (services.length > 1) {
+          context.writer.writeln(
+            context.writer.wrapInColor(
+              `Server: ${name}`,
+              CliForegroundColor.Cyan
+            )
+          );
+        }
+        context.writer.writeln(
+          `Logs for "${job.name}" execution ${execution.id.substring(0, 8)} (${statusColor(execution.status, context.writer)}):`
+        );
+        if (!execution.logs || execution.logs.length === 0) {
+          context.writer.writeInfo("  No log entries.");
+          return;
+        }
+        for (const entry of execution.logs) {
+          const ts = new Date(entry.timestamp).toLocaleTimeString();
+          const level = logLevelColor(
+            entry.level,
+            context.writer
+          ).padEnd(12);
+          context.writer.writeln(
+            `  ${context.writer.wrapInColor(ts, CliForegroundColor.White)} ${level} ${entry.message}`
+          );
+        }
+        return;
+      } catch (e) {
+        context.writer.writeError(
+          `Error on server ${name}: ${e.message}`
+        );
+      }
+    }
+  }
+  // ── Edit ─────────────────────────────────────────────────────────
+  async handleEdit(cmd, context) {
+    const nameOrId = (cmd.value ?? "").trim();
+    if (!nameOrId) {
+      context.writer.writeError("Usage: jobs edit <id|name>");
+      return;
+    }
+    const services = getServices(context, cmd.args);
+    if (services.length === 0) {
+      context.writer.writeInfo("No connected servers.");
+      return;
+    }
+    for (const { name, service } of services) {
+      try {
+        const job = await resolveJobId(service, nameOrId);
+        if (!job) {
+          if (services.length === 1) {
+            context.writer.writeError(
+              `Job "${nameOrId}" not found on server ${name}.`
+            );
+          }
+          continue;
+        }
+        context.writer.writeln(
+          `Editing job "${context.writer.wrapInColor(job.name, CliForegroundColor.Cyan)}" on server ${name}`
+        );
+        context.writer.writeln(
+          "Press Enter to keep current value, or type a new value."
+        );
+        context.writer.writeln("");
+        const update = {};
+        const newDesc = await context.reader.readLine(
+          `Description [${job.description}]: `
+        );
+        if (newDesc == null) {
+          context.writer.writeInfo("Edit cancelled.");
+          return;
+        }
+        if (newDesc.trim()) {
+          update.description = newDesc.trim();
+        }
+        const newGroup = await context.reader.readLine(
+          `Group [${job.group ?? "none"}]: `
+        );
+        if (newGroup == null) {
+          context.writer.writeInfo("Edit cancelled.");
+          return;
+        }
+        if (newGroup.trim()) {
+          update.group = newGroup.trim();
+        }
+        const currentSchedule = job.schedule ?? (job.interval ? `interval: ${job.interval}ms` : "none");
+        const newSchedule = await context.reader.readLine(
+          `Cron schedule [${currentSchedule}]: `
+        );
+        if (newSchedule == null) {
+          context.writer.writeInfo("Edit cancelled.");
+          return;
+        }
+        if (newSchedule.trim()) {
+          update.schedule = newSchedule.trim();
+        }
+        if (!newSchedule.trim()) {
+          const newInterval = await context.reader.readLine(
+            `Interval (e.g. 30s, 5m) [${job.interval ? `${job.interval}ms` : "none"}]: `
+          );
+          if (newInterval != null && newInterval.trim()) {
+            update.interval = newInterval.trim();
+          }
+        }
+        const newRetries = await context.reader.readLine(
+          `Max retries [${job.maxRetries}]: `
+        );
+        if (newRetries != null && newRetries.trim()) {
+          const parsed = parseInt(newRetries.trim(), 10);
+          if (!isNaN(parsed)) {
+            update.maxRetries = parsed;
+          }
+        }
+        const newTimeout = await context.reader.readLine(
+          `Timeout (e.g. 5m, 1h) [${job.timeout ? `${job.timeout}ms` : "none"}]: `
+        );
+        if (newTimeout != null && newTimeout.trim()) {
+          update.timeout = newTimeout.trim();
+        }
+        const newOverlap = await context.reader.readLine(
+          `Overlap policy (skip/queue/cancel) [${job.overlapPolicy}]: `
+        );
+        if (newOverlap != null && newOverlap.trim() && ["skip", "queue", "cancel"].includes(
+          newOverlap.trim().toLowerCase()
+        )) {
+          update.overlapPolicy = newOverlap.trim().toLowerCase();
+        }
+        if (Object.keys(update).length === 0) {
+          context.writer.writeInfo("No changes made.");
+          return;
+        }
+        const confirm = await context.reader.readConfirm(
+          "Apply changes?"
+        );
+        if (!confirm) {
+          context.writer.writeInfo("Edit cancelled.");
+          return;
+        }
+        await service.updateJob(job.id, update);
+        context.writer.writeSuccess(
+          `Job "${job.name}" updated successfully.`
+        );
+        return;
+      } catch (e) {
+        context.writer.writeError(
+          `Error on server ${name}: ${e.message}`
+        );
+      }
+    }
+  }
+  // ── Watch ────────────────────────────────────────────────────────
+  async handleWatch(cmd, context) {
+    const manager = context.services.get("cli-server-manager");
+    if (!manager || !manager.connections) {
+      context.writer.writeInfo("No connected servers.");
+      return;
+    }
+    const targetServer = cmd.args["server"];
+    context.writer.writeln(
+      context.writer.wrapInColor(
+        "Watching job events... (press Ctrl+C to stop)",
+        CliForegroundColor.Cyan
+      )
+    );
+    context.writer.writeln("");
+    const sockets = [];
+    const abortHandler = () => {
+      for (const ws of sockets) {
+        try {
+          ws.close();
+        } catch {
+        }
+      }
+    };
+    context.onAbort.subscribe(abortHandler);
+    for (const [serverName, connection] of manager.connections) {
+      if (targetServer && serverName !== targetServer) continue;
+      if (!connection.connected) continue;
+      const config = connection.config;
+      const baseUrl = config.url.endsWith("/") ? config.url.slice(0, -1) : config.url;
+      const wsUrl = baseUrl.replace(/^https:/, "wss:").replace(/^http:/, "ws:") + "/ws/v1/qcli/events";
+      try {
+        const ws = new WebSocket(wsUrl);
+        sockets.push(ws);
+        ws.onmessage = (event) => {
+          try {
+            const data = JSON.parse(event.data);
+            if (!data.type || !data.type.startsWith("job:")) {
+              return;
+            }
+            const ts = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+            const serverPrefix = manager.connections.size > 1 ? context.writer.wrapInColor(
+              `[${serverName}] `,
+              CliForegroundColor.Cyan
+            ) : "";
+            let detail = "";
+            if (data.jobId) {
+              detail += ` jobId=${data.jobId}`;
+            }
+            if (data.executionId) {
+              detail += ` execId=${data.executionId.substring(0, 8)}`;
+            }
+            if (data.duration != null) {
+              detail += ` duration=${formatDuration(data.duration)}`;
+            }
+            if (data.error) {
+              detail += ` error="${data.error}"`;
+            }
+            const eventType = statusColor(
+              data.type.replace("job:", ""),
+              context.writer
+            );
+            context.writer.writeln(
+              `${context.writer.wrapInColor(ts, CliForegroundColor.White)} ${serverPrefix}${eventType}${detail}`
+            );
+          } catch {
+          }
+        };
+        ws.onerror = () => {
+          context.writer.writeError(
+            `WebSocket error on server ${serverName}`
+          );
+        };
+        ws.onclose = () => {
+        };
+      } catch (e) {
+        context.writer.writeError(
+          `Failed to connect to ${serverName}: ${e.message}`
+        );
+      }
+    }
+    await new Promise((resolve) => {
+      const sub = context.onAbort.subscribe(() => {
+        sub.unsubscribe();
+        resolve();
+      });
+      if (context.signal) {
+        context.signal.addEventListener("abort", () => {
+          sub.unsubscribe();
+          resolve();
+        });
+      }
+    });
+    context.writer.writeln("");
+    context.writer.writeInfo("Stopped watching job events.");
+  }
+};
+
+// src/lib/completion/cli-job-name-completion-provider.ts
+var JOB_NAME_SUBCOMMANDS = /* @__PURE__ */ new Set([
+  "info",
+  "trigger",
+  "pause",
+  "resume",
+  "stop",
+  "cancel",
+  "history",
+  "logs",
+  "edit"
+]);
+var CliJobNameCompletionProvider = class {
+  constructor() {
+    this.priority = 50;
+    this.services = null;
+  }
+  setServices(services) {
+    this.services = services;
+  }
+  async getCompletions(context) {
+    const { tokens, tokenIndex, token } = context;
+    if (tokenIndex !== 3 || tokens.length < 3) {
+      return [];
+    }
+    if (tokens[0].toLowerCase() !== "server") {
+      return [];
+    }
+    if (tokens[1].toLowerCase() !== "jobs") {
+      return [];
+    }
+    const subCommand = tokens[2].toLowerCase();
+    if (!JOB_NAME_SUBCOMMANDS.has(subCommand)) {
+      return [];
+    }
+    if (!this.services) {
+      return [];
+    }
+    const lowerPrefix = token.toLowerCase();
+    try {
+      const manager = this.services.get("cli-server-manager");
+      if (!manager?.connections) {
+        return [];
+      }
+      const names = [];
+      for (const [, connection] of manager.connections) {
+        if (!connection.connected) continue;
+        const config = connection.config;
+        const baseUrl = config.url.endsWith("/") ? config.url.slice(0, -1) : config.url;
+        const headers = config.headers ?? {};
+        const service = new CliJobsService(baseUrl, headers);
+        try {
+          const jobs = await service.listJobs();
+          for (const job of jobs) {
+            if (!names.includes(job.name)) {
+              names.push(job.name);
+            }
+          }
+        } catch {
+        }
+      }
+      return names.filter((name) => name.toLowerCase().startsWith(lowerPrefix)).sort();
+    } catch {
+      return [];
+    }
+  }
+};
+
+// src/lib/version.ts
+var LIBRARY_VERSION = "2.0.0-beta.3";
+var API_VERSION = 2;
+var completionProvider = new CliJobNameCompletionProvider();
+var jobsModule = {
+  apiVersion: API_VERSION,
+  name: "@qodalis/cli-server-jobs",
+  processors: [new CliJobsCommandProcessor()],
+  services: [
+    {
+      provide: ICliCompletionProvider_TOKEN,
+      useValue: completionProvider,
+      multi: true
+    }
+  ],
+  async onInit(context) {
+    completionProvider.setServices(context.services);
+  }
+};
+
+export { API_VERSION, CliJobNameCompletionProvider, CliJobsCommandProcessor, CliJobsService, LIBRARY_VERSION, jobsModule };
+//# sourceMappingURL=public-api.mjs.map
+//# sourceMappingURL=public-api.mjs.map