@fargowealth/fargo-ai-cli 0.4.0 → 0.4.2

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 0.4.2
+
+- Windows no longer calls `chmod` while reading or writing credentials; `%APPDATA%` continues to provide the inherited NTFS user ACL without a sandbox-blocked metadata write.
+- `workbuddy install` preserves the Windows executable search `PATH` in the MCP environment so the host can launch `npx` reliably.
+
+## 0.4.1
+
+- **Windows behavior change:** WorkBuddy credentials now use `%APPDATA%\Fargo AI\credentials.json` instead of DPAPI, because sandboxed WorkBuddy sessions may be unable to read or update DPAPI-protected data.
+- `workbuddy install` writes `FARGO_CREDENTIAL_STORE=file` plus absolute credential and refresh-lock paths into the Windows MCP configuration.
+- Existing DPAPI credentials are not migrated. Windows users must reconnect once with 0.4.1.
+
 ## 0.4.0
 
 - **Behavior change:** Fargo CLI is explicitly WorkBuddy-only. On macOS, credentials use the sandbox-compatible private file at `~/.fargo/credentials.json`; the unsupported Keychain mode is rejected. Windows remains protected by DPAPI.

package/README.md

@@ -13,10 +13,10 @@ The login opens the shared Fargo AI consent page and returns to `http://127.0.0.
 ## Credential storage
 
 - **WorkBuddy on macOS:** `~/.fargo/credentials.json`. WorkBuddy's sandbox blocks both the `security` CLI and native Keychain Services. The CLI therefore uses a private file by default and never asks for Full Disk Access.
-- **WorkBuddy on Windows:** DPAPI `CurrentUser`, stored as encrypted bytes under `%APPDATA%\Fargo AI\credentials.bin`.
+- **WorkBuddy on Windows:** `%APPDATA%\Fargo AI\credentials.json`. WorkBuddy may also restrict DPAPI access, so the CLI uses a user-profile credential file and does not depend on DPAPI.
 - **WorkBuddy on Linux:** `~/.fargo/credentials.json`.
 
-On macOS and Linux, the credential directory is forced to `0700` and the credential file to `0600`. Writes use an `fsync`-backed temporary file followed by atomic replacement, symbolic-link reads are rejected, and refresh-token rotation is serialized across local CLI processes.
+On macOS and Linux, the credential directory is forced to `0700` and the credential file to `0600`. Windows inherits the current user's NTFS ACL from `%APPDATA%`. Writes use an `fsync`-backed temporary file followed by atomic replacement, symbolic-link reads are rejected, and refresh-token rotation is serialized across local CLI processes.
 
 The local file contains an OAuth refresh credential. Do not copy, upload, commit, print, or include it in logs. Use `npx -y @fargowealth/fargo-ai-cli@latest auth logout` to remove it when a device is no longer trusted, and revoke the connection from Fargo AI.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fargowealth/fargo-ai-cli",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "Fargo AI OAuth and stdio MCP bridge for WorkBuddy",
   "type": "module",
   "bin": {

package/src/constants.mjs

@@ -1,4 +1,4 @@
-export const CLI_VERSION = "0.4.0";
+export const CLI_VERSION = "0.4.2";
 export const DEVICE_CODE_GRANT_TYPE = "urn:ietf:params:oauth:grant-type:device_code";
 export const DEFAULT_AUTH_URL = "https://auth.fargowealth.app";
 export const DEFAULT_MCP_URL = "https://mcp.fargowealth.app/mcp";

package/src/credential-store.mjs

@@ -1,7 +1,6 @@
 import { chmod, lstat, mkdir, open, readFile, rename, rm, stat } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
-import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { setTimeout as delay } from "node:timers/promises";
 
@@ -9,51 +8,29 @@ export function createCredentialStore(options = {}) {
   const platform = options.platform ?? process.platform;
   const env = options.env ?? process.env;
   const home = options.home ?? homedir();
-  const run = options.run ?? runCommand;
   const storeKind = env.FARGO_CREDENTIAL_STORE;
   if (storeKind === "keychain") {
     throw new Error("FARGO_CREDENTIAL_STORE=keychain is not supported by the WorkBuddy CLI; use file on macOS");
   }
-  if (storeKind && !["dpapi", "file"].includes(storeKind)) {
-    throw new Error(`Unsupported FARGO_CREDENTIAL_STORE: ${storeKind}`);
-  }
-  if (storeKind === "dpapi" && platform !== "win32") {
-    throw new Error("FARGO_CREDENTIAL_STORE=dpapi is only supported on Windows");
+  if (storeKind === "dpapi") {
+    throw new Error("FARGO_CREDENTIAL_STORE=dpapi is not supported by the WorkBuddy CLI; use file on Windows");
   }
-  const filePath = env.FARGO_CREDENTIAL_PATH ?? join(home, ".fargo", "credentials.json");
-  const refreshLockPath = env.FARGO_REFRESH_LOCK_PATH ?? (platform === "win32"
-    ? join(env.APPDATA || home, "Fargo AI", "oauth-refresh.lock")
-    : join(home, ".fargo", "oauth-refresh.lock"));
-  const withRefreshLock = (callback) => withFileLock(refreshLockPath, callback);
-
-  if (platform === "win32" && storeKind !== "file") {
-    const protectedPath = env.FARGO_CREDENTIAL_PATH ?? join(env.APPDATA || home, "Fargo AI", "credentials.bin");
-    return {
-      kind: "windows-dpapi",
-      withRefreshLock,
-      async load() {
-        const script = "$p=$env:FARGO_CREDENTIAL_PATH;if(!(Test-Path -LiteralPath $p)){exit 3};$e=[IO.File]::ReadAllBytes($p);$b=[Security.Cryptography.ProtectedData]::Unprotect($e,$null,[Security.Cryptography.DataProtectionScope]::CurrentUser);[Console]::Out.Write([Text.Encoding]::UTF8.GetString($b))";
-        const result = await run("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], { allowFailure: true, env: { ...env, FARGO_CREDENTIAL_PATH: protectedPath } });
-        if (result.code !== 0 || !result.stdout.trim()) return undefined;
-        return parseCredential(result.stdout.trim());
-      },
-      async save(value) {
-        const script = "$p=$env:FARGO_CREDENTIAL_PATH;$d=Split-Path -Parent $p;[IO.Directory]::CreateDirectory($d)|Out-Null;$s=[Console]::In.ReadToEnd();$b=[Text.Encoding]::UTF8.GetBytes($s);$e=[Security.Cryptography.ProtectedData]::Protect($b,$null,[Security.Cryptography.DataProtectionScope]::CurrentUser);[IO.File]::WriteAllBytes($p,$e)";
-        const result = await run("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], { allowFailure: true, env: { ...env, FARGO_CREDENTIAL_PATH: protectedPath }, stdin: JSON.stringify(value) });
-        if (result.code !== 0) throw new Error("Unable to save Fargo credentials with Windows DPAPI");
-      },
-      async clear() {
-        await rm(protectedPath, { force: true });
-      }
-    };
+  if (storeKind && storeKind !== "file") {
+    throw new Error(`Unsupported FARGO_CREDENTIAL_STORE: ${storeKind}`);
   }
+  const credentialDirectory = platform === "win32"
+    ? join(env.APPDATA || home, "Fargo AI")
+    : join(home, ".fargo");
+  const filePath = env.FARGO_CREDENTIAL_PATH ?? join(credentialDirectory, "credentials.json");
+  const refreshLockPath = env.FARGO_REFRESH_LOCK_PATH ?? join(credentialDirectory, "oauth-refresh.lock");
+  const withRefreshLock = (callback) => withFileLock(refreshLockPath, callback, platform);
 
   return {
     kind: "private-file",
     withRefreshLock,
     async load() {
       try {
-        await secureExistingFile(filePath);
+        await secureExistingFile(filePath, platform);
         return parseCredential(await readFile(filePath, "utf8"));
       } catch (error) {
         if (error?.code === "ENOENT") return undefined;
@@ -62,7 +39,7 @@ export function createCredentialStore(options = {}) {
     },
     async save(value) {
       const directory = dirname(filePath);
-      await ensurePrivateDirectory(directory);
+      await ensurePrivateDirectory(directory, platform);
       const temporaryPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
       let handle;
       try {
@@ -71,16 +48,16 @@ export function createCredentialStore(options = {}) {
         await handle.sync();
         await handle.close();
         handle = undefined;
-        await chmod(temporaryPath, 0o600);
+        if (platform !== "win32") await chmod(temporaryPath, 0o600);
         await rename(temporaryPath, filePath);
-        await secureExistingFile(filePath);
+        await secureExistingFile(filePath, platform);
       } finally {
         await handle?.close().catch(() => {});
         await rm(temporaryPath, { force: true });
       }
     },
     async clear() {
-      await secureExistingFile(filePath).catch((error) => {
+      await secureExistingFile(filePath, platform).catch((error) => {
         if (error?.code !== "ENOENT") throw error;
       });
       await rm(filePath, { force: true });
@@ -88,8 +65,8 @@ export function createCredentialStore(options = {}) {
   };
 }
 
-async function withFileLock(lockPath, callback) {
-  await ensurePrivateDirectory(dirname(lockPath));
+async function withFileLock(lockPath, callback, platform) {
+  await ensurePrivateDirectory(dirname(lockPath), platform);
   const deadline = Date.now() + 15_000;
   const owner = `${process.pid}:${randomUUID()}`;
   let handle;
@@ -125,23 +102,23 @@ async function withFileLock(lockPath, callback) {
   }
 }
 
-async function ensurePrivateDirectory(directoryPath) {
+async function ensurePrivateDirectory(directoryPath, platform) {
   await mkdir(directoryPath, { recursive: true, mode: 0o700 });
   const details = await lstat(directoryPath);
   if (!details.isDirectory() || details.isSymbolicLink()) {
     throw new Error(`Fargo credential directory is not a private directory: ${directoryPath}`);
   }
   assertCurrentUserOwns(details, "credential directory");
-  await chmod(directoryPath, 0o700);
+  if (platform !== "win32") await chmod(directoryPath, 0o700);
 }
 
-async function secureExistingFile(filePath) {
+async function secureExistingFile(filePath, platform) {
   const details = await lstat(filePath);
   if (!details.isFile() || details.isSymbolicLink()) {
     throw new Error(`Fargo credential path is not a regular file: ${filePath}`);
   }
   assertCurrentUserOwns(details, "credential file");
-  await chmod(filePath, 0o600);
+  if (platform !== "win32") await chmod(filePath, 0o600);
 }
 
 function assertCurrentUserOwns(details, label) {
@@ -158,20 +135,3 @@ function parseCredential(value) {
   }
   return parsed;
 }
-
-function runCommand(command, args, options = {}) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(command, args, { env: options.env ?? process.env, stdio: ["pipe", "pipe", "pipe"], windowsHide: true });
-    let stdout = "";
-    let stderr = "";
-    child.stdout.setEncoding("utf8").on("data", (chunk) => { stdout += chunk; });
-    child.stderr.setEncoding("utf8").on("data", (chunk) => { stderr += chunk; });
-    child.on("error", reject);
-    child.on("close", (code) => {
-      const result = { code: code ?? 1, stderr, stdout };
-      if (!options.allowFailure && result.code !== 0) reject(new Error(stderr.trim() || `${command} failed`));
-      else resolve(result);
-    });
-    child.stdin.end(options.stdin ?? "");
-  });
-}

package/src/workbuddy-install.mjs

@@ -24,14 +24,20 @@ export async function installWorkBuddyMcp(options = {}) {
     args: ["-y", packageSpec, "mcp", "serve"],
     timeout: 60000
   };
-  if (platform === "darwin") {
-    const credentialDirectory = join(homeDirectory, ".fargo");
+  if (platform === "darwin" || platform === "win32") {
+    const credentialDirectory = platform === "win32"
+      ? join(env.APPDATA || homeDirectory, "Fargo AI")
+      : join(homeDirectory, ".fargo");
     nextServer.env = {
       FARGO_CREDENTIAL_PATH: join(credentialDirectory, "credentials.json"),
       FARGO_CREDENTIAL_STORE: "file",
-      FARGO_REFRESH_LOCK_PATH: join(credentialDirectory, "oauth-refresh.lock"),
-      PATH: buildMacPath(npxCommand)
+      FARGO_REFRESH_LOCK_PATH: join(credentialDirectory, "oauth-refresh.lock")
     };
+    if (platform === "darwin") nextServer.env.PATH = buildMacPath(npxCommand);
+    if (platform === "win32") {
+      const windowsPath = env.PATH ?? env.Path ?? env.path;
+      if (windowsPath) nextServer.env.PATH = windowsPath;
+    }
   }
   const previousServer = config.mcpServers?.["fargo-ai"];
   const changed = JSON.stringify(previousServer) !== JSON.stringify(nextServer);