psyche-ai 9.2.3 → 9.2.5

package/dist/update.js

@@ -1,43 +1,84 @@
 // ============================================================
-// Auto-update checker — non-blocking, fire-and-forget
+// Update manager — context-aware update checks and explicit upgrades
 //
-// Checks npm registry for newer version on initialize().
-// Never blocks, never throws to caller, checks at most once per hour.
+// Goals:
+// - Never block agent startup
+// - Never mutate a dirty local git worktree behind the user's back
+// - Give the right update instruction for the current install shape
+// - Allow explicit self-update via CLI when safe
 // ============================================================
-import { readFile, writeFile, mkdir } from "node:fs/promises";
-import { join, dirname } from "node:path";
+import { readFile, writeFile, mkdir, access } from "node:fs/promises";
+import { constants as fsConstants } from "node:fs";
+import { join, dirname, resolve, sep } from "node:path";
 import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 const execFileAsync = promisify(execFile);
 const PACKAGE_NAME = "psyche-ai";
-// Read version from package.json at module load so it stays in sync automatically
-let CURRENT_VERSION = "9.0.0"; // fallback
-try {
-    const __dirname = dirname(fileURLToPath(import.meta.url));
-    const pkg = JSON.parse(await readFile(join(__dirname, "..", "package.json"), "utf-8"));
-    CURRENT_VERSION = pkg.version ?? CURRENT_VERSION;
-}
-catch {
-    // Silent — use fallback
-}
+const FALLBACK_VERSION = "0.0.0";
 const CHECK_INTERVAL_MS = 60 * 60 * 1000; // 1 hour
 const CACHE_DIR = join(homedir(), ".psyche-ai");
 const CACHE_FILE = join(CACHE_DIR, "update-check.json");
 const FETCH_TIMEOUT_MS = 5000;
+const APPLY_TIMEOUT_MS = 30_000;
+const BUILD_TIMEOUT_MS = 60_000;
+function shellQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+async function readPackageMetadata(root) {
+    const raw = await readFile(join(root, "package.json"), "utf-8");
+    const pkg = JSON.parse(raw);
+    return {
+        version: pkg.version ?? FALLBACK_VERSION,
+        hasBuildScript: typeof pkg.scripts?.build === "string" && pkg.scripts.build.length > 0,
+    };
+}
+async function resolvePackageMetadata() {
+    const __dirname = dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        join(__dirname, ".."),
+        join(__dirname, "..", ".."),
+    ];
+    for (const root of candidates) {
+        try {
+            const meta = await readPackageMetadata(root);
+            return { root, version: meta.version };
+        }
+        catch {
+            // Try next candidate.
+        }
+    }
+    return { root: process.cwd(), version: process.env.npm_package_version ?? FALLBACK_VERSION };
+}
+let packageMetadataPromise = null;
+async function getPackageMetadata() {
+    packageMetadataPromise ??= resolvePackageMetadata();
+    return packageMetadataPromise;
+}
+export function getPackageVersion() {
+    return getPackageMetadata().then((meta) => meta.version);
+}
+function compareSemverPart(a, b) {
+    const na = Number(a ?? 0);
+    const nb = Number(b ?? 0);
+    if (na < nb)
+        return -1;
+    if (na > nb)
+        return 1;
+    return 0;
+}
 /**
  * Compare two semver strings. Returns:
  *  -1 if a < b, 0 if a == b, 1 if a > b
  */
-function compareSemver(a, b) {
-    const pa = a.split(".").map(Number);
-    const pb = b.split(".").map(Number);
+export function compareSemver(a, b) {
+    const pa = a.split(".");
+    const pb = b.split(".");
     for (let i = 0; i < 3; i++) {
-        if ((pa[i] ?? 0) < (pb[i] ?? 0))
-            return -1;
-        if ((pa[i] ?? 0) > (pb[i] ?? 0))
-            return 1;
+        const cmp = compareSemverPart(pa[i], pb[i]);
+        if (cmp !== 0)
+            return cmp;
     }
     return 0;
 }
@@ -56,7 +97,7 @@ async function writeCache(cache) {
         await writeFile(CACHE_FILE, JSON.stringify(cache), "utf-8");
     }
     catch {
-        // Silent — cache is optional
+        // Silent — cache is optional.
     }
 }
 async function fetchLatestVersion() {
@@ -74,45 +115,283 @@ async function fetchLatestVersion() {
         return null;
     }
 }
