@cremini/skillpack 1.0.7 → 1.0.9-im.0

package/README.md

@@ -1,8 +1,10 @@
 # SkillPack.sh - Pack AI Skills into Standalone Apps
 
+Skillpack by Cremini is built on the idea of distributed intelligence, much like cremini mushrooms that grow from a vast, interconnected mycelial network.
+
 Go to [skillpack.sh](https://skillpack.sh) to pack skills and try existing skill packs.
 
-One command to orchestrate [Skills](https://skills.sh), tools, mcps into a standalone app users can download and use on their own computer!
+One command to orchestrate [Skills](https://skills.sh), tools, mcps into a standalone app users can download and use on their own computer to address a well-defined problem or complete specific tasks!
 
 ```bash
 npx @cremini/skillpack create
@@ -84,7 +86,7 @@ skillpack/
 
 ```bash
 # macOS / Linux
-chmod +x start.sh && ./start.sh
+./start.sh
 
 # Windows
 start.bat

package/dist/cli.js

@@ -317,6 +317,13 @@ import fs3 from "fs";
 import path3 from "path";
 import { fileURLToPath } from "url";
 var __dirname = path3.dirname(fileURLToPath(import.meta.url));
+var EXECUTABLE_RUNTIME_FILES = /* @__PURE__ */ new Set(["start.sh", "start.bat"]);
+function isExecutableRuntimeFile(relativePath) {
+  return EXECUTABLE_RUNTIME_FILES.has(relativePath);
+}
+function withExecuteBits(mode) {
+  return mode | 73;
+}
 function getRuntimeDir() {
   const projectRoot = path3.resolve(__dirname, "..");
   return path3.join(projectRoot, "runtime");
@@ -335,6 +342,10 @@ function collectRuntimeTemplateEntries(runtimeDir) {
       if (dirEntry.name === "node_modules") {
         continue;
       }
+      const currentRelative = relativeDir ? path3.posix.join(relativeDir, dirEntry.name) : dirEntry.name;
+      if (currentRelative === "server/src" || currentRelative === "server/tsconfig.json") {
+        continue;
+      }
       const absolutePath = path3.join(currentDir, dirEntry.name);
       const relativePath = relativeDir ? path3.posix.join(relativeDir, dirEntry.name) : dirEntry.name;
       const stats = fs3.statSync(absolutePath);
@@ -374,6 +385,16 @@ function copyRuntimeTemplate(runtimeDir, workDir) {
     fs3.chmodSync(destinationPath, entry.stats.mode);
   }
 }
+function ensureRuntimeLaunchersExecutable(workDir) {
+  for (const relativePath of EXECUTABLE_RUNTIME_FILES) {
+    const filePath = path3.join(workDir, relativePath);
+    if (!fs3.existsSync(filePath)) {
+      continue;
+    }
+    const currentMode = fs3.statSync(filePath).mode;
+    fs3.chmodSync(filePath, withExecuteBits(currentMode));
+  }
+}
 function addRuntimeFiles(archive, runtimeDir, prefix) {
   const entries = collectRuntimeTemplateEntries(runtimeDir);
   for (const entry of entries) {
@@ -387,7 +408,7 @@ function addRuntimeFiles(archive, runtimeDir, prefix) {
     }
     archive.file(entry.absolutePath, {
       name: archivePath,
-      mode: entry.stats.mode
+      mode: isExecutableRuntimeFile(entry.relativePath) ? withExecuteBits(entry.stats.mode) : entry.stats.mode
     });
   }
 }
@@ -433,6 +454,25 @@ async function bundle(workDir) {
 function parseSkillNames(value) {
   return value.split(",").map((name) => name.trim()).filter(Boolean);
 }
+function normalizeSourceInput(value) {
+  return value.trim().replace(/^npx\s+skills\s+add\s+/u, "");
+}
+function parseSourceInput(value) {
+  const trimmedValue = normalizeSourceInput(value);
+  const skillFlagIndex = trimmedValue.indexOf(" --skill ");
+  if (skillFlagIndex === -1) {
+    return {
+      source: trimmedValue,
+      inlineSkillNames: []
+    };
+  }
+  const source = trimmedValue.slice(0, skillFlagIndex).trim();
+  const inlineSkillValue = trimmedValue.slice(skillFlagIndex + " --skill ".length).trim();
+  return {
+    source,
+    inlineSkillNames: inlineSkillValue.split(/[,\s]+/).map((name) => name.trim()).filter(Boolean)
+  };
+}
 async function createCommand(directory) {
   const workDir = directory ? path5.resolve(directory) : process.cwd();
   if (directory) {
@@ -476,7 +516,10 @@ async function createCommand(directory) {
     chalk3.dim("  Supported formats: owner/repo, GitHub URL, or local path")
   );
   console.log(chalk3.dim("  Example source: vercel-labs/agent-skills"));
-  console.log(chalk3.dim("  Example skill names: frontend-design, skill-creator\n"));
+  console.log(
+    chalk3.dim("  Example inline skill: vercel-labs/agent-skills --skill find-skills")
+  );
+  console.log();
   while (true) {
     const { source } = await inquirer.prompt([
       {
@@ -488,16 +531,24 @@ async function createCommand(directory) {
     if (!source.trim()) {
       break;
     }
-    const { skillNames } = await inquirer.prompt([
-      {
-        type: "input",
-        name: "skillNames",
-        message: "Skill names (comma-separated):",
-        validate: (value) => parseSkillNames(value).length > 0 ? true : "Enter at least one skill name"
-      }
-    ]);
-    const nextSkills = parseSkillNames(skillNames).map((skillName) => ({
-      source: source.trim(),
+    const parsedSource = parseSourceInput(source);
+    let skillNames = parsedSource.inlineSkillNames;
+    if (skillNames.length === 0) {
+      console.log(
+        chalk3.dim("  Example skill names: frontend-design, skill-creator")
+      );
+      const promptResult = await inquirer.prompt([
+        {
+          type: "input",
+          name: "skillNames",
+          message: "Skill names (comma-separated):",
+          validate: (value) => parseSkillNames(value).length > 0 ? true : "Enter at least one skill name"
+        }
+      ]);
+      skillNames = parseSkillNames(promptResult.skillNames);
+    }
+    const nextSkills = skillNames.map((skillName) => ({
+      source: parsedSource.source,
       name: skillName,
       description: ""
     }));
@@ -610,6 +661,7 @@ async function initCommand(directory, options) {
   installConfiguredSkills(workDir, config);
   refreshDescriptionsAndSave(workDir, config);
   copyRuntimeTemplate(getRuntimeDir(), workDir);
+  ensureRuntimeLaunchersExecutable(workDir);
   if (options.bundle) {
     await bundle(workDir);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cremini/skillpack",
-  "version": "1.0.7",
+  "version": "1.0.9-im.0",
   "description": "Turn Skills into a Standalone App with UI",
   "type": "module",
   "repository": {
@@ -24,7 +24,8 @@
     "node": ">=20"
   },
   "scripts": {
-    "build": "tsup",
+    "build": "npm run build:runtime && tsup",
+    "build:runtime": "cd runtime/server && npx tsc",
     "dev": "tsup --watch",
     "check": "tsc --noEmit",
     "format": "prettier --write .",

package/runtime/server/chat-proxy.js

@@ -12,6 +12,34 @@ const DEBUG = true;
 const log = (...args) => DEBUG && console.log(...args);
 const write = (data) => DEBUG && process.stdout.write(data);
 
+function getAssistantDiagnostics(message) {
+  if (!message || message.role !== "assistant") {
+    return null;
+  }
+
+  const stopReason = message.stopReason;
+  const errorMessage =
+    message.errorMessage ||
+    (stopReason === "error" || stopReason === "aborted"
+      ? `Request ${stopReason}`
+      : "");
+
+  const content = Array.isArray(message.content) ? message.content : [];
+  const text = content
+    .filter((item) => item?.type === "text")
+    .map((item) => item.text || "")
+    .join("")
+    .trim();
+  const toolCalls = content.filter((item) => item?.type === "toolCall").length;
+
+  return {
+    stopReason,
+    errorMessage,
+    hasText: text.length > 0,
+    toolCalls,
+  };
+}
+
 /**
  * Handle incoming WebSocket connection using pi-coding-agent
  * @param {import("ws").WebSocket} ws
@@ -24,6 +52,8 @@ export async function handleWsConnection(
   { apiKey, rootDir, provider = "openai", modelId = "gpt-5.4" },
 ) {
   try {
+    let turnHadVisibleOutput = false;
+
     // Create an in-memory auth storage to avoid touching disk
     const authStorage = AuthStorage.inMemory({
       [provider]: { type: "api_key", key: apiKey },
@@ -78,6 +108,7 @@ export async function handleWsConnection(
 
         case "message_update":
           if (event.assistantMessageEvent?.type === "text_delta") {
+            turnHadVisibleOutput = true;
             write(event.assistantMessageEvent.delta);
             ws.send(
               JSON.stringify({
@@ -86,6 +117,7 @@ export async function handleWsConnection(
               }),
             );
           } else if (event.assistantMessageEvent?.type === "thinking_delta") {
+            turnHadVisibleOutput = true;
             ws.send(
               JSON.stringify({
                 type: "thinking_delta",
@@ -97,6 +129,17 @@ export async function handleWsConnection(
 
         case "message_end":
           log(`\n--- [Message End: ${event.message?.role}] ---`);
+          if (event.message?.role === "assistant") {
+            const diagnostics = getAssistantDiagnostics(event.message);
+            if (diagnostics) {
+              log(
+                `[Assistant Diagnostics] stopReason=${diagnostics.stopReason || "unknown"} text=${diagnostics.hasText ? "yes" : "no"} toolCalls=${diagnostics.toolCalls}`,
+              );
+              if (diagnostics.errorMessage) {
+                log(`[Assistant Error] ${diagnostics.errorMessage}`);
+              }
+            }
+          }
           ws.send(
             JSON.stringify({
               type: "message_end",
@@ -106,6 +149,7 @@ export async function handleWsConnection(
           break;
 
         case "tool_execution_start":
+          turnHadVisibleOutput = true;
           log(`\n>>> [Tool Execution Start: ${event.toolName}] >>>`);
           log("Args:", JSON.stringify(event.args, null, 2));
           ws.send(
@@ -118,6 +162,7 @@ export async function handleWsConnection(
           break;
 
         case "tool_execution_end":
+          turnHadVisibleOutput = true;
           log(`<<< [Tool Execution End: ${event.toolName}] <<<`);
           log(`Error: ${event.isError ? "Yes" : "No"}`);
           ws.send(
@@ -142,8 +187,31 @@ export async function handleWsConnection(
       try {
         const payload = JSON.parse(data.toString());
         if (payload.text) {
+          turnHadVisibleOutput = false;
+
           // Send prompt to the agent, the session will handle message history natively
           await session.prompt(payload.text);
+
+          const lastMessage = session.state.messages.at(-1);
+          const diagnostics = getAssistantDiagnostics(lastMessage);
+          if (diagnostics?.errorMessage) {
+            ws.send(JSON.stringify({ error: diagnostics.errorMessage }));
+            return;
+          }
+
+          if (
+            diagnostics &&
+            !diagnostics.hasText &&
+            diagnostics.toolCalls === 0 &&
+            !turnHadVisibleOutput
+          ) {
+            const emptyResponseError =
+              "Assistant returned no visible output. Check the server logs for stopReason/provider details.";
+            log(`[Assistant Warning] ${emptyResponseError}`);
+            ws.send(JSON.stringify({ error: emptyResponseError }));
+            return;
+          }
+
           ws.send(JSON.stringify({ done: true }));
         }
       } catch (err) {

package/runtime/server/dist/adapters/telegram.js

@@ -0,0 +1,200 @@
+import TelegramBot from "node-telegram-bot-api";
+const COMMANDS = {
+    "/clear": "clear",
+    "/restart": "restart",
+    "/shutdown": "shutdown",
+};
+const MAX_MESSAGE_LENGTH = 4096;
+// ---------------------------------------------------------------------------
+// Markdown → Telegram MarkdownV2 escaping
+// ---------------------------------------------------------------------------
+/**
+ * Escape special characters for Telegram MarkdownV2.
+ * Reference: https://core.telegram.org/bots/api#markdownv2-style
+ */
+function escapeMarkdownV2(text) {
+    return text.replace(/([_*\[\]()~`>#+\-=|{}.!\\])/g, "\\$1");
+}
+/**
+ * Attempt basic conversion from standard markdown to Telegram MarkdownV2.
+ * Falls back to plain text on complex formatting.
+ */
+function toTelegramFormat(text) {
+    try {
+        // For now, just escape the text for MarkdownV2.
+        // Complex markdown conversion can be enhanced later.
+        return escapeMarkdownV2(text);
+    }
+    catch {
+        return text;
+    }
+}
+// ---------------------------------------------------------------------------
+// TelegramAdapter
+// ---------------------------------------------------------------------------
+export class TelegramAdapter {
+    name = "telegram";
+    bot = null;
+    agent = null;
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async start(ctx) {
+        this.agent = ctx.agent;
+        this.bot = new TelegramBot(this.options.token, { polling: true });
+        this.bot.on("message", (msg) => {
+            this.handleTelegramMessage(msg).catch((err) => {
+                console.error("[Telegram] Error handling message:", err);
+            });
+        });
+        // Register bot commands with Telegram
+        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" },
+        ]);
+        const me = await this.bot.getMe();
+        console.log(`[TelegramAdapter] Started as @${me.username}`);
+    }
+    async stop() {
+        if (this.bot) {
+            await this.bot.stopPolling();
+            this.bot = null;
+        }
+        console.log("[TelegramAdapter] Stopped");
+    }
+    // -------------------------------------------------------------------------
+    // Message handler
+    // -------------------------------------------------------------------------
+    async handleTelegramMessage(msg) {
+        if (!this.bot || !this.agent)
+            return;
+        const chatId = msg.chat.id;
+        const text = msg.text?.trim();
+        if (!text)
+            return;
+        const channelId = `telegram-${chatId}`;
+        // --- Command handling ---
+        const commandKey = text.split(/\s/)[0].toLowerCase();
+        const command = COMMANDS[commandKey];
+        if (command) {
+            const result = await this.agent.handleCommand(command, channelId);
+            await this.sendSafe(chatId, result.message || `/${command} executed.`);
+            return;
+        }
+        // --- Regular message → agent ---
+        // Send a "thinking" indicator
+        await this.bot.sendChatAction(chatId, "typing");
+        let finalText = "";
+        let hasError = false;
+        let errorMessage = "";
+        const onEvent = (event) => {
+            // Only collect final text; skip thinking/tool intermediate events
+            switch (event.type) {
+                case "text_delta":
+                    finalText += event.delta;
+                    break;
+                // We intentionally ignore thinking_delta, tool_start, tool_end
+            }
+        };
+        try {
+            const result = await this.agent.handleMessage(channelId, text, onEvent);
+            if (result.errorMessage) {
+                hasError = true;
+                errorMessage = result.errorMessage;
+            }
+        }
+        catch (err) {
+            hasError = true;
+            errorMessage = String(err);
+        }
+        // --- Send response ---
+        if (hasError) {
+            await this.sendSafe(chatId, `❌ Error: ${errorMessage}`);
+            return;
+        }
+        if (!finalText.trim()) {
+            await this.sendSafe(chatId, "(No response generated)");
+            return;
+        }
+        // Split and send the final text
+        await this.sendLongMessage(chatId, finalText);
+    }
+    // -------------------------------------------------------------------------
+    // Send helpers
+    // -------------------------------------------------------------------------
+    /**
+     * Send a message, splitting into chunks if too long.
+     */
+    async sendLongMessage(chatId, text) {
+        // Try to send as plain text first (more reliable than MarkdownV2 for complex content)
+        const chunks = this.splitMessage(text);
+        for (const chunk of chunks) {
+            await this.sendWithRetry(chatId, chunk);
+        }
+    }
+    /**
+     * Split text into chunks respecting Telegram's message length limit.
+     * Tries to split at paragraph boundaries.
+     */
+    splitMessage(text) {
+        if (text.length <= MAX_MESSAGE_LENGTH) {
+            return [text];
+        }
+        const chunks = [];
+        let remaining = text;
+        while (remaining.length > 0) {
+            if (remaining.length <= MAX_MESSAGE_LENGTH) {
+                chunks.push(remaining);
+                break;
+            }
+            // Find a good split point (paragraph break, then line break, then space)
+            let splitAt = remaining.lastIndexOf("\n\n", MAX_MESSAGE_LENGTH);
+            if (splitAt < MAX_MESSAGE_LENGTH * 0.5) {
+                splitAt = remaining.lastIndexOf("\n", MAX_MESSAGE_LENGTH);
+            }
+            if (splitAt < MAX_MESSAGE_LENGTH * 0.3) {
+                splitAt = remaining.lastIndexOf(" ", MAX_MESSAGE_LENGTH);
+            }
+            if (splitAt < 1) {
+                splitAt = MAX_MESSAGE_LENGTH;
+            }
+            chunks.push(remaining.slice(0, splitAt));
+            remaining = remaining.slice(splitAt).trimStart();
+        }
+        return chunks;
+    }
+    /**
+     * Send a message with automatic retry on 429 (rate limit).
+     */
+    async sendWithRetry(chatId, text, maxRetries = 3) {
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            try {
+                await this.bot.sendMessage(chatId, text);
+                return;
+            }
+            catch (err) {
+                if (err?.response?.statusCode === 429 &&
+                    attempt < maxRetries) {
+                    const retryAfter = err.response?.body?.parameters?.retry_after || 5;
+                    console.log(`[Telegram] Rate limited, retrying after ${retryAfter}s...`);
+                    await new Promise((resolve) => setTimeout(resolve, retryAfter * 1000));
+                    continue;
+                }
+                throw err;
+            }
+        }
+    }
+    /**
+     * Safe send that catches and logs errors.
+     */
+    async sendSafe(chatId, text) {
+        try {
+            await this.sendWithRetry(chatId, text);
+        }
+        catch (err) {
+            console.error("[Telegram] Failed to send message:", err);
+        }
+    }
+}

package/runtime/server/dist/adapters/types.js

@@ -0,0 +1 @@
+export {};

package/runtime/server/dist/adapters/web.js

@@ -0,0 +1,176 @@
+import fs from "node:fs";
+import path from "node:path";
+import { WebSocketServer } from "ws";
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function getPackConfig(rootDir) {
+    const raw = fs.readFileSync(path.join(rootDir, "skillpack.json"), "utf-8");
+    return JSON.parse(raw);
+}
+const COMMANDS = {
+    "/clear": "clear",
+    "/restart": "restart",
+    "/shutdown": "shutdown",
+};
+function parseCommand(text) {
+    const trimmed = text.trim().toLowerCase();
+    return COMMANDS[trimmed] ?? null;
+}
+// ---------------------------------------------------------------------------
+// WebAdapter
+// ---------------------------------------------------------------------------
+export class WebAdapter {
+    name = "web";
+    wss = null;
+    agent = null;
+    async start(ctx) {
+        const { agent, server, app, rootDir } = ctx;
+        this.agent = agent;
+        // -- API key & provider (in-memory, can be overridden by frontend) ------
+        // Read from data/config.json first
+        let apiKey = "";
+        let currentProvider = "openai";
+        const configPath = path.join(rootDir, "data", "config.json");
+        if (fs.existsSync(configPath)) {
+            try {
+                const dataConfig = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+                if (dataConfig.apiKey)
+                    apiKey = dataConfig.apiKey;
+                if (dataConfig.provider)
+                    currentProvider = dataConfig.provider;
+            }
+            catch {
+                // ignore malformed config
+            }
+        }
+        // Environment variables override config file
+        if (process.env.OPENAI_API_KEY) {
+            apiKey = process.env.OPENAI_API_KEY;
+            currentProvider = "openai";
+        }
+        else if (process.env.ANTHROPIC_API_KEY) {
+            apiKey = process.env.ANTHROPIC_API_KEY;
+            currentProvider = "anthropic";
+        }
+        // -- HTTP API routes ----------------------------------------------------
+        app.get("/api/config", (_req, res) => {
+            const config = getPackConfig(rootDir);
+            res.json({
+                name: config.name,
+                description: config.description,
+                prompts: config.prompts || [],
+                skills: config.skills || [],
+                hasApiKey: !!apiKey,
+                provider: currentProvider,
+            });
+        });
+        app.get("/api/skills", (_req, res) => {
+            const config = getPackConfig(rootDir);
+            res.json(config.skills || []);
+        });
+        app.post("/api/config/key", (req, res) => {
+            const { key, provider } = req.body;
+            if (!key) {
+                res.status(400).json({ error: "API key is required" });
+                return;
+            }
+            apiKey = key;
+            if (provider)
+                currentProvider = provider;
+            res.json({ success: true, provider: currentProvider });
+        });
+        app.delete("/api/chat", (_req, res) => {
+            res.json({ success: true });
+        });
+        // -- Reserved: session history endpoints (stub) -------------------------
+        app.get("/api/sessions", (_req, res) => {
+            const sessions = agent.listSessions();
+            res.json(sessions);
+        });
+        app.get("/api/sessions/:id", (_req, res) => {
+            // TODO: restore session by id
+            res.status(501).json({ error: "Not implemented yet" });
+        });
+        // -- WebSocket ----------------------------------------------------------
+        this.wss = new WebSocketServer({ noServer: true });
+        server.on("upgrade", (request, socket, head) => {
+            if (request.url?.startsWith("/api/chat")) {
+                this.wss.handleUpgrade(request, socket, head, (ws) => {
+                    this.wss.emit("connection", ws, request);
+                });
+            }
+            else {
+                socket.destroy();
+            }
+        });
+        this.wss.on("connection", (ws, request) => {
+            const url = new URL(request.url ?? "/", `http://${request.headers.host || "127.0.0.1"}`);
+            const _reqProvider = url.searchParams.get("provider") || currentProvider;
+            if (!apiKey) {
+                ws.send(JSON.stringify({ error: "Please set an API key first" }));
+                ws.close();
+                return;
+            }
+            // Each WebSocket connection maps to a unique channel
+            const channelId = `web-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+            this.handleWsConnection(ws, channelId, agent);
+        });
+        console.log("[WebAdapter] Started");
+    }
+    async stop() {
+        if (this.wss) {
+            for (const client of this.wss.clients) {
+                client.close();
+            }
+            this.wss.close();
+            this.wss = null;
+        }
+        console.log("[WebAdapter] Stopped");
+    }
+    // -------------------------------------------------------------------------
+    // WebSocket message handler
+    // -------------------------------------------------------------------------
+    handleWsConnection(ws, channelId, agent) {
+        ws.on("message", async (data) => {
+            try {
+                const payload = JSON.parse(data.toString());
+                if (!payload.text)
+                    return;
+                const text = payload.text;
+                // Check for bot commands
+                const command = parseCommand(text);
+                if (command) {
+                    const result = await agent.handleCommand(command, channelId);
+                    ws.send(JSON.stringify({
+                        type: "command_result",
+                        command,
+                        ...result,
+                    }));
+                    if (command === "clear") {
+                        ws.send(JSON.stringify({ done: true }));
+                    }
+                    return;
+                }
+                // Regular message → stream events via WebSocket
+                const onEvent = (event) => {
+                    if (ws.readyState !== ws.OPEN)
+                        return;
+                    ws.send(JSON.stringify(event));
+                };
+                const result = await agent.handleMessage(channelId, text, onEvent);
+                if (result.errorMessage) {
+                    ws.send(JSON.stringify({ error: result.errorMessage }));
+                    return;
+                }
+                ws.send(JSON.stringify({ done: true }));
+            }
+            catch (err) {
+                ws.send(JSON.stringify({ error: String(err) }));
+            }
+        });
+        ws.on("close", () => {
+            agent.dispose(channelId);
+        });
+    }
+}