@indigoai-us/hq-cli 5.56.0 → 5.57.0

package/src/utils/sandbox-runner-client.ts

@@ -0,0 +1,175 @@
+export type SandboxRunnerState = "queued" | "running" | "succeeded" | "failed";
+
+export interface SandboxRunnerStartRequest {
+  skillId: string;
+  companyUid: string;
+  args?: Record<string, unknown>;
+  companySlug?: string;
+  only?: string[];
+  usage?: unknown;
+}
+
+export interface SandboxRunnerStartResponse {
+  jobId: string;
+  status: SandboxRunnerState;
+}
+
+export interface SandboxRunnerJob {
+  jobId: string;
+  status: SandboxRunnerState;
+  stdout?: string;
+  stderr?: string;
+  logsTail?: string;
+  exitCode?: number;
+  error?: string;
+}
+
+export interface SandboxRunnerClientOptions {
+  baseUrl?: string;
+  fetchImpl?: typeof fetch;
+}
+
+export interface SandboxRunnerPollOptions {
+  intervalMs?: number;
+  maxPolls?: number;
+}
+
+const DEFAULT_SANDBOX_RUNNER_URL = "https://hqapi.getindigo.ai/sandbox";
+
+function normalizeBaseUrl(baseUrl: string): string {
+  return baseUrl.replace(/\/+$/, "");
+}
+
+function getSandboxRunnerBaseUrl(): string {
+  return normalizeBaseUrl(
+    process.env.HQ_SANDBOX_RUNNER_URL ?? DEFAULT_SANDBOX_RUNNER_URL,
+  );
+}
+
+function isSandboxRunnerState(value: unknown): value is SandboxRunnerState {
+  return value === "queued" || value === "running" || value === "succeeded" || value === "failed";
+}
+
+async function parseJsonResponse(res: Response): Promise<Record<string, unknown>> {
+  return (await res.json().catch(() => ({}))) as Record<string, unknown>;
+}
+
+function requireString(body: Record<string, unknown>, key: string): string {
+  const value = body[key];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`Sandbox Runner returned an invalid '${key}'.`);
+  }
+  return value;
+}
+
+function normalizeJob(
+  body: Record<string, unknown>,
+  jobIdFallback?: string,
+): SandboxRunnerJob {
+  const status = body.status;
+  if (!isSandboxRunnerState(status)) {
+    throw new Error("Sandbox Runner returned an invalid job status.");
+  }
+  const output =
+    typeof body.stdout === "string"
+      ? body.stdout
+      : typeof body.output === "string"
+        ? body.output
+        : undefined;
+  return {
+    jobId:
+      typeof body.jobId === "string" && body.jobId.length > 0
+        ? body.jobId
+        : jobIdFallback ?? requireString(body, "jobId"),
+    status,
+    stdout: output,
+    stderr: typeof body.stderr === "string" ? body.stderr : undefined,
+    logsTail: typeof body.logsTail === "string" ? body.logsTail : undefined,
+    exitCode: typeof body.exitCode === "number" ? body.exitCode : undefined,
+    error: typeof body.error === "string" ? body.error : undefined,
+  };
+}
+
+function delay(ms: number): Promise<void> {
+  if (ms <= 0) return Promise.resolve();
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export class SandboxRunnerClient {
+  private readonly baseUrl: string;
+  private readonly fetchImpl: typeof fetch;
+
+  constructor(options: SandboxRunnerClientOptions = {}) {
+    this.baseUrl = normalizeBaseUrl(options.baseUrl ?? getSandboxRunnerBaseUrl());
+    this.fetchImpl = options.fetchImpl ?? fetch;
+  }
+
+  async startJob(
+    token: string,
+    request: SandboxRunnerStartRequest,
+  ): Promise<SandboxRunnerStartResponse> {
+    const res = await this.fetchImpl(`${this.baseUrl}/jobs`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(request),
+    });
+    const body = await parseJsonResponse(res);
+    if (!res.ok) {
+      const message =
+        typeof body.message === "string"
+          ? body.message
+          : typeof body.error === "string"
+            ? body.error
+            : res.statusText;
+      throw new Error(`Sandbox Runner rejected job: ${message}`);
+    }
+    const status = body.status;
+    if (!isSandboxRunnerState(status)) {
+      throw new Error("Sandbox Runner returned an invalid start status.");
+    }
+    return {
+      jobId: requireString(body, "jobId"),
+      status,
+    };
+  }
+
+  async getJob(token: string, jobId: string): Promise<SandboxRunnerJob> {
+    const res = await this.fetchImpl(
+      `${this.baseUrl}/jobs/${encodeURIComponent(jobId)}`,
+      {
+        headers: { Authorization: `Bearer ${token}` },
+      },
+    );
+    const body = await parseJsonResponse(res);
+    if (!res.ok) {
+      const message =
+        typeof body.message === "string"
+          ? body.message
+          : typeof body.error === "string"
+            ? body.error
+            : res.statusText;
+      throw new Error(`Sandbox Runner job lookup failed: ${message}`);
+    }
+    return normalizeJob(body, jobId);
+  }
+
+  async pollJob(
+    token: string,
+    jobId: string,
+    options: SandboxRunnerPollOptions = {},
+  ): Promise<SandboxRunnerJob> {
+    const intervalMs = options.intervalMs ?? 1000;
+    const maxPolls = options.maxPolls ?? 300;
+    for (let attempt = 0; attempt < maxPolls; attempt += 1) {
+      const job = await this.getJob(token, jobId);
+      if (job.status === "succeeded" || job.status === "failed") {
+        return job;
+      }
+      await delay(intervalMs);
+    }
+    throw new Error(`Sandbox Runner job '${jobId}' did not finish before the poll limit.`);
+  }
+}