@cremini/skillpack 1.0.2

package/runtime/README.md

@@ -0,0 +1,41 @@
+# Skillapp
+
+## Quick Start
+
+### macOS / Linux
+
+```bash
+chmod +x start.sh
+./start.sh
+```
+
+### Windows
+
+Double-click `start.bat` or run:
+
+```cmd
+start.bat
+```
+
+After the server starts, your browser opens [http://127.0.0.1:26313](http://127.0.0.1:26313) automatically.
+
+By default, the server only listens on `127.0.0.1` so the API key you enter stays on the local machine and is not exposed to your LAN.
+
+## First Use
+
+1. Enter your OpenAI or Anthropic API key in the left sidebar
+2. Type a message in the chat box to start a conversation
+3. Click a prompt example on the welcome screen to prefill the input
+
+## Requirements
+
+- Node.js >= 20
+
+## Environment Variables
+
+| Variable            | Description                                             |
+| ------------------- | ------------------------------------------------------- |
+| `OPENAI_API_KEY`    | OpenAI API key, optional if you set it in the web UI    |
+| `ANTHROPIC_API_KEY` | Anthropic API key, optional if you set it in the web UI |
+| `HOST`              | Bind address, defaults to `127.0.0.1`                   |
+| `PORT`              | Server port, defaults to `26313`                        |

package/runtime/scripts/start.bat

@@ -0,0 +1,15 @@
+@echo off
+cd /d "%~dp0"
+
+echo.
+echo   Starting Skills Pack...
+echo.
+
+if not exist "server\node_modules" (
+  echo   Installing dependencies...
+  cd server && npm ci --omit=dev && cd ..
+  echo.
+)
+
+rem Start the server (port detection and browser launch are handled by server\index.js)
+cd server && node index.js

package/runtime/scripts/start.sh

@@ -0,0 +1,22 @@
+#!/bin/bash
+cd "$(dirname "$0")"
+
+# Read the pack name
+PACK_NAME="Skills Pack"
+if [ -f "app.json" ] && command -v node &> /dev/null; then
+  PACK_NAME=$(node -e "console.log(JSON.parse(require('fs').readFileSync('app.json','utf-8')).name)" 2>/dev/null || echo "Skills Pack")
+fi
+
+echo ""
+echo "  Starting ${PACK_NAME}..."
+echo ""
+
+# Install dependencies
+if [ ! -d "server/node_modules" ]; then
+  echo "  Installing dependencies..."
+  cd server && npm install --omit=dev && cd ..
+  echo ""
+fi
+
+# Start the server
+cd server && node index.js

package/runtime/server/chat-proxy.js

@@ -0,0 +1,161 @@
+import path from "node:path";
+import {
+  AuthStorage,
+  createAgentSession,
+  ModelRegistry,
+  SessionManager,
+  DefaultResourceLoader,
+} from "@mariozechner/pi-coding-agent";
+
+const DEBUG = true;
+
+const log = (...args) => DEBUG && console.log(...args);
+const write = (data) => DEBUG && process.stdout.write(data);
+
+/**
+ * Handle incoming WebSocket connection using pi-coding-agent
+ * @param {import("ws").WebSocket} ws
+ * @param {object} options
+ * @param {string} options.apiKey - OpenAI API Key
+ * @param {string} options.rootDir - Pack root directory
+ */
+export async function handleWsConnection(
+  ws,
+  { apiKey, rootDir, provider = "openai", modelId = "gpt-5.4" },
+) {
+  try {
+    // Create an in-memory auth storage to avoid touching disk
+    const authStorage = AuthStorage.inMemory({
+      [provider]: { type: "api_key", key: apiKey },
+    });
+    authStorage.setRuntimeApiKey(provider, apiKey);
+
+    const modelRegistry = new ModelRegistry(authStorage);
+    const model = modelRegistry.find(provider, modelId);
+
+    const sessionManager = SessionManager.inMemory();
+
+    const skillsPath = path.resolve(rootDir, "skills");
+    log(`[ChatProxy] Loading additional skills from: ${skillsPath}`);
+
+    const resourceLoader = new DefaultResourceLoader({
+      cwd: rootDir,
+      additionalSkillPaths: [skillsPath], // 手动加载 rootDir/skills
+    });
+    await resourceLoader.reload();
+
+    const { session } = await createAgentSession({
+      cwd: rootDir, // Allow pi-coding-agent to find skills in this pack's directory
+      authStorage,
+      modelRegistry,
+      sessionManager,
+      resourceLoader,
+      model,
+    });
+
+    // Stream agent events to the WebSocket
+    session.subscribe((event) => {
+      switch (event.type) {
+        case "agent_start":
+          log("\n=== [PI-CODING-AGENT SESSION START] ===");
+          log("System Prompt:\n", session.systemPrompt);
+          log("========================================\n");
+          ws.send(JSON.stringify({ type: "agent_start" }));
+          break;
+
+        case "message_start":
+          log(`\n--- [Message Start: ${event.message?.role}] ---`);
+          if (event.message?.role === "user") {
+            log(JSON.stringify(event.message.content, null, 2));
+          }
+          ws.send(
+            JSON.stringify({
+              type: "message_start",
+              role: event.message?.role,
+            }),
+          );
+          break;
+
+        case "message_update":
+          if (event.assistantMessageEvent?.type === "text_delta") {
+            write(event.assistantMessageEvent.delta);
+            ws.send(
+              JSON.stringify({
+                type: "text_delta",
+                delta: event.assistantMessageEvent.delta,
+              }),
+            );
+          } else if (event.assistantMessageEvent?.type === "thinking_delta") {
+            ws.send(
+              JSON.stringify({
+                type: "thinking_delta",
+                delta: event.assistantMessageEvent.delta,
+              }),
+            );
+          }
+          break;
+
+        case "message_end":
+          log(`\n--- [Message End: ${event.message?.role}] ---`);
+          ws.send(
+            JSON.stringify({
+              type: "message_end",
+              role: event.message?.role,
+            }),
+          );
+          break;
+
+        case "tool_execution_start":
+          log(`\n>>> [Tool Execution Start: ${event.toolName}] >>>`);
+          log("Args:", JSON.stringify(event.args, null, 2));
+          ws.send(
+            JSON.stringify({
+              type: "tool_start",
+              toolName: event.toolName,
+              toolInput: event.args,
+            }),
+          );
+          break;
+
+        case "tool_execution_end":
+          log(`<<< [Tool Execution End: ${event.toolName}] <<<`);
+          log(`Error: ${event.isError ? "Yes" : "No"}`);
+          ws.send(
+            JSON.stringify({
+              type: "tool_end",
+              toolName: event.toolName,
+              isError: event.isError,
+              result: event.result,
+            }),
+          );
+          break;
+
+        case "agent_end":
+          log("\n=== [PI-CODING-AGENT SESSION END] ===\n");
+          ws.send(JSON.stringify({ type: "agent_end" }));
+          break;
+      }
+    });
+
+    // Listen for incoming messages from the frontend
+    ws.on("message", async (data) => {
+      try {
+        const payload = JSON.parse(data.toString());
+        if (payload.text) {
+          // Send prompt to the agent, the session will handle message history natively
+          await session.prompt(payload.text);
+          ws.send(JSON.stringify({ done: true }));
+        }
+      } catch (err) {
+        ws.send(JSON.stringify({ error: String(err) }));
+      }
+    });
+
+    ws.on("close", () => {
+      session.dispose();
+    });
+  } catch (err) {
+    ws.send(JSON.stringify({ error: String(err) }));
+    ws.close();
+  }
+}

package/runtime/server/index.js

@@ -0,0 +1,59 @@
+import express from "express";
+import path from "node:path";
+import fs from "node:fs";
+import { fileURLToPath } from "node:url";
+import { createServer } from "node:http";
+import { exec } from "node:child_process";
+import { registerRoutes } from "./routes.js";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const rootDir = process.env.PACK_ROOT || path.join(__dirname, "..");
+
+const webDir = fs.existsSync(path.join(rootDir, "web"))
+  ? path.join(rootDir, "web")
+  : path.join(__dirname, "..", "web");
+
+const app = express();
+app.use(express.json());
+
+// Static file serving
+app.use(express.static(webDir));
+
+const server = createServer(app);
+
+// Register API routes
+registerRoutes(app, server, rootDir);
+
+const HOST = process.env.HOST || "127.0.0.1";
+const DEFAULT_PORT = 26313;
+
+function tryListen(port) {
+  server.listen(port, HOST, () => {
+    const url = `http://${HOST}:${port}`;
+    console.log(`\n  Skills Pack Server`);
+    console.log(`  Running at ${url}\n`);
+
+    // Open the browser automatically
+    const cmd =
+      process.platform === "darwin"
+        ? `open ${url}`
+        : process.platform === "win32"
+          ? `start ${url}`
+          : `xdg-open ${url}`;
+    exec(cmd, () => {});
+  });
+
+  server.once("error", (err) => {
+    if (err.code === "EADDRINUSE") {
+      console.log(`  Port ${port} is in use, trying ${port + 1}...`);
+      server.close();
+      tryListen(port + 1);
+    } else {
+      throw err;
+    }
+  });
+}
+
+const startPort = Number(process.env.PORT) || DEFAULT_PORT;
+tryListen(startPort);

package/runtime/server/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "skillpack-server",
+  "version": "1.0.0",
+  "type": "module",
+  "scripts": {
+    "start": "node index.js"
+  },
+  "dependencies": {
+    "express": "^5.1.0",
+    "@mariozechner/pi-coding-agent": "^0.57.1",
+    "ws": "^8.19.0"
+  }
+}