-async function tryAutoUpdate(latestVersion) {
+async function pathExists(path) {
     try {
-        // Try npm update — timeout after 30s, silent on failure
-        await execFileAsync("npm", ["update", PACKAGE_NAME, "--registry", "https://registry.npmjs.org"], {
-            timeout: 30000,
-        });
-        console.log(`[psyche-ai] ✓ Auto-updated to v${latestVersion}`);
+        await access(path, fsConstants.F_OK);
         return true;
     }
     catch {
         return false;
     }
 }
+async function runCommand(file, args, cwd, timeout) {
+    try {
+        const { stdout, stderr } = await execFileAsync(file, args, {
+            cwd,
+            timeout,
+        });
+        return { ok: true, stdout, stderr };
+    }
+    catch (error) {
+        const err = error;
+        return {
+            ok: false,
+            stdout: err.stdout ?? "",
+            stderr: err.stderr ?? "",
+        };
+    }
+}
+async function detectGitContext(packageRoot, hasBuildScript) {
+    const topLevel = await runCommand("git", ["rev-parse", "--show-toplevel"], packageRoot, 5000);
+    if (!topLevel.ok)
+        return null;
+    const repoRoot = topLevel.stdout.trim();
+    if (!repoRoot)
+        return null;
+    const branchResult = await runCommand("git", ["rev-parse", "--abbrev-ref", "HEAD"], repoRoot, 5000);
+    const branch = branchResult.ok ? branchResult.stdout.trim() : null;
+    const upstreamResult = await runCommand("git", ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"], repoRoot, 5000);
+    const upstream = upstreamResult.ok ? upstreamResult.stdout.trim() : null;
+    const dirtyResult = await runCommand("git", ["status", "--porcelain"], repoRoot, 5000);
+    const dirty = dirtyResult.ok ? dirtyResult.stdout.trim().length > 0 : true;
+    const buildStep = hasBuildScript ? " && npm run build" : "";
+    const manualCommand = `cd ${shellQuote(repoRoot)} && git pull --ff-only${buildStep}`;
+    return {
+        mode: "git-worktree",
+        packageRoot,
+        updateCwd: repoRoot,
+        manualCommand,
+        autoApplyOnInit: false,
+        requiresRestart: true,
+        hasBuildScript,
+        gitBranch: branch,
+        gitUpstream: upstream,
+        dirty,
+        reason: dirty
+            ? "working tree has local changes"
+            : upstream
+                ? undefined
+                : "git branch has no tracked upstream",
+    };
+}
+export async function detectInstallContext(packageRootArg) {
+    const packageRoot = resolve(packageRootArg ?? (await getPackageMetadata()).root);
+    const { hasBuildScript } = await readPackageMetadata(packageRoot).catch(() => ({
+        version: FALLBACK_VERSION,
+        hasBuildScript: false,
+    }));
+    const gitContext = await detectGitContext(packageRoot, hasBuildScript);
+    if (gitContext)
+        return gitContext;
+    const marker = `${sep}node_modules${sep}${PACKAGE_NAME}`;
+    const idx = packageRoot.lastIndexOf(marker);
+    if (idx >= 0) {
+        const projectRoot = packageRoot.slice(0, idx) || sep;
+        return {
+            mode: "npm-project",
+            packageRoot,
+            updateCwd: projectRoot,
+            manualCommand: `cd ${shellQuote(projectRoot)} && npm update ${PACKAGE_NAME}`,
+            autoApplyOnInit: true,
+            requiresRestart: true,
+            hasBuildScript,
+        };
+    }
+    const localBuildStep = hasBuildScript && await pathExists(join(packageRoot, "tsconfig.json"))
+        ? " && npm run build"
+        : "";
+    return {
+        mode: "local-path",
+        packageRoot,
+        updateCwd: packageRoot,
+        manualCommand: `cd ${shellQuote(packageRoot)} && npm update ${PACKAGE_NAME}${localBuildStep}`,
+        autoApplyOnInit: false,
+        requiresRestart: true,
+        hasBuildScript,
+        reason: "local path install is not package-manager managed",
+    };
+}
+function formatAvailableMessage(latestVersion, currentVersion, context) {
+    return `[psyche-ai] v${latestVersion} available (current: v${currentVersion}). Run: psyche upgrade` +
+        (context.mode === "git-worktree" || context.mode === "local-path"
+            ? ` or ${context.manualCommand}`
+            : "");
+}
+async function applyNpmProjectUpdate(context, latestVersion) {
+    const result = await runCommand("npm", ["update", PACKAGE_NAME, "--registry", "https://registry.npmjs.org"], context.updateCwd, APPLY_TIMEOUT_MS);
+    if (!result.ok) {
+        return {
+            status: "failed",
+            currentVersion: await getPackageVersion(),
+            latestVersion,
+            context,
+            manualCommand: context.manualCommand,
+            message: `[psyche-ai] Auto-update failed. Run manually: ${context.manualCommand}`,
+            restartRequired: false,
+        };
+    }
+    const nextVersion = await readPackageMetadata(context.packageRoot)
+        .then((meta) => meta.version)
+        .catch(() => latestVersion);
+    return {
+        status: "updated",
+        currentVersion: nextVersion,
+        latestVersion,
+        context,
+        manualCommand: context.manualCommand,
+        message: `[psyche-ai] Updated to v${nextVersion}. Restart hosts using it to load the new build.`,
+        restartRequired: true,
+    };
+}
+async function applyGitWorktreeUpdate(context, latestVersion) {
+    const currentVersion = await getPackageVersion();
+    if (context.dirty) {
+        return {
+            status: "skipped",
+            currentVersion,
+            latestVersion,
+            context,
+            manualCommand: context.manualCommand,
+            message: `[psyche-ai] Skipped self-update: ${context.reason}. Run manually: ${context.manualCommand}`,
+            restartRequired: false,
+        };
+    }
+    if (!context.gitUpstream) {
+        return {
+            status: "skipped",
+            currentVersion,
+            latestVersion,
+            context,
+            manualCommand: context.manualCommand,
+            message: `[psyche-ai] Skipped self-update: ${context.reason}. Run manually: ${context.manualCommand}`,
+            restartRequired: false,
+        };
+    }
+    const pullResult = await runCommand("git", ["pull", "--ff-only"], context.updateCwd, APPLY_TIMEOUT_MS);
+    if (!pullResult.ok) {
+        return {
+            status: "failed",
+            currentVersion,
+            latestVersion,
+            context,
+            manualCommand: context.manualCommand,
+            message: `[psyche-ai] Git update failed. Run manually: ${context.manualCommand}`,
+            restartRequired: false,
+        };
+    }
+    if (context.hasBuildScript) {
+        const buildResult = await runCommand("npm", ["run", "build"], context.packageRoot, BUILD_TIMEOUT_MS);
+        if (!buildResult.ok) {
+            return {
+                status: "failed",
+                currentVersion,
+                latestVersion,
+                context,
+                manualCommand: context.manualCommand,
+                message: `[psyche-ai] Pulled latest code but build failed. Run manually: ${context.manualCommand}`,
+                restartRequired: false,
+            };
+        }
+    }
+    const nextVersion = await readPackageMetadata(context.packageRoot)
+        .then((meta) => meta.version)
+        .catch(() => latestVersion);
+    return {
+        status: "updated",
+        currentVersion: nextVersion,
+        latestVersion,
+        context,
+        manualCommand: context.manualCommand,
+        message: `[psyche-ai] Updated worktree to v${nextVersion}. Restart hosts using it to load the new build.`,
+        restartRequired: true,
+    };
+}
+async function applyExplicitUpdate(context, latestVersion) {
+    switch (context.mode) {
+        case "npm-project":
+            return applyNpmProjectUpdate(context, latestVersion);
+        case "git-worktree":
+            return applyGitWorktreeUpdate(context, latestVersion);
+        case "local-path":
+            return {
+                status: "skipped",
+                currentVersion: await getPackageVersion(),
+                latestVersion,
+                context,
+                manualCommand: context.manualCommand,
+                message: `[psyche-ai] This install shape needs a manual update. Run: ${context.manualCommand}`,
+                restartRequired: false,
+            };
+    }
+}
+export async function selfUpdate(opts) {
+    const currentVersion = opts?.packageRoot
+        ? await readPackageMetadata(resolve(opts.packageRoot)).then((meta) => meta.version)
+        : await getPackageVersion();
+    const context = await detectInstallContext(opts?.packageRoot);
+    const latestVersion = opts?.latestVersion ?? await fetchLatestVersion();
+    if (!latestVersion) {
+        return {
+            status: "failed",
+            currentVersion,
+            latestVersion: null,
+            context,
+            manualCommand: context.manualCommand,
+            message: "[psyche-ai] Could not reach the registry to check for updates.",
+            restartRequired: false,
+        };
+    }
+    if (compareSemver(currentVersion, latestVersion) >= 0) {
+        return {
+            status: "up-to-date",
+            currentVersion,
+            latestVersion,
+            context,
+            manualCommand: context.manualCommand,
+            message: `[psyche-ai] v${currentVersion} is up to date.`,
+            restartRequired: false,
+        };
+    }
+    if (opts?.checkOnly) {
+        return {
+            status: "available",
+            currentVersion,
+            latestVersion,
+            context,
+            manualCommand: context.manualCommand,
+            message: formatAvailableMessage(latestVersion, currentVersion, context),
+            restartRequired: false,
+        };
+    }
+    return applyExplicitUpdate(context, latestVersion);
+}
 /**
  * Check for updates. Non-blocking, safe to fire-and-forget.
  * - Checks at most once per hour (cached)
- * - If newer version found, attempts auto-update via npm
- * - If auto-update fails, prints a manual update hint
+ * - Auto-applies only for npm-managed installs
+ * - For git/local-path installs, prints the correct explicit upgrade command
  * - Never throws
  */
 export async function checkForUpdate() {
-    // Rate limit: check at most once per hour
+    const currentVersion = await getPackageVersion();
+    const context = await detectInstallContext();
     const cache = await readCache();
     if (cache && Date.now() - cache.lastCheck < CHECK_INTERVAL_MS) {
-        // Still within cooldown — but notify if we already know about a newer version
-        if (cache.latestVersion && compareSemver(CURRENT_VERSION, cache.latestVersion) < 0) {
-            console.log(`[psyche-ai] v${cache.latestVersion} available (current: v${CURRENT_VERSION}). Run: npm update ${PACKAGE_NAME}`);
+        if (cache.latestVersion && compareSemver(currentVersion, cache.latestVersion) < 0) {
+            console.log(formatAvailableMessage(cache.latestVersion, currentVersion, context));
         }
         return;
     }
-    const latest = await fetchLatestVersion();
-    await writeCache({ lastCheck: Date.now(), latestVersion: latest });
-    if (!latest || compareSemver(CURRENT_VERSION, latest) >= 0) {
-        return; // Up to date or couldn't check
+    const latestVersion = await fetchLatestVersion();
+    await writeCache({ lastCheck: Date.now(), latestVersion });
+    if (!latestVersion || compareSemver(currentVersion, latestVersion) >= 0) {
+        return;
     }
-    // Newer version available — try auto-update
-    console.log(`[psyche-ai] New version v${latest} available (current: v${CURRENT_VERSION}), updating...`);
-    const updated = await tryAutoUpdate(latest);
-    if (!updated) {
-        console.log(`[psyche-ai] Auto-update failed. Run manually: npm update ${PACKAGE_NAME}`);
+    if (!context.autoApplyOnInit) {
+        console.log(formatAvailableMessage(latestVersion, currentVersion, context));
+        return;
     }
+    console.log(`[psyche-ai] New version v${latestVersion} available (current: v${currentVersion}), updating...`);
+    const result = await applyExplicitUpdate(context, latestVersion);
+    console.log(result.message);
 }

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "psyche-ai",
   "name": "Artificial Psyche",
   "description": "Virtual endocrine system, empathy engine, and agency for OpenClaw agents",
-  "version": "5.1.0",
+  "version": "9.2.3",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,
@@ -49,6 +49,15 @@
         "type": "boolean",
         "default": true,
         "description": "Persist emotional state to disk. Set false for privacy."
+      },
+      "diagnostics": {
+        "type": "boolean",
+        "default": true,
+        "description": "Collect diagnostic metrics and write diagnostics.jsonl at session end."
+      },
+      "feedbackUrl": {
+        "type": "string",
+        "description": "Optional endpoint for auto-submitting anonymized diagnostic reports."
       }
     }
   },
@@ -89,6 +98,16 @@
       "label": "Persist State",
       "sensitive": false,
       "advanced": true
+    },
+    "diagnostics": {
+      "label": "Diagnostics Logging",
+      "sensitive": false,
+      "advanced": true
+    },
+    "feedbackUrl": {
+      "label": "Feedback Endpoint",
+      "sensitive": true,
+      "advanced": true
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "psyche-ai",
-  "version": "9.2.3",
+  "version": "9.2.5",
   "description": "Artificial Psyche — universal emotional intelligence plugin for any AI agent",
   "mcpName": "io.github.Shangri-la-0428/psyche-ai",
   "type": "module",