@cremini/skillpack 1.2.3 → 1.2.4

package/README.md

@@ -23,7 +23,7 @@ Skillpack is built for teams that want AI Agents to be deployable, trusted, and
 1. Download the example
 - [Garry Tan SkillPack](https://github.com/CreminiAI/skillpack-examples/releases/download/v.0.0.3/garry-tan.zip)
 - [Company Deep Research SkillPack](https://github.com/FinpeakInc/downloads/releases/download/v.0.0.1/Company-Deep-Research.zip)
-2. Unzip it and Run ./start.sh on Mac OS, and double click start.bat on Windows (see below), the server starts and opens http://127.0.0.1:26313 in your browser
+2. Unzip it and Run ./start.sh on Mac OS, Or double click start.bat on Windows (see below), the server starts and opens http://127.0.0.1:26313 in your browser
 
 ```bash
 # macOS / Linux
@@ -110,76 +110,14 @@ If present, `AGENTS.md` and `SOUL.md` are read by SkillPack itself when a new ch
 
 ## Slack/Telegram Integrations
 
-**Slack Configuration**: requires Slack `App Token` and `Bot Token`<br>
-**Telegram configuration**: requires `Bot Token`
+Talk to your Agents on Slack and Telegram
 
-### Slack App Setup and how to get `App Token` and `Bot Token`
+### 5 mins to get Slack `App Token` and `Bot Token`
 https://skillpack.gitbook.io/skillpack-docs/getting-started/slack-integration
 
-1. Create a new Slack app at https://api.slack.com/apps
-2. Enable Socket Mode (Settings → Socket Mode → Enable)
-3. Generate an App-Level Token with `connections:write` scope. This is **`App Token`**
-4. Add Bot Token Scopes (OAuth & Permissions):
-
-- `app_mentions:read`
-- `channels:history`
-- `channels:read`
-- `chat:write`
-- `files:read`
-- `files:write`
-- `groups:history`
-- `groups:read`
-- `im:history`
-- `im:read`
-- `im:write`
-- `users:read`
-
-5. Subscribe to Bot Events (Event Subscriptions):
-
-- `app_mention`
-- `message.channels`
-- `message.groups`
-- `message.im`
-
-6. Enable Direct Messages (App Home):
-   Go to App Home in the left sidebar
-   Under Show Tabs, enable the Messages Tab
-   Check Allow users to send Slash commands and messages from the messages tab
-
-7. Install the app to your workspace. Get the Bot User OAuth Token. This is **`Bot Token`**
-8. Add the app to any channels where you want the agent to operate (it'll only see messages in channels it's added to)
-9. On the SkillPack buit-in UI http://127.0.0.1:26313, Tap "Connect to Chat App" button and Enter the **`Bot Token`** and **`App Token`**, Save
-
-### Telegram Setup and how to get `Bot Token`
+### 1 min to get Telegram `Bot Token`
 https://skillpack.gitbook.io/skillpack-docs/getting-started/telegram-integration
 
-1. **Open Telegram** and search for the official account **`@BotFather`** (it will have a blue verified checkmark).
-2. **Start a chat** by tapping "Start" or sending the `/start` command.
-3. **Send the command** `/newbot` to the BotFather.
-4. **Follow the prompts** to choose a display name and a unique username for your bot. The username must end with the word "bot" (e.g., `MyHelperBot` or `My_Helper_bot`).
-5. **Receive the token**. Once the bot is successfully created, the BotFather will provide you with a message containing your unique API token.
-   The token will look like a long string of numbers and letters, formatted as `123456789:AABBCCddEeff.... `
-6. On the SkillPack buit-in UI http://127.0.0.1:26313, Tap "Connect to Chat App" button and Enter the **`Bot Token`**, Save
-
-### (Optional) Put tokens into data/config.json if you don't use Web UI
-
-Or Once you have telegram or slack tokens, you can also configure them in `data/config.json` (created at runtime, not included in the zip):
-The runtime supports **Slack** and **Telegram** in addition to the built-in web UI.
-
-```json
-{
-  "adapters": {
-    "telegram": {
-      "token": "123456:ABC-DEF..."
-    },
-    "slack": {
-      "botToken": "xoxb-...",
-      "appToken": "xapp-..."
-    }
-  }
-}
-```
-
 ---
 
 ## Example Use Cases

package/dist/cli.js

@@ -267,6 +267,62 @@ var init_attachment_utils = __esm({
   }
 });
 
+// src/runtime/commands/index.ts
+function resolveCommand(input) {
+  const key = input.split(/\s/)[0].toLowerCase();
+  return COMMAND_ALIASES[key] ?? null;
+}
+function getVisibleCommands() {
+  return COMMAND_REGISTRY.filter((cmd) => cmd.visibleInHelp);
+}
+function getTelegramBotCommands() {
+  return COMMAND_REGISTRY.filter((cmd) => cmd.visibleInHelp).map((cmd) => ({
+    command: cmd.command,
+    description: cmd.description
+  }));
+}
+var COMMAND_REGISTRY, COMMAND_ALIASES;
+var init_commands = __esm({
+  "src/runtime/commands/index.ts"() {
+    "use strict";
+    COMMAND_REGISTRY = [
+      {
+        command: "help",
+        description: "Show available commands, skills, and usage tips",
+        visibleInHelp: true
+      },
+      {
+        command: "clear",
+        description: "Clear current session and start fresh",
+        visibleInHelp: true
+      },
+      {
+        command: "restart",
+        description: "Restart the server process",
+        visibleInHelp: true
+      },
+      {
+        command: "shutdown",
+        description: "Shut down the server process",
+        visibleInHelp: true
+      },
+      // "new" is a hidden alias for "clear" — not shown in /help
+      {
+        command: "new",
+        description: "Start a new session (alias for /clear)",
+        visibleInHelp: false
+      }
+    ];
+    COMMAND_ALIASES = {
+      "/help": "help",
+      "/clear": "clear",
+      "/new": "clear",
+      "/restart": "restart",
+      "/shutdown": "shutdown"
+    };
+  }
+});
+
 // src/runtime/adapters/markdown.ts
 function unwrapMarkdownSourceBlocks(text) {
   return text.replace(
@@ -307,6 +363,7 @@ function formatSlackInline(text) {
   );
   formatted = formatted.replace(/\*\*([^*\n]+)\*\*/g, "*$1*");
   formatted = formatted.replace(/__([^_\n]+)__/g, "*$1*");
+  formatted = formatted.replace(/^(?:-|\*) /gm, "\u2022 ");
   return formatted;
 }
 function formatTelegramInline(text) {
@@ -386,19 +443,15 @@ var telegram_exports = {};
 __export(telegram_exports, {
   TelegramAdapter: () => TelegramAdapter
 });
-import fs11 from "fs";
+import fs12 from "fs";
 import TelegramBot from "node-telegram-bot-api";
-var COMMANDS2, MAX_MESSAGE_LENGTH, ACK_REACTION, TelegramAdapter;
+var MAX_MESSAGE_LENGTH, ACK_REACTION, TelegramAdapter;
 var init_telegram = __esm({
   "src/runtime/adapters/telegram.ts"() {
     "use strict";
     init_markdown();
     init_attachment_utils();
-    COMMANDS2 = {
-      "/clear": "clear",
-      "/restart": "restart",
-      "/shutdown": "shutdown"
-    };
+    init_commands();
     MAX_MESSAGE_LENGTH = 4096;
     ACK_REACTION = {
       type: "emoji",
@@ -422,11 +475,7 @@ var init_telegram = __esm({
             console.error("[Telegram] Error handling message:", err);
           });
         });
-        await this.bot.setMyCommands([
-          { command: "clear", description: "Clear current session and start new" },
-          { command: "restart", description: "Restart the server process" },
-          { command: "shutdown", description: "Shut down the server process" }
-        ]);
+        await this.bot.setMyCommands(getTelegramBotCommands());
         const me = await this.bot.getMe();
         console.log(`[TelegramAdapter] Started as @${me.username}`);
       }
@@ -466,7 +515,7 @@ var init_telegram = __esm({
         await this.tryAckReaction(chatId, messageId);
         if (text) {
           const commandKey = text.split(/\s/)[0].toLowerCase();
-          const command = COMMANDS2[commandKey];
+          const command = this.resolveTelegramCommand(commandKey);
           if (command) {
             const result = await this.agent.handleCommand(command, channelId);
             await this.sendSafe(chatId, result.message || `/${command} executed.`);
@@ -521,6 +570,9 @@ var init_telegram = __esm({
           await this.sendFileSafe(chatId, file.filePath, file.caption);
         }
       }
+      resolveTelegramCommand(commandKey) {
+        return resolveCommand(commandKey);
+      }
       // -------------------------------------------------------------------------
       // Send helpers
       // -------------------------------------------------------------------------
@@ -697,7 +749,7 @@ var init_telegram = __esm({
       async sendFileSafe(chatId, filePath, caption) {
         if (!this.bot) return;
         try {
-          if (!fs11.existsSync(filePath)) {
+          if (!fs12.existsSync(filePath)) {
             console.error(`[Telegram] File not found for sending: ${filePath}`);
             return;
           }
@@ -717,16 +769,18 @@ var slack_exports = {};
 __export(slack_exports, {
   SlackAdapter: () => SlackAdapter
 });
-import fs12 from "fs";
-import path11 from "path";
+import fs13 from "fs";
+import path12 from "path";
 import { App, LogLevel } from "@slack/bolt";
-var INLINE_COMMANDS, SLASH_COMMANDS, MAX_MESSAGE_LENGTH2, ACK_REACTION2, SlackAdapter;
+var INLINE_COMMANDS, SLASH_COMMANDS, MAX_MESSAGE_LENGTH2, ACK_REACTION2, PROCESSING_MESSAGE, SlackAdapter;
 var init_slack = __esm({
   "src/runtime/adapters/slack.ts"() {
     "use strict";
     init_markdown();
     init_attachment_utils();
+    init_commands();
     INLINE_COMMANDS = {
+      "/help": "help",
       "/clear": "clear",
       "/restart": "restart",
       "/shutdown": "shutdown"
@@ -738,6 +792,7 @@ var init_slack = __esm({
     };
     MAX_MESSAGE_LENGTH2 = 3500;
     ACK_REACTION2 = "eyes";
+    PROCESSING_MESSAGE = "_Processing..._";
     SlackAdapter = class {
       name = "slack";
       app = null;
@@ -807,7 +862,7 @@ var init_slack = __esm({
             console.error("[Slack] Error handling mention:", err);
           }
         });
-        for (const commandName of Object.keys(SLASH_COMMANDS)) {
+        for (const commandName of [...Object.keys(SLASH_COMMANDS), "/new"]) {
           app.command(commandName, async (args) => {
             try {
               await this.handleSlashCommand(args);
@@ -872,7 +927,7 @@ var init_slack = __esm({
           await this.sendSafe(
             client,
             route,
-            "Mention me with a message, or use `/clear` to reset this thread."
+            "Mention me with a message, or use `/clear` or `/new` to reset this thread."
           );
           return;
         }
@@ -890,7 +945,7 @@ var init_slack = __esm({
         ack
       }) {
         const commandName = command?.command;
-        const mapped = commandName ? SLASH_COMMANDS[commandName] : void 0;
+        const mapped = commandName ? this.resolveSlashCommand(commandName) : void 0;
         if (!this.agent || !mapped) {
           await this.safeAck(ack, "Unsupported slash command.");
           return;
@@ -916,6 +971,7 @@ var init_slack = __esm({
         let hasError = false;
         let errorMessage = "";
         const pendingFiles = [];
+        const placeholder = await this.sendPlaceholderMessage(client, route);
         const onEvent = (event) => {
           if (event.type === "text_delta") {
             finalText += event.delta;
@@ -943,13 +999,25 @@ var init_slack = __esm({
           errorMessage = this.getErrorMessage(err);
         }
         if (hasError) {
-          await this.sendSafe(client, route, `\u274C Error: ${errorMessage}`);
+          await this.sendOrUpdateSafe(
+            client,
+            route,
+            `\u274C Error: ${errorMessage}`,
+            placeholder
+          );
           return;
         }
         if (finalText.trim()) {
-          await this.sendLongMessage(client, route, finalText);
+          await this.sendLongMessage(client, route, finalText, placeholder);
         } else if (pendingFiles.length === 0) {
-          await this.sendSafe(client, route, "(No response generated)");
+          await this.sendOrUpdateSafe(
+            client,
+            route,
+            "(No response generated)",
+            placeholder
+          );
+        } else if (placeholder) {
+          await this.deleteMessageSafe(client, route, placeholder.ts);
         }
         for (const file of pendingFiles) {
           await this.sendFileSafe(client, route, file.filePath, file.caption);
@@ -961,7 +1029,7 @@ var init_slack = __esm({
       async tryHandleInlineCommand(text, channelId, client, route) {
         if (!this.agent) return false;
         const commandKey = text.split(/\s/)[0].toLowerCase();
-        const command = INLINE_COMMANDS[commandKey];
+        const command = this.resolveInlineCommand(commandKey);
         if (!command) return false;
         const result = await this.agent.handleCommand(command, channelId);
         await this.sendSafe(
@@ -971,6 +1039,19 @@ var init_slack = __esm({
         );
         return true;
       }
+      resolveInlineCommand(commandKey) {
+        const resolved = resolveCommand(commandKey);
+        if (resolved) {
+          return resolved;
+        }
+        return INLINE_COMMANDS[commandKey];
+      }
+      resolveSlashCommand(commandName) {
+        if (commandName === "/new") {
+          return "clear";
+        }
+        return SLASH_COMMANDS[commandName];
+      }
       resolveSlashCommandTarget(payload, context) {
         const teamId = this.getTeamId(payload, context);
         const channel = payload?.channel_id;
@@ -988,7 +1069,7 @@ var init_slack = __esm({
         );
         if (!threadTs) {
           return {
-            message: "No active Skillpack thread found in this channel. Mention the bot first, or run the command inside the thread as `@bot /clear`."
+            message: "No active Skillpack thread found in this channel. Mention the bot first, or run the command inside the thread as `@bot /clear` or `@bot /new`."
           };
         }
         return {
@@ -1017,33 +1098,35 @@ var init_slack = __esm({
         return text.replace(mention, "");
       }
       splitMessage(text) {
-        if (text.length <= MAX_MESSAGE_LENGTH2) {
+        if (this.isSlackMessageWithinLimit(text)) {
           return [text];
         }
         const chunks = [];
         let remaining = text;
         while (remaining.length > 0) {
-          if (remaining.length <= MAX_MESSAGE_LENGTH2) {
+          if (this.isSlackMessageWithinLimit(remaining)) {
             chunks.push(remaining);
             break;
           }
-          let splitAt = remaining.lastIndexOf("\n\n", MAX_MESSAGE_LENGTH2);
-          if (splitAt < MAX_MESSAGE_LENGTH2 * 0.5) {
-            splitAt = remaining.lastIndexOf("\n", MAX_MESSAGE_LENGTH2);
-          }
-          if (splitAt < MAX_MESSAGE_LENGTH2 * 0.3) {
-            splitAt = remaining.lastIndexOf(" ", MAX_MESSAGE_LENGTH2);
-          }
-          if (splitAt < 1) {
-            splitAt = MAX_MESSAGE_LENGTH2;
-          }
+          let splitAt = this.findSlackSafeSplitPoint(remaining);
           chunks.push(remaining.slice(0, splitAt));
           remaining = remaining.slice(splitAt).trimStart();
         }
         return chunks;
       }
-      async sendLongMessage(client, route, text) {
-        for (const chunk of this.splitMessage(text)) {
+      async sendLongMessage(client, route, text, placeholder) {
+        const chunks = this.splitMessage(text);
+        if (chunks.length === 0) {
+          return;
+        }
+        if (placeholder) {
+          await this.updateMessageSafe(client, route, placeholder.ts, chunks[0]);
+          for (const chunk of chunks.slice(1)) {
+            await this.sendSafe(client, route, chunk);
+          }
+          return;
+        }
+        for (const chunk of chunks) {
           await this.sendWithRetry(client, route, chunk);
         }
       }
@@ -1054,17 +1137,35 @@ var init_slack = __esm({
           console.error("[Slack] Failed to send message:", err);
         }
       }
+      async sendOrUpdateSafe(client, route, text, placeholder) {
+        if (placeholder) {
+          await this.updateMessageSafe(client, route, placeholder.ts, text);
+          return;
+        }
+        await this.sendSafe(client, route, text);
+      }
+      async sendPlaceholderMessage(client, route) {
+        try {
+          return await this.sendWithRetry(client, route, PROCESSING_MESSAGE);
+        } catch (err) {
+          console.error("[Slack] Failed to send placeholder message:", err);
+          return null;
+        }
+      }
       async sendWithRetry(client, route, text, maxRetries = 3) {
         for (let attempt = 0; attempt <= maxRetries; attempt++) {
           try {
-            await client.chat.postMessage({
+            const response = await client.chat.postMessage({
               channel: route.channel,
               text: formatSlackMessage(text),
               mrkdwn: true,
               thread_ts: route.threadTs,
               reply_broadcast: false
             });
-            return;
+            if (typeof response.ts !== "string") {
+              throw new Error("Slack postMessage response missing ts");
+            }
+            return { ts: response.ts };
           } catch (err) {
             const retryAfter = this.getRetryAfterSeconds(err);
             if (retryAfter && attempt < maxRetries) {
@@ -1079,6 +1180,93 @@ var init_slack = __esm({
             throw err;
           }
         }
+        throw new Error("Slack postMessage failed after retries");
+      }
+      async updateMessageSafe(client, route, ts, text) {
+        try {
+          await this.updateWithRetry(client, route, ts, text);
+        } catch (err) {
+          console.error("[Slack] Failed to update message:", err);
+          await this.deleteMessageSafe(client, route, ts);
+          await this.sendSafe(client, route, text);
+        }
+      }
+      async updateWithRetry(client, route, ts, text, maxRetries = 3) {
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+          try {
+            await client.chat.update({
+              channel: route.channel,
+              ts,
+              text: formatSlackMessage(text),
+              mrkdwn: true
+            });
+            return;
+          } catch (err) {
+            const retryAfter = this.getRetryAfterSeconds(err);
+            if (retryAfter && attempt < maxRetries) {
+              console.log(
+                `[Slack] Rate limited while updating, retrying after ${retryAfter}s...`
+              );
+              await new Promise(
+                (resolve) => setTimeout(resolve, retryAfter * 1e3)
+              );
+              continue;
+            }
+            throw err;
+          }
+        }
+      }
+      async deleteMessageSafe(client, route, ts) {
+        try {
+          await client.chat.delete({
+            channel: route.channel,
+            ts
+          });
+        } catch (err) {
+          console.error("[Slack] Failed to delete placeholder message:", err);
+        }
+      }
+      isSlackMessageWithinLimit(text) {
+        return formatSlackMessage(text).length <= MAX_MESSAGE_LENGTH2;
+      }
+      findSlackSafeSplitPoint(text) {
+        const preferredBreaks = ["\n\n", "\n", " "];
+        const minSplit = Math.floor(MAX_MESSAGE_LENGTH2 * 0.3);
+        for (const token of preferredBreaks) {
+          const index = this.findBestSlackSplitBefore(text, token);
+          if (index >= minSplit) {
+            return index;
+          }
+        }
+        let low = 1;
+        let high = text.length;
+        let best = Math.min(text.length, MAX_MESSAGE_LENGTH2);
+        while (low <= high) {
+          const mid = Math.floor((low + high) / 2);
+          const candidate = text.slice(0, mid);
+          if (this.isSlackMessageWithinLimit(candidate)) {
+            best = mid;
+            low = mid + 1;
+          } else {
+            high = mid - 1;
+          }
+        }
+        return Math.max(1, best);
+      }
+      findBestSlackSplitBefore(text, token) {
+        let fromIndex = Math.min(text.length, MAX_MESSAGE_LENGTH2);
+        while (fromIndex > 0) {
+          const index = text.lastIndexOf(token, fromIndex);
+          if (index < 0) {
+            return -1;
+          }
+          const splitAt = index + token.length;
+          if (this.isSlackMessageWithinLimit(text.slice(0, splitAt))) {
+            return splitAt;
+          }
+          fromIndex = index - 1;
+        }
+        return -1;
       }
       async tryAckReaction(client, event) {
         try {
@@ -1196,12 +1384,12 @@ var init_slack = __esm({
        */
       async sendFileSafe(client, route, filePath, caption) {
         try {
-          if (!fs12.existsSync(filePath)) {
+          if (!fs13.existsSync(filePath)) {
             console.error(`[Slack] File not found for sending: ${filePath}`);
             return;
           }
-          const filename = path11.basename(filePath);
-          const fileContent = fs12.readFileSync(filePath);
+          const filename = path12.basename(filePath);
+          const fileContent = fs13.readFileSync(filePath);
           await client.files.uploadV2({
             channel_id: route.channel,
             thread_ts: route.threadTs,
@@ -2242,15 +2430,15 @@ async function interactiveCreate(workDir) {
 }
 
 // src/commands/run.ts
-import path13 from "path";
-import fs14 from "fs";
+import path14 from "path";
+import fs15 from "fs";
 import inquirer2 from "inquirer";
 import chalk4 from "chalk";
 
 // src/runtime/server.ts
 import express from "express";
-import path12 from "path";
-import fs13 from "fs";
+import path13 from "path";
+import fs14 from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { createServer } from "http";
 import { exec } from "child_process";
@@ -2258,8 +2446,8 @@ import { exec } from "child_process";
 // src/runtime/agent.ts
 init_config();
 init_attachment_utils();
-import path8 from "path";
-import fs8 from "fs";
+import path9 from "path";
+import fs9 from "fs";
 import { fileURLToPath } from "url";
 import {
   AuthStorage,
@@ -5115,6 +5303,67 @@ ${lines.join("\n")}`
   };
 }
 
