@foxden-app/foxclaw 0.3.14 → 0.3.15

package/dist/main.js

@@ -9,7 +9,7 @@ import { APP_HOME, DEFAULT_ENV_PATH, DEFAULT_LOG_PATH, DEFAULT_STATUS_PATH, getL
 import { acquireProcessLock, LockHeldError } from './lock.js';
 import { readRuntimeStatus, writeRuntimeStatus } from './runtime.js';
 import { refreshFoxclawExecStartDropIns, removeFoxclawExecStartDropIns } from './systemd.js';
-import { createSelfUpdateRuntime, performSelfUpdate } from './update.js';
+import { createSelfUpdateRuntime, inferPnpmHomeFromEntryPoint, performSelfUpdate } from './update.js';
 const rawCommand = process.argv[2];
 const command = rawCommand || 'serve';
 loadEnv();
@@ -776,9 +776,17 @@ function stopLaunchd() {
     console.log(`Stopped ${plist}`);
 }
 function buildServicePath(nodeDir) {
+    const pnpmPath = resolveCommand('pnpm');
+    const inferredPnpmHome = inferPnpmHomeFromEntryPoint(entryPoint) || '';
+    const configuredPnpmHome = process.env.PNPM_HOME?.trim() || '';
     const parts = [
         path.join(process.env.HOME || '', '.local', 'bin'),
         nodeDir,
+        inferredPnpmHome,
+        inferredPnpmHome ? path.join(inferredPnpmHome, 'bin') : '',
+        configuredPnpmHome,
+        configuredPnpmHome ? path.join(configuredPnpmHome, 'bin') : '',
+        pnpmPath ? path.dirname(pnpmPath) : '',
         '/usr/local/sbin',
         '/usr/local/bin',
         '/usr/sbin',

package/dist/update.d.ts

@@ -41,7 +41,8 @@ export interface SelfUpdateOutcome {
     error: string | null;
 }
 export declare function selfUpdateStatusPath(statusPath: string): string;
-export declare function resolveSelfUpdateInstaller(entryPoint: string, nodePath?: string, exists?: (target: string) => boolean): SelfUpdateInstaller;
+export declare function inferPnpmHomeFromEntryPoint(entryPoint: string): string | null;
+export declare function resolveSelfUpdateInstaller(entryPoint: string, nodePath?: string, exists?: (target: string) => boolean, env?: NodeJS.ProcessEnv): SelfUpdateInstaller;
 export declare function readSelfUpdateStatus(statusFile: string): SelfUpdateStatus | null;
 export declare function writeSelfUpdateStatus(statusFile: string, status: SelfUpdateStatus): void;
 export declare function createSelfUpdateRuntime(options: CreateSelfUpdateRuntimeOptions): SelfUpdateRuntime;

package/dist/update.js

@@ -7,21 +7,42 @@ const UPDATE_STATUS_FILENAME = 'self-update.json';
 export function selfUpdateStatusPath(statusPath) {
     return path.join(path.dirname(statusPath), UPDATE_STATUS_FILENAME);
 }
-export function resolveSelfUpdateInstaller(entryPoint, nodePath = process.execPath, exists = fs.existsSync) {
+export function inferPnpmHomeFromEntryPoint(entryPoint) {
     const normalizedEntryPoint = entryPoint.replace(/\\/g, '/');
     const globalMarker = '/global/';
     const globalIndex = normalizedEntryPoint.indexOf(globalMarker);
-    if (globalIndex > 0 && normalizedEntryPoint.includes('/.pnpm/')) {
-        const pnpmHome = normalizedEntryPoint.slice(0, globalIndex);
-        const pnpmCommand = path.join(pnpmHome, process.platform === 'win32' ? 'pnpm.cmd' : 'pnpm');
-        if (!exists(pnpmCommand)) {
-            throw new Error(`Current installation is managed by pnpm, but pnpm was not found at ${pnpmCommand}.`);
+    if (globalIndex <= 0 || !normalizedEntryPoint.includes('/.pnpm/')) {
+        return null;
+    }
+    return normalizedEntryPoint.slice(0, globalIndex);
+}
+export function resolveSelfUpdateInstaller(entryPoint, nodePath = process.execPath, exists = fs.existsSync, env = process.env) {
+    const pnpmHome = inferPnpmHomeFromEntryPoint(entryPoint);
+    if (pnpmHome) {
+        const commandName = process.platform === 'win32' ? 'pnpm.cmd' : 'pnpm';
+        const candidates = executableCandidates(commandName, nodePath, env, [
+            path.join(pnpmHome, commandName),
+            path.join(pnpmHome, 'bin', commandName),
+            env.PNPM_HOME?.trim() ? path.join(env.PNPM_HOME.trim(), commandName) : '',
+            env.PNPM_HOME?.trim() ? path.join(env.PNPM_HOME.trim(), 'bin', commandName) : '',
+        ]);
+        const pnpmCommand = candidates.find((candidate) => exists(candidate));
+        if (pnpmCommand) {
+            return {
+                manager: 'pnpm',
+                command: pnpmCommand,
+                installArgs: ['add', '--global', PACKAGE_SPEC],
+                rootArgs: ['root', '--global'],
+            };
         }
+        const npmCommandName = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+        const npmCommand = executableCandidates(npmCommandName, nodePath, env)
+            .find((candidate) => exists(candidate)) ?? npmCommandName;
         return {
             manager: 'pnpm',
-            command: pnpmCommand,
-            installArgs: ['add', '--global', PACKAGE_SPEC],
-            rootArgs: ['root', '--global'],
+            command: npmCommand,
+            installArgs: ['exec', '--yes', '--package=pnpm@latest', '--', 'pnpm', 'add', '--global', PACKAGE_SPEC],
+            rootArgs: ['exec', '--yes', '--package=pnpm@latest', '--', 'pnpm', 'root', '--global'],
         };
     }
     const adjacentNpm = path.join(path.dirname(nodePath), process.platform === 'win32' ? 'npm.cmd' : 'npm');
@@ -117,13 +138,14 @@ export function performSelfUpdate(options) {
     const env = options.env ?? process.env;
     let toVersion = null;
     try {
-        const installer = resolveSelfUpdateInstaller(options.entryPoint, options.nodePath);
+        const installer = resolveSelfUpdateInstaller(options.entryPoint, options.nodePath, fs.existsSync, env);
+        const installerEnv = buildInstallerEnv(options.entryPoint, installer, env);
         console.log(`[UPDATE] Installing ${PACKAGE_SPEC} with ${installer.manager}...`);
-        runInherited(installer.command, installer.installArgs, env);
-        const updatedEntryPoint = resolveUpdatedEntryPoint(installer, env);
+        runInherited(installer.command, installer.installArgs, installerEnv);
+        const updatedEntryPoint = resolveUpdatedEntryPoint(installer, installerEnv);
         toVersion = readInstalledPackageVersion(updatedEntryPoint);
         console.log('[UPDATE] Running checks and restarting the FoxClaw service...');
-        runInherited(options.nodePath, [updatedEntryPoint, 'start'], env);
+        runInherited(options.nodePath, [updatedEntryPoint, 'start'], installerEnv);
         completeNotification(options.notificationFile, 'succeeded', toVersion, null);
         console.log(`[OK] FoxClaw updated and restarted: ${options.version} -> ${toVersion}`);
         return {
@@ -145,6 +167,32 @@ export function performSelfUpdate(options) {
         };
     }
 }
+function executableCandidates(commandName, nodePath, env, preferred = []) {
+    return [
+        ...preferred,
+        path.join(path.dirname(nodePath), commandName),
+        ...(env.PATH || '').split(path.delimiter).filter(Boolean).map((dir) => path.join(dir, commandName)),
+    ].filter((candidate, index, all) => candidate && all.indexOf(candidate) === index);
+}
+function buildInstallerEnv(entryPoint, installer, env) {
+    const pnpmHome = installer.manager === 'pnpm' ? inferPnpmHomeFromEntryPoint(entryPoint) : null;
+    if (!pnpmHome) {
+        return env;
+    }
+    const configuredPnpmHome = env.PNPM_HOME?.trim() || pnpmHome;
+    const pathEntries = [
+        configuredPnpmHome,
+        path.join(configuredPnpmHome, 'bin'),
+        pnpmHome,
+        path.join(pnpmHome, 'bin'),
+        ...(env.PATH || '').split(path.delimiter).filter(Boolean),
+    ];
+    return {
+        ...env,
+        PNPM_HOME: configuredPnpmHome,
+        PATH: pathEntries.filter((entry, index, all) => all.indexOf(entry) === index).join(path.delimiter),
+    };
+}
 function runInherited(command, args, env) {
     const result = spawnSync(command, args, { stdio: 'inherit', env });
     if (result.error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foxden-app/foxclaw",
-  "version": "0.3.14",
+  "version": "0.3.15",
   "description": "Foxden local execution claw for controlling Codex from trusted chat interfaces.",
   "type": "module",
   "main": "dist/main.js",