@forg3t/sdk 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,192 @@
+interface Forg3tClientOptions {
+    apiUrl?: string;
+    apiKey?: string;
+    timeoutMs?: number;
+}
+interface PaginationParams {
+    limit?: number;
+    offset?: number;
+    cursor?: string;
+}
+interface Project {
+    id: string;
+    name: string;
+    tenantId: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface ApiKey {
+    id: string;
+    name: string;
+    keyPrefix: string;
+    status: 'active' | 'revoked';
+    createdAt: string;
+    revokedAt?: string | null;
+    lastUsedAt?: string | null;
+    expiresAt?: string | null;
+}
+interface CreateApiKeyRequest {
+    name: string;
+    expiresAt?: string;
+}
+interface CreateApiKeyResponse extends ApiKey {
+    plaintextKey: string;
+}
+interface AuditEvent {
+    id: string;
+    action: string;
+    resourceType: string;
+    resourceId: string;
+    ip: string;
+    userAgent: string;
+    createdAt: string;
+    metadata: Record<string, unknown> | null;
+}
+interface AuditEventFilters {
+    action?: string;
+    resourceType?: string;
+    resourceId?: string;
+    from?: string;
+    to?: string;
+    limit?: number;
+    cursor?: string;
+}
+interface AuditEventListResponse {
+    events: AuditEvent[];
+    nextCursor?: string;
+}
+interface Job {
+    id: string;
+    projectId: string;
+    type: string;
+    status: 'pending' | 'processing' | 'completed' | 'failed' | 'dead';
+    payload: Record<string, unknown>;
+    result?: Record<string, unknown> | null;
+    error?: Record<string, unknown> | null;
+    idempotencyKey?: string | null;
+    createdAt: string;
+    updatedAt: string;
+    startedAt?: string | null;
+    completedAt?: string | null;
+}
+interface SubmitJobRequest {
+    type: string;
+    payload: Record<string, unknown>;
+    idempotencyKey?: string;
+}
+interface ClaimJobsRequest {
+    limit?: number;
+}
+interface JobResult {
+    result: Record<string, unknown>;
+}
+interface JobError {
+    error: Record<string, unknown>;
+}
+interface Webhook {
+    id: string;
+    projectId: string;
+    url: string;
+    description?: string;
+    enabled: boolean;
+    secretPrefix?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface CreateWebhookRequest {
+    url: string;
+    description?: string;
+}
+interface UpdateWebhookRequest {
+    url?: string;
+    description?: string;
+    enabled?: boolean;
+}
+interface WebhookDelivery {
+    id: string;
+    webhookId: string;
+    eventId: string;
+    eventType: string;
+    status: 'success' | 'failed' | 'pending';
+    requestHeaders: Record<string, string>;
+    requestBody: Record<string, unknown>;
+    responseStatus?: number;
+    responseBody?: string;
+    createdAt: string;
+    attemptCount: number;
+}
+interface WebhookDeliveryFilters extends PaginationParams {
+    status?: 'success' | 'failed' | 'pending' | 'dead';
+    eventType?: string;
+}
+interface EvidenceArtifact {
+    id: string;
+    jobId: string;
+    type: string;
+    content: string;
+    signature: string;
+    publicKey: string;
+    createdAt: string;
+    artifacts: unknown[];
+}
+
+declare class Forg3tClient {
+    private transport;
+    constructor(options?: Forg3tClientOptions);
+    getProjectOverview(projectId: string, requestId?: string): Promise<Project>;
+    listAuditEvents(projectId: string, filters?: AuditEventFilters, requestId?: string): Promise<AuditEventListResponse>;
+    listApiKeys(projectId: string, requestId?: string): Promise<ApiKey[]>;
+    createApiKey(projectId: string, data: CreateApiKeyRequest, requestId?: string): Promise<CreateApiKeyResponse>;
+    rotateApiKey(keyId: string, requestId?: string): Promise<CreateApiKeyResponse>;
+    revokeApiKey(keyId: string, requestId?: string): Promise<ApiKey>;
+    submitJob(projectId: string, data: SubmitJobRequest, requestId?: string): Promise<Job>;
+    getJob(projectId: string, jobId: string, requestId?: string): Promise<Job>;
+    listJobs(projectId: string, query?: {
+        status?: string;
+        limit?: number;
+        offset?: number;
+    }, requestId?: string): Promise<Job[]>;
+    claimJobs(projectId: string, data?: ClaimJobsRequest, requestId?: string): Promise<Job[]>;
+    heartbeatJob(projectId: string, jobId: string, requestId?: string): Promise<Job>;
+    completeJob(projectId: string, jobId: string, result: JobResult, requestId?: string): Promise<Job>;
+    failJob(projectId: string, jobId: string, error: JobError, requestId?: string): Promise<Job>;
+    listDeadJobs(projectId: string, requestId?: string): Promise<Job[]>;
+    replayJob(projectId: string, jobId: string, requestId?: string): Promise<Job>;
+    getEvidence(jobId: string, requestId?: string): Promise<EvidenceArtifact>;
+    /**
+     * @deprecated The current Control Plane version does not support direct artifact downloads.
+     * Please use getEvidence() to retrieve the artifact metadata and content.
+     */
+    downloadEvidenceArtifact(jobId: string, requestId?: string): Promise<void>;
+    listWebhooks(projectId: string, requestId?: string): Promise<Webhook[]>;
+    createWebhook(projectId: string, data: CreateWebhookRequest, requestId?: string): Promise<Webhook>;
+    updateWebhook(webhookId: string, data: UpdateWebhookRequest, requestId?: string): Promise<Webhook>;
+    deleteWebhook(webhookId: string, requestId?: string): Promise<void>;
+    rotateWebhookSecret(webhookId: string, requestId?: string): Promise<Webhook>;
+    enableWebhook(webhookId: string, requestId?: string): Promise<Webhook>;
+    disableWebhook(webhookId: string, requestId?: string): Promise<Webhook>;
+    listWebhookDeliveries(webhookId: string, filters?: WebhookDeliveryFilters, requestId?: string): Promise<WebhookDelivery[]>;
+    replayWebhookDelivery(deliveryId: string, requestId?: string): Promise<WebhookDelivery>;
+}
+
+declare class Forg3tError extends Error {
+    status?: number | undefined;
+    code?: string | undefined;
+    requestId?: string | undefined;
+    details?: Record<string, unknown> | undefined;
+    constructor(message: string, status?: number | undefined, code?: string | undefined, requestId?: string | undefined, details?: Record<string, unknown> | undefined);
+}
+declare class Forg3tAuthenticationError extends Forg3tError {
+    constructor(message: string, requestId?: string);
+}
+declare class Forg3tNotFoundError extends Forg3tError {
+    constructor(message: string, requestId?: string);
+}
+declare class Forg3tRateLimitError extends Forg3tError {
+    constructor(message: string, requestId?: string);
+}
+declare class Forg3tApiConnectionError extends Forg3tError {
+    constructor(message: string);
+}
+
+export { type ApiKey, type AuditEvent, type AuditEventFilters, type AuditEventListResponse, type ClaimJobsRequest, type CreateApiKeyRequest, type CreateApiKeyResponse, type CreateWebhookRequest, type EvidenceArtifact, Forg3tApiConnectionError, Forg3tAuthenticationError, Forg3tClient, type Forg3tClientOptions, Forg3tError, Forg3tNotFoundError, Forg3tRateLimitError, type Job, type JobError, type JobResult, type PaginationParams, type Project, type SubmitJobRequest, type UpdateWebhookRequest, type Webhook, type WebhookDelivery, type WebhookDeliveryFilters };

package/dist/index.d.ts

@@ -0,0 +1,192 @@
+interface Forg3tClientOptions {
+    apiUrl?: string;
+    apiKey?: string;
+    timeoutMs?: number;
+}
+interface PaginationParams {
+    limit?: number;
+    offset?: number;
+    cursor?: string;
+}
+interface Project {
+    id: string;
+    name: string;
+    tenantId: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface ApiKey {
+    id: string;
+    name: string;
+    keyPrefix: string;
+    status: 'active' | 'revoked';
+    createdAt: string;
+    revokedAt?: string | null;
+    lastUsedAt?: string | null;
+    expiresAt?: string | null;
+}
+interface CreateApiKeyRequest {
+    name: string;
+    expiresAt?: string;
+}
+interface CreateApiKeyResponse extends ApiKey {
+    plaintextKey: string;
+}
+interface AuditEvent {
+    id: string;
+    action: string;
+    resourceType: string;
+    resourceId: string;
+    ip: string;
+    userAgent: string;
+    createdAt: string;
+    metadata: Record<string, unknown> | null;
+}
+interface AuditEventFilters {
+    action?: string;
+    resourceType?: string;
+    resourceId?: string;
+    from?: string;
+    to?: string;
+    limit?: number;
+    cursor?: string;
+}
+interface AuditEventListResponse {
+    events: AuditEvent[];
+    nextCursor?: string;
+}
+interface Job {
+    id: string;
+    projectId: string;
+    type: string;
+    status: 'pending' | 'processing' | 'completed' | 'failed' | 'dead';
+    payload: Record<string, unknown>;
+    result?: Record<string, unknown> | null;
+    error?: Record<string, unknown> | null;
+    idempotencyKey?: string | null;
+    createdAt: string;
+    updatedAt: string;
+    startedAt?: string | null;
+    completedAt?: string | null;
+}
+interface SubmitJobRequest {
+    type: string;
+    payload: Record<string, unknown>;
+    idempotencyKey?: string;
+}
+interface ClaimJobsRequest {
+    limit?: number;
+}
+interface JobResult {
+    result: Record<string, unknown>;
+}
+interface JobError {
+    error: Record<string, unknown>;
+}
+interface Webhook {
+    id: string;
+    projectId: string;
+    url: string;
+    description?: string;
+    enabled: boolean;
+    secretPrefix?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface CreateWebhookRequest {
+    url: string;
+    description?: string;
+}
+interface UpdateWebhookRequest {
+    url?: string;
+    description?: string;
+    enabled?: boolean;
+}
+interface WebhookDelivery {
+    id: string;
+    webhookId: string;
+    eventId: string;
+    eventType: string;
+    status: 'success' | 'failed' | 'pending';
+    requestHeaders: Record<string, string>;
+    requestBody: Record<string, unknown>;
+    responseStatus?: number;
+    responseBody?: string;
+    createdAt: string;
+    attemptCount: number;
+}
+interface WebhookDeliveryFilters extends PaginationParams {
+    status?: 'success' | 'failed' | 'pending' | 'dead';
+    eventType?: string;
+}
+interface EvidenceArtifact {
+    id: string;
+    jobId: string;
+    type: string;
+    content: string;
+    signature: string;
+    publicKey: string;
+    createdAt: string;
+    artifacts: unknown[];
+}
+
+declare class Forg3tClient {
+    private transport;
+    constructor(options?: Forg3tClientOptions);
+    getProjectOverview(projectId: string, requestId?: string): Promise<Project>;
+    listAuditEvents(projectId: string, filters?: AuditEventFilters, requestId?: string): Promise<AuditEventListResponse>;
+    listApiKeys(projectId: string, requestId?: string): Promise<ApiKey[]>;
+    createApiKey(projectId: string, data: CreateApiKeyRequest, requestId?: string): Promise<CreateApiKeyResponse>;
+    rotateApiKey(keyId: string, requestId?: string): Promise<CreateApiKeyResponse>;
+    revokeApiKey(keyId: string, requestId?: string): Promise<ApiKey>;
+    submitJob(projectId: string, data: SubmitJobRequest, requestId?: string): Promise<Job>;
+    getJob(projectId: string, jobId: string, requestId?: string): Promise<Job>;
+    listJobs(projectId: string, query?: {
+        status?: string;
+        limit?: number;
+        offset?: number;
+    }, requestId?: string): Promise<Job[]>;
+    claimJobs(projectId: string, data?: ClaimJobsRequest, requestId?: string): Promise<Job[]>;
+    heartbeatJob(projectId: string, jobId: string, requestId?: string): Promise<Job>;
+    completeJob(projectId: string, jobId: string, result: JobResult, requestId?: string): Promise<Job>;
+    failJob(projectId: string, jobId: string, error: JobError, requestId?: string): Promise<Job>;
+    listDeadJobs(projectId: string, requestId?: string): Promise<Job[]>;
+    replayJob(projectId: string, jobId: string, requestId?: string): Promise<Job>;
+    getEvidence(jobId: string, requestId?: string): Promise<EvidenceArtifact>;
+    /**
+     * @deprecated The current Control Plane version does not support direct artifact downloads.
+     * Please use getEvidence() to retrieve the artifact metadata and content.
+     */
+    downloadEvidenceArtifact(jobId: string, requestId?: string): Promise<void>;
+    listWebhooks(projectId: string, requestId?: string): Promise<Webhook[]>;
+    createWebhook(projectId: string, data: CreateWebhookRequest, requestId?: string): Promise<Webhook>;
+    updateWebhook(webhookId: string, data: UpdateWebhookRequest, requestId?: string): Promise<Webhook>;
+    deleteWebhook(webhookId: string, requestId?: string): Promise<void>;
+    rotateWebhookSecret(webhookId: string, requestId?: string): Promise<Webhook>;
+    enableWebhook(webhookId: string, requestId?: string): Promise<Webhook>;
+    disableWebhook(webhookId: string, requestId?: string): Promise<Webhook>;
+    listWebhookDeliveries(webhookId: string, filters?: WebhookDeliveryFilters, requestId?: string): Promise<WebhookDelivery[]>;
+    replayWebhookDelivery(deliveryId: string, requestId?: string): Promise<WebhookDelivery>;
+}
+
+declare class Forg3tError extends Error {
+    status?: number | undefined;
+    code?: string | undefined;
+    requestId?: string | undefined;
+    details?: Record<string, unknown> | undefined;
+    constructor(message: string, status?: number | undefined, code?: string | undefined, requestId?: string | undefined, details?: Record<string, unknown> | undefined);
+}
+declare class Forg3tAuthenticationError extends Forg3tError {
+    constructor(message: string, requestId?: string);
+}
+declare class Forg3tNotFoundError extends Forg3tError {
+    constructor(message: string, requestId?: string);
+}
+declare class Forg3tRateLimitError extends Forg3tError {
+    constructor(message: string, requestId?: string);
+}
+declare class Forg3tApiConnectionError extends Forg3tError {
+    constructor(message: string);
+}
+
+export { type ApiKey, type AuditEvent, type AuditEventFilters, type AuditEventListResponse, type ClaimJobsRequest, type CreateApiKeyRequest, type CreateApiKeyResponse, type CreateWebhookRequest, type EvidenceArtifact, Forg3tApiConnectionError, Forg3tAuthenticationError, Forg3tClient, type Forg3tClientOptions, Forg3tError, Forg3tNotFoundError, Forg3tRateLimitError, type Job, type JobError, type JobResult, type PaginationParams, type Project, type SubmitJobRequest, type UpdateWebhookRequest, type Webhook, type WebhookDelivery, type WebhookDeliveryFilters };

package/dist/index.js

@@ -0,0 +1,363 @@
+"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, {
+  Forg3tApiConnectionError: () => Forg3tApiConnectionError,
+  Forg3tAuthenticationError: () => Forg3tAuthenticationError,
+  Forg3tClient: () => Forg3tClient,
+  Forg3tError: () => Forg3tError,
+  Forg3tNotFoundError: () => Forg3tNotFoundError,
+  Forg3tRateLimitError: () => Forg3tRateLimitError
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var Forg3tError = class extends Error {
+  constructor(message, status, code, requestId, details) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.requestId = requestId;
+    this.details = details;
+    this.name = "Forg3tError";
+  }
+};
+var Forg3tAuthenticationError = class extends Forg3tError {
+  constructor(message, requestId) {
+    super(message, 401, "AUTHENTICATION_ERROR", requestId);
+    this.name = "Forg3tAuthenticationError";
+  }
+};
+var Forg3tNotFoundError = class extends Forg3tError {
+  constructor(message, requestId) {
+    super(message, 404, "NOT_FOUND", requestId);
+    this.name = "Forg3tNotFoundError";
+  }
+};
+var Forg3tRateLimitError = class extends Forg3tError {
+  constructor(message, requestId) {
+    super(message, 429, "RATE_LIMIT_EXCEEDED", requestId);
+    this.name = "Forg3tRateLimitError";
+  }
+};
+var Forg3tApiConnectionError = class extends Forg3tError {
+  constructor(message) {
+    super(message);
+    this.name = "Forg3tApiConnectionError";
+  }
+};
+
+// src/transport.ts
+var Transport = class {
+  constructor(config) {
+    this.baseUrl = config.baseUrl || typeof process !== "undefined" && process.env.FORG3T_API_URL || "";
+    if (!this.baseUrl) {
+      throw new Error("Forg3tClient: apiUrl option or FORG3T_API_URL environment variable is required");
+    }
+    if (this.baseUrl.endsWith("/")) {
+      this.baseUrl = this.baseUrl.slice(0, -1);
+    }
+    this.apiKey = config.apiKey || (typeof process !== "undefined" ? process.env.FORG3T_API_KEY : void 0);
+    this.timeoutMs = config.timeoutMs || 3e4;
+  }
+  getBaseUrl() {
+    return this.baseUrl;
+  }
+  async request(path, options = {}, requestId) {
+    const url = `${this.baseUrl}${path.startsWith("/") ? "" : "/"}${path}`;
+    const headers = {
+      "Content-Type": "application/json",
+      "Accept": "application/json",
+      ...options.headers || {}
+    };
+    if (this.apiKey) {
+      headers["x-api-key"] = this.apiKey;
+    }
+    if (requestId) {
+      headers["x-request-id"] = requestId;
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeoutMs);
+    const signal = controller.signal;
+    try {
+      const response = await fetch(url, {
+        ...options,
+        headers,
+        signal
+        // Add the abort signal
+      });
+      clearTimeout(timeoutId);
+      const responseRequestId = response.headers.get("x-request-id") || requestId;
+      if (!response.ok) {
+        let errorData = {};
+        try {
+          errorData = await response.json();
+        } catch {
+          errorData = { error: response.statusText };
+        }
+        const message = errorData.error || errorData.message || "Unknown error occurred";
+        if (response.status === 401 || response.status === 403) {
+          throw new Forg3tAuthenticationError(message, responseRequestId);
+        }
+        if (response.status === 404) {
+          throw new Forg3tNotFoundError(message, responseRequestId);
+        }
+        if (response.status === 429) {
+          throw new Forg3tRateLimitError(message, responseRequestId);
+        }
+        throw new Forg3tError(
+          message,
+          response.status,
+          errorData.code,
+          responseRequestId,
+          errorData
+        );
+      }
+      if (response.status === 204) {
+        return {};
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Forg3tError) {
+        throw error;
+      }
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new Forg3tApiConnectionError(`Request timeout after ${this.timeoutMs}ms`);
+      }
+      throw new Forg3tApiConnectionError(error instanceof Error ? error.message : "Network error");
+    }
+  }
+  async download(url, requestId) {
+    const headers = {
+      "Accept": "*/*"
+      // Accept any type for downloads
+    };
+    if (this.apiKey) {
+      headers["x-api-key"] = this.apiKey;
+    }
+    if (requestId) {
+      headers["x-request-id"] = requestId;
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeoutMs);
+    const signal = controller.signal;
+    try {
+      const response = await fetch(url, {
+        method: "GET",
+        headers,
+        signal
+        // Add the abort signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        let errorData = {};
+        try {
+          errorData = await response.json();
+        } catch {
+          errorData = { error: response.statusText };
+        }
+        const message = errorData.error || errorData.message || "Unknown error occurred";
+        if (response.status === 401 || response.status === 403) {
+          throw new Forg3tAuthenticationError(message, requestId);
+        }
+        if (response.status === 404) {
+          throw new Forg3tNotFoundError(message, requestId);
+        }
+        if (response.status === 429) {
+          throw new Forg3tRateLimitError(message, requestId);
+        }
+        throw new Forg3tError(
+          message,
+          response.status,
+          errorData.code,
+          requestId,
+          errorData
+        );
+      }
+      return await response.blob();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Forg3tError) {
+        throw error;
+      }
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new Forg3tApiConnectionError(`Download timeout after ${this.timeoutMs}ms`);
+      }
+      throw new Forg3tApiConnectionError(error instanceof Error ? error.message : "Network error");
+    }
+  }
+};
+
+// src/client.ts
+var Forg3tClient = class {
+  constructor(options = {}) {
+    this.transport = new Transport({
+      baseUrl: options.apiUrl,
+      apiKey: options.apiKey,
+      timeoutMs: options.timeoutMs
+    });
+  }
+  // --- Projects ---
+  async getProjectOverview(projectId, requestId) {
+    return this.transport.request(`/v1/projects/${projectId}/overview`, { method: "GET" }, requestId);
+  }
+  async listAuditEvents(projectId, filters = {}, requestId) {
+    const params = new URLSearchParams();
+    if (filters.action) params.append("action", filters.action);
+    if (filters.resourceType) params.append("resourceType", filters.resourceType);
+    if (filters.resourceId) params.append("resourceId", filters.resourceId);
+    if (filters.from) params.append("from", filters.from);
+    if (filters.to) params.append("to", filters.to);
+    if (filters.limit) params.append("limit", filters.limit.toString());
+    if (filters.cursor) params.append("cursor", filters.cursor);
+    return this.transport.request(`/v1/projects/${projectId}/audit?${params.toString()}`, { method: "GET" }, requestId);
+  }
+  // --- API Keys ---
+  async listApiKeys(projectId, requestId) {
+    return this.transport.request(`/v1/projects/${projectId}/api-keys`, { method: "GET" }, requestId);
+  }
+  async createApiKey(projectId, data, requestId) {
+    return this.transport.request(`/v1/projects/${projectId}/api-keys`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    }, requestId);
+  }
+  async rotateApiKey(keyId, requestId) {
+    return this.transport.request(`/v1/api-keys/${keyId}/rotate`, { method: "POST" }, requestId);
+  }
+  async revokeApiKey(keyId, requestId) {
+    return this.transport.request(`/v1/api-keys/${keyId}/revoke`, { method: "POST" }, requestId);
+  }
+  // --- Jobs ---
+  async submitJob(projectId, data, requestId) {
+    const res = await this.transport.request(`/v1/projects/${projectId}/jobs`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    }, requestId);
+    if (res && res.jobId && !res.id) {
+      return {
+        ...res,
+        id: res.jobId,
+        projectId
+        // Ensure projectId is present if server omits it in minimal response
+      };
+    }
+    return res;
+  }
+  async getJob(projectId, jobId, requestId) {
+    return this.transport.request(`/v1/projects/${projectId}/jobs/${jobId}`, { method: "GET" }, requestId);
+  }
+  async listJobs(projectId, query, requestId) {
+    const params = new URLSearchParams();
+    if (query?.status) params.append("status", query.status);
+    if (query?.limit) params.append("limit", query.limit.toString());
+    if (query?.offset) params.append("offset", query.offset.toString());
+    return this.transport.request(`/v1/projects/${projectId}/jobs?${params.toString()}`, { method: "GET" }, requestId);
+  }
+  async claimJobs(projectId, data = {}, requestId) {
+    return this.transport.request(`/v1/projects/${projectId}/jobs/claim`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    }, requestId);
+  }
+  async heartbeatJob(projectId, jobId, requestId) {
+    return this.transport.request(`/v1/projects/${projectId}/jobs/${jobId}/heartbeat`, { method: "POST" }, requestId);
+  }
+  async completeJob(projectId, jobId, result, requestId) {
+    return this.transport.request(`/v1/projects/${projectId}/jobs/${jobId}/complete`, {
+      method: "POST",
+      body: JSON.stringify(result)
+    }, requestId);
+  }
+  async failJob(projectId, jobId, error, requestId) {
+    return this.transport.request(`/v1/projects/${projectId}/jobs/${jobId}/fail`, {
+      method: "POST",
+      body: JSON.stringify(error)
+    }, requestId);
+  }
+  async listDeadJobs(projectId, requestId) {
+    return this.transport.request(`/v1/projects/${projectId}/jobs/dead`, { method: "GET" }, requestId);
+  }
+  async replayJob(projectId, jobId, requestId) {
+    return this.transport.request(`/v1/projects/${projectId}/jobs/${jobId}/replay`, { method: "POST" }, requestId);
+  }
+  // --- Evidence ---
+  async getEvidence(jobId, requestId) {
+    return this.transport.request(`/v1/jobs/evidence/${jobId}`, { method: "GET" }, requestId);
+  }
+  /**
+   * @deprecated The current Control Plane version does not support direct artifact downloads.
+   * Please use getEvidence() to retrieve the artifact metadata and content.
+   */
+  async downloadEvidenceArtifact(jobId, requestId) {
+    throw new Error("Artifact download not supported by current API version. Use getEvidence() to retrieve content.");
+  }
+  // --- Webhooks ---
+  async listWebhooks(projectId, requestId) {
+    return this.transport.request(`/v1/projects/${projectId}/webhooks`, { method: "GET" }, requestId);
+  }
+  async createWebhook(projectId, data, requestId) {
+    return this.transport.request(`/v1/projects/${projectId}/webhooks`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    }, requestId);
+  }
+  async updateWebhook(webhookId, data, requestId) {
+    return this.transport.request(`/v1/webhooks/${webhookId}`, {
+      method: "PATCH",
+      body: JSON.stringify(data)
+    }, requestId);
+  }
+  async deleteWebhook(webhookId, requestId) {
+    return this.transport.request(`/v1/webhooks/${webhookId}`, { method: "DELETE" }, requestId);
+  }
+  async rotateWebhookSecret(webhookId, requestId) {
+    return this.transport.request(`/v1/webhooks/${webhookId}/rotate-secret`, { method: "POST" }, requestId);
+  }
+  async enableWebhook(webhookId, requestId) {
+    return this.updateWebhook(webhookId, { enabled: true }, requestId);
+  }
+  async disableWebhook(webhookId, requestId) {
+    return this.updateWebhook(webhookId, { enabled: false }, requestId);
+  }
+  // --- Webhook Deliveries ---
+  async listWebhookDeliveries(webhookId, filters = {}, requestId) {
+    const params = new URLSearchParams();
+    if (filters.status) params.append("status", filters.status);
+    if (filters.eventType) params.append("eventType", filters.eventType);
+    if (filters.limit) params.append("limit", filters.limit.toString());
+    if (filters.offset) params.append("offset", filters.offset.toString());
+    return this.transport.request(`/v1/webhooks/${webhookId}/deliveries?${params.toString()}`, { method: "GET" }, requestId);
+  }
+  async replayWebhookDelivery(deliveryId, requestId) {
+    return this.transport.request(`/v1/webhook-deliveries/${deliveryId}/replay`, { method: "POST" }, requestId);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Forg3tApiConnectionError,
+  Forg3tAuthenticationError,
+  Forg3tClient,
+  Forg3tError,
+  Forg3tNotFoundError,
+  Forg3tRateLimitError
+});

