@cremini/skillpack 1.0.7 → 1.0.9-im.0

package/runtime/server/dist/agent.js

@@ -0,0 +1,218 @@
+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);
+function getAssistantDiagnostics(message) {
+    if (!message || message.role !== "assistant") {
+        return null;
+    }
+    const stopReason = message.stopReason ?? "unknown";
+    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 };
+}
+// ---------------------------------------------------------------------------
+// PackAgent
+// ---------------------------------------------------------------------------
+export class PackAgent {
+    options;
+    channels = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    /**
+     * Lazily create (or return existing) session for a channel.
+     */
+    async getOrCreateSession(channelId) {
+        const existing = this.channels.get(channelId);
+        if (existing)
+            return existing;
+        const { apiKey, rootDir, provider, modelId } = this.options;
+        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(`[PackAgent] Loading skills from: ${skillsPath}`);
+        const resourceLoader = new DefaultResourceLoader({
+            cwd: rootDir,
+            additionalSkillPaths: [skillsPath],
+        });
+        await resourceLoader.reload();
+        const { session } = await createAgentSession({
+            cwd: rootDir,
+            authStorage,
+            modelRegistry,
+            sessionManager,
+            resourceLoader,
+            model,
+        });
+        const channelSession = { session, running: false };
+        this.channels.set(channelId, channelSession);
+        return channelSession;
+    }
+    async handleMessage(channelId, text, onEvent) {
+        const cs = await this.getOrCreateSession(channelId);
+        cs.running = true;
+        let turnHadVisibleOutput = false;
+        // Subscribe to agent events and forward to adapter
+        const unsubscribe = cs.session.subscribe((event) => {
+            switch (event.type) {
+                case "agent_start":
+                    log("\n=== [AGENT SESSION START] ===");
+                    log("System Prompt:\n", cs.session.systemPrompt);
+                    log("============================\n");
+                    onEvent({ 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));
+                    }
+                    onEvent({ type: "message_start", role: event.message?.role ?? "" });
+                    break;
+                case "message_update":
+                    if (event.assistantMessageEvent?.type === "text_delta") {
+                        turnHadVisibleOutput = true;
+                        write(event.assistantMessageEvent.delta);
+                        onEvent({
+                            type: "text_delta",
+                            delta: event.assistantMessageEvent.delta,
+                        });
+                    }
+                    else if (event.assistantMessageEvent?.type === "thinking_delta") {
+                        turnHadVisibleOutput = true;
+                        onEvent({
+                            type: "thinking_delta",
+                            delta: event.assistantMessageEvent.delta,
+                        });
+                    }
+                    break;
+                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} text=${diagnostics.hasText ? "yes" : "no"} toolCalls=${diagnostics.toolCalls}`);
+                            if (diagnostics.errorMessage) {
+                                log(`[Assistant Error] ${diagnostics.errorMessage}`);
+                            }
+                        }
+                    }
+                    onEvent({ type: "message_end", role: event.message?.role ?? "" });
+                    break;
+                case "tool_execution_start":
+                    turnHadVisibleOutput = true;
+                    log(`\n>>> [Tool Start: ${event.toolName}] >>>`);
+                    log("Args:", JSON.stringify(event.args, null, 2));
+                    onEvent({
+                        type: "tool_start",
+                        toolName: event.toolName,
+                        toolInput: event.args,
+                    });
+                    break;
+                case "tool_execution_end":
+                    turnHadVisibleOutput = true;
+                    log(`<<< [Tool End: ${event.toolName}] <<<`);
+                    log(`Error: ${event.isError ? "Yes" : "No"}`);
+                    onEvent({
+                        type: "tool_end",
+                        toolName: event.toolName,
+                        isError: event.isError,
+                        result: event.result,
+                    });
+                    break;
+                case "agent_end":
+                    log("\n=== [AGENT SESSION END] ===\n");
+                    onEvent({ type: "agent_end" });
+                    break;
+            }
+        });
+        try {
+            await cs.session.prompt(text);
+            const lastMessage = cs.session.state.messages.at(-1);
+            const diagnostics = getAssistantDiagnostics(lastMessage);
+            if (diagnostics?.errorMessage) {
+                return {
+                    stopReason: diagnostics.stopReason,
+                    errorMessage: diagnostics.errorMessage,
+                };
+            }
+            if (diagnostics &&
+                !diagnostics.hasText &&
+                diagnostics.toolCalls === 0 &&
+                !turnHadVisibleOutput) {
+                return {
+                    stopReason: diagnostics.stopReason,
+                    errorMessage: "Assistant returned no visible output. Check the server logs for details.",
+                };
+            }
+            return { stopReason: diagnostics?.stopReason ?? "unknown" };
+        }
+        finally {
+            cs.running = false;
+            unsubscribe();
+        }
+    }
+    async handleCommand(command, channelId) {
+        switch (command) {
+            case "clear": {
+                const cs = this.channels.get(channelId);
+                if (cs) {
+                    cs.session.dispose();
+                    this.channels.delete(channelId);
+                }
+                return { success: true, message: "Session cleared." };
+            }
+            case "restart":
+                log("[PackAgent] Restart requested");
+                // Give a brief delay so the response can be sent
+                setTimeout(() => process.exit(0), 500);
+                return { success: true, message: "Restarting..." };
+            case "shutdown":
+                log("[PackAgent] Shutdown requested");
+                setTimeout(() => process.exit(0), 500);
+                return { success: true, message: "Shutting down..." };
+            default:
+                return { success: false, message: `Unknown command: ${command}` };
+        }
+    }
+    abort(channelId) {
+        const cs = this.channels.get(channelId);
+        if (cs?.running) {
+            cs.session.abort?.();
+        }
+    }
+    isRunning(channelId) {
+        return this.channels.get(channelId)?.running ?? false;
+    }
+    dispose(channelId) {
+        const cs = this.channels.get(channelId);
+        if (cs) {
+            cs.session.dispose();
+            this.channels.delete(channelId);
+        }
+    }
+    /** Reserved: list all sessions */
+    listSessions() {
+        // TODO: Implement session persistence and listing
+        return [];
+    }
+    /** Reserved: restore a historical session */
+    async restoreSession(_sessionId) {
+        // TODO: Implement session restoration
+    }
+}

package/runtime/server/dist/index.js

@@ -0,0 +1,116 @@
+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 { PackAgent } from "./agent.js";
+import { WebAdapter } from "./adapters/web.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+// ---------------------------------------------------------------------------
+// Resolve root directory
+// ---------------------------------------------------------------------------
+// In dev (running from dist/), go up two levels: dist/ → server/ → pack root
+// In production (copied to target), go up one level: dist/ → server/ → pack root
+const serverDir = path.resolve(__dirname, "..");
+const rootDir = process.env.PACK_ROOT || path.resolve(serverDir, "..");
+let dataConfig = {};
+const configPath = path.join(rootDir, "data", "config.json");
+if (fs.existsSync(configPath)) {
+    try {
+        dataConfig = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+        console.log("  Loaded config from data/config.json");
+    }
+    catch (err) {
+        console.warn("  Warning: Failed to parse data/config.json:", err);
+    }
+}
+let apiKey = dataConfig.apiKey || "";
+let provider = dataConfig.provider || "openai";
+// Environment variables override config file
+if (process.env.OPENAI_API_KEY) {
+    apiKey = process.env.OPENAI_API_KEY;
+    provider = "openai";
+}
+else if (process.env.ANTHROPIC_API_KEY) {
+    apiKey = process.env.ANTHROPIC_API_KEY;
+    provider = "anthropic";
+}
+const modelId = provider === "anthropic" ? "claude-opus-4-6" : "gpt-5.4";
+// ---------------------------------------------------------------------------
+// Create Express app & HTTP server
+// ---------------------------------------------------------------------------
+const webDir = fs.existsSync(path.join(rootDir, "web"))
+    ? path.join(rootDir, "web")
+    : path.join(serverDir, "..", "web");
+const app = express();
+app.use(express.json());
+app.use(express.static(webDir));
+const server = createServer(app);
+// ---------------------------------------------------------------------------
+// Create PackAgent (shared instance)
+// ---------------------------------------------------------------------------
+const agent = new PackAgent({ apiKey, rootDir, provider, modelId });
+// ---------------------------------------------------------------------------
+// Start adapters
+// ---------------------------------------------------------------------------
+async function startAdapters() {
+    // Web adapter is always enabled
+    const webAdapter = new WebAdapter();
+    await webAdapter.start({ agent, server, app, rootDir });
+    // Telegram adapter (conditional)
+    if (dataConfig.adapters?.telegram?.token) {
+        try {
+            const { TelegramAdapter } = await import("./adapters/telegram.js");
+            const telegramAdapter = new TelegramAdapter({
+                token: dataConfig.adapters.telegram.token,
+            });
+            await telegramAdapter.start({ agent, server, app, rootDir });
+        }
+        catch (err) {
+            console.error("[Telegram] Failed to start:", err);
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Listen
+// ---------------------------------------------------------------------------
+const HOST = process.env.HOST || "127.0.0.1";
+const DEFAULT_PORT = 26313;
+server.once("listening", () => {
+    const address = server.address();
+    const actualPort = typeof address === "string" ? address : address?.port;
+    const url = `http://${HOST}:${actualPort}`;
+    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, () => { });
+});
+function tryListen(port) {
+    server.listen(port, HOST);
+    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;
+        }
+    });
+}
+// Start adapters, then listen
+startAdapters()
+    .then(() => {
+    const startPort = Number(process.env.PORT) || DEFAULT_PORT;
+    tryListen(startPort);
+})
+    .catch((err) => {
+    console.error("Failed to start adapters:", err);
+    process.exit(1);
+});