@cremini/skillpack 1.1.7 → 1.1.8-beta.1

package/dist/runtime/registry.js

@@ -0,0 +1,244 @@
+#!/usr/bin/env node
+
+// src/runtime/registry.ts
+import crypto from "crypto";
+import fs from "fs";
+import os from "os";
+import path from "path";
+var SKILLPACK_HOME = path.join(os.homedir(), ".skillpack");
+var LEGACY_REGISTRY_FILE = path.join(SKILLPACK_HOME, "registry.json");
+var REGISTRY_DIR = path.join(SKILLPACK_HOME, "registry.d");
+var migrationChecked = false;
+function getRegistryPath() {
+  ensureRegistryReady();
+  return REGISTRY_DIR;
+}
+function ensureHomeDir() {
+  if (!fs.existsSync(SKILLPACK_HOME)) {
+    fs.mkdirSync(SKILLPACK_HOME, { recursive: true });
+  }
+}
+function ensureRegistryDir() {
+  ensureHomeDir();
+  if (!fs.existsSync(REGISTRY_DIR)) {
+    fs.mkdirSync(REGISTRY_DIR, { recursive: true });
+  }
+}
+function canonicalizeDir(dir) {
+  const resolved = path.resolve(dir);
+  try {
+    return fs.realpathSync(resolved);
+  } catch {
+    return resolved;
+  }
+}
+function hashDir(dir) {
+  return crypto.createHash("md5").update(canonicalizeDir(dir)).digest("hex");
+}
+function getEntryPathForCanonicalDir(dir) {
+  return path.join(REGISTRY_DIR, `${hashDir(dir)}.json`);
+}
+function getEntryPath(dir) {
+  ensureRegistryReady();
+  return getEntryPathForCanonicalDir(canonicalizeDir(dir));
+}
+function listEntryFiles() {
+  ensureRegistryReady();
+  return fs.readdirSync(REGISTRY_DIR).filter((file) => file.endsWith(".json")).sort().map((file) => path.join(REGISTRY_DIR, file));
+}
+function readEntryFile(filePath) {
+  try {
+    const raw = fs.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;
+    }
+    return {
+      dir: canonicalizeDir(data.dir),
+      name: data.name,
+      version: data.version,
+      port: data.port,
+      pid: data.pid,
+      status: data.status,
+      startedAt: data.startedAt,
+      stoppedAt: data.stoppedAt,
+      updatedAt: data.updatedAt
+    };
+  } catch {
+    return null;
+  }
+}
+function createTmpPath(entryPath) {
+  const suffix = `${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}`;
+  return `${entryPath}.tmp.${suffix}`;
+}
+function writeEntryFile(entry) {
+  ensureRegistryReady();
+  const normalized = {
+    ...entry,
+    dir: canonicalizeDir(entry.dir),
+    updatedAt: entry.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const entryPath = getEntryPathForCanonicalDir(normalized.dir);
+  const tmpPath = createTmpPath(entryPath);
+  fs.writeFileSync(tmpPath, JSON.stringify(normalized, null, 2), "utf-8");
+  fs.renameSync(tmpPath, entryPath);
+}
+function migrateLegacyRegistryIfNeeded() {
+  if (migrationChecked) {
+    return;
+  }
+  migrationChecked = true;
+  ensureRegistryDir();
+  if (!fs.existsSync(LEGACY_REGISTRY_FILE)) {
+    return;
+  }
+  if (listEntryFiles().length > 0) {
+    return;
+  }
+  try {
+    const raw = fs.readFileSync(LEGACY_REGISTRY_FILE, "utf-8");
+    const data = JSON.parse(raw);
+    const packs = Array.isArray(data?.packs) ? data.packs : [];
+    for (const pack of packs) {
+      try {
+        writeEntryFile({
+          ...pack,
+          dir: canonicalizeDir(pack.dir),
+          updatedAt: pack.updatedAt ?? pack.stoppedAt ?? pack.startedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+        });
+      } catch {
+      }
+    }
+    fs.renameSync(LEGACY_REGISTRY_FILE, `${LEGACY_REGISTRY_FILE}.legacy`);
+  } catch (err) {
+    console.warn("  [Registry] Failed to migrate legacy registry.json:", err);
+  }
+}
+function ensureRegistryReady() {
+  ensureRegistryDir();
+  migrateLegacyRegistryIfNeeded();
+}
+function entriesEqual(a, b) {
+  return a.dir === b.dir && a.name === b.name && a.version === b.version && a.port === b.port && a.pid === b.pid && a.status === b.status && a.startedAt === b.startedAt && a.stoppedAt === b.stoppedAt;
+}
+function readEntry(dir) {
+  ensureRegistryReady();
+  return readEntryFile(getEntryPath(dir));
+}
+function writeEntry(entry) {
+  writeEntryFile(entry);
+}
+function deleteEntry(dir) {
+  ensureRegistryReady();
+  const entryPath = getEntryPath(dir);
+  if (fs.existsSync(entryPath)) {
+    fs.unlinkSync(entryPath);
+  }
+}
+function readRegistry() {
+  return { packs: readAll() };
+}
+function writeRegistry(data) {
+  ensureRegistryReady();
+  const nextPaths = /* @__PURE__ */ new Set();
+  for (const pack of data.packs) {
+    const normalized = {
+      ...pack,
+      dir: canonicalizeDir(pack.dir),
+      updatedAt: pack.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const entryPath = getEntryPathForCanonicalDir(normalized.dir);
+    nextPaths.add(entryPath);
+    writeEntryFile(normalized);
+  }
+  for (const existingPath of listEntryFiles()) {
+    if (!nextPaths.has(existingPath)) {
+      fs.unlinkSync(existingPath);
+    }
+  }
+}
+function register(opts) {
+  try {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const entry = {
+      dir: canonicalizeDir(opts.dir),
+      name: opts.name,
+      version: opts.version,
+      port: opts.port,
+      pid: process.pid,
+      status: "running",
+      startedAt: now,
+      updatedAt: now
+    };
+    writeEntryFile(entry);
+    console.log(`  [Registry] Registered "${opts.name}" (pid ${process.pid})`);
+  } catch (err) {
+    console.warn("  [Registry] Failed to register:", err);
+  }
+}
+function deregister(dir, pid) {
+  try {
+    const entry = readEntry(dir);
+    if (!entry || entry.pid !== pid) {
+      return;
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    writeEntryFile({
+      ...entry,
+      pid: null,
+      status: "stopped",
+      stoppedAt: now,
+      updatedAt: now
+    });
+    console.log(`  [Registry] Deregistered "${entry.name}"`);
+  } catch (err) {
+    console.warn("  [Registry] Failed to deregister:", err);
+  }
+}
+function readAll() {
+  return listEntryFiles().map((entryPath) => readEntryFile(entryPath)).filter((entry) => entry !== null);
+}
+function isPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function validateEntries() {
+  const entries = readAll();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  for (const entry of entries) {
+    if (entry.status === "running" && entry.pid !== null && !isPidAlive(entry.pid)) {
+      writeEntryFile({
+        ...entry,
+        pid: null,
+        status: "stopped",
+        stoppedAt: now,
+        updatedAt: now
+      });
+    }
+  }
+  const nextEntries = readAll();
+  if (entries.length === nextEntries.length && entries.every((entry, index) => entriesEqual(entry, nextEntries[index]))) {
+    return entries;
+  }
+  return nextEntries;
+}
+export {
+  canonicalizeDir,
+  deleteEntry,
+  deregister,
+  getEntryPath,
+  getRegistryPath,
+  isPidAlive,
+  readAll,
+  readEntry,
+  readRegistry,
+  register,
+  validateEntries,
+  writeEntry,
+  writeRegistry
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cremini/skillpack",
-  "version": "1.1.7",
+  "version": "1.1.8-beta.1",
   "description": "Pack AI Skills into Local Agents",
   "type": "module",
   "repository": {
@@ -49,6 +49,7 @@
     "commander": "^14.0.3",
     "express": "^5.1.0",
     "inquirer": "^13.3.0",
+    "node-cron": "^4.2.1",
     "node-telegram-bot-api": "^0.66.0",
     "ws": "^8.19.0"
   },
@@ -57,10 +58,11 @@
     "@types/express": "^5.0.0",
     "@types/inquirer": "^9.0.9",
     "@types/node": "^25.5.0",
+    "@types/node-cron": "^3.0.11",
     "@types/node-telegram-bot-api": "^0.64.0",
     "@types/ws": "^8.18.0",
     "prettier": "^3.8.1",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3"
   }
-}
+}

package/web/js/api-key-dialog.js

@@ -136,19 +136,17 @@ async function handleSave() {
       apiKeyInput.value = "";
     }
     
-    state.config.runtimeControl = res.runtimeControl;
+
     state.restartRequired = !!res.requiresRestart;
 
     updateApiKeyButton();
 
     if (res.requiresRestart) {
       setStatus(
-        res.runtimeControl?.canManagedRestart
-          ? "API key saved. Restart service to apply changes."
-          : "API key saved. Restart the service manually to apply changes.",
+        "API key saved. Restart service to apply changes.",
         "warning",
       );
-      updateRestartButton(!!res.runtimeControl?.canManagedRestart);
+      updateRestartButton(true);
     } else {
       setStatus("API key saved successfully", "success");
       // 延迟关闭让用户看到成功消息

package/web/js/chat-apps-dialog.js

@@ -101,14 +101,11 @@ function populateForm() {
 
   // Restart required status
   if (state.restartRequired) {
-    const canRestart = config.runtimeControl?.canManagedRestart;
     setStatus(
-      canRestart
-        ? "Settings changed. Restart service to apply."
-        : "Settings changed. Restart the service manually to apply.",
+      "Settings changed. Restart service to apply.",
       "warning",
     );
-    updateRestartButton(canRestart);
+    updateRestartButton(true);
   } else {
     setStatus("", "");
     updateRestartButton(false);
@@ -139,17 +136,14 @@ async function handleSave() {
     const res = await saveConfigData(updates);
 
     state.config.adapters = res.adapters;
-    state.config.runtimeControl = res.runtimeControl;
     state.restartRequired = !!res.requiresRestart;
 
     if (res.requiresRestart) {
       setStatus(
-        res.runtimeControl?.canManagedRestart
-          ? "Settings saved. Restart service to apply changes."
-          : "Settings saved. Restart the service manually to apply changes.",
+        "Settings saved. Restart service to apply changes.",
         "warning",
       );
-      updateRestartButton(!!res.runtimeControl?.canManagedRestart);
+      updateRestartButton(true);
     } else {
       close();
     }

package/web/js/settings.js

@@ -72,9 +72,7 @@ function populateForm() {
 
   if (state.restartRequired) {
     setStatus(
-      config.runtimeControl?.canManagedRestart
-        ? "Settings saved. Restart service to apply changes."
-        : "Settings saved. Restart the service manually to apply changes.",
+      "Settings saved. Restart service to apply changes.",
       "warning",
     );
     updateRestartButton(true);
@@ -139,7 +137,6 @@ async function handleSave() {
     // Update local config
     state.config.provider = res.provider;
     state.config.adapters = res.adapters;
-    state.config.runtimeControl = res.runtimeControl;
     if (updates.key) {
       state.config.hasApiKey = true;
       state.config.apiKey = updates.key;
@@ -156,12 +153,10 @@ async function handleSave() {
 
     if (res.requiresRestart) {
       setStatus(
-        res.runtimeControl.canManagedRestart
-          ? "Settings saved. Restart service to apply changes."
-          : "Settings saved. Restart the service manually to apply changes.",
+        "Settings saved. Restart service to apply changes.",
         "warning",
       );
-      updateRestartButton(res.runtimeControl.canManagedRestart);
+      updateRestartButton(true);
       return;
     }