package/dist/index.mjs

@@ -0,0 +1,331 @@
+// src/errors.ts
+var Forg3tError = class extends Error {
+  constructor(message, status, code, requestId, details) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.requestId = requestId;
+    this.details = details;
+    this.name = "Forg3tError";
+  }
+};
+var Forg3tAuthenticationError = class extends Forg3tError {
+  constructor(message, requestId) {
+    super(message, 401, "AUTHENTICATION_ERROR", requestId);
+    this.name = "Forg3tAuthenticationError";
+  }
+};
+var Forg3tNotFoundError = class extends Forg3tError {
+  constructor(message, requestId) {
+    super(message, 404, "NOT_FOUND", requestId);
+    this.name = "Forg3tNotFoundError";
+  }
+};
+var Forg3tRateLimitError = class extends Forg3tError {
+  constructor(message, requestId) {
+    super(message, 429, "RATE_LIMIT_EXCEEDED", requestId);
+    this.name = "Forg3tRateLimitError";
+  }
+};
+var Forg3tApiConnectionError = class extends Forg3tError {
+  constructor(message) {
+    super(message);
+    this.name = "Forg3tApiConnectionError";
+  }
+};
+
+// src/transport.ts
+var Transport = class {
+  constructor(config) {
+    this.baseUrl = config.baseUrl || typeof process !== "undefined" && process.env.FORG3T_API_URL || "";
+    if (!this.baseUrl) {
+      throw new Error("Forg3tClient: apiUrl option or FORG3T_API_URL environment variable is required");
+    }
+    if (this.baseUrl.endsWith("/")) {
+      this.baseUrl = this.baseUrl.slice(0, -1);
+    }
+    this.apiKey = config.apiKey || (typeof process !== "undefined" ? process.env.FORG3T_API_KEY : void 0);
+    this.timeoutMs = config.timeoutMs || 3e4;
+  }
+  getBaseUrl() {
+    return this.baseUrl;
+  }
+  async request(path, options = {}, requestId) {
+    const url = `${this.baseUrl}${path.startsWith("/") ? "" : "/"}${path}`;
+    const headers = {
+      "Content-Type": "application/json",
+      "Accept": "application/json",
+      ...options.headers || {}
+    };
+    if (this.apiKey) {
+      headers["x-api-key"] = this.apiKey;
+    }
+    if (requestId) {
+      headers["x-request-id"] = requestId;
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeoutMs);
+    const signal = controller.signal;
+    try {
+      const response = await fetch(url, {
+        ...options,
+        headers,
+        signal
+        // Add the abort signal
+      });
+      clearTimeout(timeoutId);
+      const responseRequestId = response.headers.get("x-request-id") || requestId;
+      if (!response.ok) {
+        let errorData = {};
+        try {
+          errorData = await response.json();
+        } catch {
+          errorData = { error: response.statusText };
+        }
+        const message = errorData.error || errorData.message || "Unknown error occurred";
+        if (response.status === 401 || response.status === 403) {
+          throw new Forg3tAuthenticationError(message, responseRequestId);
+        }
+        if (response.status === 404) {
+          throw new Forg3tNotFoundError(message, responseRequestId);
+        }
+        if (response.status === 429) {
+          throw new Forg3tRateLimitError(message, responseRequestId);
+        }
+        throw new Forg3tError(
+          message,
+          response.status,
+          errorData.code,
+          responseRequestId,
+          errorData
+        );
+      }
+      if (response.status === 204) {
+        return {};
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Forg3tError) {
+        throw error;
+      }
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new Forg3tApiConnectionError(`Request timeout after ${this.timeoutMs}ms`);
+      }
+      throw new Forg3tApiConnectionError(error instanceof Error ? error.message : "Network error");
+    }
+  }
+  async download(url, requestId) {
+    const headers = {
+      "Accept": "*/*"
+      // Accept any type for downloads
+    };
+    if (this.apiKey) {
+      headers["x-api-key"] = this.apiKey;
+    }
+    if (requestId) {
+      headers["x-request-id"] = requestId;
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeoutMs);
+    const signal = controller.signal;
+    try {
+      const response = await fetch(url, {
+        method: "GET",
+        headers,
+        signal
+        // Add the abort signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        let errorData = {};
+        try {
+          errorData = await response.json();
+        } catch {
+          errorData = { error: response.statusText };
+        }
+        const message = errorData.error || errorData.message || "Unknown error occurred";
+        if (response.status === 401 || response.status === 403) {
+          throw new Forg3tAuthenticationError(message, requestId);
+        }
+        if (response.status === 404) {
+          throw new Forg3tNotFoundError(message, requestId);
+        }
+        if (response.status === 429) {
+          throw new Forg3tRateLimitError(message, requestId);
+        }
+        throw new Forg3tError(
+          message,
+          response.status,
+          errorData.code,
+          requestId,
+          errorData
+        );
+      }
+      return await response.blob();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Forg3tError) {
+        throw error;
+      }
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new Forg3tApiConnectionError(`Download timeout after ${this.timeoutMs}ms`);
+      }
+      throw new Forg3tApiConnectionError(error instanceof Error ? error.message : "Network error");
+    }
+  }
+};
+
+// src/client.ts
+var Forg3tClient = class {
+  constructor(options = {}) {
+    this.transport = new Transport({
+      baseUrl: options.apiUrl,
+      apiKey: options.apiKey,
+      timeoutMs: options.timeoutMs
+    });
+  }
+  // --- Projects ---
+  async getProjectOverview(projectId, requestId) {
+    return this.transport.request(`/v1/projects/${projectId}/overview`, { method: "GET" }, requestId);
+  }
+  async listAuditEvents(projectId, filters = {}, requestId) {
+    const params = new URLSearchParams();
+    if (filters.action) params.append("action", filters.action);
+    if (filters.resourceType) params.append("resourceType", filters.resourceType);
+    if (filters.resourceId) params.append("resourceId", filters.resourceId);
+    if (filters.from) params.append("from", filters.from);
+    if (filters.to) params.append("to", filters.to);
+    if (filters.limit) params.append("limit", filters.limit.toString());
+    if (filters.cursor) params.append("cursor", filters.cursor);
+    return this.transport.request(`/v1/projects/${projectId}/audit?${params.toString()}`, { method: "GET" }, requestId);
+  }
+  // --- API Keys ---
+  async listApiKeys(projectId, requestId) {
+    return this.transport.request(`/v1/projects/${projectId}/api-keys`, { method: "GET" }, requestId);
+  }
+  async createApiKey(projectId, data, requestId) {
+    return this.transport.request(`/v1/projects/${projectId}/api-keys`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    }, requestId);
+  }
+  async rotateApiKey(keyId, requestId) {
+    return this.transport.request(`/v1/api-keys/${keyId}/rotate`, { method: "POST" }, requestId);
+  }
+  async revokeApiKey(keyId, requestId) {
+    return this.transport.request(`/v1/api-keys/${keyId}/revoke`, { method: "POST" }, requestId);
+  }
+  // --- Jobs ---
+  async submitJob(projectId, data, requestId) {
+    const res = await this.transport.request(`/v1/projects/${projectId}/jobs`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    }, requestId);
+    if (res && res.jobId && !res.id) {
+      return {
+        ...res,
+        id: res.jobId,
+        projectId
+        // Ensure projectId is present if server omits it in minimal response
+      };
+    }
+    return res;
+  }
+  async getJob(projectId, jobId, requestId) {
+    return this.transport.request(`/v1/projects/${projectId}/jobs/${jobId}`, { method: "GET" }, requestId);
+  }
+  async listJobs(projectId, query, requestId) {
+    const params = new URLSearchParams();
+    if (query?.status) params.append("status", query.status);
+    if (query?.limit) params.append("limit", query.limit.toString());
+    if (query?.offset) params.append("offset", query.offset.toString());
+    return this.transport.request(`/v1/projects/${projectId}/jobs?${params.toString()}`, { method: "GET" }, requestId);
+  }
+  async claimJobs(projectId, data = {}, requestId) {
+    return this.transport.request(`/v1/projects/${projectId}/jobs/claim`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    }, requestId);
+  }
+  async heartbeatJob(projectId, jobId, requestId) {
+    return this.transport.request(`/v1/projects/${projectId}/jobs/${jobId}/heartbeat`, { method: "POST" }, requestId);
+  }
+  async completeJob(projectId, jobId, result, requestId) {
+    return this.transport.request(`/v1/projects/${projectId}/jobs/${jobId}/complete`, {
+      method: "POST",
+      body: JSON.stringify(result)
+    }, requestId);
+  }
+  async failJob(projectId, jobId, error, requestId) {
+    return this.transport.request(`/v1/projects/${projectId}/jobs/${jobId}/fail`, {
+      method: "POST",
+      body: JSON.stringify(error)
+    }, requestId);
+  }
+  async listDeadJobs(projectId, requestId) {
+    return this.transport.request(`/v1/projects/${projectId}/jobs/dead`, { method: "GET" }, requestId);
+  }
+  async replayJob(projectId, jobId, requestId) {
+    return this.transport.request(`/v1/projects/${projectId}/jobs/${jobId}/replay`, { method: "POST" }, requestId);
+  }
+  // --- Evidence ---
+  async getEvidence(jobId, requestId) {
+    return this.transport.request(`/v1/jobs/evidence/${jobId}`, { method: "GET" }, requestId);
+  }
+  /**
+   * @deprecated The current Control Plane version does not support direct artifact downloads.
+   * Please use getEvidence() to retrieve the artifact metadata and content.
+   */
+  async downloadEvidenceArtifact(jobId, requestId) {
+    throw new Error("Artifact download not supported by current API version. Use getEvidence() to retrieve content.");
+  }
+  // --- Webhooks ---
+  async listWebhooks(projectId, requestId) {
+    return this.transport.request(`/v1/projects/${projectId}/webhooks`, { method: "GET" }, requestId);
+  }
+  async createWebhook(projectId, data, requestId) {
+    return this.transport.request(`/v1/projects/${projectId}/webhooks`, {
+      method: "POST",
+      body: JSON.stringify(data)
+    }, requestId);
+  }
+  async updateWebhook(webhookId, data, requestId) {
+    return this.transport.request(`/v1/webhooks/${webhookId}`, {
+      method: "PATCH",
+      body: JSON.stringify(data)
+    }, requestId);
+  }
+  async deleteWebhook(webhookId, requestId) {
+    return this.transport.request(`/v1/webhooks/${webhookId}`, { method: "DELETE" }, requestId);
+  }
+  async rotateWebhookSecret(webhookId, requestId) {
+    return this.transport.request(`/v1/webhooks/${webhookId}/rotate-secret`, { method: "POST" }, requestId);
+  }
+  async enableWebhook(webhookId, requestId) {
+    return this.updateWebhook(webhookId, { enabled: true }, requestId);
+  }
+  async disableWebhook(webhookId, requestId) {
+    return this.updateWebhook(webhookId, { enabled: false }, requestId);
+  }
+  // --- Webhook Deliveries ---
+  async listWebhookDeliveries(webhookId, filters = {}, requestId) {
+    const params = new URLSearchParams();
+    if (filters.status) params.append("status", filters.status);
+    if (filters.eventType) params.append("eventType", filters.eventType);
+    if (filters.limit) params.append("limit", filters.limit.toString());
+    if (filters.offset) params.append("offset", filters.offset.toString());
+    return this.transport.request(`/v1/webhooks/${webhookId}/deliveries?${params.toString()}`, { method: "GET" }, requestId);
+  }
+  async replayWebhookDelivery(deliveryId, requestId) {
+    return this.transport.request(`/v1/webhook-deliveries/${deliveryId}/replay`, { method: "POST" }, requestId);
+  }
+};
+export {
+  Forg3tApiConnectionError,
+  Forg3tAuthenticationError,
+  Forg3tClient,
+  Forg3tError,
+  Forg3tNotFoundError,
+  Forg3tRateLimitError
+};

