@teamlearners/clawops 0.1.0

package/dist/index.cjs

@@ -0,0 +1,601 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var chunkJNSHMKDI_cjs = require('./chunk-JNSHMKDI.cjs');
+var zod = require('zod');
+var crypto = require('crypto');
+
+// src/version.ts
+var VERSION = "0.1.0";
+
+// src/base-client.ts
+var LOCALHOST_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "0.0.0.0", "[::1]"]);
+function validateBaseUrl(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new chunkJNSHMKDI_cjs.ClawOpsError(`Invalid base_url: ${url}`);
+  }
+  if (parsed.protocol === "https:") return url;
+  if (parsed.protocol === "http:" && LOCALHOST_HOSTS.has(parsed.hostname)) return url;
+  throw new chunkJNSHMKDI_cjs.ClawOpsError(
+    `base_url\uC740 HTTPS\uB97C \uC0AC\uC6A9\uD574\uC57C \uD569\uB2C8\uB2E4 (\uBC1B\uC740 \uAC12: '${url}'). \uB85C\uCEEC \uAC1C\uBC1C \uC2DC\uC5D0\uB294 http://localhost\uB97C \uC0AC\uC6A9\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4.`
+  );
+}
+var APIClient = class {
+  _apiKey;
+  _baseURL;
+  _maxRetries;
+  _timeout;
+  _fetch;
+  _defaultHeaders;
+  constructor(options) {
+    this._apiKey = options.apiKey;
+    this._baseURL = validateBaseUrl((options.baseURL ?? chunkJNSHMKDI_cjs.DEFAULT_BASE_URL).replace(/\/+$/, ""));
+    this._maxRetries = options.maxRetries ?? chunkJNSHMKDI_cjs.DEFAULT_MAX_RETRIES;
+    this._timeout = options.timeout ?? chunkJNSHMKDI_cjs.DEFAULT_TIMEOUT;
+    this._fetch = options.fetch ?? globalThis.fetch;
+    this._defaultHeaders = options.defaultHeaders ?? {};
+  }
+  _buildHeaders(extra) {
+    const headers = {
+      Authorization: `Bearer ${this._apiKey}`,
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      "User-Agent": `claw-ops-node/${VERSION}`,
+      ...this._defaultHeaders
+    };
+    if (extra) Object.assign(headers, extra);
+    return headers;
+  }
+  async _request(method2, path, options = {}) {
+    const headers = this._buildHeaders(options.extraHeaders);
+    const params = new URLSearchParams();
+    const queryObj = { ...options.query, ...options.extraQuery };
+    for (const [k, v] of Object.entries(queryObj)) {
+      if (v != null) params.set(k, String(v));
+    }
+    const queryString = params.toString();
+    const url = `${this._baseURL}${path}${queryString ? `?${queryString}` : ""}`;
+    const reqTimeout = options.timeout ?? this._timeout;
+    let retriesLeft = this._maxRetries;
+    while (true) {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), reqTimeout);
+      let response;
+      try {
+        response = await this._fetch(url, {
+          method: method2,
+          headers,
+          body: options.body ? JSON.stringify(options.body) : void 0,
+          signal: controller.signal
+        });
+      } catch (err) {
+        clearTimeout(timeoutId);
+        if (err instanceof DOMException && err.name === "AbortError") {
+          if (retriesLeft > 0) {
+            retriesLeft--;
+            await this._sleep(this._retryDelay(this._maxRetries - retriesLeft));
+            continue;
+          }
+          throw new chunkJNSHMKDI_cjs.APITimeoutError({ method: method2, url });
+        }
+        if (retriesLeft > 0) {
+          retriesLeft--;
+          await this._sleep(this._retryDelay(this._maxRetries - retriesLeft));
+          continue;
+        }
+        throw new chunkJNSHMKDI_cjs.APIConnectionError({ method: method2, url });
+      } finally {
+        clearTimeout(timeoutId);
+      }
+      if (response.ok) {
+        if (response.status === 204 || !options.castTo) {
+          return null;
+        }
+        let json;
+        try {
+          json = await response.json();
+        } catch {
+          throw new chunkJNSHMKDI_cjs.APIResponseValidationError({ status: response.status }, { method: method2, url });
+        }
+        const parsed = options.castTo.safeParse(json);
+        if (!parsed.success) {
+          throw new chunkJNSHMKDI_cjs.APIResponseValidationError({ status: response.status }, { method: method2, url });
+        }
+        return parsed.data;
+      }
+      if (retriesLeft > 0 && this._shouldRetry(response.status)) {
+        retriesLeft--;
+        await this._sleep(this._retryDelay(this._maxRetries - retriesLeft));
+        continue;
+      }
+      let body;
+      try {
+        body = await response.json();
+      } catch {
+        body = null;
+      }
+      throw chunkJNSHMKDI_cjs.makeStatusError(response.status, body, response.headers, { method: method2, url });
+    }
+  }
+  _shouldRetry(status) {
+    return status === 408 || status === 409 || status === 429 || status >= 500;
+  }
+  _retryDelay(retriesTaken) {
+    const delay = Math.min(chunkJNSHMKDI_cjs.INITIAL_RETRY_DELAY * 2 ** retriesTaken, chunkJNSHMKDI_cjs.MAX_RETRY_DELAY);
+    return delay * (1 + Math.random());
+  }
+  _sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  async _get(path, options) {
+    const result = await this._request(method("GET"), path, options);
+    return result;
+  }
+  async _post(path, options) {
+    const result = await this._request("POST", path, options);
+    return result;
+  }
+  async _put(path, options) {
+    const result = await this._request("PUT", path, options);
+    return result;
+  }
+  async _delete(path, options = {}) {
+    await this._request("DELETE", path, options);
+  }
+};
+function method(m) {
+  return m;
+}
+
+// src/resource.ts
+var APIResource = class {
+  _client;
+  _accountId;
+  constructor(client, accountId) {
+    this._client = client;
+    this._accountId = accountId;
+  }
+  get _basePath() {
+    return `/v1/accounts/${this._accountId}`;
+  }
+};
+
+// src/util.ts
+function stripNotGiven(data) {
+  const result = {};
+  for (const [k, v] of Object.entries(data)) {
+    if (v != null) {
+      result[k] = v;
+    }
+  }
+  return result;
+}
+var PaginationMetaSchema = zod.z.object({
+  total: zod.z.number(),
+  page: zod.z.number(),
+  pageSize: zod.z.number()
+}).passthrough();
+
+// src/pagination.ts
+function PageSchema(itemSchema) {
+  return zod.z.object({
+    data: zod.z.array(itemSchema),
+    meta: PaginationMetaSchema
+  }).passthrough();
+}
+var Page = class _Page {
+  data;
+  meta;
+  _client = null;
+  _path = "";
+  _itemSchema = null;
+  _query = {};
+  constructor(data, meta) {
+    this.data = data;
+    this.meta = meta;
+  }
+  /** @internal */
+  _setClient(client, path, itemSchema, query) {
+    this._client = client;
+    this._path = path;
+    this._itemSchema = itemSchema;
+    this._query = query;
+  }
+  hasNextPage() {
+    return (this.meta.page + 1) * this.meta.pageSize < this.meta.total;
+  }
+  async nextPage() {
+    if (!this._client || !this._itemSchema) {
+      throw new Error("Page client is not set");
+    }
+    if (!this.hasNextPage()) {
+      throw new Error("No more pages");
+    }
+    const nextQuery = { ...this._query, page: this.meta.page + 1 };
+    const schema = PageSchema(this._itemSchema);
+    const raw = await this._client._get(this._path, {
+      castTo: schema,
+      query: nextQuery
+    });
+    const page = new _Page(raw.data, raw.meta);
+    page._setClient(this._client, this._path, this._itemSchema, this._query);
+    return page;
+  }
+  [Symbol.iterator]() {
+    return this.data[Symbol.iterator]();
+  }
+  async *autoPagingIter() {
+    let page = this;
+    while (true) {
+      for (const item of page.data) {
+        yield item;
+      }
+      if (!page.hasNextPage()) break;
+      page = await page.nextPage();
+    }
+  }
+};
+var CallSchema = zod.z.object({
+  callId: zod.z.string(),
+  status: zod.z.enum(["queued", "ringing", "in-progress", "completed", "failed"]),
+  to: zod.z.string(),
+  from: zod.z.string(),
+  direction: zod.z.enum(["outbound", "inbound"]),
+  duration: zod.z.number().nullable().optional(),
+  accountId: zod.z.string(),
+  dateCreated: zod.z.string(),
+  dateUpdated: zod.z.string().nullable().optional()
+}).passthrough();
+var CallControlResponseSchema = zod.z.object({
+  callId: zod.z.string(),
+  status: zod.z.string()
+}).passthrough();
+
+// src/resources/calls.ts
+var Calls = class extends APIResource {
+  async create(params, options = {}) {
+    const body = stripNotGiven({
+      To: params.to,
+      From: params.from,
+      Url: params.url,
+      StatusCallback: params.statusCallback,
+      StatusCallbackEvent: params.statusCallbackEvent
+    });
+    return this._client._post(`${this._basePath}/calls`, {
+      body,
+      castTo: CallSchema,
+      ...options
+    });
+  }
+  async list(params = {}, options = {}) {
+    const query = stripNotGiven({
+      status: params.status,
+      page: params.page,
+      pageSize: params.pageSize
+    });
+    const path = `${this._basePath}/calls`;
+    const schema = PageSchema(CallSchema);
+    const raw = await this._client._get(path, {
+      castTo: schema,
+      query: Object.keys(query).length ? query : void 0,
+      ...options
+    });
+    const page = new Page(raw.data, raw.meta);
+    page._setClient(this._client, path, CallSchema, query);
+    return page;
+  }
+  async get(callId, options = {}) {
+    return this._client._get(`${this._basePath}/calls/${callId}`, {
+      castTo: CallSchema,
+      ...options
+    });
+  }
+  async update(callId, params = {}, options = {}) {
+    return this._client._post(`${this._basePath}/calls/${callId}`, {
+      body: { Status: params.status ?? "completed" },
+      castTo: CallControlResponseSchema,
+      ...options
+    });
+  }
+};
+var MessageSchema = zod.z.object({
+  messageId: zod.z.string(),
+  status: zod.z.enum(["queued", "sending", "sent", "failed", "received"]),
+  type: zod.z.enum(["sms", "mms", "rcs", "kakao"]),
+  to: zod.z.string(),
+  from: zod.z.string(),
+  body: zod.z.string().nullable().optional(),
+  direction: zod.z.enum(["outbound", "inbound"]),
+  accountId: zod.z.string(),
+  dateCreated: zod.z.string(),
+  dateUpdated: zod.z.string().nullable().optional()
+}).passthrough();
+
+// src/resources/messages.ts
+var Messages = class extends APIResource {
+  async create(params, options = {}) {
+    const body = stripNotGiven({
+      To: params.to,
+      From: params.from,
+      Body: params.body,
+      Type: params.type,
+      Subject: params.subject
+    });
+    return this._client._post(`${this._basePath}/messages`, {
+      body,
+      castTo: MessageSchema,
+      ...options
+    });
+  }
+  async list(params = {}, options = {}) {
+    const query = stripNotGiven({
+      type: params.type,
+      status: params.status,
+      page: params.page,
+      pageSize: params.pageSize
+    });
+    const path = `${this._basePath}/messages`;
+    const schema = PageSchema(MessageSchema);
+    const raw = await this._client._get(path, {
+      castTo: schema,
+      query: Object.keys(query).length ? query : void 0,
+      ...options
+    });
+    const page = new Page(raw.data, raw.meta);
+    page._setClient(this._client, path, MessageSchema, query);
+    return page;
+  }
+  async get(messageId, options = {}) {
+    return this._client._get(`${this._basePath}/messages/${messageId}`, {
+      castTo: MessageSchema,
+      ...options
+    });
+  }
+};
+var PhoneNumberSchema = zod.z.object({
+  number: zod.z.string(),
+  source: zod.z.string().nullable().optional(),
+  webhookUrl: zod.z.string().nullable().optional(),
+  webhookMethod: zod.z.enum(["POST", "GET"]).nullable().optional(),
+  createdAt: zod.z.string().nullable().optional()
+}).passthrough();
+
+// src/resources/numbers.ts
+var Numbers = class extends APIResource {
+  async create(params = {}, options = {}) {
+    const body = stripNotGiven({ webhookUrl: params.webhookUrl });
+    return this._client._post(`${this._basePath}/numbers`, {
+      body: Object.keys(body).length ? body : void 0,
+      castTo: PhoneNumberSchema,
+      ...options
+    });
+  }
+  async list(options = {}) {
+    const schema = zod.z.object({ data: zod.z.array(PhoneNumberSchema) }).passthrough();
+    const result = await this._client._get(`${this._basePath}/numbers`, {
+      castTo: schema,
+      ...options
+    });
+    return result.data;
+  }
+  async update(number, params = {}, options = {}) {
+    const body = stripNotGiven({
+      webhookUrl: params.webhookUrl,
+      webhookMethod: params.webhookMethod
+    });
+    return this._client._put(`${this._basePath}/numbers/${number}`, {
+      body,
+      castTo: PhoneNumberSchema,
+      ...options
+    });
+  }
+  async delete(number, options = {}) {
+    await this._client._delete(`${this._basePath}/numbers/${number}`, options);
+  }
+};
+var WebhookLogSchema = zod.z.object({
+  id: zod.z.string(),
+  webhookId: zod.z.string(),
+  event: zod.z.string(),
+  requestUrl: zod.z.string(),
+  requestPayload: zod.z.record(zod.z.unknown()),
+  responseStatus: zod.z.number().nullable().optional(),
+  responseBody: zod.z.string().nullable().optional(),
+  responseTimeMs: zod.z.number().nullable().optional(),
+  status: zod.z.enum(["pending", "delivered", "failed"]),
+  attempt: zod.z.number(),
+  maxAttempts: zod.z.number(),
+  createdAt: zod.z.string(),
+  completedAt: zod.z.string().nullable().optional()
+}).passthrough();
+
+// src/resources/webhook-logs.ts
+var WebhookLogs = class extends APIResource {
+  async list(webhookId, params = {}, options = {}) {
+    const query = stripNotGiven({ page: params.page, pageSize: params.pageSize });
+    const path = `${this._basePath}/webhooks/${webhookId}/logs`;
+    const schema = PageSchema(WebhookLogSchema);
+    const raw = await this._client._get(path, {
+      castTo: schema,
+      query: Object.keys(query).length ? query : void 0,
+      ...options
+    });
+    const page = new Page(raw.data, raw.meta);
+    page._setClient(this._client, path, WebhookLogSchema, query);
+    return page;
+  }
+};
+
+// src/resources/accounts.ts
+var AccountContext = class {
+  _client;
+  _accountId;
+  constructor(client, accountId) {
+    this._client = client;
+    this._accountId = accountId;
+  }
+  get calls() {
+    return new Calls(this._client, this._accountId);
+  }
+  get messages() {
+    return new Messages(this._client, this._accountId);
+  }
+  get numbers() {
+    return new Numbers(this._client, this._accountId);
+  }
+  get webhookLogs() {
+    return new WebhookLogs(this._client, this._accountId);
+  }
+};
+var WebhookVerificationError = class extends chunkJNSHMKDI_cjs.ClawOpsError {
+  constructor(message = "Webhook \uC11C\uBA85\uC774 \uC77C\uCE58\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.") {
+    super(message);
+    this.name = "WebhookVerificationError";
+  }
+};
+var Webhooks = class _Webhooks {
+  verify(options) {
+    const expected = _Webhooks._computeSignature(options.url, options.params, options.signingKey);
+    const expectedBuf = Buffer.from(expected, "utf-8");
+    const signatureBuf = Buffer.from(options.signature, "utf-8");
+    if (expectedBuf.length !== signatureBuf.length || !crypto.timingSafeEqual(expectedBuf, signatureBuf)) {
+      throw new WebhookVerificationError();
+    }
+    return true;
+  }
+  static _computeSignature(url, params, signingKey) {
+    const sortedParams = Object.keys(params).sort().map((k) => `${k}${params[k]}`).join("");
+    const dataToSign = url + sortedParams;
+    const digest = crypto.createHmac("sha256", signingKey).update(dataToSign, "utf-8").digest();
+    return digest.toString("base64");
+  }
+};
+
+// src/client.ts
+var ClawOps = class extends APIClient {
+  _defaultAccountId;
+  constructor(options = {}) {
+    let apiKey = options.apiKey ?? process.env.CLAWOPS_API_KEY;
+    if (!apiKey) {
+      throw new chunkJNSHMKDI_cjs.ClawOpsError("apiKey\uB97C \uC9C0\uC815\uD558\uAC70\uB098 CLAWOPS_API_KEY \uD658\uACBD\uBCC0\uC218\uB97C \uC124\uC815\uD558\uC138\uC694.");
+    }
+    let accountId = options.accountId ?? process.env.CLAWOPS_ACCOUNT_ID;
+    if (!accountId) {
+      throw new chunkJNSHMKDI_cjs.ClawOpsError("accountId\uB97C \uC9C0\uC815\uD558\uAC70\uB098 CLAWOPS_ACCOUNT_ID \uD658\uACBD\uBCC0\uC218\uB97C \uC124\uC815\uD558\uC138\uC694.");
+    }
+    const baseURL = options.baseURL ?? process.env.CLAWOPS_BASE_URL ?? chunkJNSHMKDI_cjs.DEFAULT_BASE_URL;
+    super({
+      apiKey,
+      baseURL,
+      timeout: options.timeout,
+      maxRetries: options.maxRetries,
+      fetch: options.fetch,
+      defaultHeaders: options.defaultHeaders
+    });
+    this._defaultAccountId = accountId;
+  }
+  get calls() {
+    return new Calls(this, this._defaultAccountId);
+  }
+  get messages() {
+    return new Messages(this, this._defaultAccountId);
+  }
+  get numbers() {
+    return new Numbers(this, this._defaultAccountId);
+  }
+  get webhookLogs() {
+    return new WebhookLogs(this, this._defaultAccountId);
+  }
+  get webhooks() {
+    return new Webhooks();
+  }
+  accounts(accountId) {
+    return new AccountContext(this, accountId);
+  }
+};
+
+// src/client-default.ts
+var client_default_default = ClawOps;
+
+Object.defineProperty(exports, "APIConnectionError", {
+  enumerable: true,
+  get: function () { return chunkJNSHMKDI_cjs.APIConnectionError; }
+});
+Object.defineProperty(exports, "APIError", {
+  enumerable: true,
+  get: function () { return chunkJNSHMKDI_cjs.APIError; }
+});
+Object.defineProperty(exports, "APIResponseValidationError", {
+  enumerable: true,
+  get: function () { return chunkJNSHMKDI_cjs.APIResponseValidationError; }
+});
+Object.defineProperty(exports, "APIStatusError", {
+  enumerable: true,
+  get: function () { return chunkJNSHMKDI_cjs.APIStatusError; }
+});
+Object.defineProperty(exports, "APITimeoutError", {
+  enumerable: true,
+  get: function () { return chunkJNSHMKDI_cjs.APITimeoutError; }
+});
+Object.defineProperty(exports, "AgentConnectionError", {
+  enumerable: true,
+  get: function () { return chunkJNSHMKDI_cjs.AgentConnectionError; }
+});
+Object.defineProperty(exports, "AgentError", {
+  enumerable: true,
+  get: function () { return chunkJNSHMKDI_cjs.AgentError; }
+});
+Object.defineProperty(exports, "AuthenticationError", {
+  enumerable: true,
+  get: function () { return chunkJNSHMKDI_cjs.AuthenticationError; }
+});
+Object.defineProperty(exports, "BadRequestError", {
+  enumerable: true,
+  get: function () { return chunkJNSHMKDI_cjs.BadRequestError; }
+});
+Object.defineProperty(exports, "ClawOpsError", {
+  enumerable: true,
+  get: function () { return chunkJNSHMKDI_cjs.ClawOpsError; }
+});
+Object.defineProperty(exports, "ConflictError", {
+  enumerable: true,
+  get: function () { return chunkJNSHMKDI_cjs.ConflictError; }
+});
+Object.defineProperty(exports, "InternalServerError", {
+  enumerable: true,
+  get: function () { return chunkJNSHMKDI_cjs.InternalServerError; }
+});
+Object.defineProperty(exports, "NotFoundError", {
+  enumerable: true,
+  get: function () { return chunkJNSHMKDI_cjs.NotFoundError; }
+});
+Object.defineProperty(exports, "PermissionDeniedError", {
+  enumerable: true,
+  get: function () { return chunkJNSHMKDI_cjs.PermissionDeniedError; }
+});
+Object.defineProperty(exports, "ServiceUnavailableError", {
+  enumerable: true,
+  get: function () { return chunkJNSHMKDI_cjs.ServiceUnavailableError; }
+});
+Object.defineProperty(exports, "UnprocessableEntityError", {
+  enumerable: true,
+  get: function () { return chunkJNSHMKDI_cjs.UnprocessableEntityError; }
+});
+exports.APIClient = APIClient;
+exports.AccountContext = AccountContext;
+exports.Calls = Calls;
+exports.ClawOps = ClawOps;
+exports.Messages = Messages;
+exports.Numbers = Numbers;
+exports.Page = Page;
+exports.VERSION = VERSION;
+exports.WebhookLogs = WebhookLogs;
+exports.WebhookVerificationError = WebhookVerificationError;
+exports.Webhooks = Webhooks;
+exports.default = client_default_default;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map