+// src/runtime/commands/help-command.ts
+init_commands();
+import fs8 from "fs";
+import path8 from "path";
+function buildHelpMessage(rootDir) {
+  const sections = [];
+  const commands = getVisibleCommands();
+  const commandLines = commands.map(
+    (cmd) => `- \`/${cmd.command}\` \u2014 ${cmd.description}`
+  );
+  sections.push(`\u{1F4CB} **Available Commands**
+
+${commandLines.join("\n")}`);
+  const configPath = path8.resolve(rootDir, "skillpack.json");
+  const skills = readInstalledSkills(configPath);
+  if (skills.length > 0) {
+    const skillLines = skills.map(
+      (skill) => `- **${skill.name}**${skill.description ? ` \u2014 ${skill.description}` : ""}`
+    );
+    sections.push(
+      `\u{1F9E9} **Installed Skills** (${skills.length})
+
+${skillLines.join("\n")}`
+    );
+  } else {
+    sections.push("\u{1F9E9} **Installed Skills**\nNo skills installed.");
+  }
+  sections.push(
+    [
+      "\u23F0 **Scheduled Tasks**",
+      "",
+      "You can set up recurring tasks using natural language. For example:",
+      "",
+      '- "Send me a daily market briefing every morning at 9 AM"',
+      `- "Summarize this week's trading data every Friday at 6 PM"`,
+      '- "Check for new announcements every 30 minutes"',
+      "",
+      "I will handle the cron scheduling automatically."
+    ].join("\n")
+  );
+  return sections.join("\n\n");
+}
+function handleHelpCommand(rootDir) {
+  return {
+    success: true,
+    message: buildHelpMessage(rootDir)
+  };
+}
+function readInstalledSkills(configPath) {
+  if (!fs8.existsSync(configPath)) {
+    return [];
+  }
+  try {
+    const raw = fs8.readFileSync(configPath, "utf-8");
+    const config = JSON.parse(raw);
+    return Array.isArray(config.skills) ? config.skills : [];
+  } catch {
+    return [];
+  }
+}
+
 // src/runtime/agent.ts
 var DEBUG = true;
 var log = (...args) => DEBUG && console.log(...args);
