tentacle-sdk 0.0.1

package/dist/index.cjs

@@ -0,0 +1,889 @@
+'use strict';
+
+// src/http.ts
+var TentacleError = class extends Error {
+  constructor(message, status, code) {
+    super(message);
+    this.name = "TentacleError";
+    this.status = status;
+    this.code = code;
+  }
+};
+var HttpClient = class {
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+    this.accessToken = config.accessToken;
+  }
+  /**
+   * Get the headers for a request.
+   */
+  getHeaders() {
+    const headers = new Headers();
+    headers.set("Content-Type", "application/json");
+    if (this.accessToken) {
+      headers.set("Authorization", `Bearer ${this.accessToken}`);
+    }
+    return headers;
+  }
+  /**
+   * Build the tRPC URL for a procedure call.
+   *
+   * @param procedure - Full procedure path (e.g., "apps.list")
+   * @param input - Optional input for queries (will be URL encoded)
+   */
+  buildTrpcUrl(procedure, input) {
+    const url = new URL(`${this.baseUrl}/api/trpc/${procedure}`);
+    if (input !== void 0) {
+      url.searchParams.set("input", JSON.stringify(input));
+    }
+    return url.toString();
+  }
+  /**
+   * Handle the tRPC response.
+   */
+  async handleResponse(response) {
+    const data = await response.json();
+    if (data.error) {
+      const message = data.error.message || `Request failed with status ${response.status}`;
+      const code = data.error.data?.code;
+      const status = data.error.data?.httpStatus || response.status;
+      throw new TentacleError(message, status, code);
+    }
+    if (!response.ok) {
+      throw new TentacleError(`Request failed with status ${response.status}`, response.status);
+    }
+    if (data.result?.data === void 0) {
+      throw new TentacleError("Invalid response: missing result data", response.status);
+    }
+    return data.result.data;
+  }
+  /**
+   * Make a tRPC query (GET request).
+   *
+   * @param procedure - Full procedure path (e.g., "apps.list")
+   * @param input - Optional input data
+   * @returns The response data
+   * @throws {TentacleError} If the request fails
+   */
+  async query(procedure, input) {
+    const url = this.buildTrpcUrl(procedure, input);
+    const response = await fetch(url, {
+      method: "GET",
+      headers: this.getHeaders()
+    });
+    return this.handleResponse(response);
+  }
+  /**
+   * Make a tRPC mutation (POST request).
+   *
+   * @param procedure - Full procedure path (e.g., "apps.create")
+   * @param input - Input data for the mutation
+   * @returns The response data
+   * @throws {TentacleError} If the request fails
+   */
+  async mutate(procedure, input) {
+    const url = this.buildTrpcUrl(procedure);
+    const response = await fetch(url, {
+      method: "POST",
+      headers: this.getHeaders(),
+      body: JSON.stringify(input)
+    });
+    return this.handleResponse(response);
+  }
+  /**
+   * Get the base URL for SSE connections.
+   */
+  getBaseUrl() {
+    return this.baseUrl;
+  }
+  /**
+   * Get the access token for SSE connections.
+   */
+  getAccessToken() {
+    return this.accessToken;
+  }
+};
+
+// src/realtime.ts
+function createRealtimeSubscription(baseUrl, accessToken, options) {
+  const url = `${baseUrl}/api/trpc/realtime.subscribe`;
+  const controller = new AbortController();
+  const connect = async () => {
+    try {
+      const response = await fetch(url, {
+        method: "GET",
+        headers: {
+          Accept: "text/event-stream",
+          Authorization: `Bearer ${accessToken}`,
+          "Cache-Control": "no-cache"
+        },
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to connect: ${response.status} ${response.statusText}`);
+      }
+      if (!response.body) {
+        throw new Error("Response body is null");
+      }
+      options.onOpen?.();
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          options.onClose?.();
+          break;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        let eventData = "";
+        for (const line of lines) {
+          if (line.startsWith("data: ")) {
+            eventData += line.slice(6);
+          } else if (line === "" && eventData) {
+            try {
+              const parsed = JSON.parse(eventData);
+              if (parsed.error) {
+                options.onError?.(new Error(parsed.error.message));
+              } else if (parsed.result?.data) {
+                if (parsed.result.data.kind !== "ConnectionConfirmed") {
+                  options.onEvent(parsed.result.data);
+                }
+              }
+            } catch (parseError) {
+              console.error("Failed to parse SSE event:", parseError);
+            }
+            eventData = "";
+          }
+        }
+      }
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        options.onClose?.();
+        return;
+      }
+      options.onError?.(error instanceof Error ? error : new Error(String(error)));
+      if (!controller.signal.aborted) {
+        setTimeout(() => {
+          if (!controller.signal.aborted) {
+            void connect();
+          }
+        }, 5e3);
+      }
+    }
+  };
+  void connect();
+  return () => {
+    controller.abort();
+  };
+}
+var RealtimeApi = class {
+  constructor(baseUrl, accessToken) {
+    this.baseUrl = baseUrl;
+    this.accessToken = accessToken;
+  }
+  /**
+   * Subscribe to realtime events from Twitch and Kick.
+   *
+   * This establishes a Server-Sent Events (SSE) connection to receive live updates:
+   * - **StreamChatMessage**: Chat messages from Twitch or Kick
+   * - **StreamEvent**: Events like follows, subscriptions, raids, cheers
+   * - **StreamViewerActivity**: Viewer activity updates
+   *
+   * Each event includes viewer data (when available) via the `$viewerId` field
+   * and platform-specific user info.
+   *
+   * @param options - Subscription options with event callbacks
+   * @returns Function to unsubscribe and close the connection
+   *
+   * @example
+   * ```typescript
+   * const unsubscribe = client.realtime.subscribe({
+   *   onEvent: (event) => {
+   *     switch (event.kind) {
+   *       case 'StreamChatMessage':
+   *         // Chat message from Twitch or Kick
+   *         const msg = event.payload
+   *         console.log(`[${msg.$platform}] ${msg.$text}`)
+   *         console.log(`Viewer ID: ${msg.$viewerId}`)
+   *         break
+   *
+   *       case 'StreamEvent':
+   *         // Stream event (follow, sub, raid, etc.)
+   *         const evt = event.payload
+   *         if (evt.$platform === 'twitch') {
+   *           switch (evt.$type) {
+   *             case 'channel.follow':
+   *               console.log(`New Twitch follower: ${evt.userDisplayName}`)
+   *               break
+   *             case 'channel.subscribe':
+   *               console.log(`New Twitch sub: ${evt.userDisplayName}`)
+   *               break
+   *             case 'channel.raid':
+   *               console.log(`Raid from ${evt.fromBroadcasterUserName} with ${evt.viewers} viewers`)
+   *               break
+   *           }
+   *         } else if (evt.$platform === 'kick') {
+   *           switch (evt.$type) {
+   *             case 'channel.followed':
+   *               console.log(`New Kick follower: ${evt.username}`)
+   *               break
+   *             case 'channel.subscription.new':
+   *               console.log(`New Kick sub: ${evt.username}`)
+   *               break
+   *           }
+   *         }
+   *         break
+   *
+   *       case 'StreamViewerActivity':
+   *         console.log(`Viewer activity: ${event.payload.viewerId}`)
+   *         break
+   *     }
+   *   },
+   *   onError: (error) => console.error('Connection error:', error),
+   *   onOpen: () => console.log('Connected!'),
+   *   onClose: () => console.log('Disconnected'),
+   * })
+   *
+   * // When done, unsubscribe:
+   * unsubscribe()
+   * ```
+   *
+   * @throws {Error} If no access token is configured
+   */
+  subscribe(options) {
+    if (!this.accessToken) {
+      throw new Error("Access token is required for realtime subscription");
+    }
+    return createRealtimeSubscription(this.baseUrl, this.accessToken, options);
+  }
+};
+
+// src/auth/device-auth.ts
+var DeviceAuthFlow = class {
+  constructor(baseUrl) {
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+  }
+  /**
+   * Initiates a device authorization request.
+   *
+   * @param options - Options for the request.
+   * @returns Device and user codes for authorization.
+   */
+  async initiate(options = {}) {
+    const url = `${this.baseUrl}/api/trpc/access.initiateDeviceAuth`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ clientInfo: options.clientInfo })
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to initiate device auth: ${response.statusText}`);
+    }
+    const data = await response.json();
+    if (data.error) {
+      throw new Error(`Device auth error: ${data.error.message}`);
+    }
+    if (!data.result?.data) {
+      throw new Error("Invalid response from device auth endpoint");
+    }
+    return data.result.data;
+  }
+  /**
+   * Polls for the current authorization status.
+   *
+   * @param deviceCode - The device code from initiate().
+   * @returns Current authorization status.
+   */
+  async poll(deviceCode) {
+    const url = new URL(`${this.baseUrl}/api/trpc/access.pollDeviceAuth`);
+    url.searchParams.set("input", JSON.stringify({ deviceCode }));
+    const response = await fetch(url.toString(), {
+      method: "GET",
+      headers: { "Content-Type": "application/json" }
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to poll device auth: ${response.statusText}`);
+    }
+    const data = await response.json();
+    if (data.error) {
+      throw new Error(`Device auth poll error: ${data.error.message}`);
+    }
+    if (!data.result?.data) {
+      throw new Error("Invalid response from poll endpoint");
+    }
+    return data.result.data;
+  }
+  /**
+   * Polls until authorization is complete (approved, denied, or expired).
+   *
+   * @param deviceCode - The device code from initiate().
+   * @param intervalMs - Polling interval in milliseconds.
+   * @param timeoutMs - Maximum time to wait in milliseconds.
+   * @returns Final authorization result.
+   */
+  async pollUntilComplete(deviceCode, intervalMs = 5e3, timeoutMs = 6e5) {
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeoutMs) {
+      const result = await this.poll(deviceCode);
+      if (result.status !== "pending") {
+        return result;
+      }
+      await new Promise((resolve) => {
+        setTimeout(resolve, intervalMs);
+      });
+    }
+    return { status: "expired" };
+  }
+};
+async function validateAccessToken(baseUrl, token) {
+  const url = new URL(`${baseUrl.replace(/\/$/, "")}/api/trpc/access.getAccessTokenStatus`);
+  url.searchParams.set("input", JSON.stringify({ jwt: token }));
+  try {
+    const response = await fetch(url.toString(), {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`
+      }
+    });
+    if (!response.ok) {
+      return false;
+    }
+    const data = await response.json();
+    return data.result?.data.isValid ?? false;
+  } catch {
+    return false;
+  }
+}
+async function performDeviceAuth(options) {
+  const { baseUrl, credentialStore, deviceAuthOptions } = options;
+  const cachedToken = await credentialStore.getAccessToken();
+  if (cachedToken) {
+    const isValid = await validateAccessToken(baseUrl, cachedToken);
+    if (isValid) {
+      return cachedToken;
+    }
+    await credentialStore.clearAccessToken();
+  }
+  const flow = new DeviceAuthFlow(baseUrl);
+  const { deviceCode, userCode, verificationUrl, interval } = await flow.initiate({
+    clientInfo: deviceAuthOptions.clientInfo
+  });
+  deviceAuthOptions.onAuthRequired({ verificationUrl, userCode });
+  const timeoutMs = deviceAuthOptions.pollTimeout ?? 6e5;
+  const result = await flow.pollUntilComplete(deviceCode, interval * 1e3, timeoutMs);
+  if (result.status === "approved" && result.accessToken) {
+    await credentialStore.setAccessToken(result.accessToken);
+    deviceAuthOptions.onAuthApproved?.();
+    return result.accessToken;
+  }
+  if (result.status === "denied") {
+    deviceAuthOptions.onAuthDenied?.();
+    throw new Error("Device authorization was denied");
+  }
+  if (result.status === "expired") {
+    deviceAuthOptions.onAuthTimeout?.();
+    throw new Error("Device authorization timed out");
+  }
+  throw new Error(`Unexpected authorization status: ${result.status}`);
+}
+
+// src/client.ts
+var AppsApi = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Create a new app.
+   *
+   * @param options - App creation options
+   * @param options.name - Name of the app
+   * @returns The created app
+   *
+   * @example
+   * ```typescript
+   * const { app } = await client.apps.create({ name: "My Game" })
+   * console.log(`Created app: ${app.id}`)
+   * ```
+   */
+  async create(options) {
+    return this.http.mutate("apps.create", options);
+  }
+  /**
+   * List all apps for the current user.
+   *
+   * @returns Array of apps
+   *
+   * @example
+   * ```typescript
+   * const { apps } = await client.apps.list()
+   * for (const app of apps) {
+   *   console.log(`${app.name}: ${app.id}`)
+   * }
+   * ```
+   */
+  async list() {
+    return this.http.query("apps.list");
+  }
+  /**
+   * Get an app by name.
+   *
+   * @param options - Query options
+   * @param options.name - Name of the app
+   * @returns The app
+   *
+   * @example
+   * ```typescript
+   * const { app } = await client.apps.getByName({ name: "My Game" })
+   * console.log(`App ID: ${app.id}`)
+   * ```
+   */
+  async getByName(options) {
+    return this.http.query("apps.getByName", options);
+  }
+  /**
+   * List apps for a viewer.
+   * Requires viewer authentication.
+   *
+   * @param options - Query options
+   * @param options.where - Filter options
+   * @param options.where.isActive - Filter by active status
+   * @returns Array of apps
+   *
+   * @example
+   * ```typescript
+   * const { apps } = await client.apps.listForViewer({ where: { isActive: true } })
+   * ```
+   */
+  async listForViewer(options) {
+    return this.http.query("apps.listForViewer", options);
+  }
+  /**
+   * Create or update viewer properties.
+   *
+   * @param properties - Array of viewer properties to create/update
+   * @returns Success status
+   *
+   * @example
+   * ```typescript
+   * await client.apps.createViewerProperties([
+   *   { id: "prop1", appId: "app1", viewerId: "v1", name: "score", type: "number", value: 100 },
+   * ])
+   * ```
+   */
+  async createViewerProperties(properties) {
+    return this.http.mutate("apps.createViewerProperties", properties);
+  }
+  /**
+   * Update viewer properties.
+   *
+   * @param properties - Array of viewer properties to update
+   * @returns Success status
+   *
+   * @example
+   * ```typescript
+   * await client.apps.updateViewerProperties([
+   *   { id: "prop1", appId: "app1", viewerId: "v1", name: "score", type: "number", value: 150 },
+   * ])
+   * ```
+   */
+  async updateViewerProperties(properties) {
+    return this.http.mutate("apps.updateViewerProperties", properties);
+  }
+  /**
+   * Get viewers by property.
+   *
+   * @param options - Query options
+   * @param options.appId - App ID
+   * @param options.propertyName - Property name to query
+   * @param options.propertyType - Property type
+   * @param options.orderDirection - Order direction (asc/desc)
+   * @param options.take - Number of results (1-1000, default 20)
+   * @returns Viewers with the specified property
+   *
+   * @example
+   * ```typescript
+   * const result = await client.apps.getViewersByProperty({
+   *   appId: "app1",
+   *   propertyName: "score",
+   *   propertyType: "number",
+   *   orderDirection: "desc",
+   *   take: 10,
+   * })
+   * for (const viewer of result.viewers) {
+   *   console.log(`${viewer.twitch?.displayName}: ${viewer.properties.score.value}`)
+   * }
+   * ```
+   */
+  async getViewersByProperty(options) {
+    return this.http.query("apps.getViewersByProperty", options);
+  }
+};
+var StreamApi = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get the latest chat messages from Twitch and Kick.
+   *
+   * @param options - Query options
+   * @param options.take - Maximum number of messages to return (default: 50)
+   * @param options.isCommand - Filter to only command messages (starting with !)
+   * @returns Array of chat messages from both platforms
+   *
+   * @example
+   * ```typescript
+   * // Get latest 50 chat messages
+   * const messages = await client.stream.getChatMessages()
+   *
+   * // Get latest 10 command messages
+   * const commands = await client.stream.getChatMessages({
+   *   take: 10,
+   *   isCommand: true,
+   * })
+   *
+   * for (const msg of messages) {
+   *   console.log(`[${msg.$platform}] ${msg.$text}`)
+   * }
+   * ```
+   */
+  async getChatMessages(options) {
+    return this.http.query("stream.getLatestChatMessages", options);
+  }
+  /**
+   * Get the latest stream events from Twitch and Kick.
+   *
+   * Events include follows, subscriptions, raids, cheers, and more.
+   *
+   * @param options - Query options
+   * @param options.take - Maximum number of events to return (default: 50)
+   * @returns Array of stream events from both platforms
+   *
+   * @example
+   * ```typescript
+   * const events = await client.stream.getEvents({ take: 20 })
+   *
+   * for (const event of events) {
+   *   if (event.$platform === 'twitch') {
+   *     switch (event.$type) {
+   *       case 'channel.follow':
+   *         console.log(`New follower: ${event.userDisplayName}`)
+   *         break
+   *       case 'channel.subscribe':
+   *         console.log(`New subscriber: ${event.userDisplayName}`)
+   *         break
+   *     }
+   *   }
+   * }
+   * ```
+   */
+  async getEvents(options) {
+    return this.http.query("stream.getLatestEvents", options);
+  }
+};
+var SubathonApi = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get subscription stats.
+   *
+   * @returns Subscription statistics
+   *
+   * @example
+   * ```typescript
+   * const stats = await client.subathonStats.getSubs()
+   * console.log(`Subs: ${stats.count}/${stats.goal}`)
+   * ```
+   */
+  async getSubs() {
+    return this.http.query("subathonStats.subs");
+  }
+  /**
+   * Get gifted subscription stats.
+   *
+   * @returns Gifted subscription statistics
+   *
+   * @example
+   * ```typescript
+   * const stats = await client.subathonStats.getGiftedSubs()
+   * console.log(`Gifted subs: ${stats.count}`)
+   * ```
+   */
+  async getGiftedSubs() {
+    return this.http.query("subathonStats.giftedSubs");
+  }
+  /**
+   * Get donation stats.
+   *
+   * @returns Donation statistics
+   *
+   * @example
+   * ```typescript
+   * const stats = await client.subathonStats.getDonations()
+   * console.log(`Donations: $${stats.dollars}`)
+   * ```
+   */
+  async getDonations() {
+    return this.http.query("subathonStats.donations");
+  }
+  /**
+   * Get subscription stats for overlay.
+   * Public endpoint - no authentication required.
+   *
+   * @param options - Query options
+   * @param options.email - User email
+   * @returns Subscription statistics or null if user not found
+   *
+   * @example
+   * ```typescript
+   * const stats = await client.subathonStats.getOverlaySubs({ email: "user@example.com" })
+   * if (stats) {
+   *   console.log(`Subs: ${stats.count}`)
+   * }
+   * ```
+   */
+  async getOverlaySubs(options) {
+    return this.http.query("subathonStats.overlaySubs", options);
+  }
+  /**
+   * Get gifted subscription stats for overlay.
+   * Public endpoint - no authentication required.
+   *
+   * @param options - Query options
+   * @param options.email - User email
+   * @returns Gifted subscription statistics or null if user not found
+   *
+   * @example
+   * ```typescript
+   * const stats = await client.subathonStats.getOverlayGiftedSubs({ email: "user@example.com" })
+   * ```
+   */
+  async getOverlayGiftedSubs(options) {
+    return this.http.query("subathonStats.overlayGiftedSubs", options);
+  }
+  /**
+   * Get donation stats for overlay.
+   * Public endpoint - no authentication required.
+   *
+   * @param options - Query options
+   * @param options.email - User email
+   * @returns Donation statistics or null if user not found
+   *
+   * @example
+   * ```typescript
+   * const stats = await client.subathonStats.getOverlayDonations({ email: "user@example.com" })
+   * ```
+   */
+  async getOverlayDonations(options) {
+    return this.http.query("subathonStats.overlayDonations", options);
+  }
+};
+var ViewerApi = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Create a viewer action.
+   * Requires viewer authentication.
+   *
+   * @param options - Action options
+   * @param options.name - Action name
+   * @param options.data - Action data
+   * @param options.appId - App ID
+   * @returns Success status
+   *
+   * @example
+   * ```typescript
+   * await client.viewer.createAction({
+   *   name: "button_click",
+   *   data: { buttonId: "play" },
+   *   appId: "app1",
+   * })
+   * ```
+   */
+  async createAction(options) {
+    return this.http.mutate("viewer.createViewerAction", options);
+  }
+  /**
+   * Get mini viewer data.
+   *
+   * @param options - Query options
+   * @param options.viewerId - Viewer ID
+   * @returns Viewer mini data
+   *
+   * @example
+   * ```typescript
+   * const viewer = await client.viewer.getMini({ viewerId: "v1" })
+   * console.log(`Twitch: ${viewer.twitch?.displayName}`)
+   * ```
+   */
+  async getMini(options) {
+    return this.http.query("viewer.getViewerMini", options);
+  }
+  /**
+   * Get full viewer data including properties.
+   *
+   * @param options - Query options
+   * @param options.viewerId - Viewer ID
+   * @returns Full viewer data
+   *
+   * @example
+   * ```typescript
+   * const viewer = await client.viewer.get({ viewerId: "v1" })
+   * console.log(`Twitch: ${viewer.twitch?.displayName}`)
+   * if (viewer.properties) {
+   *   for (const [name, prop] of Object.entries(viewer.properties)) {
+   *     console.log(`${name}: ${prop.value}`)
+   *   }
+   * }
+   * ```
+   */
+  async get(options) {
+    return this.http.query("viewer.getViewerFull", options);
+  }
+};
+var TentacleClient = class _TentacleClient {
+  /**
+   * Creates a TentacleClient with automatic authentication.
+   *
+   * This factory method handles the device authorization flow:
+   * 1. Checks for a cached token in the credential store
+   * 2. Validates the cached token with the API
+   * 3. If invalid or missing, initiates device authorization
+   * 4. Caches the new token after successful authorization
+   *
+   * @param options - Creation options
+   * @returns A configured TentacleClient
+   *
+   * @example
+   * ```typescript
+   * const client = await TentacleClient.create({
+   *   baseUrl: "https://api.tentacle.live",
+   *   credentialStore: new FileCredentialStore(),
+   *   deviceAuthOptions: {
+   *     clientInfo: "My Unreal Game",
+   *     onAuthRequired: ({ verificationUrl, userCode }) => {
+   *       console.log(`Visit: ${verificationUrl}`)
+   *       console.log(`Enter code: ${userCode}`)
+   *     },
+   *   },
+   * })
+   * ```
+   */
+  static async create(options) {
+    const accessToken = await performDeviceAuth({
+      baseUrl: options.baseUrl,
+      credentialStore: options.credentialStore,
+      deviceAuthOptions: options.deviceAuthOptions
+    });
+    return new _TentacleClient({
+      baseUrl: options.baseUrl,
+      accessToken
+    });
+  }
+  /**
+   * Create a new Tentacle client.
+   *
+   * @param config - Client configuration
+   * @param config.baseUrl - Base URL of the Tentacle API
+   * @param config.accessToken - Access token for authentication
+   *
+   * @example
+   * ```typescript
+   * const client = new TentacleClient({
+   *   baseUrl: 'https://api.tentacle.live',
+   *   accessToken: 'your-access-token',
+   * })
+   * ```
+   */
+  constructor(config) {
+    this.http = new HttpClient(config);
+    this.apps = new AppsApi(this.http);
+    this.realtime = new RealtimeApi(config.baseUrl, config.accessToken);
+    this.stream = new StreamApi(this.http);
+    this.subathon = new SubathonApi(this.http);
+    this.viewer = new ViewerApi(this.http);
+  }
+};
+
+// src/auth/file-credential-store.ts
+var FileCredentialStore = class {
+  constructor(options = {}) {
+    this.path = options.path ?? this.getDefaultPath();
+  }
+  /**
+   * Gets the default credentials file path.
+   */
+  getDefaultPath() {
+    const home = process.env.HOME || process.env.USERPROFILE || "";
+    return `${home}/.tentacle/credentials.json`;
+  }
+  /**
+   * Retrieves the stored access token.
+   */
+  async getAccessToken() {
+    try {
+      const fs = await import('fs/promises');
+      const content = await fs.readFile(this.path, "utf-8");
+      const data = JSON.parse(content);
+      return data.accessToken ?? null;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Stores an access token.
+   *
+   * Creates the directory if it doesn't exist.
+   * Sets file permissions to 0o600 (user read/write only).
+   */
+  async setAccessToken(token) {
+    const fs = await import('fs/promises');
+    const path = await import('path');
+    const dir = path.dirname(this.path);
+    await fs.mkdir(dir, { recursive: true, mode: 448 });
+    let existingData = {};
+    try {
+      const content = await fs.readFile(this.path, "utf-8");
+      existingData = JSON.parse(content);
+    } catch {
+    }
+    const data = {
+      ...existingData,
+      accessToken: token
+    };
+    await fs.writeFile(this.path, JSON.stringify(data, null, 2), {
+      mode: 384
+    });
+  }
+  /**
+   * Removes the stored access token.
+   */
+  async clearAccessToken() {
+    const fs = await import('fs/promises');
+    try {
+      const content = await fs.readFile(this.path, "utf-8");
+      const data = JSON.parse(content);
+      delete data.accessToken;
+      if (Object.keys(data).length === 0) {
+        await fs.unlink(this.path);
+      } else {
+        await fs.writeFile(this.path, JSON.stringify(data, null, 2), {
+          mode: 384
+        });
+      }
+    } catch {
+    }
+  }
+};
+
+exports.DeviceAuthFlow = DeviceAuthFlow;
+exports.FileCredentialStore = FileCredentialStore;
+exports.TentacleClient = TentacleClient;
+exports.TentacleError = TentacleError;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map