Add remote sync commands

.github/copilot-instructions.md

@@ -24,3 +24,6 @@
 - **New Commands**: To add a command, create a new file in `src/commands/` (or a subfolder). It must export a definition object (default or named) with `name`, `description`, and `action`.
 - **Error Handling**: Follow the pattern in [src/commands/health.ts](src/commands/health.ts) for handling Axios errors (check for `error.response`, `error.request`, etc.).
 - **No Global Scope**: Keep command logic within the `action` function or extracted to utility modules to maintain testability.
+
+## Versioning
+- **Versioning**: Always increment the version number in package.json whenever a change is merged into main. The version format is major.minor.patch.

.github/workflows/publish.yml

@@ -28,6 +28,7 @@ jobs:
           node-version: '24'
 
       - run: pnpm install --no-frozen-lockfile
+      - run: pnpm test
       - run: pnpm build
 
       - name: Zip dist directory

.gitignore

@@ -1,4 +1,5 @@
 node_modules
 dist
 build
-pnpm-lock.yaml
+pnpm-lock.yaml
+testing

OpenclawSkill.md

@@ -16,8 +16,6 @@ shsf health
 this will check the health, and if not setup, it will prompt you to set up the CLI.
 
 ## Commands
-
-### Count
 - `shsf count functions`: Count your functions. Add `--full` to list them.
 - `shsf count namespaces`: Count your namespaces. Add `--full` to list them.
 - `shsf count storages`: Count your storages. Add `--full` to list them.
@@ -35,6 +33,14 @@ this will check the health, and if not setup, it will prompt you to set up the C
 - `shsf get namespace <id>`: Get details of a specific namespace by its ID
 - `shsf get trigger <functionId> <triggerId>`: Get details of a specific trigger from a function.
 
+- `shsf storage create --name <name> --purpose <purpose>`: Create a new storage.
+- `shsf storage delete --name <name>`: Delete a storage.
+- `shsf storage list`: List all storages.
+- `shsf storage get-items --name <name>`: List all items in a storage.
+- `shsf storage set-item --name <name> --key <key> --value <value> [--expires <expires>]`: Set a storage item (value can be JSON).
+- `shsf storage delete-item --name <name> --key <key>`: Delete a storage item.
+- `shsf storage clear-items --name <name>`: Clear all items from a storage.
+
 - `shsf update function <id>`: Update a specific serverless function by its ID. (use `shsf update function -h` first)
 - `shsf update namespace <id>`: Update a specific namespace by its ID. (use `shsf update namespace -h` first)
 - `shsf update trigger <functionId> <triggerId>`: Update a specific trigger from a function. (use `shsf update trigger -h` first)
@@ -44,6 +50,9 @@ this will check the health, and if not setup, it will prompt you to set up the C
 - `shsf file delete`: Delete a file from a storage. (use `shsf file delete -h` first)
 - `shsf file list`: List files in a storage. (use `shsf file list -h` first)
 
+- `shsf remote pull --id <id> --into <path> [--force]`: Pull files from a function into a local directory.
+- `shsf remote push --id <id> --from <path> [--force]`: Push files from a local directory to a function.
+
 ## Instructions
 Use these commands for when you need to interact with shsf from the command line. Its faster than using the ui for almost all ops.
 