@@ -5127,24 +5376,24 @@ var BUILTIN_SKILL_CREATOR_TEMPLATE_DIR = fileURLToPath(
 var PACK_AGENTS_FILE = "AGENTS.md";
 var PACK_SOUL_FILE = "SOUL.md";
 function materializeBuiltinSkillCreator(rootDir, skillsPath) {
-  if (!fs8.existsSync(BUILTIN_SKILL_CREATOR_TEMPLATE_DIR)) {
+  if (!fs9.existsSync(BUILTIN_SKILL_CREATOR_TEMPLATE_DIR)) {
     log(
       `[PackAgent] Built-in skill-creator template missing: ${BUILTIN_SKILL_CREATOR_TEMPLATE_DIR}`
     );
     return null;
   }
-  const packConfigPath = path8.resolve(rootDir, "skillpack.json");
-  const skillDir = path8.resolve(skillsPath, BUILTIN_SKILL_CREATOR_NAME);
-  const skillPath = path8.join(skillDir, "SKILL.md");
+  const packConfigPath = path9.resolve(rootDir, "skillpack.json");
+  const skillDir = path9.resolve(skillsPath, BUILTIN_SKILL_CREATOR_NAME);
+  const skillPath = path9.join(skillDir, "SKILL.md");
   const renderTemplate = (content) => content.replaceAll("{{SKILLS_PATH}}", skillsPath).replaceAll("{{PACK_CONFIG_PATH}}", packConfigPath);
   const copyDir = (srcDir, destDir) => {
-    fs8.mkdirSync(destDir, { recursive: true });
-    for (const entry of fs8.readdirSync(srcDir, { withFileTypes: true })) {
+    fs9.mkdirSync(destDir, { recursive: true });
+    for (const entry of fs9.readdirSync(srcDir, { withFileTypes: true })) {
       if (entry.name === ".DS_Store") {
         continue;
       }
-      const srcPath = path8.join(srcDir, entry.name);
-      const destPath = path8.join(destDir, entry.name);
+      const srcPath = path9.join(srcDir, entry.name);
+      const destPath = path9.join(destDir, entry.name);
       if (entry.isDirectory()) {
         copyDir(srcPath, destPath);
         continue;
@@ -5153,17 +5402,17 @@ function materializeBuiltinSkillCreator(rootDir, skillsPath) {
         continue;
       }
       if (entry.name.endsWith(".md") || entry.name.endsWith(".py")) {
-        const content = fs8.readFileSync(srcPath, "utf-8");
-        fs8.writeFileSync(destPath, renderTemplate(content), "utf-8");
+        const content = fs9.readFileSync(srcPath, "utf-8");
+        fs9.writeFileSync(destPath, renderTemplate(content), "utf-8");
         continue;
       }
-      fs8.copyFileSync(srcPath, destPath);
+      fs9.copyFileSync(srcPath, destPath);
     }
   };
-  if (!fs8.existsSync(skillDir)) {
+  if (!fs9.existsSync(skillDir)) {
     copyDir(BUILTIN_SKILL_CREATOR_TEMPLATE_DIR, skillDir);
   }
-  if (!fs8.existsSync(skillPath)) {
+  if (!fs9.existsSync(skillPath)) {
     log(
       `[PackAgent] Materialized built-in skill-creator but SKILL.md is missing: ${skillPath}`
     );
@@ -5191,11 +5440,11 @@ function overrideBuiltinSkillCreator(base, materializedSkill) {
   };
 }
 function readOptionalPackPromptFile(filePath) {
-  if (!fs8.existsSync(filePath)) {
+  if (!fs9.existsSync(filePath)) {
     return void 0;
   }
   try {
-    const content = fs8.readFileSync(filePath, "utf-8").trim();
+    const content = fs9.readFileSync(filePath, "utf-8").trim();
     return content.length > 0 ? content : void 0;
   } catch (error) {
     console.warn(`[PackAgent] Warning: Could not read ${filePath}:`, error);
@@ -5203,8 +5452,8 @@ function readOptionalPackPromptFile(filePath) {
   }
 }
 function buildPackPromptBlock(rootDir) {
-  const agentsPath = path8.resolve(rootDir, PACK_AGENTS_FILE);
-  const soulPath = path8.resolve(rootDir, PACK_SOUL_FILE);
+  const agentsPath = path9.resolve(rootDir, PACK_AGENTS_FILE);
+  const soulPath = path9.resolve(rootDir, PACK_SOUL_FILE);
   const agentsContent = readOptionalPackPromptFile(agentsPath);
   const soulContent = readOptionalPackPromptFile(soulPath);
   if (!agentsContent && !soulContent) {
@@ -5270,7 +5519,7 @@ var PackAgent = class {
   authStorage;
   constructor(options) {
     this.options = options;
-    const configPath = path8.resolve(options.rootDir, "data", "config.json");
+    const configPath = path9.resolve(options.rootDir, "data", "config.json");
     const backend = new ConfigFileAuthBackend(configPath);
     this.authStorage = AuthStorage.fromStorage(backend);
     const providerMeta = SUPPORTED_PROVIDERS[options.provider];
@@ -5321,24 +5570,24 @@ var PackAgent = class {
       if (resolvedModel && baseUrl) {
         log(`[PackAgent] Overriding ${provider}/${modelId} baseUrl -> ${baseUrl}`);
       }
-      const sessionDir = path8.resolve(
+      const sessionDir = path9.resolve(
         rootDir,
         "data",
         "sessions",
         channelId
       );
-      fs8.mkdirSync(sessionDir, { recursive: true });
+      fs9.mkdirSync(sessionDir, { recursive: true });
       const sessionManager = SessionManager.continueRecent(rootDir, sessionDir);
       log(`[PackAgent] Session dir: ${sessionDir}`);
-      const workspaceDir = path8.resolve(
+      const workspaceDir = path9.resolve(
         rootDir,
         "data",
         "workspaces",
         channelId
       );
-      fs8.mkdirSync(workspaceDir, { recursive: true });
+      fs9.mkdirSync(workspaceDir, { recursive: true });
       log(`[PackAgent] Workspace dir: ${workspaceDir}`);
-      const skillsPath = path8.resolve(rootDir, "skills");
+      const skillsPath = path9.resolve(rootDir, "skills");
       log(`[PackAgent] Loading skills from: ${skillsPath}`);
       const materializedSkillCreator = materializeBuiltinSkillCreator(
         rootDir,
@@ -5529,6 +5778,8 @@ ${text}`;
   }
   async handleCommand(command, channelId) {
     switch (command) {
+      case "help":
+        return handleHelpCommand(this.options.rootDir);
       case "new":
       case "clear": {
         const cs = this.channels.get(channelId);
@@ -5537,9 +5788,9 @@ ${text}`;
           this.channels.delete(channelId);
         }
         const { rootDir } = this.options;
-        const sessionDir = path8.resolve(rootDir, "data", "sessions", channelId);
-        if (fs8.existsSync(sessionDir)) {
-          fs8.rmSync(sessionDir, { recursive: true, force: true });
+        const sessionDir = path9.resolve(rootDir, "data", "sessions", channelId);
+        if (fs9.existsSync(sessionDir)) {
+          fs9.rmSync(sessionDir, { recursive: true, force: true });
           log(`[PackAgent] Cleared session dir: ${sessionDir}`);
         }
         return {
@@ -5588,22 +5839,20 @@ ${text}`;
 
 // src/runtime/adapters/web.ts
 init_config();
-import fs9 from "fs";
-import path9 from "path";
+init_commands();
+import fs10 from "fs";
+import path10 from "path";
 import { WebSocketServer } from "ws";
 function getPackConfig(rootDir) {
-  const raw = fs9.readFileSync(path9.join(rootDir, "skillpack.json"), "utf-8");
+  const raw = fs10.readFileSync(path10.join(rootDir, "skillpack.json"), "utf-8");
   return JSON.parse(raw);
 }
-var COMMANDS = {
-  "/new": "new",
-  "/clear": "clear",
-  "/restart": "restart",
-  "/shutdown": "shutdown"
-};
 function parseCommand(text) {
-  const trimmed = text.trim().toLowerCase();
-  return COMMANDS[trimmed] ?? null;
+  return resolveCommand(text.trim().toLowerCase());
+}
+function sendWsEvent(ws, event) {
+  if (ws.readyState !== ws.OPEN) return;
+  ws.send(JSON.stringify(event));
 }
 function getRuntimeConfigSignature(config) {
   return JSON.stringify({
@@ -5744,23 +5993,23 @@ var WebAdapter = class {
         res.status(400).json({ error: "Missing 'path' query parameter" });
         return;
       }
-      const resolvedPath = path9.resolve(filePath);
-      const dataDir = path9.resolve(rootDir, "data");
+      const resolvedPath = path10.resolve(filePath);
+      const dataDir = path10.resolve(rootDir, "data");
       if (!resolvedPath.startsWith(dataDir)) {
         res.status(403).json({ error: "Access denied" });
         return;
       }
-      if (!fs9.existsSync(resolvedPath)) {
+      if (!fs10.existsSync(resolvedPath)) {
         res.status(404).json({ error: "File not found" });
         return;
       }
-      const filename = path9.basename(resolvedPath);
+      const filename = path10.basename(resolvedPath);
       res.setHeader("Content-Type", "application/octet-stream");
       res.setHeader(
         "Content-Disposition",
         `attachment; filename="${filename}"`
       );
-      fs9.createReadStream(resolvedPath).pipe(res);
+      fs10.createReadStream(resolvedPath).pipe(res);
     });
     const getScheduler = () => {
       const schedulerAdapter = ctx.adapterMap?.get("scheduler");
@@ -5881,21 +6130,14 @@ var WebAdapter = class {
         const command = parseCommand(text);
         if (command) {
           const result2 = await agent.handleCommand(command, channelId);
-          ws.send(
-            JSON.stringify({
-              type: "command_result",
-              command,
-              ...result2
-            })
-          );
-          if (command === "clear" || command === "new") {
-            ws.send(JSON.stringify({ done: true }));
+          if (result2.message) {
+            sendWsEvent(ws, { type: "text_delta", delta: result2.message });
           }
+          ws.send(JSON.stringify({ done: true }));
           return;
         }
         const onEvent = (event) => {
-          if (ws.readyState !== ws.OPEN) return;
-          ws.send(JSON.stringify(event));
+          sendWsEvent(ws, event);
         };
         const result = await agent.handleMessage("web", channelId, text, onEvent);
         if (result.errorMessage) {
@@ -5989,28 +6231,28 @@ var Lifecycle = class {
 
 // src/runtime/registry.ts
 import crypto from "crypto";
-import fs10 from "fs";
+import fs11 from "fs";
 import os from "os";
-import path10 from "path";
-var SKILLPACK_HOME = path10.join(os.homedir(), ".skillpack");
-var LEGACY_REGISTRY_FILE = path10.join(SKILLPACK_HOME, "registry.json");
-var REGISTRY_DIR = path10.join(SKILLPACK_HOME, "registry.d");
+import path11 from "path";
+var SKILLPACK_HOME = path11.join(os.homedir(), ".skillpack");
+var LEGACY_REGISTRY_FILE = path11.join(SKILLPACK_HOME, "registry.json");
+var REGISTRY_DIR = path11.join(SKILLPACK_HOME, "registry.d");
 var migrationChecked = false;
 function ensureHomeDir() {
-  if (!fs10.existsSync(SKILLPACK_HOME)) {
-    fs10.mkdirSync(SKILLPACK_HOME, { recursive: true });
+  if (!fs11.existsSync(SKILLPACK_HOME)) {
+    fs11.mkdirSync(SKILLPACK_HOME, { recursive: true });
   }
 }
 function ensureRegistryDir() {
   ensureHomeDir();
-  if (!fs10.existsSync(REGISTRY_DIR)) {
-    fs10.mkdirSync(REGISTRY_DIR, { recursive: true });
+  if (!fs11.existsSync(REGISTRY_DIR)) {
+    fs11.mkdirSync(REGISTRY_DIR, { recursive: true });
   }
 }
 function canonicalizeDir(dir) {
-  const resolved = path10.resolve(dir);
+  const resolved = path11.resolve(dir);
   try {
-    return fs10.realpathSync(resolved);
+    return fs11.realpathSync(resolved);
   } catch {
     return resolved;
   }
@@ -6019,7 +6261,7 @@ function hashDir(dir) {
   return crypto.createHash("md5").update(canonicalizeDir(dir)).digest("hex");
 }
 function getEntryPathForCanonicalDir(dir) {
-  return path10.join(REGISTRY_DIR, `${hashDir(dir)}.json`);
+  return path11.join(REGISTRY_DIR, `${hashDir(dir)}.json`);
 }
 function getEntryPath(dir) {
   ensureRegistryReady();
@@ -6027,11 +6269,11 @@ function getEntryPath(dir) {
 }
 function listEntryFiles() {
   ensureRegistryReady();
-  return fs10.readdirSync(REGISTRY_DIR).filter((file) => file.endsWith(".json")).sort().map((file) => path10.join(REGISTRY_DIR, file));
+  return fs11.readdirSync(REGISTRY_DIR).filter((file) => file.endsWith(".json")).sort().map((file) => path11.join(REGISTRY_DIR, file));
 }
 function readEntryFile(filePath) {
   try {
-    const raw = fs10.readFileSync(filePath, "utf-8");
+    const raw = fs11.readFileSync(filePath, "utf-8");
     const data = JSON.parse(raw);
     if (typeof data?.dir !== "string" || typeof data?.name !== "string" || typeof data?.version !== "string" || typeof data?.port !== "number" || typeof data?.pid !== "number" && data?.pid !== null || data?.status !== "running" && data?.status !== "stopped") {
       return null;
@@ -6064,8 +6306,8 @@ function writeEntryFile(entry) {
   };
   const entryPath = getEntryPathForCanonicalDir(normalized.dir);
   const tmpPath = createTmpPath(entryPath);
-  fs10.writeFileSync(tmpPath, JSON.stringify(normalized, null, 2), "utf-8");
-  fs10.renameSync(tmpPath, entryPath);
+  fs11.writeFileSync(tmpPath, JSON.stringify(normalized, null, 2), "utf-8");
+  fs11.renameSync(tmpPath, entryPath);
 }
 function migrateLegacyRegistryIfNeeded() {
   if (migrationChecked) {
@@ -6073,14 +6315,14 @@ function migrateLegacyRegistryIfNeeded() {
   }
   migrationChecked = true;
   ensureRegistryDir();
-  if (!fs10.existsSync(LEGACY_REGISTRY_FILE)) {
+  if (!fs11.existsSync(LEGACY_REGISTRY_FILE)) {
     return;
   }
   if (listEntryFiles().length > 0) {
     return;
   }
   try {
-    const raw = fs10.readFileSync(LEGACY_REGISTRY_FILE, "utf-8");
+    const raw = fs11.readFileSync(LEGACY_REGISTRY_FILE, "utf-8");
     const data = JSON.parse(raw);
     const packs = Array.isArray(data?.packs) ? data.packs : [];
     for (const pack of packs) {
@@ -6093,7 +6335,7 @@ function migrateLegacyRegistryIfNeeded() {
       } catch {
       }
     }
-    fs10.renameSync(LEGACY_REGISTRY_FILE, `${LEGACY_REGISTRY_FILE}.legacy`);
+    fs11.renameSync(LEGACY_REGISTRY_FILE, `${LEGACY_REGISTRY_FILE}.legacy`);
   } catch (err) {
     console.warn("  [Registry] Failed to migrate legacy registry.json:", err);
   }
@@ -6146,7 +6388,7 @@ function deregister(dir, pid) {
 }
 
 // src/runtime/server.ts
-var __dirname = path12.dirname(fileURLToPath2(import.meta.url));
+var __dirname = path13.dirname(fileURLToPath2(import.meta.url));
 async function startServer(options) {
   const {
     rootDir,
@@ -6161,8 +6403,8 @@ async function startServer(options) {
   const packConfig = loadConfig(canonicalRootDir);
   const baseUrl = dataConfig.baseUrl?.trim() || void 0;
   const modelId = SUPPORTED_PROVIDERS[provider]?.defaultModelId ?? SUPPORTED_PROVIDERS.openai.defaultModelId;
-  const packageRoot = path12.resolve(__dirname, "..");
-  const webDir = fs13.existsSync(path12.join(rootDir, "web")) ? path12.join(rootDir, "web") : path12.join(packageRoot, "web");
+  const packageRoot = path13.resolve(__dirname, "..");
+  const webDir = fs14.existsSync(path13.join(rootDir, "web")) ? path13.join(rootDir, "web") : path13.join(packageRoot, "web");
   const app = express();
   app.use(express.json());
   app.use(express.static(webDir));
@@ -6330,23 +6572,23 @@ function findMissingSkills(workDir, config) {
   });
 }
 function copyStartTemplates2(workDir) {
-  const templateDir = path13.resolve(
+  const templateDir = path14.resolve(
     new URL("../templates", import.meta.url).pathname
   );
   for (const file of ["start.sh", "start.bat"]) {
-    const src = path13.join(templateDir, file);
-    const dest = path13.join(workDir, file);
-    if (fs14.existsSync(src)) {
-      fs14.copyFileSync(src, dest);
+    const src = path14.join(templateDir, file);
+    const dest = path14.join(workDir, file);
+    if (fs15.existsSync(src)) {
+      fs15.copyFileSync(src, dest);
       if (file === "start.sh") {
-        fs14.chmodSync(dest, 493);
+        fs15.chmodSync(dest, 493);
       }
     }
   }
 }
 async function runCommand(directory) {
-  const workDir = directory ? path13.resolve(directory) : process.cwd();
-  fs14.mkdirSync(workDir, { recursive: true });
+  const workDir = directory ? path14.resolve(directory) : process.cwd();
+  fs15.mkdirSync(workDir, { recursive: true });
   if (!configExists(workDir)) {
     console.log(chalk4.blue("\n  No skillpack.json found. Let's set one up.\n"));
     const { name, description } = await inquirer2.prompt([
@@ -6391,9 +6633,9 @@ async function runCommand(directory) {
 }
 
 // src/cli.ts
-import fs15 from "fs";
+import fs16 from "fs";
 var packageJson = JSON.parse(
-  fs15.readFileSync(new URL("../package.json", import.meta.url), "utf-8")
+  fs16.readFileSync(new URL("../package.json", import.meta.url), "utf-8")
 );
 var program = new Command();
 program.name("skillpack").description("Assemble, package, and run Agent Skills packs").version(packageJson.version);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cremini/skillpack",
-  "version": "1.2.3",
+  "version": "1.2.4",
   "description": "Pack AI Skills into Local Agents",
   "type": "module",
   "repository": {
@@ -65,4 +65,4 @@
     "tsup": "^8.5.1",
     "typescript": "^5.9.3"
   }
-}
+}

package/web/js/chat.js

@@ -282,21 +282,6 @@ function handleAgentEvent(event) {
     hideLoadingIndicator();
   }
 
-  // Handle bot command results injected by the backend WebSocket response
-  if (event.type === "command_result") {
-    const textBlock = getOrCreateTextBlock();
-    let resText = `Command \`${event.command}\` succeeded.`;
-    if (event.errorMessage) {
-      resText = `Command \`${event.command}\` failed: ${event.errorMessage}`;
-    } else if (event.result) {
-      resText = `Command \`${event.command}\` result:\n\n${event.result}`;
-    }
-    textBlock.dataset.mdContent += resText;
-    textBlock.innerHTML = renderMarkdown(textBlock.dataset.mdContent);
-    scrollToBottom();
-    return;
-  }
-
   switch (event.type) {
     case "agent_start":
     case "message_start":