package/package.json

@@ -0,0 +1,50 @@
+{
+    "name": "@forg3t/sdk",
+    "version": "0.1.0",
+    "description": "Official TypeScript SDK for Forg3t Protocol",
+    "main": "./dist/index.js",
+    "module": "./dist/index.mjs",
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": {
+            "import": "./dist/index.mjs",
+            "require": "./dist/index.js",
+            "types": "./dist/index.d.ts"
+        }
+    },
+    "engines": {
+        "node": ">=18"
+    },
+    "files": [
+        "dist",
+        "README.md",
+        "LICENSE"
+    ],
+    "scripts": {
+        "build": "tsup src/index.ts --format cjs,esm --dts",
+        "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+        "lint": "eslint src/",
+        "prepublishOnly": "npm run build",
+        "test": "npm run typecheck && npm run lint:cleanroom && npm run lint:no-localhost && npm run test:contract && npm run test:exports && npm run test:types",
+        "test:contract": "node tools/probe_contract.mjs",
+        "test:exports": "node tools/exports_smoke_esm.mjs && node tools/exports_smoke_cjs.cjs",
+        "test:types": "npx tsc tools/types_smoke.ts --noEmit",
+        "typecheck": "tsc -p tsconfig.json --noEmit",
+        "lint:cleanroom": "node scripts/cleanroom_check.js",
+        "lint:no-localhost": "node scripts/no_localhost_check.js",
+        "pack:check": "npm pack --dry-run"
+    },
+    "keywords": [
+        "forg3t",
+        "sdk",
+        "unlearning"
+    ],
+    "author": "Forg3t Inc.",
+    "license": "MIT",
+    "devDependencies": {
+        "tsup": "^8.0.0",
+        "typescript": "^5.0.0",
+        "@types/node": "^20.0.0"
+    },
+    "dependencies": {}
+}