@@ -87,7 +96,7 @@ After creating a function and receiving an ID (for example, 81), you can share t
 ```
 
 ## Update
-Update with your package manager of choice. Preferably pnpm:
+Update with your package manager of choice. ALWAYS pnpm:
 ```bash
 pnpm add -g shsf-cli
 ```

package.json

@@ -1,6 +1,6 @@
 {
   "name": "shsf-cli",
-  "version": "2.0.4",
+  "version": "2.1.7",
   "description": "",
   "type": "module",
   "files": [
@@ -12,7 +12,9 @@
   "scripts": {
     "build": "rimraf dist && tsc",
     "start": "node dist/index.js",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
   },
   "keywords": [],
   "author": "",
@@ -21,9 +23,11 @@
   "devDependencies": {
     "@types/inquirer": "^9.0.9",
     "@types/node": "^25.5.0",
+    "@vitest/coverage-v8": "^4.1.0",
     "rimraf": "^6.1.3",
     "ts-node": "^10.9.2",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.0"
   },
   "dependencies": {
     "axios": "^1.13.6",

src/__tests__/commands.test.ts

@@ -0,0 +1,52 @@
+import { describe, it, expect, vi } from 'vitest';
+import path from 'path';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+describe('Command Loading', () => {
+  it('all command files should export a valid definition', async () => {
+    const commandsDir = path.resolve(__dirname, '../commands');
+    
+    function getCommandFiles(dir: string): string[] {
+      const files = fs.readdirSync(dir);
+      let commandFiles: string[] = [];
+
+      for (const file of files) {
+        const fullPath = path.join(dir, file);
+        if (fs.statSync(fullPath).isDirectory()) {
+          commandFiles = commandFiles.concat(getCommandFiles(fullPath));
+        } else if (file.endsWith('.ts') || file.endsWith('.js')) {
+          commandFiles.push(fullPath);
+        }
+      }
+
+      return commandFiles;
+    }
+
+    const files = getCommandFiles(commandsDir);
+    expect(files.length).toBeGreaterThan(0);
+
+    for (const file of files) {
+      // Use dynamic import to check the module
+      // We convert absolute path to file:// URL for ESM import on Linux/Windows
+      const module = await import(`file://${file}`);
+      
+      const definition = module.default || Object.values(module).find((val: any) => 
+        val && typeof val === 'object' && val.name && typeof val.action === 'function'
+      );
+
+      if (!definition) {
+        throw new Error(`Command file ${file} does not export a valid command definition (needs name and action function)`);
+      }
+
+      expect(definition).toBeDefined();
+      expect(typeof definition.name).toBe('string');
+      expect(typeof definition.action).toBe('function');
+      
+      console.log(`✓ Validated command: ${definition.name} (${path.relative(commandsDir, file)})`);
+    }
+  });
+});

src/__tests__/config.test.ts

@@ -0,0 +1,11 @@
+import { describe, it, expect, vi } from 'vitest';
+import path from 'path';
+import os from 'os';
+import { getConfigPath } from '../config.js';
+
+describe('config', () => {
+  it('should return the correct config path', () => {
+    const expectedPath = path.join(os.homedir(), '.shsf_config');
+    expect(getConfigPath()).toBe(expectedPath);
+  });
+});

src/__tests__/url_prefix.test.ts

