@hasna/connectors 1.3.44 → 1.3.46

package/connectors/cloudflare-workers/src/cli/index.ts

@@ -0,0 +1,206 @@
+#!/usr/bin/env bun
+import { readFileSync } from "node:fs";
+import { Command } from "commander";
+import { CloudflareWorkers } from "../api";
+import type { HttpMethod, JsonObject, JsonValue, OutputFormat, QueryParams, QueryValue } from "../types";
+import { clearConfig, getAccountId, getApiToken, getBaseUrl, loadConfig, setAccountId, setApiToken, setBaseUrl } from "../utils/config";
+import { error, info, print, success } from "../utils/output";
+
+const CONNECTOR_NAME = "connect-cloudflare-workers";
+const VERSION = "0.0.1";
+
+const program = new Command();
+
+program
+  .name(CONNECTOR_NAME)
+  .description("Cloudflare Workers REST API CLI")
+  .version(VERSION)
+  .option("-f, --format <format>", "Output format (json, pretty)", "pretty")
+  .option("--api-token <token>", "Cloudflare API token")
+  .option("--account-id <id>", "Cloudflare account ID")
+  .option("--base-url <url>", "Cloudflare API base URL");
+
+function globalOptions(): Record<string, unknown> {
+  return program.opts() as Record<string, unknown>;
+}
+
+function optionString(source: Record<string, unknown>, key: string): string | undefined {
+  const value = source[key];
+  return typeof value === "string" ? value : undefined;
+}
+
+function getFormat(): OutputFormat {
+  return (optionString(globalOptions(), "format") || "pretty") as OutputFormat;
+}
+
+function client(): CloudflareWorkers {
+  const opts = globalOptions();
+  return new CloudflareWorkers({
+    apiToken: optionString(opts, "apiToken") || getApiToken(),
+    accountId: optionString(opts, "accountId") || getAccountId(),
+    baseUrl: optionString(opts, "baseUrl") || getBaseUrl(),
+  });
+}
+
+function parseJsonValue(value: string | undefined, label: string, fallback: JsonValue | undefined): JsonValue | undefined {
+  if (!value) return fallback;
+  try {
+    return JSON.parse(value) as JsonValue;
+  } catch (err) {
+    throw new Error(`Invalid ${label}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+
+function parseJsonObject(value: string | undefined, label: string, fallback: JsonObject = {}): JsonObject {
+  const parsed = parseJsonValue(value, label, fallback);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error(`${label} must be a JSON object`);
+  return parsed as JsonObject;
+}
+
+function optionalJsonObject(value: string | undefined, label: string): JsonObject | undefined {
+  if (!value) return undefined;
+  return parseJsonObject(value, label);
+}
+
+function toQueryValue(value: unknown, label: string): QueryValue | QueryValue[] {
+  if (value === undefined || value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value as QueryValue;
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      if (item !== null && typeof item !== "string" && typeof item !== "number" && typeof item !== "boolean") {
+        throw new Error(`${label} array values must be string, number, boolean, or null`);
+      }
+    }
+    return value as QueryValue[];
+  }
+  throw new Error(`${label} must be string, number, boolean, array, null, or undefined`);
+}
+
+function params(source: Record<string, unknown>): QueryParams {
+  const parsed = parseJsonObject(optionString(source, "params"), "params", {});
+  const output: QueryParams = {};
+  for (const [key, value] of Object.entries(parsed)) output[key] = toQueryValue(value, `params.${key}`);
+  return output;
+}
+
+function body(source: Record<string, unknown>): JsonObject {
+  return parseJsonObject(optionString(source, "body"), "body");
+}
+
+function bodyValue(source: Record<string, unknown>): JsonValue {
+  const parsed = parseJsonValue(optionString(source, "body"), "body", undefined);
+  if (parsed === undefined) throw new Error("body is required");
+  return parsed;
+}
+
+function scriptBody(source: Record<string, unknown>): string | Uint8Array {
+  const file = optionString(source, "file");
+  if (file) return readFileSync(file);
+  const text = optionString(source, "text");
+  if (text !== undefined) return text;
+  throw new Error("upload-script requires --file or --text");
+}
+
+function method(value: unknown): HttpMethod {
+  const input = typeof value === "string" ? value.toUpperCase() : "GET";
+  if (!["GET", "POST", "PUT", "PATCH", "DELETE"].includes(input)) throw new Error("method must be one of GET, POST, PUT, PATCH, DELETE");
+  return input as HttpMethod;
+}
+
+async function run(action: () => Promise<unknown>): Promise<void> {
+  try {
+    print(await action(), getFormat());
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}
+
+const configCmd = program.command("config").description("Manage CLI configuration");
+
+configCmd.command("set-token <apiToken>").description("Store a Cloudflare API token").action((apiToken: string) => {
+  setApiToken(apiToken);
+  success("API token saved");
+});
+
+configCmd.command("set-account <accountId>").description("Store a Cloudflare account ID").action((accountId: string) => {
+  setAccountId(accountId);
+  success("Account ID saved");
+});
+
+configCmd.command("set-base-url <baseUrl>").description("Store the Cloudflare API base URL").action((baseUrl: string) => {
+  setBaseUrl(baseUrl);
+  success(`Base URL set to ${baseUrl}`);
+});
+
+configCmd.command("show").description("Show current configuration").action(() => {
+  const api = client();
+  const stored = loadConfig();
+  info(`API token: ${getApiToken() ? "configured" : "not set"}`);
+  info(`Account ID: ${getAccountId() ? "configured" : "not set"}`);
+  info(`Base URL: ${api.getBaseUrl()}`);
+  if (Object.keys(stored).length > 0) info("Stored config file is present");
+});
+
+configCmd.command("clear").description("Clear saved configuration").action(() => {
+  clearConfig();
+  success("Configuration cleared");
+});
+
+program.command("list-scripts").description("List Workers scripts").option("--params <json>", "Query parameters JSON").action((opts: Record<string, unknown>) => run(() => client().listScripts(params(opts))));
+program.command("get-script <scriptName>").description("Get Workers script metadata").action((scriptName: string) => run(() => client().getScript(scriptName)));
+program.command("script-content <scriptName>").description("Get Workers script source text").action((scriptName: string) => run(() => client().getScriptContent(scriptName)));
+program.command("upload-script <scriptName>").description("Upload a Workers script as multipart form data").option("--file <path>", "Read script body from file").option("--text <value>", "Use text as script body").option("--metadata <json>", "Worker metadata JSON").option("--filename <name>", "Script part filename").option("--content-type <type>", "Script Content-Type").action((scriptName: string, opts: Record<string, unknown>) => run(() => client().uploadScript(scriptName, scriptBody(opts), {
+  metadata: optionalJsonObject(optionString(opts, "metadata"), "metadata"),
+  filename: optionString(opts, "filename"),
+  contentType: optionString(opts, "contentType"),
+})));
+program.command("delete-script <scriptName>").description("Delete a Workers script").action((scriptName: string) => run(() => client().deleteScript(scriptName)));
+
+program.command("get-settings <scriptName>").description("Get script settings").action((scriptName: string) => run(() => client().getScriptSettings(scriptName)));
+program.command("update-settings <scriptName>").description("Patch script settings").requiredOption("--body <json>", "Settings JSON body").action((scriptName: string, opts: Record<string, unknown>) => run(() => client().updateScriptSettings(scriptName, body(opts))));
+program.command("list-deployments <scriptName>").description("List script deployments").action((scriptName: string) => run(() => client().listDeployments(scriptName)));
+program.command("create-deployment <scriptName>").description("Create a script deployment").requiredOption("--body <json>", "Deployment JSON body").action((scriptName: string, opts: Record<string, unknown>) => run(() => client().createDeployment(scriptName, body(opts))));
+program.command("list-versions <scriptName>").description("List script versions").action((scriptName: string) => run(() => client().listVersions(scriptName)));
+program.command("get-version <scriptName> <versionId>").description("Get a script version").action((scriptName: string, versionId: string) => run(() => client().getVersion(scriptName, versionId)));
+program.command("list-secrets <scriptName>").description("List script secrets").action((scriptName: string) => run(() => client().listSecrets(scriptName)));
+program.command("put-secret <scriptName>").description("Create or update a script secret").requiredOption("--body <json>", "Secret JSON body").action((scriptName: string, opts: Record<string, unknown>) => run(() => client().putSecret(scriptName, body(opts))));
+program.command("delete-secret <scriptName> <secretName>").description("Delete a script secret").action((scriptName: string, secretName: string) => run(() => client().deleteSecret(scriptName, secretName)));
+program.command("get-schedules <scriptName>").description("Get script cron schedules").action((scriptName: string) => run(() => client().getSchedules(scriptName)));
+program.command("put-schedules <scriptName>").description("Replace script cron schedules").requiredOption("--body <json>", "Schedules JSON body").action((scriptName: string, opts: Record<string, unknown>) => run(() => client().putSchedules(scriptName, body(opts))));
+program.command("create-tail <scriptName>").description("Create a Workers tail").action((scriptName: string) => run(() => client().createTail(scriptName)));
+program.command("delete-tail <scriptName> <tailId>").description("Delete a Workers tail").action((scriptName: string, tailId: string) => run(() => client().deleteTail(scriptName, tailId)));
+
+program.command("get-account-subdomain").description("Get the account Workers subdomain").action(() => run(() => client().getAccountSubdomain()));
+program.command("update-account-subdomain").description("Update the account Workers subdomain").requiredOption("--body <json>", "Subdomain JSON body").action((opts: Record<string, unknown>) => run(() => client().updateAccountSubdomain(body(opts))));
+program.command("get-script-subdomain <scriptName>").description("Get a script subdomain setting").action((scriptName: string) => run(() => client().getScriptSubdomain(scriptName)));
+program.command("update-script-subdomain <scriptName>").description("Update a script subdomain setting").requiredOption("--body <json>", "Script subdomain JSON body").action((scriptName: string, opts: Record<string, unknown>) => run(() => client().updateScriptSubdomain(scriptName, body(opts))));
+
+program.command("list-routes <zoneId>").description("List zone Workers routes").action((zoneId: string) => run(() => client().listRoutes(zoneId)));
+program.command("get-route <zoneId> <routeId>").description("Get a zone Workers route").action((zoneId: string, routeId: string) => run(() => client().getRoute(zoneId, routeId)));
+program.command("create-route <zoneId>").description("Create a zone Workers route").requiredOption("--body <json>", "Route JSON body").action((zoneId: string, opts: Record<string, unknown>) => run(() => client().createRoute(zoneId, body(opts))));
+program.command("update-route <zoneId> <routeId>").description("Update a zone Workers route").requiredOption("--body <json>", "Route JSON body").action((zoneId: string, routeId: string, opts: Record<string, unknown>) => run(() => client().updateRoute(zoneId, routeId, body(opts))));
+program.command("delete-route <zoneId> <routeId>").description("Delete a zone Workers route").action((zoneId: string, routeId: string) => run(() => client().deleteRoute(zoneId, routeId)));
+
+program.command("get-account-settings").description("Get Workers account settings").action(() => run(() => client().getAccountSettings()));
+program.command("update-account-settings").description("Patch Workers account settings").requiredOption("--body <json>", "Account settings JSON body").action((opts: Record<string, unknown>) => run(() => client().updateAccountSettings(body(opts))));
+
+program.command("list-beta-workers").description("List beta Workers").option("--params <json>", "Query parameters JSON").action((opts: Record<string, unknown>) => run(() => client().listBetaWorkers(params(opts))));
+program.command("create-beta-worker").description("Create a beta Worker").requiredOption("--body <json>", "Beta Worker JSON body").action((opts: Record<string, unknown>) => run(() => client().createBetaWorker(body(opts))));
+program.command("get-beta-worker <workerId>").description("Get a beta Worker").action((workerId: string) => run(() => client().getBetaWorker(workerId)));
+program.command("delete-beta-worker <workerId>").description("Delete a beta Worker").action((workerId: string) => run(() => client().deleteBetaWorker(workerId)));
+program.command("list-beta-versions <workerId>").description("List beta Worker versions").action((workerId: string) => run(() => client().listBetaVersions(workerId)));
+program.command("create-beta-version <workerId>").description("Create a beta Worker version").requiredOption("--body <json>", "Beta version JSON body").action((workerId: string, opts: Record<string, unknown>) => run(() => client().createBetaVersion(workerId, body(opts))));
+program.command("get-beta-version <workerId> <versionId>").description("Get a beta Worker version").action((workerId: string, versionId: string) => run(() => client().getBetaVersion(workerId, versionId)));
+
+program
+  .command("raw <path>")
+  .description("Run a constrained raw Cloudflare Workers API request")
+  .option("-X, --method <method>", "HTTP method", "GET")
+  .option("--params <json>", "Query parameters JSON")
+  .option("--body <json>", "Request JSON body")
+  .action((path: string, opts: Record<string, unknown>) => run(() => client().rawRequest(method(opts.method), path, {
+    query: params(opts),
+    body: optionString(opts, "body") ? bodyValue(opts) : undefined,
+  })));
+
+program.parse();

package/connectors/cloudflare-workers/src/index.ts

@@ -0,0 +1,16 @@
+export { CloudflareWorkers, CloudflareWorkersClient } from "./api";
+export type {
+  CloudflareWorkersConfig,
+  CloudflareWorkersRawResponse,
+  CloudflareWorkersRequestOptions,
+  HttpMethod,
+  JsonObject,
+  JsonPrimitive,
+  JsonValue,
+  OutputFormat,
+  QueryParams,
+  QueryValue,
+  RequestBody,
+  ResponseType,
+} from "./types";
+export { CloudflareWorkersApiError } from "./types";

package/connectors/cloudflare-workers/src/types/index.ts

@@ -0,0 +1,53 @@
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonObject | JsonValue[];
+
+export interface JsonObject {
+  [key: string]: JsonValue | undefined;
+}
+
+export type OutputFormat = "json" | "pretty";
+export type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+
+export type QueryPrimitive = string | number | boolean;
+export type QueryValue = QueryPrimitive | Date | null | undefined;
+
+export interface QueryParams {
+  [key: string]: QueryValue | QueryValue[];
+}
+
+export type RequestBody = JsonValue | string | Uint8Array | ArrayBuffer | Blob | FormData;
+export type ResponseType = "json" | "text" | "arrayBuffer";
+
+export interface CloudflareWorkersConfig {
+  apiToken?: string;
+  accountId?: string;
+  baseUrl?: string;
+  timeoutMs?: number;
+}
+
+export interface CloudflareWorkersRawResponse {
+  status: number;
+  headers: Record<string, string>;
+  body: ArrayBuffer;
+}
+
+export interface CloudflareWorkersRequestOptions {
+  method?: HttpMethod;
+  query?: QueryParams;
+  body?: RequestBody;
+  headers?: Record<string, string>;
+  rawBody?: boolean;
+  responseType?: ResponseType;
+  signal?: AbortSignal;
+}
+
+export class CloudflareWorkersApiError extends Error {
+  constructor(
+    message: string,
+    readonly status?: number,
+    readonly details?: unknown,
+  ) {
+    super(message);
+    this.name = "CloudflareWorkersApiError";
+  }
+}

package/connectors/cloudflare-workers/src/utils/config.ts

@@ -0,0 +1,61 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+interface StoredConfig {
+  apiToken?: string;
+  accountId?: string;
+  baseUrl?: string;
+}
+
+const configPath = join(homedir(), ".hasna", "connectors", "cloudflare-workers.json");
+
+function readConfig(): StoredConfig {
+  if (!existsSync(configPath)) return {};
+  try {
+    return JSON.parse(readFileSync(configPath, "utf8")) as StoredConfig;
+  } catch {
+    return {};
+  }
+}
+
+function writeConfig(config: StoredConfig): void {
+  mkdirSync(dirname(configPath), { recursive: true });
+  writeFileSync(configPath, JSON.stringify(config, null, 2));
+}
+
+export function getConfigPath(): string {
+  return configPath;
+}
+
+export function getApiToken(): string | undefined {
+  return process.env.CLOUDFLARE_WORKERS_API_TOKEN || process.env.CLOUDFLARE_API_TOKEN || readConfig().apiToken;
+}
+
+export function setApiToken(apiToken: string): void {
+  writeConfig({ ...readConfig(), apiToken });
+}
+
+export function getAccountId(): string | undefined {
+  return process.env.CLOUDFLARE_WORKERS_ACCOUNT_ID || process.env.CLOUDFLARE_ACCOUNT_ID || readConfig().accountId;
+}
+
+export function setAccountId(accountId: string): void {
+  writeConfig({ ...readConfig(), accountId });
+}
+
+export function getBaseUrl(): string | undefined {
+  return process.env.CLOUDFLARE_WORKERS_BASE_URL || readConfig().baseUrl;
+}
+
+export function setBaseUrl(baseUrl: string): void {
+  writeConfig({ ...readConfig(), baseUrl });
+}
+
+export function loadConfig(): StoredConfig {
+  return readConfig();
+}
+
+export function clearConfig(): void {
+  if (existsSync(configPath)) rmSync(configPath);
+}

package/connectors/cloudflare-workers/src/utils/output.ts

@@ -0,0 +1,26 @@
+import chalk from "chalk";
+import type { OutputFormat } from "../types";
+
+export function print(data: unknown, format: OutputFormat = "pretty"): void {
+  if (format === "json") {
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+  if (typeof data === "string") {
+    console.log(data);
+    return;
+  }
+  console.log(JSON.stringify(data, null, 2));
+}
+
+export function success(message: string): void {
+  console.log(chalk.green(message));
+}
+
+export function info(message: string): void {
+  console.log(chalk.cyan(message));
+}
+
+export function error(message: string): void {
+  console.error(chalk.red(message));
+}

package/connectors/cloudflare-workers/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["node_modules", "dist", "bin", "src/**/*.test.ts"]
+}

package/connectors/cloudflare-workers/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "outDir": "dist",
+    "types": ["bun-types"]
+  },
+  "include": ["src/**/*.ts"]
+}

package/connectors/tidio/.env.example

@@ -1,2 +1,3 @@
-# Tidio OpenAPI key (Developer > OpenAPI in Tidio panel)
-TIDIO_API_KEY=your-api-key-here
+# Tidio OpenAPI credentials from Developer > OpenAPI in the Tidio panel.
+TIDIO_CLIENT_ID=ci_your_client_id_here
+TIDIO_CLIENT_SECRET=cs_your_client_secret_here

package/connectors/tidio/CLAUDE.md

@@ -1,105 +1,30 @@
-# CLAUDE.md
+# connect-tidio
 
-This file provides guidance to Claude Code when working with the connect-tidio connector.
+Tidio OpenAPI connector package.
 
-## Project Overview
+## Current API Contract
 
-connect-tidio is a TypeScript connector for the Tidio OpenAPI. It provides CLI and library access to manage contacts, conversations, operators, departments, tags, automations, canned responses, webhooks, and project settings.
+- Base URL: `https://api.tidio.com/`
+- Accept header: `application/json; version=1`
+- Auth headers:
+  - `X-Tidio-Openapi-Client-Id`
+  - `X-Tidio-Openapi-Client-Secret`
 
-## Build & Run Commands
+Do not reintroduce the legacy `https://api.tidio.co/v1` base URL or a single `X-Tidio-Openapi-Key` header.
 
-```bash
-bun install
-bun run dev
-bun run build
-bun run typecheck
-bun run dev contact list
-bun run dev conversation list
-bun run dev project get
-bun run dev config show
-```
+## Supported Areas
 
-## API Details
+- Contacts and contact properties
+- Contact messages at `/contacts/{contactId}/messages`
+- Departments
+- Operators
+- Project info
+- Tickets
+- Products for Lyro recommendations
+- Lyro data sources and ticket answering helpers
 
-- **Base URL**: `https://api.tidio.co/v1`
-- **Auth**: Custom header `X-Tidio-Openapi-Key: <api_key>` (NOT Bearer token)
-- **Format**: JSON REST
-- **Docs**: https://developers.tidio.com/reference
+Do not add undocumented CRUD helpers for `/conversations`, `/tags`, `/automations`, `/canned-responses`, or `/webhooks` unless the current Tidio docs prove those OpenAPI paths exist.
 
-## Project Structure
+## Security
 
-```
-src/
-├── api/
-│   ├── client.ts     # HTTP client with X-Tidio-Openapi-Key auth and retry
-│   └── index.ts      # Tidio API wrapper class
-├── cli/
-│   └── index.ts      # CLI commands
-├── types/
-│   └── index.ts      # Type definitions
-├── utils/
-│   ├── config.ts     # Multi-profile configuration
-│   └── output.ts     # CLI output formatting
-└── index.ts          # Library exports
-```
-
-## API Coverage
-
-### Contacts
-- List, get, create, update, delete contacts
-
-### Conversations
-- List, get conversations
-- List and send messages
-- Set status (open/closed/snoozed)
-- Assign to operator or department
-
-### Operators & Departments
-- List and get operators
-- List departments
-
-### Tags
-- List, create, delete tags
-
-### Automations
-- List automations
-
-### Canned Responses
-- List and create canned responses
-
-### Webhooks
-- List, create, delete webhooks
-
-### Project
-- Get project details
-
-## Authentication
-
-Uses API key authentication with the Tidio OpenAPI:
-
-```typescript
-'X-Tidio-Openapi-Key': apiKey
-```
-
-Generate the key in Tidio Panel under **Developer > OpenAPI**.
-
-## Environment Variables
-
-| Variable | Description |
-|----------|-------------|
-| `TIDIO_API_KEY` | OpenAPI key (overrides profile) |
-
-## Data Storage
-
-```
-~/.hasna/connectors/connect-tidio/
-├── current_profile   # Active profile name
-└── profiles/
-    ├── default.json
-    └── {name}.json
-```
-
-## Dependencies
-
-- commander: CLI framework
-- chalk: Terminal styling
+Profiles store client id and client secret under the connector config directory. Keep config directories `0700`, profile files `0600`, and validate profile names before joining filesystem paths.

package/connectors/tidio/README.md

@@ -1,14 +1,18 @@
 # connect-tidio
 
-TypeScript connector for the [Tidio OpenAPI](https://developers.tidio.com/reference). Manage live chat contacts, conversations, operators, tags, webhooks, and more.
+TypeScript connector for the [Tidio OpenAPI](https://developers.tidio.com/reference).
 
 ## Features
 
-- Multi-profile configuration
-- `X-Tidio-Openapi-Key` authentication
-- Contacts, conversations, operators, departments, tags, automations, canned responses, webhooks
+- Tidio OpenAPI v1 server: `https://api.tidio.com/`
+- Required `Accept: application/json; version=1` requests
+- `X-Tidio-Openapi-Client-Id` and `X-Tidio-Openapi-Client-Secret` authentication
+- Contacts, contact messages, departments, operators, project info, tickets, products, and Lyro data source helpers
+- Secure local profiles with private config directories and profile files
 - Pretty and JSON output formats
-- Automatic retry on rate limits (429) and server errors (5xx)
+- Automatic retry on rate limits and server errors
+
+This connector intentionally does not expose undocumented `/conversations`, `/tags`, `/automations`, `/canned-responses`, or `/webhooks` CRUD paths.
 
 ## Quick Start
 
@@ -16,30 +20,30 @@ TypeScript connector for the [Tidio OpenAPI](https://developers.tidio.com/refere
 cd connectors/tidio
 bun install
 bun run dev --help
-bun run dev config set-key YOUR_API_KEY
-bun run dev project get
+bun run dev config set-credentials ci_your_client_id cs_your_client_secret
+bun run dev project
 ```
 
 ## Environment Variables
 
 | Variable | Description |
 |----------|-------------|
-| `TIDIO_API_KEY` | OpenAPI key (overrides profile) |
+| `TIDIO_CLIENT_ID` | OpenAPI client id, prefixed by `ci_` |
+| `TIDIO_CLIENT_SECRET` | OpenAPI client secret, prefixed by `cs_` |
+
+Environment variables override the active profile.
 
 ## CLI Commands
 
 ```bash
-connect-tidio contact list|get|create|update|delete
-connect-tidio conversation list|get|messages|send|status|assign
-connect-tidio operator list|get
-connect-tidio department list
-connect-tidio tag list|create|delete
-connect-tidio automation list
-connect-tidio canned-response list|create
-connect-tidio webhook list|create|delete
-connect-tidio project get
+connect-tidio contact list|get|create|update|delete|properties|viewed-pages|messages|send-message
+connect-tidio operator
+connect-tidio department
+connect-tidio project
+connect-tidio ticket list|get|reply|tags|custom-fields
+connect-tidio lyro sources|ask-ticket
 connect-tidio profile list|use|create|delete|show
-connect-tidio config set-key|show|clear
+connect-tidio config set-credentials|show|clear
 ```
 
 ## Build

package/connectors/tidio/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hasna/connect-tidio",
   "version": "0.0.1",
-  "description": "Tidio connector - Live chat support, contacts, conversations, and operators",
+  "description": "Tidio OpenAPI connector - contacts, contact messages, departments, operators, project, tickets, products, and Lyro",
   "type": "module",
   "bin": {
     "connect-tidio": "./bin/index.js"
@@ -25,6 +25,8 @@
     "live-chat",
     "support",
     "messaging",
+    "tickets",
+    "lyro",
     "connector",
     "cli",
     "typescript",
@@ -45,6 +47,6 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/hasna/connect-tidio.git"
+    "url": "git+https://github.com/hasna/connectors.git"
   }
 }