@cremini/skillpack 1.2.4 → 1.2.5-beta.1

package/dist/cli.js

@@ -323,6 +323,20 @@ var init_commands = __esm({
   }
 });
 
+// src/runtime/adapters/types.ts
+var types_exports = {};
+__export(types_exports, {
+  isMessageSender: () => isMessageSender
+});
+function isMessageSender(adapter) {
+  return typeof adapter.sendMessage === "function";
+}
+var init_types = __esm({
+  "src/runtime/adapters/types.ts"() {
+    "use strict";
+  }
+});
+
 // src/runtime/adapters/markdown.ts
 function unwrapMarkdownSourceBlocks(text) {
   return text.replace(
@@ -443,7 +457,7 @@ var telegram_exports = {};
 __export(telegram_exports, {
   TelegramAdapter: () => TelegramAdapter
 });
-import fs12 from "fs";
+import fs13 from "fs";
 import TelegramBot from "node-telegram-bot-api";
 var MAX_MESSAGE_LENGTH, ACK_REACTION, TelegramAdapter;
 var init_telegram = __esm({
@@ -463,12 +477,14 @@ var init_telegram = __esm({
       agent = null;
       options;
       rootDir = "";
+      ipcBroadcaster = null;
       constructor(options) {
         this.options = options;
       }
       async start(ctx) {
         this.agent = ctx.agent;
         this.rootDir = ctx.rootDir;
+        this.ipcBroadcaster = ctx.ipcBroadcaster ?? null;
         this.bot = new TelegramBot(this.options.token, { polling: true });
         this.bot.on("message", (msg) => {
           this.handleTelegramMessage(msg).catch((err) => {
@@ -510,6 +526,15 @@ var init_telegram = __esm({
         const messageId = msg.message_id;
         const text = (msg.text || msg.caption || "").trim();
         const channelId = `telegram-${chatId}`;
+        this.ipcBroadcaster?.broadcastInbound(
+          channelId,
+          "telegram",
+          {
+            id: String(msg.from?.id || ""),
+            username: msg.from?.username || msg.from?.first_name || ""
+          },
+          text
+        );
         const attachments = await this.extractAttachments(msg, channelId);
         if (!text && attachments.length === 0) return;
         await this.tryAckReaction(chatId, messageId);
@@ -539,6 +564,7 @@ var init_telegram = __esm({
               });
               break;
           }
+          this.ipcBroadcaster?.broadcastAgentEvent(channelId, event);
         };
         try {
           const userText = text || "(User sent an attachment)";
@@ -749,7 +775,7 @@ var init_telegram = __esm({
       async sendFileSafe(chatId, filePath, caption) {
         if (!this.bot) return;
         try {
-          if (!fs12.existsSync(filePath)) {
+          if (!fs13.existsSync(filePath)) {
             console.error(`[Telegram] File not found for sending: ${filePath}`);
             return;
           }
@@ -769,8 +795,8 @@ var slack_exports = {};
 __export(slack_exports, {
   SlackAdapter: () => SlackAdapter
 });
-import fs13 from "fs";
-import path12 from "path";
+import fs14 from "fs";
+import path13 from "path";
 import { App, LogLevel } from "@slack/bolt";
 var INLINE_COMMANDS, SLASH_COMMANDS, MAX_MESSAGE_LENGTH2, ACK_REACTION2, PROCESSING_MESSAGE, SlackAdapter;
 var init_slack = __esm({
@@ -801,12 +827,14 @@ var init_slack = __esm({
       botUserId = null;
       lastThreadByChannel = /* @__PURE__ */ new Map();
       rootDir = "";
+      ipcBroadcaster = null;
       constructor(options) {
         this.options = options;
       }
       async start(ctx) {
         this.agent = ctx.agent;
         this.rootDir = ctx.rootDir;
+        this.ipcBroadcaster = ctx.ipcBroadcaster ?? null;
         this.app = new App({
           token: this.options.botToken,
           appToken: this.options.appToken,
@@ -892,6 +920,15 @@ var init_slack = __esm({
         const teamId = this.getTeamId(body, context);
         const channelId = `slack-dm-${teamId}-${event.channel}`;
         const route = { channel: event.channel };
+        this.ipcBroadcaster?.broadcastInbound(
+          channelId,
+          "slack",
+          {
+            id: String(event.user || ""),
+            username: String(event.user || "")
+          },
+          text
+        );
         const attachments = await this.extractSlackFiles(event, channelId, client);
         if (!text && attachments.length === 0) return;
         await this.tryAckReaction(client, event);
@@ -922,6 +959,15 @@ var init_slack = __esm({
           threadTs
         );
         const text = this.stripBotMention(event.text || "").trim();
+        this.ipcBroadcaster?.broadcastInbound(
+          channelId,
+          "slack",
+          {
+            id: String(event.user || ""),
+            username: String(event.user || "")
+          },
+          text
+        );
         const attachments = await this.extractSlackFiles(event, channelId, client);
         if (!text && attachments.length === 0) {
           await this.sendSafe(
@@ -981,6 +1027,7 @@ var init_slack = __esm({
               caption: event.caption
             });
           }
+          this.ipcBroadcaster?.broadcastAgentEvent(channelId, event);
         };
         try {
           const result = await this.agent.handleMessage(
@@ -1384,12 +1431,12 @@ var init_slack = __esm({
        */
       async sendFileSafe(client, route, filePath, caption) {
         try {
-          if (!fs13.existsSync(filePath)) {
+          if (!fs14.existsSync(filePath)) {
             console.error(`[Slack] File not found for sending: ${filePath}`);
             return;
           }
-          const filename = path12.basename(filePath);
-          const fileContent = fs13.readFileSync(filePath);
+          const filename = path13.basename(filePath);
+          const fileContent = fs14.readFileSync(filePath);
           await client.files.uploadV2({
             channel_id: route.channel,
             thread_ts: route.threadTs,
@@ -1406,20 +1453,6 @@ var init_slack = __esm({
   }
 });
 
-// src/runtime/adapters/types.ts
-var types_exports = {};
-__export(types_exports, {
-  isMessageSender: () => isMessageSender
-});
-function isMessageSender(adapter) {
-  return typeof adapter.sendMessage === "function";
-}
-var init_types = __esm({
-  "src/runtime/adapters/types.ts"() {
-    "use strict";
-  }
-});
-
 // src/runtime/adapters/scheduler.ts
 var scheduler_exports = {};
 __export(scheduler_exports, {
@@ -2430,15 +2463,15 @@ async function interactiveCreate(workDir) {
 }
 
 // src/commands/run.ts
-import path14 from "path";
-import fs15 from "fs";
+import path15 from "path";
+import fs16 from "fs";
 import inquirer2 from "inquirer";
 import chalk4 from "chalk";
 
 // src/runtime/server.ts
 import express from "express";
-import path13 from "path";
-import fs14 from "fs";
+import path14 from "path";
+import fs15 from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { createServer } from "http";
 import { exec } from "child_process";
@@ -5835,6 +5868,9 @@ ${text}`;
   /** Reserved: restore a historical session */
   async restoreSession(_sessionId) {
   }
+  getActiveChannelIds() {
+    return Array.from(this.channels.keys());
+  }
 };
 
 // src/runtime/adapters/web.ts
@@ -5868,9 +5904,11 @@ var WebAdapter = class {
   name = "web";
   wss = null;
   agent = null;
+  ipcBroadcaster = null;
   async start(ctx) {
     const { agent, server, app, rootDir, lifecycle } = ctx;
     this.agent = agent;
+    this.ipcBroadcaster = ctx.ipcBroadcaster ?? null;
     const currentConf = configManager.getConfig();
     let apiKey = currentConf.apiKey || "";
     let currentProvider = currentConf.provider || "openai";
@@ -6138,6 +6176,7 @@ var WebAdapter = class {
         }
         const onEvent = (event) => {
           sendWsEvent(ws, event);
+          this.ipcBroadcaster?.broadcastAgentEvent(channelId, event);
         };
         const result = await agent.handleMessage("web", channelId, text, onEvent);
         if (result.errorMessage) {
@@ -6155,6 +6194,367 @@ var WebAdapter = class {
   }
 };
 
+// src/runtime/adapters/ipc.ts
+init_config();
+
+// src/runtime/services/conversation.ts
+import fs11 from "fs";
+import path11 from "path";
+import {
+  parseSessionEntries
+} from "@mariozechner/pi-coding-agent";
+var ConversationService = class {
+  constructor(rootDir) {
+    this.rootDir = rootDir;
+  }
+  /**
+   * Scan data/sessions and return conversation summaries sorted by recency.
+   */
+  listConversations(activeChannels) {
+    const sessionsDir = path11.resolve(this.rootDir, "data", "sessions");
+    const channelIds = new Set(activeChannels);
+    if (fs11.existsSync(sessionsDir)) {
+      for (const entry of fs11.readdirSync(sessionsDir)) {
+        const channelDir = path11.join(sessionsDir, entry);
+        try {
+          if (fs11.statSync(channelDir).isDirectory()) {
+            channelIds.add(entry);
+          }
+        } catch {
+        }
+      }
+    }
+    const results = [];
+    for (const channelId of channelIds) {
+      const channelDir = path11.join(sessionsDir, channelId);
+      const sessionFile = this.findLatestSessionFile(channelDir);
+      let messageCount = 0;
+      let lastMessageAt = "";
+      let lastMessagePreview = "";
+      if (sessionFile) {
+        const entries = this.loadEntries(sessionFile);
+        const messages = entries.filter(
+          (entry) => entry.type === "message"
+        );
+        messageCount = messages.length;
+        const lastMessage = messages[messages.length - 1];
+        if (lastMessage) {
+          lastMessageAt = lastMessage.timestamp;
+          lastMessagePreview = this.extractTextPreview(lastMessage, 100);
+        }
+      }
+      results.push({
+        channelId,
+        platform: this.detectPlatform(channelId),
+        sessionFile,
+        messageCount,
+        lastMessageAt,
+        lastMessagePreview
+      });
+    }
+    return results.sort((a, b) => {
+      const recency = (b.lastMessageAt || "").localeCompare(a.lastMessageAt || "");
+      if (recency !== 0) return recency;
+      return a.channelId.localeCompare(b.channelId);
+    });
+  }
+  /**
+   * Load latest messages for a channel in a simplified format.
+   */
+  getMessages(channelId, limit = 100) {
+    const channelDir = path11.resolve(
+      this.rootDir,
+      "data",
+      "sessions",
+      channelId
+    );
+    const sessionFile = this.findLatestSessionFile(channelDir);
+    if (!sessionFile) return [];
+    const safeLimit = Number.isFinite(limit) ? Math.max(0, Math.floor(limit)) : 100;
+    if (safeLimit === 0) return [];
+    const entries = this.loadEntries(sessionFile);
+    const messages = [];
+    for (const entry of entries) {
+      if (entry.type !== "message") continue;
+      const role = entry.message?.role;
+      if (role !== "user" && role !== "assistant") continue;
+      const text = this.extractText(entry.message);
+      if (!text) continue;
+      const toolCalls = role === "assistant" ? this.extractToolCallSummaries(entry.message) : void 0;
+      messages.push({
+        id: entry.id,
+        role,
+        text,
+        timestamp: entry.timestamp,
+        toolCalls
+      });
+    }
+    return messages.slice(-safeLimit);
+  }
+  findLatestSessionFile(channelDir) {
+    if (!fs11.existsSync(channelDir)) return null;
+    let stats;
+    try {
+      stats = fs11.statSync(channelDir);
+    } catch {
+      return null;
+    }
+    if (!stats.isDirectory()) return null;
+    const files = fs11.readdirSync(channelDir).filter((file) => file.endsWith(".jsonl")).sort((a, b) => b.localeCompare(a));
+    return files[0] ? path11.join(channelDir, files[0]) : null;
+  }
+  loadEntries(filePath) {
+    try {
+      const content = fs11.readFileSync(filePath, "utf-8");
+      const fileEntries = parseSessionEntries(content);
+      return fileEntries.filter((entry) => entry.type !== "session");
+    } catch (err) {
+      console.warn(`[ConversationService] Failed to load ${filePath}:`, err);
+      return [];
+    }
+  }
+  extractText(message) {
+    if (!message?.content) return "";
+    if (typeof message.content === "string") return message.content.trim();
+    if (!Array.isArray(message.content)) return "";
+    return message.content.filter((item) => item?.type === "text").map((item) => typeof item?.text === "string" ? item.text : "").join("").trim();
+  }
+  extractTextPreview(entry, maxLen) {
+    const text = this.extractText(entry.message);
+    return text.length > maxLen ? `${text.slice(0, maxLen)}\u2026` : text;
+  }
+  extractToolCallSummaries(message) {
+    if (!Array.isArray(message?.content)) return void 0;
+    const toolCalls = message.content.filter((item) => item?.type === "toolCall").map((item) => ({
+      name: typeof item?.name === "string" && item.name ? item.name : "unknown",
+      isError: false
+    }));
+    return toolCalls.length > 0 ? toolCalls : void 0;
+  }
+  detectPlatform(channelId) {
+    if (channelId.startsWith("telegram-")) return "telegram";
+    if (channelId.startsWith("slack-")) return "slack";
+    if (channelId.startsWith("scheduler-")) return "scheduler";
+    return "web";
+  }
+};
+
+// src/runtime/adapters/ipc.ts
+init_types();
+var IpcAdapter = class {
+  name = "ipc";
+  agent = null;
+  rootDir = "";
+  adapterMap = null;
+  conversationService = null;
+  messageListener;
+  started = false;
+  async start(ctx) {
+    if (typeof process.send !== "function") {
+      return;
+    }
+    this.agent = ctx.agent;
+    this.rootDir = ctx.rootDir;
+    this.adapterMap = ctx.adapterMap ?? null;
+    this.conversationService = new ConversationService(ctx.rootDir);
+    this.messageListener = (message) => {
+      if (!this.isIpcRequest(message)) return;
+      void this.handleRequest(message);
+    };
+    process.on("message", this.messageListener);
+    this.started = true;
+    console.log("[IpcAdapter] Started");
+  }
+  async stop() {
+    if (this.messageListener) {
+      process.off("message", this.messageListener);
+      this.messageListener = void 0;
+    }
+    if (this.started) {
+      console.log("[IpcAdapter] Stopped");
+    }
+    this.started = false;
+  }
+  notifyReady(port) {
+    this.sendIpc({
+      type: "ready",
+      port
+    });
+  }
+  broadcastInbound(channelId, platform, sender, text) {
+    this.sendIpc({
+      type: "inbound_message",
+      channelId,
+      platform,
+      sender,
+      text,
+      timestamp: Date.now()
+    });
+  }
+  broadcastAgentEvent(channelId, event) {
+    this.sendIpc({
+      type: "agent_event",
+      channelId,
+      event
+    });
+  }
+  isIpcRequest(message) {
+    if (!message || typeof message !== "object") return false;
+    const maybe = message;
+    return typeof maybe.id === "string" && typeof maybe.type === "string";
+  }
+  async handleRequest(request) {
+    if (!this.agent || !this.conversationService) {
+      this.replyError(request.id, "IPC adapter is not ready yet");
+      return;
+    }
+    try {
+      switch (request.type) {
+        case "get_conversations": {
+          const activeChannels = new Set(this.agent.getActiveChannelIds());
+          const conversations = this.conversationService.listConversations(activeChannels);
+          this.reply(request.id, conversations);
+          return;
+        }
+        case "get_messages": {
+          if (!request.channelId || typeof request.channelId !== "string") {
+            this.replyError(request.id, "channelId is required");
+            return;
+          }
+          const messages = this.conversationService.getMessages(
+            request.channelId,
+            request.limit ?? 100
+          );
+          this.reply(request.id, messages);
+          return;
+        }
+        case "send_message": {
+          if (!request.channelId || typeof request.channelId !== "string") {
+            this.replyError(request.id, "channelId is required");
+            return;
+          }
+          if (typeof request.text !== "string") {
+            this.replyError(request.id, "text is required");
+            return;
+          }
+          const platform = this.detectPlatform(request.channelId);
+          let fullText = "";
+          const result = await this.agent.handleMessage(
+            platform,
+            request.channelId,
+            request.text,
+            (event) => {
+              if (event.type === "text_delta") {
+                fullText += event.delta;
+              }
+              this.broadcastAgentEvent(request.channelId, event);
+            }
+          );
+          if (fullText.trim() && platform !== "web" && platform !== "scheduler") {
+            const adapter = this.adapterMap?.get(platform);
+            if (adapter && isMessageSender(adapter)) {
+              await adapter.sendMessage(request.channelId, fullText);
+            }
+          }
+          this.reply(request.id, {
+            ...result,
+            text: fullText
+          });
+          return;
+        }
+        case "command": {
+          if (!request.channelId || typeof request.channelId !== "string") {
+            this.replyError(request.id, "channelId is required");
+            return;
+          }
+          const result = await this.agent.handleCommand(request.command, request.channelId);
+          this.reply(request.id, result);
+          return;
+        }
+        case "get_config": {
+          this.reply(request.id, configManager.getConfig());
+          return;
+        }
+        case "update_config": {
+          configManager.save(this.rootDir, request.updates || {});
+          const updated = configManager.getConfig();
+          const provider = updated.provider || "openai";
+          this.agent.updateAuth(provider, updated.apiKey);
+          this.reply(request.id, updated);
+          return;
+        }
+        case "get_status": {
+          this.reply(request.id, {
+            status: "running",
+            pid: process.pid
+          });
+          return;
+        }
+        case "get_scheduled_jobs": {
+          const scheduler = this.getSchedulerAdapter();
+          this.reply(request.id, scheduler ? scheduler.listJobs() : []);
+          return;
+        }
+        case "add_scheduled_job": {
+          const scheduler = this.getSchedulerAdapter();
+          if (!scheduler) {
+            this.replyError(request.id, "Scheduler adapter is not available");
+            return;
+          }
+          const result = scheduler.addJob(request.job);
+          if (!result.success) {
+            this.replyError(request.id, result.message);
+            return;
+          }
+          this.reply(request.id, result);
+          return;
+        }
+        case "remove_scheduled_job": {
+          const scheduler = this.getSchedulerAdapter();
+          if (!scheduler) {
+            this.replyError(request.id, "Scheduler adapter is not available");
+            return;
+          }
+          const result = scheduler.removeJob(request.name);
+          if (!result.success) {
+            this.replyError(request.id, result.message);
+            return;
+          }
+          this.reply(request.id, result);
+          return;
+        }
+      }
+    } catch (err) {
+      this.replyError(
+        request.id,
+        err instanceof Error ? err.message : String(err)
+      );
+    }
+  }
+  getSchedulerAdapter() {
+    const adapter = this.adapterMap?.get("scheduler");
+    if (!adapter) return null;
+    return adapter;
+  }
+  detectPlatform(channelId) {
+    if (channelId.startsWith("telegram-")) return "telegram";
+    if (channelId.startsWith("slack-")) return "slack";
+    if (channelId.startsWith("scheduler-")) return "scheduler";
+    return "web";
+  }
+  sendIpc(payload) {
+    if (typeof process.send === "function") {
+      process.send(payload);
+    }
+  }
+  reply(id, data) {
+    this.sendIpc({ id, type: "result", data });
+  }
+  replyError(id, message) {
+    this.sendIpc({ id, type: "error", message });
+  }
+};
+
 // src/runtime/server.ts
 init_config();
 
@@ -6231,28 +6631,28 @@ var Lifecycle = class {
 
 // src/runtime/registry.ts
 import crypto from "crypto";
-import fs11 from "fs";
+import fs12 from "fs";
 import os from "os";
-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");
+import path12 from "path";
+var SKILLPACK_HOME = path12.join(os.homedir(), ".skillpack");
+var LEGACY_REGISTRY_FILE = path12.join(SKILLPACK_HOME, "registry.json");
+var REGISTRY_DIR = path12.join(SKILLPACK_HOME, "registry.d");
 var migrationChecked = false;
 function ensureHomeDir() {
-  if (!fs11.existsSync(SKILLPACK_HOME)) {
-    fs11.mkdirSync(SKILLPACK_HOME, { recursive: true });
+  if (!fs12.existsSync(SKILLPACK_HOME)) {
+    fs12.mkdirSync(SKILLPACK_HOME, { recursive: true });
   }
 }
 function ensureRegistryDir() {
   ensureHomeDir();
-  if (!fs11.existsSync(REGISTRY_DIR)) {
-    fs11.mkdirSync(REGISTRY_DIR, { recursive: true });
+  if (!fs12.existsSync(REGISTRY_DIR)) {
+    fs12.mkdirSync(REGISTRY_DIR, { recursive: true });
   }
 }
 function canonicalizeDir(dir) {
-  const resolved = path11.resolve(dir);
+  const resolved = path12.resolve(dir);
   try {
-    return fs11.realpathSync(resolved);
+    return fs12.realpathSync(resolved);
   } catch {
     return resolved;
   }
@@ -6261,7 +6661,7 @@ function hashDir(dir) {
   return crypto.createHash("md5").update(canonicalizeDir(dir)).digest("hex");
 }
 function getEntryPathForCanonicalDir(dir) {
-  return path11.join(REGISTRY_DIR, `${hashDir(dir)}.json`);
+  return path12.join(REGISTRY_DIR, `${hashDir(dir)}.json`);
 }
 function getEntryPath(dir) {
   ensureRegistryReady();
@@ -6269,11 +6669,11 @@ function getEntryPath(dir) {
 }
 function listEntryFiles() {
   ensureRegistryReady();
-  return fs11.readdirSync(REGISTRY_DIR).filter((file) => file.endsWith(".json")).sort().map((file) => path11.join(REGISTRY_DIR, file));
+  return fs12.readdirSync(REGISTRY_DIR).filter((file) => file.endsWith(".json")).sort().map((file) => path12.join(REGISTRY_DIR, file));
 }
 function readEntryFile(filePath) {
   try {
-    const raw = fs11.readFileSync(filePath, "utf-8");
+    const raw = fs12.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;
@@ -6306,8 +6706,8 @@ function writeEntryFile(entry) {
   };
   const entryPath = getEntryPathForCanonicalDir(normalized.dir);
   const tmpPath = createTmpPath(entryPath);
-  fs11.writeFileSync(tmpPath, JSON.stringify(normalized, null, 2), "utf-8");
-  fs11.renameSync(tmpPath, entryPath);
+  fs12.writeFileSync(tmpPath, JSON.stringify(normalized, null, 2), "utf-8");
+  fs12.renameSync(tmpPath, entryPath);
 }
 function migrateLegacyRegistryIfNeeded() {
   if (migrationChecked) {
@@ -6315,14 +6715,14 @@ function migrateLegacyRegistryIfNeeded() {
   }
   migrationChecked = true;
   ensureRegistryDir();
-  if (!fs11.existsSync(LEGACY_REGISTRY_FILE)) {
+  if (!fs12.existsSync(LEGACY_REGISTRY_FILE)) {
     return;
   }
   if (listEntryFiles().length > 0) {
     return;
   }
   try {
-    const raw = fs11.readFileSync(LEGACY_REGISTRY_FILE, "utf-8");
+    const raw = fs12.readFileSync(LEGACY_REGISTRY_FILE, "utf-8");
     const data = JSON.parse(raw);
     const packs = Array.isArray(data?.packs) ? data.packs : [];
     for (const pack of packs) {
@@ -6335,7 +6735,7 @@ function migrateLegacyRegistryIfNeeded() {
       } catch {
       }
     }
-    fs11.renameSync(LEGACY_REGISTRY_FILE, `${LEGACY_REGISTRY_FILE}.legacy`);
+    fs12.renameSync(LEGACY_REGISTRY_FILE, `${LEGACY_REGISTRY_FILE}.legacy`);
   } catch (err) {
     console.warn("  [Registry] Failed to migrate legacy registry.json:", err);
   }
@@ -6388,7 +6788,7 @@ function deregister(dir, pid) {
 }
 
 // src/runtime/server.ts
-var __dirname = path13.dirname(fileURLToPath2(import.meta.url));
+var __dirname = path14.dirname(fileURLToPath2(import.meta.url));
 async function startServer(options) {
   const {
     rootDir,
@@ -6403,8 +6803,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 = path13.resolve(__dirname, "..");
-  const webDir = fs14.existsSync(path13.join(rootDir, "web")) ? path13.join(rootDir, "web") : path13.join(packageRoot, "web");
+  const packageRoot = path14.resolve(__dirname, "..");
+  const webDir = fs15.existsSync(path14.join(rootDir, "web")) ? path14.join(rootDir, "web") : path14.join(packageRoot, "web");
   const app = express();
   app.use(express.json());
   app.use(express.static(webDir));
@@ -6432,8 +6832,31 @@ async function startServer(options) {
   });
   const adapters = [];
   const adapterMap = /* @__PURE__ */ new Map();
+  const hasIpcChannel = typeof process.send === "function";
+  const ipcAdapter = new IpcAdapter();
+  if (hasIpcChannel) {
+    await ipcAdapter.start({
+      agent,
+      server,
+      app,
+      rootDir,
+      lifecycle,
+      adapterMap
+    });
+    adapters.push(ipcAdapter);
+    adapterMap.set(ipcAdapter.name, ipcAdapter);
+  }
+  const ipcBroadcaster = hasIpcChannel ? ipcAdapter : void 0;
   const webAdapter = new WebAdapter();
-  await webAdapter.start({ agent, server, app, rootDir, lifecycle, adapterMap });
+  await webAdapter.start({
+    agent,
+    server,
+    app,
+    rootDir,
+    lifecycle,
+    adapterMap,
+    ipcBroadcaster
+  });
   adapters.push(webAdapter);
   adapterMap.set(webAdapter.name, webAdapter);
   if (dataConfig.adapters?.telegram?.token) {
@@ -6442,7 +6865,15 @@ async function startServer(options) {
       const telegramAdapter = new TelegramAdapter2({
         token: dataConfig.adapters.telegram.token
       });
-      await telegramAdapter.start({ agent, server, app, rootDir, lifecycle });
+      await telegramAdapter.start({
+        agent,
+        server,
+        app,
+        rootDir,
+        lifecycle,
+        adapterMap,
+        ipcBroadcaster
+      });
       adapters.push(telegramAdapter);
       adapterMap.set(telegramAdapter.name, telegramAdapter);
     } catch (err) {
@@ -6462,7 +6893,15 @@ async function startServer(options) {
           botToken: slackConfig.botToken,
           appToken: slackConfig.appToken
         });
-        await slackAdapter.start({ agent, server, app, rootDir, lifecycle });
+        await slackAdapter.start({
+          agent,
+          server,
+          app,
+          rootDir,
+          lifecycle,
+          adapterMap,
+          ipcBroadcaster
+        });
         adapters.push(slackAdapter);
         adapterMap.set(slackAdapter.name, slackAdapter);
       } catch (err) {
@@ -6525,6 +6964,9 @@ async function startServer(options) {
     } catch (err) {
       console.warn("  [Registry] Could not register pack:", err);
     }
+    if (hasIpcChannel) {
+      ipcAdapter.notifyReady(typeof actualPort === "number" ? actualPort : port);
+    }
     if (!daemonRun) {
       const cmd = process.platform === "darwin" ? `open ${url}` : process.platform === "win32" ? `start ${url}` : `xdg-open ${url}`;
       exec(cmd, (err) => {
@@ -6572,23 +7014,23 @@ function findMissingSkills(workDir, config) {
   });
 }
 function copyStartTemplates2(workDir) {
-  const templateDir = path14.resolve(
+  const templateDir = path15.resolve(
     new URL("../templates", import.meta.url).pathname
   );
   for (const file of ["start.sh", "start.bat"]) {
-    const src = path14.join(templateDir, file);
-    const dest = path14.join(workDir, file);
-    if (fs15.existsSync(src)) {
-      fs15.copyFileSync(src, dest);
+    const src = path15.join(templateDir, file);
+    const dest = path15.join(workDir, file);
+    if (fs16.existsSync(src)) {
+      fs16.copyFileSync(src, dest);
       if (file === "start.sh") {
-        fs15.chmodSync(dest, 493);
+        fs16.chmodSync(dest, 493);
       }
     }
   }
 }
 async function runCommand(directory) {
-  const workDir = directory ? path14.resolve(directory) : process.cwd();
-  fs15.mkdirSync(workDir, { recursive: true });
+  const workDir = directory ? path15.resolve(directory) : process.cwd();
+  fs16.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([
@@ -6633,9 +7075,9 @@ async function runCommand(directory) {
 }
 
 // src/cli.ts
-import fs16 from "fs";
+import fs17 from "fs";
 var packageJson = JSON.parse(
-  fs16.readFileSync(new URL("../package.json", import.meta.url), "utf-8")
+  fs17.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.4",
+  "version": "1.2.5-beta.1",
   "description": "Pack AI Skills into Local Agents",
   "type": "module",
   "repository": {