package/runtime/server/routes.js

@@ -0,0 +1,104 @@
+import fs from "node:fs";
+import path from "node:path";
+import { WebSocketServer } from "ws";
+
+import { handleWsConnection } from "./chat-proxy.js";
+
+/**
+ * Read the app.json config.
+ * @param {string} rootDir
+ */
+function getPackConfig(rootDir) {
+  const raw = fs.readFileSync(path.join(rootDir, "app.json"), "utf-8");
+  return JSON.parse(raw);
+}
+
+/**
+ * Register all API routes.
+ * @param {import("express").Express} app
+ * @param {import("node:http").Server} server
+ * @param {string} rootDir - Root directory containing app.json and skills/
+ */
+export function registerRoutes(app, server, rootDir) {
+  // API key and provider are stored in runtime memory
+  let apiKey = "";
+  let currentProvider = "openai";
+
+  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";
+  }
+
+  // Get pack config
+  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,
+    });
+  });
+
+  // Get skills list
+  app.get("/api/skills", (req, res) => {
+    const config = getPackConfig(rootDir);
+    res.json(config.skills || []);
+  });
+
+  // Set API key
+  app.post("/api/config/key", (req, res) => {
+    const { key, provider } = req.body;
+    if (!key) {
+      return res.status(400).json({ error: "API key is required" });
+    }
+    apiKey = key;
+    if (provider) {
+      currentProvider = provider;
+    }
+    res.json({ success: true, provider: currentProvider });
+  });
+
+  // WebSocket chat service
+  const wss = new WebSocketServer({ noServer: true });
+
+  server.on("upgrade", (request, socket, head) => {
+    if (request.url.startsWith("/api/chat")) {
+      wss.handleUpgrade(request, socket, head, (ws) => {
+        wss.emit("connection", ws, request);
+      });
+    } else {
+      socket.destroy();
+    }
+  });
+
+  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;
+    }
+
+    const config = getPackConfig(rootDir);
+
+    const modelId = reqProvider === "anthropic" ? "claude-opus-4-6" : "gpt-5.4";
+
+    handleWsConnection(ws, { apiKey, rootDir, provider: reqProvider, modelId });
+  });
+
+  // Clear session
+  app.delete("/api/chat", (req, res) => {
+    res.json({ success: true });
+  });
+}

package/runtime/server/skills-loader.js

@@ -0,0 +1,31 @@
+import fs from "node:fs";
+import path from "node:path";
+
+/**
+ * Recursively load the contents of all SKILL.md files under skills/.
+ * @param {string} rootDir - Root directory containing skills/
+ * @returns {string[]} Array of SKILL.md file contents
+ */
+export function loadSkillContents(rootDir) {
+  const skillsDir = path.join(rootDir, "skills");
+  const contents = [];
+
+  if (!fs.existsSync(skillsDir)) {
+    return contents;
+  }
+
+  function walk(dir) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(full);
+      } else if (entry.name === "SKILL.md") {
+        contents.push(fs.readFileSync(full, "utf-8"));
+      }
+    }
+  }
+
+  walk(skillsDir);
+  return contents;
+}