@ayurak/sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,787 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Aribot: () => Aribot,
+  AribotError: () => AribotError,
+  AuthenticationError: () => AuthenticationError,
+  CloudSecurityAPI: () => CloudSecurityAPI,
+  ComplianceAPI: () => ComplianceAPI,
+  NotFoundError: () => NotFoundError,
+  PipelineAPI: () => PipelineAPI,
+  RateLimitError: () => RateLimitError,
+  ServerError: () => ServerError,
+  ThreatModelingAPI: () => ThreatModelingAPI,
+  ValidationError: () => ValidationError
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var AribotError = class extends Error {
+  constructor(message, statusCode, response) {
+    super(message);
+    this.name = "AribotError";
+    this.statusCode = statusCode;
+    this.response = response;
+  }
+};
+var AuthenticationError = class extends AribotError {
+  constructor(message, statusCode, response) {
+    super(message, statusCode, response);
+    this.name = "AuthenticationError";
+  }
+};
+var RateLimitError = class extends AribotError {
+  constructor(message, retryAfter, statusCode, response) {
+    super(message, statusCode, response);
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var ValidationError = class extends AribotError {
+  constructor(message, errors = [], statusCode, response) {
+    super(message, statusCode, response);
+    this.name = "ValidationError";
+    this.errors = errors;
+  }
+};
+var NotFoundError = class extends AribotError {
+  constructor(message, statusCode, response) {
+    super(message, statusCode, response);
+    this.name = "NotFoundError";
+  }
+};
+var ServerError = class extends AribotError {
+  constructor(message, statusCode, response) {
+    super(message, statusCode, response);
+    this.name = "ServerError";
+  }
+};
+
+// src/http.ts
+var DEFAULT_BASE_URL = "https://api.aribot.ayurak.com/aribot-api";
+var DEFAULT_TIMEOUT = 3e4;
+var MAX_RETRIES = 3;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var HttpClient = class {
+  constructor(options) {
+    this.apiKey = options.apiKey;
+    this.baseUrl = (options.baseUrl || DEFAULT_BASE_URL).replace(/\/$/, "");
+    this.timeout = options.timeout || DEFAULT_TIMEOUT;
+  }
+  async handleResponse(response) {
+    let data = {};
+    try {
+      const text = await response.text();
+      if (text) {
+        data = JSON.parse(text);
+      }
+    } catch {
+      data = {};
+    }
+    if (response.status === 401) {
+      throw new AuthenticationError(
+        data.detail || "Invalid API key",
+        401,
+        data
+      );
+    }
+    if (response.status === 403) {
+      throw new AuthenticationError(
+        data.detail || "Access denied",
+        403,
+        data
+      );
+    }
+    if (response.status === 404) {
+      throw new NotFoundError(
+        data.detail || "Resource not found",
+        404,
+        data
+      );
+    }
+    if (response.status === 422) {
+      throw new ValidationError(
+        data.detail || "Validation error",
+        data.errors || [],
+        422,
+        data
+      );
+    }
+    if (response.status === 429) {
+      const retryAfter = response.headers.get("Retry-After");
+      throw new RateLimitError(
+        data.detail || "Rate limit exceeded",
+        retryAfter ? parseInt(retryAfter, 10) : void 0,
+        429,
+        data
+      );
+    }
+    if (response.status >= 500) {
+      throw new ServerError(
+        data.detail || "Server error",
+        response.status,
+        data
+      );
+    }
+    if (response.status >= 400) {
+      throw new AribotError(
+        data.detail || `Request failed with status ${response.status}`,
+        response.status,
+        data
+      );
+    }
+    return data;
+  }
+  async request(method, path, options = {}, retry = 0) {
+    const url = new URL(path, this.baseUrl);
+    if (options.params) {
+      for (const [key, value] of Object.entries(options.params)) {
+        url.searchParams.set(key, String(value));
+      }
+    }
+    const headers = {
+      "X-API-Key": this.apiKey,
+      "User-Agent": "aribot-js/1.0.0"
+    };
+    let body;
+    if (options.formData) {
+      body = options.formData;
+    } else if (options.body) {
+      headers["Content-Type"] = "application/json";
+      body = JSON.stringify(options.body);
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url.toString(), {
+        method,
+        headers,
+        body,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      return await this.handleResponse(response);
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof RateLimitError) {
+        if (retry < MAX_RETRIES && error.retryAfter) {
+          await sleep(Math.min(error.retryAfter * 1e3, 6e4));
+          return this.request(method, path, options, retry + 1);
+        }
+        throw error;
+      }
+      if (error instanceof AribotError) {
+        throw error;
+      }
+      if (error instanceof Error && error.name === "AbortError") {
+        if (retry < MAX_RETRIES) {
+          await sleep(Math.pow(2, retry) * 1e3);
+          return this.request(method, path, options, retry + 1);
+        }
+        throw new AribotError("Request timed out");
+      }
+      if (retry < MAX_RETRIES) {
+        await sleep(Math.pow(2, retry) * 1e3);
+        return this.request(method, path, options, retry + 1);
+      }
+      throw new AribotError("Connection error");
+    }
+  }
+  async get(path, params) {
+    return this.request("GET", path, { params });
+  }
+  async post(path, body, formData) {
+    return this.request("POST", path, { body, formData });
+  }
+  async put(path, body) {
+    return this.request("PUT", path, { body });
+  }
+  async patch(path, body) {
+    return this.request("PATCH", path, { body });
+  }
+  async delete(path) {
+    return this.request("DELETE", path);
+  }
+};
+
+// src/threat-modeling.ts
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var ThreatModelingAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Upload and analyze a diagram for threats
+   */
+  async analyzeDiagram(file, options = {}) {
+    const {
+      filename = "diagram",
+      analysisDepth = "comprehensive",
+      wait = true,
+      timeout = 3e5
+    } = options;
+    const formData = new FormData();
+    formData.append("file", file, filename);
+    formData.append("filename", filename);
+    formData.append("analysis_depth", analysisDepth);
+    const result = await this.http.post(
+      "/v2/threat-modeling/diagrams/upload-and-analyze/",
+      void 0,
+      formData
+    );
+    if (!wait) {
+      return result;
+    }
+    const diagramId = result.diagram_id;
+    if (!diagramId) {
+      return result;
+    }
+    return this.waitForAnalysis(diagramId, timeout);
+  }
+  async waitForAnalysis(diagramId, timeout) {
+    const start = Date.now();
+    while (Date.now() - start < timeout) {
+      const diagram = await this.get(diagramId);
+      const status = diagram.status;
+      if (["completed", "analyzed", "done"].includes(status)) {
+        return diagram;
+      }
+      if (["failed", "error"].includes(status)) {
+        throw new Error(`Analysis failed: ${diagram.error || "Unknown error"}`);
+      }
+      await sleep2(5e3);
+    }
+    throw new Error(`Analysis did not complete within ${timeout}ms`);
+  }
+  /**
+   * List diagrams
+   */
+  async list(options = {}) {
+    const { page = 1, limit = 25, status, search } = options;
+    const params = { page, limit };
+    if (status) params.status = status;
+    if (search) params.search = search;
+    return await this.http.get("/v1/tm/diagrams/", params);
+  }
+  /**
+   * Get diagram details
+   */
+  async get(diagramId) {
+    return await this.http.get(`/v1/tm/diagrams/${diagramId}/`);
+  }
+  /**
+   * Get threats for a diagram
+   */
+  async getThreats(diagramId) {
+    const result = await this.http.get(`/v1/tm/diagrams/${diagramId}/threats/`);
+    if (Array.isArray(result)) {
+      return result;
+    }
+    const data = result;
+    return data.results || data.threats || [];
+  }
+  /**
+   * Get components detected in diagram
+   */
+  async getComponents(diagramId) {
+    const result = await this.http.get(`/v1/tm/diagrams/${diagramId}/components/`);
+    if (Array.isArray(result)) {
+      return result;
+    }
+    const data = result;
+    return data.results || data.components || [];
+  }
+  /**
+   * Run AI-powered analysis on diagram
+   */
+  async analyzeWithAI(diagramId, analysisTypes) {
+    const body = {};
+    if (analysisTypes) {
+      body.analysis_types = analysisTypes;
+    }
+    return await this.http.post(
+      `/v2/threat-modeling/diagrams/${diagramId}/analyze-with-ai/`,
+      body
+    );
+  }
+  /**
+   * Delete a diagram
+   */
+  async delete(diagramId) {
+    await this.http.delete(`/v1/tm/diagrams/${diagramId}/`);
+  }
+  /**
+   * Get threat modeling dashboard
+   */
+  async dashboard(period = "month", includeTrends = true) {
+    return await this.http.get("/v1/tm/dashboard/", {
+      period,
+      include_trends: includeTrends
+    });
+  }
+};
+
+// src/compliance.ts
+var ComplianceAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Run compliance scan on a diagram
+   */
+  async scan(diagramId, options = {}) {
+    const { standards, includeRecommendations = true } = options;
+    const body = {
+      include_recommendations: includeRecommendations
+    };
+    if (standards) {
+      body.standards = standards;
+    }
+    return await this.http.post(
+      `/v2/compliances/diagram-compliance/${diagramId}/scan/`,
+      body
+    );
+  }
+  /**
+   * Get compliance report for a diagram
+   */
+  async getReport(diagramId, format = "json") {
+    return await this.http.get(
+      `/v2/compliances/diagram-compliance/${diagramId}/report/`,
+      { format }
+    );
+  }
+  /**
+   * List available compliance standards
+   */
+  async listStandards() {
+    const result = await this.http.get("/v2/compliances/standards/");
+    if (Array.isArray(result)) {
+      return result;
+    }
+    const data = result;
+    return data.results || data.standards || [];
+  }
+  /**
+   * Get details of a compliance standard
+   */
+  async getStandard(standardId) {
+    return await this.http.get(
+      `/v2/compliances/standards/${standardId}/`
+    );
+  }
+  /**
+   * List controls for a compliance standard
+   */
+  async listControls(standardId, category) {
+    const params = {};
+    if (category) params.category = category;
+    const result = await this.http.get(
+      `/v2/compliances/standards/${standardId}/controls/`,
+      params
+    );
+    if (Array.isArray(result)) {
+      return result;
+    }
+    const data = result;
+    return data.results || data.controls || [];
+  }
+  /**
+   * Get compliance gaps for a diagram
+   */
+  async getGaps(diagramId, standardId) {
+    const params = {};
+    if (standardId) params.standard = standardId;
+    const result = await this.http.get(
+      `/v2/compliances/diagram-compliance/${diagramId}/gaps/`,
+      params
+    );
+    if (Array.isArray(result)) {
+      return result;
+    }
+    const data = result;
+    return data.results || data.gaps || [];
+  }
+  /**
+   * Create a custom compliance standard
+   */
+  async addCustomStandard(name, description, controls) {
+    return await this.http.post("/v2/compliances/standards/", {
+      name,
+      description,
+      controls
+    });
+  }
+  /**
+   * Get compliance dashboard metrics
+   */
+  async dashboard(period = "month") {
+    return await this.http.get("/v2/compliances/dashboard/", {
+      period
+    });
+  }
+};
+
+// src/cloud.ts
+var CloudSecurityAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Run cloud security scan
+   */
+  async scan(projectId, options = {}) {
+    const body = { project_id: projectId };
+    if (options.provider) body.provider = options.provider;
+    if (options.regions) body.regions = options.regions;
+    if (options.services) body.services = options.services;
+    if (options.complianceStandards) body.compliance_standards = options.complianceStandards;
+    return await this.http.post("/v2/cloud-security/scans/", body);
+  }
+  /**
+   * Get scan details and results
+   */
+  async getScan(scanId) {
+    return await this.http.get(`/v2/cloud-security/scans/${scanId}/`);
+  }
+  /**
+   * List cloud security scans
+   */
+  async listScans(options = {}) {
+    const { projectId, provider, status, page = 1, limit = 25 } = options;
+    const params = { page, limit };
+    if (projectId) params.project_id = projectId;
+    if (provider) params.provider = provider;
+    if (status) params.status = status;
+    return await this.http.get("/v2/cloud-security/scans/", params);
+  }
+  /**
+   * Get findings from a scan
+   */
+  async getFindings(scanId, options = {}) {
+    const { severity, service, status } = options;
+    const params = {};
+    if (severity) params.severity = severity;
+    if (service) params.service = service;
+    if (status) params.status = status;
+    const result = await this.http.get(`/v2/cloud-security/scans/${scanId}/findings/`, params);
+    if (Array.isArray(result)) {
+      return result;
+    }
+    const data = result;
+    return data.results || data.findings || [];
+  }
+  /**
+   * Connect a cloud account for scanning
+   */
+  async connectAccount(provider, credentials, options = {}) {
+    const body = {
+      provider,
+      credentials
+    };
+    if (options.name) body.name = options.name;
+    if (options.regions) body.regions = options.regions;
+    return await this.http.post("/v2/cloud-security/accounts/", body);
+  }
+  /**
+   * List connected cloud accounts
+   */
+  async listAccounts(provider) {
+    const params = {};
+    if (provider) params.provider = provider;
+    const result = await this.http.get("/v2/cloud-security/accounts/", params);
+    if (Array.isArray(result)) {
+      return result;
+    }
+    const data = result;
+    return data.results || data.accounts || [];
+  }
+  /**
+   * Disconnect a cloud account
+   */
+  async deleteAccount(accountId) {
+    await this.http.delete(`/v2/cloud-security/accounts/${accountId}/`);
+  }
+  /**
+   * Mark a finding as resolved
+   */
+  async resolveFinding(findingId, resolution, notes) {
+    const body = { resolution };
+    if (notes) body.notes = notes;
+    return await this.http.post(
+      `/v2/cloud-security/findings/${findingId}/resolve/`,
+      body
+    );
+  }
+  /**
+   * Suppress a finding
+   */
+  async suppressFinding(findingId, reason, durationDays) {
+    const body = { reason };
+    if (durationDays) body.duration_days = durationDays;
+    return await this.http.post(
+      `/v2/cloud-security/findings/${findingId}/suppress/`,
+      body
+    );
+  }
+  /**
+   * Get remediation steps for a finding
+   */
+  async getRemediation(findingId) {
+    return await this.http.get(
+      `/v2/cloud-security/findings/${findingId}/remediation/`
+    );
+  }
+  /**
+   * Get cloud security dashboard
+   */
+  async dashboard(projectId, period = "month") {
+    const params = { period };
+    if (projectId) params.project_id = projectId;
+    return await this.http.get("/v2/cloud-security/dashboard/", params);
+  }
+};
+
+// src/pipeline.ts
+function sleep3(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var PipelineAPI = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Create a pipeline project
+   */
+  async createProject(name, options = {}) {
+    const body = {
+      name,
+      default_branch: options.defaultBranch || "main"
+    };
+    if (options.repositoryUrl) body.repository_url = options.repositoryUrl;
+    if (options.scanTypes) body.scan_types = options.scanTypes;
+    return await this.http.post("/v1/pipeline/projects/", body);
+  }
+  /**
+   * List pipeline projects
+   */
+  async listProjects(page = 1, limit = 25) {
+    return await this.http.get("/v1/pipeline/projects/", { page, limit });
+  }
+  /**
+   * Get project details
+   */
+  async getProject(projectId) {
+    return await this.http.get(`/v1/pipeline/projects/${projectId}/`);
+  }
+  /**
+   * Delete a pipeline project
+   */
+  async deleteProject(projectId) {
+    await this.http.delete(`/v1/pipeline/projects/${projectId}/`);
+  }
+  /**
+   * Run pipeline security scan
+   */
+  async scan(projectId, options = {}) {
+    const {
+      commitSha,
+      branch,
+      scanTypes,
+      failOnSeverity,
+      wait = false,
+      timeout = 6e5
+    } = options;
+    const body = { project_id: projectId };
+    if (commitSha) body.commit_sha = commitSha;
+    if (branch) body.branch = branch;
+    if (scanTypes) body.scan_types = scanTypes;
+    if (failOnSeverity) body.fail_on_severity = failOnSeverity;
+    const result = await this.http.post("/v1/pipeline/scans/", body);
+    if (!wait) {
+      return result;
+    }
+    const scanId = result.scan_id;
+    if (!scanId) {
+      return result;
+    }
+    return this.waitForScan(scanId, timeout);
+  }
+  async waitForScan(scanId, timeout) {
+    const start = Date.now();
+    while (Date.now() - start < timeout) {
+      const scan = await this.getScan(scanId);
+      const status = scan.status;
+      if (["completed", "passed", "failed"].includes(status)) {
+        return scan;
+      }
+      if (status === "error") {
+        throw new Error(`Scan error: ${scan.error || "Unknown error"}`);
+      }
+      await sleep3(5e3);
+    }
+    throw new Error(`Scan did not complete within ${timeout}ms`);
+  }
+  /**
+   * Get scan details and results
+   */
+  async getScan(scanId) {
+    return await this.http.get(`/v1/pipeline/scans/${scanId}/`);
+  }
+  /**
+   * List pipeline scans
+   */
+  async listScans(options = {}) {
+    const { projectId, status, branch, page = 1, limit = 25 } = options;
+    const params = { page, limit };
+    if (projectId) params.project_id = projectId;
+    if (status) params.status = status;
+    if (branch) params.branch = branch;
+    return await this.http.get("/v1/pipeline/scans/", params);
+  }
+  /**
+   * Get findings from a scan
+   */
+  async getFindings(scanId, options = {}) {
+    const { scanType, severity } = options;
+    const params = {};
+    if (scanType) params.type = scanType;
+    if (severity) params.severity = severity;
+    const result = await this.http.get(`/v1/pipeline/scans/${scanId}/findings/`, params);
+    if (Array.isArray(result)) {
+      return result;
+    }
+    const data = result;
+    return data.results || data.findings || [];
+  }
+  /**
+   * Get SAST (static analysis) findings
+   */
+  async getSastFindings(scanId) {
+    return this.getFindings(scanId, { scanType: "sast" });
+  }
+  /**
+   * Get SCA (dependency) findings
+   */
+  async getScaFindings(scanId) {
+    return this.getFindings(scanId, { scanType: "sca" });
+  }
+  /**
+   * Get secrets detection findings
+   */
+  async getSecretsFindings(scanId) {
+    return this.getFindings(scanId, { scanType: "secrets" });
+  }
+  /**
+   * Configure security gates for a project
+   */
+  async configureGates(projectId, gates) {
+    return await this.http.patch(
+      `/v1/pipeline/projects/${projectId}/gates/`,
+      gates
+    );
+  }
+  /**
+   * Set scan as baseline (suppress existing findings)
+   */
+  async addBaseline(projectId, scanId) {
+    return await this.http.post(`/v1/pipeline/projects/${projectId}/baseline/`, {
+      baseline_scan_id: scanId
+    });
+  }
+  /**
+   * Suppress a finding
+   */
+  async suppressFinding(findingId, reason, expiresAt) {
+    const body = { reason };
+    if (expiresAt) body.expires_at = expiresAt;
+    return await this.http.post(
+      `/v1/pipeline/findings/${findingId}/suppress/`,
+      body
+    );
+  }
+  /**
+   * Get pipeline security dashboard
+   */
+  async dashboard(projectId, period = "month") {
+    const params = { period };
+    if (projectId) params.project_id = projectId;
+    return await this.http.get("/v1/pipeline/dashboard/", params);
+  }
+};
+
+// src/client.ts
+var Aribot = class {
+  /**
+   * Create Aribot client
+   *
+   * @param apiKey - Your Aribot API key
+   * @param options - Client configuration options
+   */
+  constructor(apiKey, options = {}) {
+    this.http = new HttpClient({
+      apiKey,
+      baseUrl: options.baseUrl,
+      timeout: options.timeout
+    });
+    this.threatModeling = new ThreatModelingAPI(this.http);
+    this.compliance = new ComplianceAPI(this.http);
+    this.cloud = new CloudSecurityAPI(this.http);
+    this.pipeline = new PipelineAPI(this.http);
+  }
+  /**
+   * Check API health status
+   */
+  async health() {
+    return await this.http.get("/health/");
+  }
+  /**
+   * Get current user/organization info
+   */
+  async me() {
+    return await this.http.get("/v1/users/me/");
+  }
+  /**
+   * Get API usage statistics
+   */
+  async usage(period = "month") {
+    return await this.http.get("/v1/usage/", { period });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Aribot,
+  AribotError,
+  AuthenticationError,
+  CloudSecurityAPI,
+  ComplianceAPI,
+  NotFoundError,
+  PipelineAPI,
+  RateLimitError,
+  ServerError,
+  ThreatModelingAPI,
+  ValidationError
+});