@gamaze/hicortex 0.3.6 → 0.3.8

package/dist/init.js

@@ -106,6 +106,11 @@ async function detect() {
 // ---------------------------------------------------------------------------
 function registerCcMcp(serverUrl) {
     try {
+        // Remove existing entry first (idempotent — ignore if not found)
+        try {
+            (0, node_child_process_1.execSync)("claude mcp remove hicortex 2>/dev/null", { encoding: "utf-8", stdio: "pipe" });
+        }
+        catch { /* not found */ }
         // Use claude CLI to register — it knows the correct config format and location
         (0, node_child_process_1.execSync)(`claude mcp add hicortex --transport sse ${serverUrl}/sse`, { encoding: "utf-8", stdio: "pipe" });
         console.log(`  ✓ Registered MCP server via claude CLI`);
@@ -223,21 +228,84 @@ Tell them: "Get a license key at https://hicortex.gamaze.com/ — after purchase
     (0, node_fs_1.writeFileSync)((0, node_path_1.join)(CC_COMMANDS_DIR, "hicortex-activate.md"), activateContent);
     console.log(`  ✓ Installed /learn and /hicortex-activate commands in ${CC_COMMANDS_DIR}`);
 }
-function getPackageVersion() {
+/**
+ * Detect LLM API key from current shell environment and persist to
+ * ~/.hicortex/config.json so the daemon can use it (launchd/systemd
+ * don't inherit shell env vars).
+ */
+function persistLlmConfig() {
+    const configPath = (0, node_path_1.join)(HICORTEX_HOME, "config.json");
+    // Read existing config (may have licenseKey)
+    let config = {};
     try {
-        const pkgPath = (0, node_path_1.join)(__dirname, "..", "package.json");
-        const pkg = JSON.parse((0, node_fs_1.readFileSync)(pkgPath, "utf-8"));
-        return pkg.version ?? "latest";
+        config = JSON.parse((0, node_fs_1.readFileSync)(configPath, "utf-8"));
     }
-    catch {
-        return "latest";
+    catch { /* new file */ }
+    // Don't overwrite if LLM config already persisted
+    if (config.llmApiKey && config.llmBaseUrl) {
+        console.log(`  ✓ LLM config already in ${configPath}`);
+        return;
+    }
+    // Detect from environment (same priority as resolveLlmConfigForCC)
+    const hcKey = process.env.HICORTEX_LLM_API_KEY;
+    const hcUrl = process.env.HICORTEX_LLM_BASE_URL;
+    const hcModel = process.env.HICORTEX_LLM_MODEL;
+    if (hcKey && hcUrl) {
+        config.llmApiKey = hcKey;
+        config.llmBaseUrl = hcUrl;
+        if (hcModel)
+            config.llmModel = hcModel;
+    }
+    else if (process.env.ANTHROPIC_API_KEY) {
+        config.llmApiKey = process.env.ANTHROPIC_API_KEY;
+        config.llmBaseUrl = process.env.ANTHROPIC_BASE_URL ?? "https://api.anthropic.com";
+        config.llmProvider = "anthropic";
+    }
+    else if (process.env.OPENAI_API_KEY) {
+        config.llmApiKey = process.env.OPENAI_API_KEY;
+        config.llmBaseUrl = process.env.OPENAI_BASE_URL ?? "https://api.openai.com";
+        config.llmProvider = "openai";
+    }
+    else if (process.env.GOOGLE_API_KEY) {
+        config.llmApiKey = process.env.GOOGLE_API_KEY;
+        config.llmBaseUrl = "https://generativelanguage.googleapis.com/v1beta";
+        config.llmProvider = "google";
+    }
+    else {
+        console.log("  ⚠ No LLM API key found in environment. Server will use Ollama fallback.");
+        console.log("    Set ANTHROPIC_API_KEY and re-run init, or edit ~/.hicortex/config.json");
+        return;
+    }
+    (0, node_fs_1.mkdirSync)(HICORTEX_HOME, { recursive: true });
+    (0, node_fs_1.writeFileSync)(configPath, JSON.stringify(config, null, 2));
+    console.log(`  ✓ LLM config saved to ${configPath}`);
+}
+/**
+ * Determine the npm package specifier for the daemon.
+ * Uses tag-based resolution so restarts pick up new versions automatically.
+ *
+ * Checks if the current version matches the npm `latest` tag.
+ * If not (e.g. running from @next), uses @gamaze/hicortex@next.
+ * If it does match latest, uses bare @gamaze/hicortex.
+ */
+function getPackageSpec() {
+    try {
+        const currentVersion = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(__dirname, "..", "package.json"), "utf-8")).version;
+        const latestVersion = (0, node_child_process_1.execSync)("npm view @gamaze/hicortex version 2>/dev/null", {
+            encoding: "utf-8",
+            timeout: 5000,
+        }).trim();
+        if (currentVersion !== latestVersion) {
+            return "@gamaze/hicortex@next";
+        }
     }
+    catch { /* can't check — default to bare */ }
+    return "@gamaze/hicortex";
 }
 function installDaemon() {
     const os = (0, node_os_1.platform)();
     const npxPath = findNpxPath();
-    const version = getPackageVersion();
-    const packageSpec = `@gamaze/hicortex@${version}`;
+    const packageSpec = getPackageSpec();
     if (os === "darwin") {
         return installLaunchd(npxPath, packageSpec);
     }
@@ -412,6 +480,8 @@ async function runInit() {
     }
     console.log();
     // Phase 3: Execute
+    // Persist LLM config from current environment for the daemon
+    persistLlmConfig();
     // Install daemon if needed
     if (!d.localServer && !d.remoteServer) {
         installDaemon();

package/dist/mcp-server.js

@@ -179,13 +179,18 @@ async function startServer(options = {}) {
     console.log(`[hicortex] Initializing database at ${dbPath}`);
     db = (0, db_js_1.initDb)(dbPath);
     stateDir = dbPath.replace(/\/hicortex\.db$/, "");
-    // LLM config
-    const llmConfig = (0, llm_js_1.resolveLlmConfigForCC)();
+    // LLM config: read from config.json first (persisted by init), then env vars
+    const savedConfig = readConfigFile(stateDir);
+    const llmConfig = (0, llm_js_1.resolveLlmConfigForCC)({
+        llmBaseUrl: savedConfig?.llmBaseUrl,
+        llmApiKey: savedConfig?.llmApiKey,
+        llmModel: savedConfig?.llmModel,
+    });
     llm = new llm_js_1.LlmClient(llmConfig);
     console.log(`[hicortex] LLM: ${llmConfig.provider}/${llmConfig.model} (reflect: ${llmConfig.reflectModel})`);
     // License: read from options, config file, or env var
     const licenseKey = options.licenseKey
-        ?? readConfigLicenseKey(stateDir)
+        ?? savedConfig?.licenseKey
         ?? process.env.HICORTEX_LICENSE_KEY;
     (0, license_js_1.validateLicense)(licenseKey, stateDir).catch((err) => console.log(`[hicortex] License validation failed: ${err}`));
     if (licenseKey) {
@@ -196,16 +201,16 @@ async function startServer(options = {}) {
     cancelConsolidation = (0, consolidate_js_1.scheduleConsolidation)(db, llm, embedder_js_1.embed, consolidateHour);
     // Seed lesson on first run
     await (0, seed_lesson_js_1.injectSeedLesson)(db);
+    // Self-heal: fix pinned version in daemon config
+    fixDaemonVersionPin();
     // Stats
     const stats = (0, db_js_1.getStats)(db, dbPath);
     console.log(`[hicortex] Ready: ${stats.memories} memories, ${stats.links} links, ` +
         `${Math.round(stats.db_size_bytes / 1024)} KB`);
-    // Create MCP server
-    const mcpServer = createMcpServer();
     // Express app
     const app = (0, express_1.default)();
     app.use(express_1.default.json());
-    // SSE transport management
+    // SSE transport management — each connection gets its own McpServer instance
     const transports = new Map();
     // Health endpoint
     app.get("/health", (_req, res) => {
@@ -219,9 +224,10 @@ async function startServer(options = {}) {
             llm: `${llmConfig.provider}/${llmConfig.model}`,
         });
     });
-    // SSE endpoint — client connects here to establish MCP session
+    // SSE endpoint — each connection gets its own McpServer + transport
     app.get("/sse", async (req, res) => {
         const transport = new sse_js_1.SSEServerTransport("/messages", res);
+        const mcpServer = createMcpServer();
         transports.set(transport.sessionId, transport);
         transport.onclose = () => {
             transports.delete(transport.sessionId);
@@ -282,20 +288,55 @@ async function startServer(options = {}) {
 // Helpers
 // ---------------------------------------------------------------------------
 /**
- * Read license key from ~/.hicortex/config.json.
- * Written by /hicortex-activate CC command.
+ * Read ~/.hicortex/config.json (persisted by init with LLM and license config).
  */
-function readConfigLicenseKey(stateDir) {
+function readConfigFile(stateDir) {
     try {
         const { readFileSync } = require("node:fs");
         const { join } = require("node:path");
         const configPath = join(stateDir, "config.json");
-        const raw = readFileSync(configPath, "utf-8");
-        const config = JSON.parse(raw);
-        return config.licenseKey || undefined;
+        return JSON.parse(readFileSync(configPath, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Self-heal: if the daemon plist/systemd unit has a pinned version
+ * (e.g. @gamaze/hicortex@0.3.4), rewrite it to use the bare package
+ * name so future restarts pick up the latest version automatically.
+ */
+function fixDaemonVersionPin() {
+    try {
+        const os = require("node:os");
+        const fs = require("node:fs");
+        const path = require("node:path");
+        if (os.platform() === "darwin") {
+            const plistPath = path.join(os.homedir(), "Library", "LaunchAgents", "com.gamaze.hicortex.plist");
+            if (!fs.existsSync(plistPath))
+                return;
+            const content = fs.readFileSync(plistPath, "utf-8");
+            // Match @gamaze/hicortex@X.Y.Z (pinned to specific version)
+            if (/@gamaze\/hicortex@\d+\.\d+\.\d+/.test(content)) {
+                const fixed = content.replace(/@gamaze\/hicortex@\d+\.\d+\.\d+/, "@gamaze/hicortex");
+                fs.writeFileSync(plistPath, fixed);
+                console.log("[hicortex] Fixed daemon config: removed pinned version (will use latest on next restart)");
+            }
+        }
+        else if (os.platform() === "linux") {
+            const servicePath = path.join(os.homedir(), ".config", "systemd", "user", "hicortex.service");
+            if (!fs.existsSync(servicePath))
+                return;
+            const content = fs.readFileSync(servicePath, "utf-8");
+            if (/@gamaze\/hicortex@\d+\.\d+\.\d+/.test(content)) {
+                const fixed = content.replace(/@gamaze\/hicortex@\d+\.\d+\.\d+/, "@gamaze/hicortex");
+                fs.writeFileSync(servicePath, fixed);
+                console.log("[hicortex] Fixed daemon config: removed pinned version");
+            }
+        }
     }
     catch {
-        return undefined;
+        // Non-fatal
     }
 }
 function formatResults(results) {

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "hicortex",
   "name": "Hicortex — Long-term Memory That Learns",
   "description": "Your agents remember past decisions, avoid repeated mistakes, and get smarter every day. Nightly reflection generates actionable lessons that automatically update agent behavior.",
-  "version": "0.3.6",
+  "version": "0.3.8",
   "kind": "lifecycle",
   "skills": ["./skills/hicortex-memory", "./skills/hicortex-learn", "./skills/hicortex-activate"],
   "configSchema": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gamaze/hicortex",
-  "version": "0.3.6",
+  "version": "0.3.8",
   "description": "Human-like memory for self-improving AI agents. Automatic capturing, nightly reflection, and cross-agent learning. Works with Claude Code and OpenClaw.",
   "main": "dist/index.js",
   "bin": {