@@ -0,0 +1,44 @@
+import { describe, it, expect } from 'vitest';
+import { readFileSync, readdirSync, statSync } from 'fs';
+import path from 'path';
+
+function getFilesRecursively(dir: string): string[] {
+  let files: string[] = [];
+  const items = readdirSync(dir);
+  for (const item of items) {
+    const fullPath = path.join(dir, item);
+    if (statSync(fullPath).isDirectory()) {
+      if (item !== '__tests__') {
+        files = files.concat(getFilesRecursively(fullPath));
+      }
+    } else if (item.endsWith('.ts')) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+
+describe('API URL validation', () => {
+  it('should ensure all API client calls start with /api/', () => {
+    const tsFiles = getFilesRecursively('src');
+    const violations: string[] = [];
+
+    // Regex to match common patterns like client.get('/path') or client.post(`/path`)
+    // specifically looking for paths that start with / but NOT /api/ or /health
+    const urlPattern = /client\.(get|post|put|delete|patch)\(['"`]\/(?!(api|health)\/)[^'"`]+['"`]/g;
+
+    tsFiles.forEach(file => {
+      const content = readFileSync(file, 'utf-8');
+      let match;
+      while ((match = urlPattern.exec(content)) !== null) {
+        // Double check for exact /health match (without trailing slash)
+        if (match[0].includes("'/health'") || match[0].includes('"/health"') || match[0].includes('`/health`')) {
+          continue;
+        }
+        violations.push(`${file}: ${match[0]}`);
+      }
+    });
+
+    expect(violations, `Found API calls not starting with /api/:\n${violations.join('\n')}`).toHaveLength(0);
+  });
+});

src/commands/function/pipinstall.ts

@@ -0,0 +1,56 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+
+export const pipInstallDefinition = {
+  name: "pipinstall",
+  description: "Install Python dependencies for a function using requirements.txt",
+  options: [
+    {
+      name: "--id <id>",
+      description: "The ID of the function.",
+      required: true,
+    },
+  ],
+  action: async (options: { id: string }) => {
+    await pipInstallFunction(options.id);
+  },
+};
+
+async function pipInstallFunction(id: string) {
+  const client = await getApiClient();
+
+  try {
+    const response = await client.post(`/api/function/${id}/pip-install`);
+
+    if (response.status === 200) {
+      console.log(`${chalk.green("✓")} Dependencies installed successfully for function ${chalk.yellow(id)}.`);
+      if (response.data && response.data.status) {
+        console.log(`${chalk.gray("Status:")} ${response.data.status}`);
+      }
+    } else {
+      console.log(
+        `${chalk.yellow("!")} Unexpected response from server.`,
+      );
+      console.log(`Status Code: ${chalk.blue(response.status)}`);
+    }
+  } catch (error: any) {
+    if (error.response) {
+      console.error(
+        `${chalk.red("✗")} Failed to install dependencies.`,
+      );
+      console.error(`Status Code: ${chalk.red(error.response.status)}`);
+      console.error(
+        `Message: ${chalk.yellow(error.response.data?.message || "Unknown error from server")}`,
+      );
+    } else if (error.request) {
+      console.error(
+        `${chalk.red("✗")} Failed to install dependencies.`,
+      );
+      console.error(
+        `${chalk.yellow("Could not connect to the SHSF instance. Check your connection.")}`,
+      );
+    } else {
+      console.error(`${chalk.red("✗")} Error:`, error.message);
+    }
+  }
+}

src/commands/remote/pull.ts

@@ -0,0 +1,35 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+import fs from "fs";
+import path from "path";
+
+export const pullDefinition = {
+  name: "pull",
+  description: "Pull files from a remote function.",
+  options: [
+    { name: "--id <id>", description: "Function ID", required: true },
+    { name: "--into <path>", description: "Target directory", required: true },
+    { name: "--force", description: "Force overwrite" },
+  ],
+  action: async (options: any) => {
+    const client = await getApiClient();
+
+    try {
+      const response = await client.get(`/api/function/${options.id}/files`);
+      const files = response.data.data; // Expecting { name: string, content: string }[]
+
+      if (!fs.existsSync(options.into)) {
+        fs.mkdirSync(options.into, { recursive: true });
+      } else if (fs.readdirSync(options.into).length > 0 && !options.force) {
+        console.error(chalk.red(`Directory ${options.into} is not empty. Use --force to overwrite.`));
+        return;
+      }
+      for (const file of files) {
+        fs.writeFileSync(path.join(options.into, file.name), file.content);
+      }
+      console.log(chalk.green(`Successfully pulled ${files.length} files into ${options.into}`));
+    } catch (error: any) {
+      console.error(chalk.red(`Failed to pull files: ${error.message}`));
+    }
+  },
+};

src/commands/remote/push.ts

@@ -0,0 +1,158 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+import fs from "fs";
+import path from "path";
+import { createHash } from "crypto";
+
+async function deleteNonexistentFiles(
+  currentFiles: any[],
+  files: any[],
+  client: any,
+  options: any,
+): Promise<{ didDeletion: boolean }> {
+  let didDeletion = false;
+  for (const currentFile of currentFiles) {
+    if (!files.some((f: any) => f.filename === currentFile.name)) {
+      try {
+      await client.delete(
+        `/api/function/${options.id}/file/${currentFile.id}`,
+        {
+          data: { filename: currentFile.name },
+        },
+      );} catch (error: any) {
+        throw error;
+      }
+      console.log(
+        chalk.green(`Deleted ${currentFile.name} from function ${options.id}`),
+      );
+      didDeletion = true;
+    }
+  }
+  return { didDeletion };
+}
+
+export const pushDefinition = {
+  name: "push",
+  description: "Push files to a remote function.",
+  options: [
+    { name: "--id <id>", description: "Function ID", required: true },
+    { name: "--from <path>", description: "Source directory", required: true },
+    { name: "--force", description: "Force overwrite" },
+  ],
+  action: async (options: any) => {
+    const client = await getApiClient();
+
+    if (!fs.existsSync(options.from)) {
+      console.error(chalk.red(`Source ${options.from} does not exist.`));
+      return;
+    }
+
+    let didDeletion = false; // Track if any deletions were made
+
+    const currentFilesResponse = await client.get(
+      `/api/function/${options.id}/files`,
+    );
+    const currentFiles = currentFilesResponse.data.data; // Expecting { name: string, id: string [...] }[]
+
+    const files = fs.readdirSync(options.from).map((file) => ({
+      filename: file,
+      content: fs.readFileSync(path.join(options.from, file), "utf-8"),
+    }));
+
+    if (!options.force && files.length > 5) {
+      console.log(
+        chalk.yellow("Too many modifications. Please use --force to confirm."),
+      );
+      return;
+    }
+
+    // Push new and modified files
+    let pushedFilesCount = 0;
+    try {
+      for (const file of files) {
+        // Hash first, save traffic
+        const fileHash = createHash("md5").update(file.content).digest("hex");
+        const currentFile = currentFiles.find(
+          (f: any) => f.name === file.filename,
+        );
+        if (currentFile) {
+          // If the file content exists in the response, we can hash it. 
+          // Note: currentFiles from /api/function/:id/files might not have content by default depending on API,
+          // but the original code assumes it does.
+          const currentFileHash = createHash("md5")
+            .update(currentFile.content || "")
+            .digest("hex");
+          if (fileHash === currentFileHash) {
+            console.log(
+              chalk.yellow(
+                `Skipping ${file.filename}, no changes detected for function ${options.id}`,
+              ),
+            );
+            continue;
+          }
+        }
+
+        await client.put(`/api/function/${options.id}/file`, {
+          filename: file.filename,
+          code: file.content,
+        });
+
+        console.log(
+          chalk.green(`Pushed ${file.filename} to function ${options.id}`),
+        );
+        pushedFilesCount++;
+      }
+
+      // Delete files that no longer exist on the remote AFTER pushing new/updated files
+      // This avoids the "cannot delete only file" error if we are pushing at least one file.
+      try {
+        const deletionResult = await deleteNonexistentFiles(
+          currentFiles,
+          files,
+          client,
+          options,
+        );
+        if (deletionResult.didDeletion) {
+          didDeletion = true;
+        }
+      } catch (error: any) {
+        if (error.response) {
+          console.error(
+            chalk.red(
+              `Failed to delete files: ${error.response.data?.message || error.response.statusText}`,
+            ),
+          );
+        } else {
+          console.error(chalk.red(`Error during deletion: ${error.message}`));
+        }
+      }
+
+      console.log(
+        chalk.green(
+          `Successfully pushed ${pushedFilesCount} files to function ${options.id}`,
+        ),
+      );
+
+      if (didDeletion) {
+        console.log("");
+        console.log(
+          chalk.blue(
+            `Hint: We might delete files that you renamed, but don't worry, we'll push the newly named file right after!`,
+          ),
+        );
+      }
+    } catch (error: any) {
+      if (error.response) {
+        console.error(
+          chalk.red(
+            `Failed to push files: ${error.response.data?.message || error.response.statusText}`,
+          ),
+        );
+      } else if (error.request) {
+        console.error(chalk.red("No response received from server."));
+      } else {
+        console.error(chalk.red(`Error: ${error.message}`));
+      }
+    }
+  },
+};

src/commands/storage/clear-items.ts

@@ -0,0 +1,35 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+
+export const clearItemsDefinition = {
+  name: "clear-items",
+  description: "Clear all items from a storage.",
+  options: [
+    { name: "--name <name>", description: "Storage name", required: true },
+  ],
+  action: async (options: any) => {
+    const client = await getApiClient();
+
+    try {
+      const response = await client.delete(`/api/storage/${options.name}/items`);
+
+      if (response.status === 200) {
+        console.log(
+          `${chalk.green("✓")} All items cleared from storage ${chalk.cyan(options.name)}!`,
+        );
+      } else {
+        console.log(
+          `${chalk.yellow("!")} Unexpected response from server: ${response.status}`,
+        );
+      }
+    } catch (error: any) {
+      if (error.response) {
+        console.error(
+          `${chalk.red("✗")} Failed to clear items: ${chalk.yellow(error.response.data.message || "Unknown error")}`,
+        );
+      } else {
+        console.error(`${chalk.red("✗")} Error: ${error.message}`);
+      }
+    }
+  },
+};

src/commands/storage/create.ts

@@ -0,0 +1,41 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+
+export const createStorageDefinition = {
+  name: "create",
+  description: "Create a new storage.",
+  options: [
+    { name: "--name <name>", description: "Storage name", required: true },
+    { name: "--purpose <purpose>", description: "Storage purpose", required: true },
+  ],
+  action: async (options: any) => {
+    const data = {
+      name: options.name,
+      purpose: options.purpose,
+    };
+
+    const client = await getApiClient();
+
+    try {
+      const response = await client.post("/api/storage", data);
+
+      if (response.status === 200 || response.status === 201) {
+        console.log(
+          `${chalk.green("✓")} Storage ${chalk.cyan(data.name)} created successfully!`,
+        );
+      } else {
+        console.log(
+          `${chalk.yellow("!")} Unexpected response from server: ${response.status}`,
+        );
+      }
+    } catch (error: any) {
+      if (error.response) {
+        console.error(
+          `${chalk.red("✗")} Failed to create storage: ${chalk.yellow(error.response.data.message || "Unknown error")}`,
+        );
+      } else {
+        console.error(`${chalk.red("✗")} Error: ${error.message}`);
+      }
+    }
+  },
+};

src/commands/storage/delete-item.ts

@@ -0,0 +1,36 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+
+export const deleteItemDefinition = {
+  name: "delete-item",
+  description: "Delete a storage item.",
+  options: [
+    { name: "--name <name>", description: "Storage name", required: true },
+    { name: "--key <key>", description: "Item key", required: true },
+  ],
+  action: async (options: any) => {
+    const client = await getApiClient();
+
+    try {
+      const response = await client.delete(`/api/storage/${options.name}/item/${options.key}`);
+
+      if (response.status === 200) {
+        console.log(
+          `${chalk.green("✓")} Item ${chalk.cyan(options.key)} deleted from ${chalk.cyan(options.name)}!`,
+        );
+      } else {
+        console.log(
+          `${chalk.yellow("!")} Unexpected response from server: ${response.status}`,
+        );
+      }
+    } catch (error: any) {
+      if (error.response) {
+        console.error(
+          `${chalk.red("✗")} Failed to delete item: ${chalk.yellow(error.response.data.message || "Unknown error")}`,
+        );
+      } else {
+        console.error(`${chalk.red("✗")} Error: ${error.message}`);
+      }
+    }
+  },
+};

src/commands/storage/delete.ts

@@ -0,0 +1,35 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+
+export const deleteStorageDefinition = {
+  name: "delete",
+  description: "Delete a storage.",
+  options: [
+    { name: "--name <name>", description: "Storage name", required: true },
+  ],
+  action: async (options: any) => {
+    const client = await getApiClient();
+
+    try {
+      const response = await client.delete(`/api/storage/${options.name}`);
+
+      if (response.status === 200) {
+        console.log(
+          `${chalk.green("✓")} Storage ${chalk.cyan(options.name)} deleted successfully!`,
+        );
+      } else {
+        console.log(
+          `${chalk.yellow("!")} Unexpected response from server: ${response.status}`,
+        );
+      }
+    } catch (error: any) {
+      if (error.response) {
+        console.error(
+          `${chalk.red("✗")} Failed to delete storage: ${chalk.yellow(error.response.data.message || "Unknown error")}`,
+        );
+      } else {
+        console.error(`${chalk.red("✗")} Error: ${error.message}`);
+      }
+    }
+  },
+};

src/commands/storage/get-items.ts

@@ -0,0 +1,42 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+
+export const listItemsDefinition = {
+  name: "get-items",
+  description: "List all items in a storage.",
+  options: [
+    { name: "--name <name>", description: "Storage name", required: true },
+  ],
+  action: async (options: any) => {
+    const client = await getApiClient();
+
+    try {
+      const response = await client.get(`/api/storage/${options.name}/items`);
+
+      if (response.status === 200 && response.data.data) {
+        const items = response.data.data;
+        if (items.length === 0) {
+          console.log(`${chalk.yellow("!")} Storage ${chalk.cyan(options.name)} is empty.`);
+          return;
+        }
+
+        console.log(chalk.blue(`Items in ${chalk.cyan(options.name)}:`));
+        items.forEach((item: any) => {
+          console.log(`- ${chalk.cyan(item.key)}: ${JSON.stringify(item.value)}`);
+        });
+      } else {
+        console.log(
+          `${chalk.yellow("!")} Unexpected response from server: ${response.status}`,
+        );
+      }
+    } catch (error: any) {
+      if (error.response) {
+        console.error(
+          `${chalk.red("✗")} Failed to list items: ${chalk.yellow(error.response.data.message || "Unknown error")}`,
+        );
+      } else {
+        console.error(`${chalk.red("✗")} Error: ${error.message}`);
+      }
+    }
+  },
+};

src/commands/storage/list.ts

@@ -0,0 +1,40 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+
+export const listStoragesDefinition = {
+  name: "list",
+  description: "List all storages.",
+  action: async () => {
+    const client = await getApiClient();
+
+    try {
+      const response = await client.get("/api/storage");
+
+      if (response.status === 200 && response.data.data) {
+        const storages = response.data.data;
+        if (storages.length === 0) {
+          console.log(`${chalk.yellow("!")} No storages found.`);
+          return;
+        }
+
+        console.log(chalk.blue("Storages:"));
+        storages.forEach((s: any) => {
+          const purposeInfo = s.purpose ? chalk.gray(` - ${s.purpose}`) : "";
+          console.log(`- ${chalk.cyan(s.name)}${purposeInfo}`);
+        });
+      } else {
+        console.log(
+          `${chalk.yellow("!")} Unexpected response from server: ${response.status}`,
+        );
+      }
+    } catch (error: any) {
+      if (error.response) {
+        console.error(
+          `${chalk.red("✗")} Failed to list storages: ${chalk.yellow(error.response.data.message || "Unknown error")}`,
+        );
+      } else {
+        console.error(`${chalk.red("✗")} Error: ${error.message}`);
+      }
+    }
+  },
+};

src/commands/storage/set-item.ts

@@ -0,0 +1,59 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+
+export const setItemDefinition = {
+  name: "set-item",
+  description: "Set a storage item.",
+  options: [
+    { name: "--name <name>", description: "Storage name", required: true },
+    { name: "--key <key>", description: "Item key", required: true },
+    { name: "--value <value>", description: "Item value (JSON string)", required: true },
+    { name: "--expires <expires>", description: "Expiration (ISO string or hours)" },
+  ],
+  action: async (options: any) => {
+    let value;
+    try {
+      value = JSON.parse(options.value);
+    } catch (e) {
+      // If not valid JSON, treat as string
+      value = options.value;
+    }
+
+    const data: any = {
+      key: options.key,
+      value: value,
+    };
+
+    if (options.expires) {
+      if (!isNaN(Number(options.expires))) {
+        data.expiresAt = Number(options.expires);
+      } else {
+        data.expiresAt = options.expires;
+      }
+    }
+
+    const client = await getApiClient();
+
+    try {
+      const response = await client.post(`/api/storage/${options.name}/item`, data);
+
+      if (response.status === 200 || response.status === 201) {
+        console.log(
+          `${chalk.green("✓")} Item ${chalk.cyan(options.key)} set successfully in ${chalk.cyan(options.name)}!`,
+        );
+      } else {
+        console.log(
+          `${chalk.yellow("!")} Unexpected response from server: ${response.status}`,
+        );
+      }
+    } catch (error: any) {
+      if (error.response) {
+        console.error(
+          `${chalk.red("✗")} Failed to set item: ${chalk.yellow(error.response.data.message || "Unknown error")}`,
+        );
+      } else {
+        console.error(`${chalk.red("✗")} Error: ${error.message}`);
+      }
+    }
+  },
+};

vitest.config.ts

@@ -0,0 +1,13 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    exclude: ['**/node_modules/**', '**/dist/**', '**/cypress/**', '**/.{idea,git,cache,output,temp}/**'],
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html'],
+    }
+  },
+});