chore: bump version to 2.1.5 and add versioning policy

.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

@@ -4,9 +4,15 @@ on:
   push:
     branches:
       - '**'
+    paths:
+      - '**/*.ts'
+      - '**/*.json'
   pull_request:
     branches:
       - main
+    paths:
+      - '**/*.ts'
+      - '**/*.json'
 
 jobs:
   build:

OpenclawSkill.md

@@ -17,7 +17,6 @@ this will check the health, and if not setup, it will prompt you to set up the C
 
 ## 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 +34,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)
@@ -46,3 +53,60 @@ this will check the health, and if not setup, it will prompt you to set up the C
 
 ## 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.
+
+## Ui Links
+Get the ui url with:
+```bash
+shsf uiurl
+```
+
+## Available UI Routes
+
+Below are the main routes you can use in the SHSF web UI. These are not clickable links, but you can navigate to them in your browser.
+
+**General**
+- `/`: Home Page
+
+**Documentation**
+- `/docs`: Documentation
+
+**Account**
+- `/account`: Account Settings
+- `/login`: Login
+- `/register`: Register
+
+**Functions**
+- `/functions`: Shows your functions, grouped by their respective namespaces (requires auth).
+- `/functions/:id`: View details for a specific function (requires auth).
+
+**Other**
+- `/admin`: Admin dashboard (admin only, requires authentication)
+- `/storage`: Storage management (requires auth)
+- `/cron-jobs`: Cron job management (requires auth)
+- `/access-tokens`: Access token management (requires auth)
+- `/guest-users`: Guest user management (requires auth)
+- `/guest-access`: Guest access portal
+
+### Example
+After creating a function and receiving an ID (for example, 81), you can share the following URL with your human so they can view the function in the UI:
+```
+[UI_URL]/functions/[ID]
+```
+
+## Update
+Update with your package manager of choice. Preferably pnpm:
+```bash
+pnpm add -g shsf-cli
+```
+Note that new features are often released and a user might tell you to do things that are only in the latest version. So its a good idea to always keep it updated.
+
+It is also good practice to update this skill every now and then, as it might get new features that are not documented here yet.
+Download the latest version with:
+```
+curl https://raw.githubusercontent.com/Space-Banane/shsf-cli/refs/heads/main/OpenclawSkill.md > /tmp/OpenclawSkill.md
+```
+and then replace the old one with the new one using `mv`.
+
+## Missing a feature?
+Features might be not documented yet, as this skill document rarely updates.
+Use the shsf -h command to see options and features.

package.json

@@ -1,6 +1,6 @@
 {
   "name": "shsf-cli",
-  "version": "2.0.3",
+  "version": "2.1.5",
   "description": "",
   "type": "module",
   "files": [

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/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}`);
+      }
+    }
+  },
+};

src/commands/uiurl.ts

@@ -0,0 +1,52 @@
+import chalk from "chalk";
+import { getApiClient } from "../api.js";
+
+export const uiUrlDefinition = {
+    name: "uiurl",
+    description: "Get the URL for the SHSF UI.",
+    action: async () => {
+        await getUiURL();
+    },
+};
+
+async function getUiURL(): Promise<void> {
+    const client = await getApiClient();
+
+    try {
+        const response = await client.get<{ status: string; uiUrl: string }>("/api/global/uiUrl");
+
+        if (response.status === 200 && response.data.status === "OK") {
+            console.log(
+                `${chalk.green("✓")} SHSF UI URL: ${chalk.bgGreen.black(` ${response.data.uiUrl} `)}`
+            );
+        } else {
+            console.log(
+                `${chalk.yellow("!")} SHSF Status: ${chalk.bgYellow.black(" UNEXPECTED RESPONSE ")}`,
+            );
+            console.log(`Status Code: ${chalk.blue(response.status)}`);
+            console.log(`Response Data: ${JSON.stringify(response.data)}`);
+        }
+    } catch (error: any) {
+        if (error.response) {
+            console.error(
+                `${chalk.red("✗")} SHSF Status: ${chalk.bgRed.black(" UNHEALTHY ")}`,
+            );
+            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("✗")} SHSF Status: ${chalk.bgRed.black(" DISCONNECTED ")}`,
+            );
+            console.error(
+                `Error: ${chalk.yellow("Could not connect to the SHSF instance. Check your connection or SHSF_INSTANCE URL.")}`,
+            );
+        } else {
+            console.error(
+                `${chalk.red("✗")} SHSF Status: ${chalk.bgRed.black(" LOCAL ERROR ")}`,
+            );
+            console.error(`Error: ${chalk.yellow(error.message)}`);
+        }
+    }
+}