edilkamin 1.6.2 → 1.7.3

package/src/library.ts

@@ -1,7 +1,7 @@
 import { strict as assert } from "assert";
 import { Amplify } from "aws-amplify";
 import * as amplifyAuth from "aws-amplify/auth";
-import axios, { AxiosInstance } from "axios";
+import { cognitoUserPoolsTokenProvider } from "aws-amplify/auth/cognito";
 
 import { processResponse } from "./buffer-utils";
 import { API_URL } from "./constants";
@@ -13,6 +13,22 @@ import {
   EditDeviceAssociationBody,
 } from "./types";
 
+/**
+ * Makes a fetch request and returns parsed JSON response.
+ * Throws an error for non-2xx status codes.
+ */
+const fetchJson = async <T>(
+  baseURL: string,
+  path: string,
+  options: RequestInit = {},
+): Promise<T> => {
+  const response = await fetch(`${baseURL}${path}`, options);
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+  }
+  return response.json();
+};
+
 const amplifyconfiguration = {
   aws_project_region: "eu-central-1",
   aws_user_pools_id: "eu-central-1_BYmQ2VBlo",
@@ -31,10 +47,19 @@ let amplifyConfigured = false;
 /**
  * Configures Amplify if not already configured.
  * Uses a local flag to avoid calling getConfig() which prints a warning.
+ * @param {object} [storage] - Optional custom storage adapter for token persistence
  */
-const configureAmplify = () => {
+const configureAmplify = (storage?: {
+  setItem: (key: string, value: string) => Promise<void>;
+  getItem: (key: string) => Promise<string | null>;
+  removeItem: (key: string) => Promise<void>;
+  clear: () => Promise<void>;
+}) => {
   if (amplifyConfigured) return;
   Amplify.configure(amplifyconfiguration);
+  if (storage) {
+    cognitoUserPoolsTokenProvider.setKeyValueStorage(storage);
+  }
   amplifyConfigured = true;
 };
 
@@ -55,7 +80,7 @@ const createAuthService = (auth: typeof amplifyAuth) => {
   const signIn = async (
     username: string,
     password: string,
-    legacy: boolean = false
+    legacy: boolean = false,
   ): Promise<string> => {
     configureAmplify();
     await auth.signOut(); // Ensure the user is signed out first
@@ -70,14 +95,38 @@ const createAuthService = (auth: typeof amplifyAuth) => {
     assert.ok(tokens.idToken, "No ID token found");
     return tokens.idToken.toString();
   };
-  return { signIn };
+
+  /**
+   * Retrieves the current session, refreshing tokens if necessary.
+   * Requires a prior successful signIn() call.
+   * @param {boolean} [forceRefresh=false] - Force token refresh even if valid
+   * @param {boolean} [legacy=false] - If true, returns accessToken for legacy API
+   * @returns {Promise<string>} - The JWT token (idToken or accessToken)
+   * @throws {Error} - If no session exists (user needs to sign in)
+   */
+  const getSession = async (
+    forceRefresh: boolean = false,
+    legacy: boolean = false,
+  ): Promise<string> => {
+    configureAmplify();
+    const { tokens } = await auth.fetchAuthSession({ forceRefresh });
+    assert.ok(tokens, "No session found - please sign in first");
+    if (legacy) {
+      assert.ok(tokens.accessToken, "No access token found");
+      return tokens.accessToken.toString();
+    }
+    assert.ok(tokens.idToken, "No ID token found");
+    return tokens.idToken.toString();
+  };
+
+  return { signIn, getSession };
 };
 
 // Create the default auth service using amplifyAuth
-const { signIn } = createAuthService(amplifyAuth);
+const { signIn, getSession } = createAuthService(amplifyAuth);
 
 const deviceInfo =
-  (axiosInstance: AxiosInstance) =>
+  (baseURL: string) =>
   /**
    * Retrieves information about a device by its MAC address.
    * Automatically decompresses any gzip-compressed Buffer fields in the response.
@@ -87,28 +136,33 @@ const deviceInfo =
    * @returns {Promise<DeviceInfoType>} - A promise that resolves to the device info.
    */
   async (jwtToken: string, macAddress: string): Promise<DeviceInfoType> => {
-    const response = await axiosInstance.get<DeviceInfoRawType>(
+    const data = await fetchJson<DeviceInfoRawType>(
+      baseURL,
       `device/${macAddress}/info`,
       {
+        method: "GET",
         headers: headers(jwtToken),
-      }
+      },
     );
     // Process response to decompress any gzipped Buffer fields
-    return processResponse(response.data) as DeviceInfoType;
+    return processResponse(data) as DeviceInfoType;
   };
 
 const mqttCommand =
-  (axiosInstance: AxiosInstance) =>
+  (baseURL: string) =>
   // eslint-disable-next-line  @typescript-eslint/no-explicit-any
   (jwtToken: string, macAddress: string, payload: any) =>
-    axiosInstance.put(
-      "mqtt/command",
-      { mac_address: macAddress, ...payload },
-      { headers: headers(jwtToken) }
-    );
+    fetchJson(baseURL, "mqtt/command", {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json",
+        ...headers(jwtToken),
+      },
+      body: JSON.stringify({ mac_address: macAddress, ...payload }),
+    });
 
 const setPower =
-  (axiosInstance: AxiosInstance) =>
+  (baseURL: string) =>
   /**
    * Sends a command to set the power state of a device.
    *
@@ -118,10 +172,10 @@ const setPower =
    * @returns {Promise<string>} - A promise that resolves to the command response.
    */
   (jwtToken: string, macAddress: string, value: number) =>
-    mqttCommand(axiosInstance)(jwtToken, macAddress, { name: "power", value });
+    mqttCommand(baseURL)(jwtToken, macAddress, { name: "power", value });
 
 const setPowerOn =
-  (axiosInstance: AxiosInstance) =>
+  (baseURL: string) =>
   /**
    * Turns a device ON by setting its power state.
    *
@@ -134,10 +188,10 @@ const setPowerOn =
    * console.log(response);
    */
   (jwtToken: string, macAddress: string) =>
-    setPower(axiosInstance)(jwtToken, macAddress, 1);
+    setPower(baseURL)(jwtToken, macAddress, 1);
 
 const setPowerOff =
-  (axiosInstance: AxiosInstance) =>
+  (baseURL: string) =>
   /**
    * Turns a device OFF by setting its power state.
    *
@@ -150,10 +204,10 @@ const setPowerOff =
    * console.log(response);
    */
   (jwtToken: string, macAddress: string) =>
-    setPower(axiosInstance)(jwtToken, macAddress, 0);
+    setPower(baseURL)(jwtToken, macAddress, 0);
 
 const getPower =
-  (axiosInstance: AxiosInstance) =>
+  (baseURL: string) =>
   /**
    * Retrieves the power status of the device.
    *
@@ -162,12 +216,12 @@ const getPower =
    * @returns {Promise<boolean>} - A promise that resolves to the power status.
    */
   async (jwtToken: string, macAddress: string): Promise<boolean> => {
-    const info = await deviceInfo(axiosInstance)(jwtToken, macAddress);
+    const info = await deviceInfo(baseURL)(jwtToken, macAddress);
     return info.status.commands.power;
   };
 
 const getEnvironmentTemperature =
-  (axiosInstance: AxiosInstance) =>
+  (baseURL: string) =>
   /**
    * Retrieves the environment temperature from the device's sensors.
    *
@@ -176,12 +230,12 @@ const getEnvironmentTemperature =
    * @returns {Promise<number>} - A promise that resolves to the temperature value.
    */
   async (jwtToken: string, macAddress: string): Promise<number> => {
-    const info = await deviceInfo(axiosInstance)(jwtToken, macAddress);
+    const info = await deviceInfo(baseURL)(jwtToken, macAddress);
     return info.status.temperatures.enviroment;
   };
 
 const getTargetTemperature =
-  (axiosInstance: AxiosInstance) =>
+  (baseURL: string) =>
   /**
    * Retrieves the target temperature value set on the device.
    *
@@ -190,12 +244,12 @@ const getTargetTemperature =
    * @returns {Promise<number>} - A promise that resolves to the target temperature (degree celsius).
    */
   async (jwtToken: string, macAddress: string): Promise<number> => {
-    const info = await deviceInfo(axiosInstance)(jwtToken, macAddress);
+    const info = await deviceInfo(baseURL)(jwtToken, macAddress);
     return info.nvm.user_parameters.enviroment_1_temperature;
   };
 
 const setTargetTemperature =
-  (axiosInstance: AxiosInstance) =>
+  (baseURL: string) =>
   /**
    * Sends a command to set the target temperature (degree celsius) of a device.
    *
@@ -205,13 +259,13 @@ const setTargetTemperature =
    * @returns {Promise<string>} - A promise that resolves to the command response.
    */
   (jwtToken: string, macAddress: string, temperature: number) =>
-    mqttCommand(axiosInstance)(jwtToken, macAddress, {
+    mqttCommand(baseURL)(jwtToken, macAddress, {
       name: "enviroment_1_temperature",
       value: temperature,
     });
 
 const registerDevice =
-  (axiosInstance: AxiosInstance) =>
+  (baseURL: string) =>
   /**
    * Registers a device with the user's account.
    * This must be called before other device operations will work on the new API.
@@ -228,7 +282,7 @@ const registerDevice =
     macAddress: string,
     serialNumber: string,
     deviceName: string = "",
-    deviceRoom: string = ""
+    deviceRoom: string = "",
   ): Promise<DeviceAssociationResponse> => {
     const body: DeviceAssociationBody = {
       macAddress: macAddress.replace(/:/g, ""),
@@ -236,16 +290,18 @@ const registerDevice =
       deviceRoom,
       serialNumber,
     };
-    const response = await axiosInstance.post<DeviceAssociationResponse>(
-      "device",
-      body,
-      { headers: headers(jwtToken) }
-    );
-    return response.data;
+    return fetchJson<DeviceAssociationResponse>(baseURL, "device", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...headers(jwtToken),
+      },
+      body: JSON.stringify(body),
+    });
   };
 
 const editDevice =
-  (axiosInstance: AxiosInstance) =>
+  (baseURL: string) =>
   /**
    * Updates a device's name and room.
    *
@@ -259,19 +315,25 @@ const editDevice =
     jwtToken: string,
     macAddress: string,
     deviceName: string = "",
-    deviceRoom: string = ""
+    deviceRoom: string = "",
   ): Promise<DeviceAssociationResponse> => {
     const normalizedMac = macAddress.replace(/:/g, "");
     const body: EditDeviceAssociationBody = {
       deviceName,
       deviceRoom,
     };
-    const response = await axiosInstance.put<DeviceAssociationResponse>(
+    return fetchJson<DeviceAssociationResponse>(
+      baseURL,
       `device/${normalizedMac}`,
-      body,
-      { headers: headers(jwtToken) }
+      {
+        method: "PUT",
+        headers: {
+          "Content-Type": "application/json",
+          ...headers(jwtToken),
+        },
+        body: JSON.stringify(body),
+      },
     );
-    return response.data;
   };
 
 /**
@@ -285,31 +347,24 @@ const editDevice =
  * const api = configure();
  * const power = await api.getPower(jwtToken, macAddress);
  */
-const configure = (baseURL: string = API_URL) => {
-  const axiosInstance = axios.create({ baseURL });
-  const deviceInfoInstance = deviceInfo(axiosInstance);
-  const registerDeviceInstance = registerDevice(axiosInstance);
-  const editDeviceInstance = editDevice(axiosInstance);
-  const setPowerInstance = setPower(axiosInstance);
-  const setPowerOffInstance = setPowerOff(axiosInstance);
-  const setPowerOnInstance = setPowerOn(axiosInstance);
-  const getPowerInstance = getPower(axiosInstance);
-  const getEnvironmentTemperatureInstance =
-    getEnvironmentTemperature(axiosInstance);
-  const getTargetTemperatureInstance = getTargetTemperature(axiosInstance);
-  const setTargetTemperatureInstance = setTargetTemperature(axiosInstance);
-  return {
-    deviceInfo: deviceInfoInstance,
-    registerDevice: registerDeviceInstance,
-    editDevice: editDeviceInstance,
-    setPower: setPowerInstance,
-    setPowerOff: setPowerOffInstance,
-    setPowerOn: setPowerOnInstance,
-    getPower: getPowerInstance,
-    getEnvironmentTemperature: getEnvironmentTemperatureInstance,
-    getTargetTemperature: getTargetTemperatureInstance,
-    setTargetTemperature: setTargetTemperatureInstance,
-  };
-};
+const configure = (baseURL: string = API_URL) => ({
+  deviceInfo: deviceInfo(baseURL),
+  registerDevice: registerDevice(baseURL),
+  editDevice: editDevice(baseURL),
+  setPower: setPower(baseURL),
+  setPowerOff: setPowerOff(baseURL),
+  setPowerOn: setPowerOn(baseURL),
+  getPower: getPower(baseURL),
+  getEnvironmentTemperature: getEnvironmentTemperature(baseURL),
+  getTargetTemperature: getTargetTemperature(baseURL),
+  setTargetTemperature: setTargetTemperature(baseURL),
+});
 
-export { configure, createAuthService, headers, signIn };
+export {
+  configure,
+  configureAmplify,
+  createAuthService,
+  getSession,
+  headers,
+  signIn,
+};

package/src/token-storage.ts

@@ -0,0 +1,78 @@
+import { promises as fs } from "fs";
+import * as os from "os";
+import * as path from "path";
+
+const TOKEN_DIR = path.join(os.homedir(), ".edilkamin");
+const TOKEN_FILE = path.join(TOKEN_DIR, "session.json");
+
+interface StoredData {
+  [key: string]: string;
+}
+
+/**
+ * Custom storage adapter for AWS Amplify that persists to file system.
+ * Used for CLI to maintain sessions between invocations.
+ */
+export const createFileStorage = () => {
+  let cache: StoredData = {};
+  let loaded = false;
+
+  const ensureDir = async (): Promise<void> => {
+    try {
+      await fs.mkdir(TOKEN_DIR, { recursive: true, mode: 0o700 });
+    } catch {
+      // Directory may already exist
+    }
+  };
+
+  const load = async (): Promise<void> => {
+    if (loaded) return;
+    try {
+      const data = await fs.readFile(TOKEN_FILE, "utf-8");
+      cache = JSON.parse(data);
+    } catch {
+      cache = {};
+    }
+    loaded = true;
+  };
+
+  const save = async (): Promise<void> => {
+    await ensureDir();
+    await fs.writeFile(TOKEN_FILE, JSON.stringify(cache), {
+      encoding: "utf-8",
+      mode: 0o600,
+    });
+  };
+
+  return {
+    setItem: async (key: string, value: string): Promise<void> => {
+      await load();
+      cache[key] = value;
+      await save();
+    },
+    getItem: async (key: string): Promise<string | null> => {
+      await load();
+      return cache[key] ?? null;
+    },
+    removeItem: async (key: string): Promise<void> => {
+      await load();
+      delete cache[key];
+      await save();
+    },
+    clear: async (): Promise<void> => {
+      cache = {};
+      await save();
+    },
+  };
+};
+
+/**
+ * Clears all stored session data.
+ */
+export const clearSession = async (): Promise<void> => {
+  try {
+    await fs.unlink(TOKEN_FILE);
+  } catch {
+    // File may not exist
+  }
+};