@opencoreai/opencore 0.4.0 → 0.4.1

package/bin/opencore.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import "dotenv/config";
 import { spawn } from "node:child_process";
-import { constants, promises as fs } from "node:fs";
+import { promises as fs } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import readline from "node:readline/promises";
@@ -16,10 +16,6 @@ const entry = path.join(rootDir, "src", "index.ts");
 const setupScript = path.join(rootDir, "scripts", "postinstall.mjs");
 const openCoreHome = path.join(os.homedir(), ".opencore");
 const settingsPath = path.join(openCoreHome, "configs", "settings.json");
-const runtimeRoot = path.join(openCoreHome, "runtime");
-const runtimeInstallRoot = path.join(runtimeRoot, "current");
-const localBinDir = path.join(openCoreHome, "bin");
-const zshRcPath = path.join(os.homedir(), ".zshrc");
 const publishedPackageName = "@opencoreai/opencore";
 
 const args = process.argv.slice(2);
@@ -95,140 +91,12 @@ async function runInitialSetupIfNeeded() {
   });
 }
 
-async function fileExists(targetPath) {
-  try {
-    await fs.access(targetPath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-async function ensureDir(targetPath) {
-  await fs.mkdir(targetPath, { recursive: true });
-}
-
-async function isWritableDirectory(targetPath) {
-  try {
-    await ensureDir(targetPath);
-    await fs.access(targetPath, constants.W_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-async function installPersistentRuntime() {
-  await ensureDir(runtimeInstallRoot);
-
-  await new Promise((resolve, reject) => {
-    const installer = spawn(
-      "npm",
-      ["install", "--no-fund", "--no-audit", "--prefix", runtimeInstallRoot, rootDir],
-      {
-        cwd: rootDir,
-        stdio: "inherit",
-        env: process.env,
-      },
-    );
-
-    installer.on("exit", (code, signal) => {
-      if (signal) {
-        reject(new Error(`Local install exited with signal ${signal}`));
-        return;
-      }
-      if ((code ?? 1) !== 0) {
-        reject(new Error(`Local install exited with code ${code ?? 1}`));
-        return;
-      }
-      resolve();
-    });
-
-    installer.on("error", reject);
-  });
-}
-
-function getPersistentEntryPath() {
-  return path.join(runtimeInstallRoot, "node_modules", publishedPackageName, "bin", "opencore.mjs");
-}
-
-function renderLauncherScript(entryPath) {
-  return `#!/bin/sh
-exec node "${entryPath}" "$@"
-`;
-}
-
-async function findPreferredLauncherDir() {
-  const pathEntries = String(process.env.PATH || "")
-    .split(path.delimiter)
-    .map((item) => item.trim())
-    .filter(Boolean);
-
-  const preferred = [
-    ...pathEntries,
-    "/opt/homebrew/bin",
-    "/usr/local/bin",
-    path.join(os.homedir(), "bin"),
-    path.join(os.homedir(), ".local", "bin"),
-    localBinDir,
-  ];
-
-  const seen = new Set();
-  for (const dir of preferred) {
-    if (seen.has(dir)) continue;
-    seen.add(dir);
-    if (await isWritableDirectory(dir)) {
-      return { dir, alreadyOnPath: pathEntries.includes(dir) };
-    }
-  }
-
-  return { dir: localBinDir, alreadyOnPath: pathEntries.includes(localBinDir) };
-}
-
-async function ensureZshPathEntry(binDir) {
-  const exportLine = `export PATH="${binDir}:$PATH"`;
-  const existing = (await fs.readFile(zshRcPath, "utf8").catch(() => "")).toString();
-  if (existing.includes(exportLine)) return false;
-  const next = existing.trimEnd();
-  const content = `${next ? `${next}\n\n` : ""}# OpenCore CLI\n${exportLine}\n`;
-  await fs.writeFile(zshRcPath, content, "utf8");
-  return true;
-}
-
-async function installPersistentLauncher() {
-  const entryPath = getPersistentEntryPath();
-  if (!(await fileExists(entryPath))) {
-    throw new Error("Persistent OpenCore runtime was not installed correctly.");
-  }
-
-  const { dir, alreadyOnPath } = await findPreferredLauncherDir();
-  await ensureDir(dir);
-
-  const launcherPath = path.join(dir, "opencore");
-  await fs.writeFile(launcherPath, renderLauncherScript(entryPath), "utf8");
-  await fs.chmod(launcherPath, 0o755);
-
-  let zshUpdated = false;
-  if (!alreadyOnPath) {
-    zshUpdated = await ensureZshPathEntry(dir);
-  }
-
-  return { launcherPath, binDir: dir, alreadyOnPath, zshUpdated };
-}
-
 async function runSetupCommand() {
   try {
-    console.log("Installing persistent OpenCore launcher...");
-    await installPersistentRuntime();
-    const launcher = await installPersistentLauncher();
+    console.log("Running OpenCore onboarding...");
     await runInitialSetupIfNeeded();
     console.log("OpenCore setup is complete.");
-    console.log(`OpenCore launcher: ${launcher.launcherPath}`);
-    if (!launcher.alreadyOnPath) {
-      console.log(`Added ${launcher.binDir} to ~/.zshrc`);
-      console.log("Open a new terminal window or run: source ~/.zshrc");
-    }
-    console.log("You can then run: opencore engage");
+    console.log("You can now run: opencore engage");
     process.exit(0);
   } catch (error) {
     console.error(`OpenCore setup failed: ${error instanceof Error ? error.message : String(error)}`);

package/opencore dashboard/app.js

@@ -238,6 +238,14 @@
       }
     }, [page]);
 
+    useEffect(() => {
+      if (page !== "skills") return undefined;
+      const timer = setInterval(() => {
+        loadSkills().catch(() => {});
+      }, 3000);
+      return () => clearInterval(timer);
+    }, [page]);
+
     async function sendChat() {
       const text = chatText.trim();
       if (!text || chatBusy) return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencoreai/opencore",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "private": false,
   "type": "module",
   "license": "LicenseRef-OpenCore-Personal-Use-1.0",
@@ -26,6 +26,7 @@
     "opencore": "bin/opencore.mjs"
   },
   "scripts": {
+    "postinstall": "node scripts/install-migrate.mjs",
     "start": "tsx src/index.ts",
     "engage": "node bin/opencore.mjs engage"
   },

package/scripts/install-migrate.mjs

@@ -0,0 +1,63 @@
+import os from "node:os";
+import path from "node:path";
+import { promises as fs } from "node:fs";
+
+const homeDir = os.homedir();
+const openCoreBinPath = path.join(homeDir, ".opencore", "bin", "opencore");
+const zshRcPath = path.join(homeDir, ".zshrc");
+const legacyPathLine = 'export PATH="$HOME/.opencore/bin:$PATH"';
+const legacyPathLineExpanded = `export PATH="${path.join(homeDir, ".opencore", "bin")}:$PATH"`;
+
+async function removeLegacyLauncher() {
+  try {
+    const content = await fs.readFile(openCoreBinPath, "utf8");
+    const isLegacy =
+      content.includes(`${path.join(homeDir, ".opencore", "runtime", "current")}`) ||
+      content.includes(".opencore/runtime/current/node_modules/@opencoreai/opencore/bin/opencore.mjs");
+    if (!isLegacy) return false;
+    await fs.unlink(openCoreBinPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function cleanLegacyZshrc() {
+  try {
+    const existing = await fs.readFile(zshRcPath, "utf8");
+    const lines = existing.split("\n");
+    const cleaned = [];
+    let removed = false;
+    for (let i = 0; i < lines.length; i += 1) {
+      const line = lines[i];
+      const trimmed = line.trim();
+      if (trimmed === "# OpenCore CLI") {
+        const next = String(lines[i + 1] || "").trim();
+        if (next === legacyPathLine || next === legacyPathLineExpanded) {
+          removed = true;
+          i += 1;
+          continue;
+        }
+      }
+      if (trimmed === legacyPathLine || trimmed === legacyPathLineExpanded) {
+        removed = true;
+        continue;
+      }
+      cleaned.push(line);
+    }
+    if (!removed) return false;
+    await fs.writeFile(zshRcPath, `${cleaned.join("\n").replace(/\n{3,}/g, "\n\n").trimEnd()}\n`, "utf8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function main() {
+  const [removedLauncher, cleanedZshrc] = await Promise.all([removeLegacyLauncher(), cleanLegacyZshrc()]);
+  if (removedLauncher || cleanedZshrc) {
+    console.log("[OpenCore] Removed legacy ~/.opencore launcher migration artifacts.");
+  }
+}
+
+await main();

package/src/dashboard-server.ts

@@ -164,6 +164,89 @@ export class DashboardServer {
     return installed;
   }
 
+  private extractFrontmatterField(content: string, key: string) {
+    const text = String(content || "");
+    if (!text.startsWith("---")) return "";
+    const end = text.indexOf("\n---", 3);
+    if (end === -1) return "";
+    const frontmatter = text.slice(3, end);
+    const match = frontmatter.match(new RegExp(`^${key}:\\s*(.+)$`, "m"));
+    return match ? String(match[1] || "").trim().replace(/^["']|["']$/g, "") : "";
+  }
+
+  private extractFirstHeading(content: string) {
+    const match = String(content || "").match(/^#\s+(.+)$/m);
+    return match ? String(match[1] || "").trim() : "";
+  }
+
+  private async listSkillsDetailed() {
+    const catalogMap = new Map(SKILL_CATALOG.map((skill) => [skill.id, skill]));
+    const items = new Map<string, any>();
+
+    for (const skill of SKILL_CATALOG) {
+      items.set(skill.id, {
+        id: skill.id,
+        name: skill.name,
+        description: skill.description,
+        installed: false,
+        external: false,
+      });
+    }
+
+    try {
+      const entries = await fs.readdir(this.skillsDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const id = entry.name;
+        const skillDir = path.join(this.skillsDir, id);
+        const skillFile = path.join(skillDir, "SKILL.md");
+        const configFile = path.join(skillDir, "config.json");
+        try {
+          await fs.access(skillFile);
+        } catch {
+          continue;
+        }
+
+        let config: any = {};
+        let markdown = "";
+        try {
+          const raw = await fs.readFile(configFile, "utf8");
+          config = JSON.parse(raw || "{}");
+        } catch {}
+        try {
+          markdown = await fs.readFile(skillFile, "utf8");
+        } catch {}
+
+        const catalogSkill = catalogMap.get(id);
+        const resolvedName =
+          String(config?.name || "").trim() ||
+          this.extractFrontmatterField(markdown, "name") ||
+          this.extractFirstHeading(markdown) ||
+          catalogSkill?.name ||
+          id;
+        const resolvedDescription =
+          String(config?.description || "").trim() ||
+          this.extractFrontmatterField(markdown, "description") ||
+          catalogSkill?.description ||
+          "External OpenCore skill.";
+
+        items.set(id, {
+          id,
+          name: resolvedName,
+          description: resolvedDescription,
+          installed: true,
+          external: !catalogSkill,
+        });
+      }
+    } catch {}
+
+    return Array.from(items.values()).sort((a, b) => {
+      if (a.installed !== b.installed) return a.installed ? -1 : 1;
+      if (a.external !== b.external) return a.external ? -1 : 1;
+      return String(a.name || a.id).localeCompare(String(b.name || b.id));
+    });
+  }
+
   private async installSkill(id: string) {
     const skill = SKILL_CATALOG.find((item) => item.id === id);
     if (!skill) {
@@ -267,15 +350,7 @@ export class DashboardServer {
     });
 
     this.app.get("/api/skills", async (_req, res) => {
-      const installed = await this.listInstalledSkillIds();
-      res.json({
-        items: SKILL_CATALOG.map((skill) => ({
-          id: skill.id,
-          name: skill.name,
-          description: skill.description,
-          installed: installed.has(skill.id),
-        })),
-      });
+      res.json({ items: await this.listSkillsDetailed() });
     });
 
     this.app.get("/api/schedules", async (_req, res) => {