@skrr-ai/cli 0.1.24 → 0.1.25

package/dist/node_modules/@skrr-ai/auth-core/dist/cjs/kek/linux.js

@@ -64,7 +64,6 @@ exports.__resetKekCacheForTest = __resetKekCacheForTest;
  * cleaning up the corresponding Secret Service entry when finished.
  */
 const node_child_process_1 = require("node:child_process");
-const node_util_1 = require("node:util");
 const node_crypto_1 = __importDefault(require("node:crypto"));
 const node_os_1 = __importDefault(require("node:os"));
 const node_fs_1 = __importDefault(require("node:fs"));
@@ -104,7 +103,6 @@ const HKDF_INFO = Buffer.from('oversky-cred-kek-v1');
 /** Filesystem paths for Tier-3 IKM components. */
 const PATH_LOGINUID = '/proc/self/loginuid';
 const PATH_MACHINE_ID = '/etc/machine-id';
-const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
 let _execFileForTest = null;
 /**
  * @internal Test seam — inject a mock execFile for hermetic tests so the
@@ -118,23 +116,38 @@ function __setExecFileForTest(fn) {
     _secretToolProbeCache = undefined;
     _tierSelection = null;
 }
-/** Default execFile wrapper used when no test override is installed. */
-const defaultExec = async (file, args, options) => {
-    const result = await execFileAsync(file, args, {
-        encoding: 'utf-8',
-        ...(options ?? {}),
+/**
+ * Default execFile wrapper used when no test override is installed.
+ *
+ * `input` is WRITTEN to the child's stdin here, and stdin is always closed. The
+ * previous version forwarded `input` as an execFile option — but only the SYNC
+ * child_process functions honour `input`; async `execFile` ignores it. So
+ * `secret-tool store`, which reads the secret from stdin, got neither the secret
+ * nor EOF and waited forever: Tier-2 enrollment could not complete on any Linux
+ * desktop with a working Secret Service. Closing stdin also means no other call
+ * can block on a tool that unexpectedly reads it.
+ */
+const defaultExec = (file, args, options) => new Promise((resolve, reject) => {
+    const { input, ...execOptions } = options ?? {};
+    const child = (0, node_child_process_1.execFile)(file, args, { encoding: 'utf-8', ...execOptions }, (err, stdout, stderr) => {
+        // Defensive coercion — when callers override the encoding, output may
+        // surface as Buffer; normalize both shapes.
+        const out = typeof stdout === 'string' ? stdout : Buffer.from(stdout).toString('utf-8');
+        const errOut = typeof stderr === 'string' ? stderr : Buffer.from(stderr).toString('utf-8');
+        if (err) {
+            // Same shape promisify(execFile) produced, which the probe reads.
+            reject(Object.assign(err, { stdout: out, stderr: errOut }));
+            return;
+        }
+        resolve({ stdout: out, stderr: errOut });
     });
-    // Defensive coercion — when callers override the encoding, stdout may
-    // surface as Buffer/Uint8Array; the typeof guard keeps both shapes safe.
-    return {
-        stdout: typeof result.stdout === 'string'
-            ? result.stdout
-            : Buffer.from(result.stdout).toString('utf-8'),
-        stderr: typeof result.stderr === 'string'
-            ? result.stderr
-            : Buffer.from(result.stderr).toString('utf-8'),
-    };
-};
+    if (child.stdin) {
+        // A child that exits without reading stdin makes the write fail with EPIPE;
+        // the exit status is what reports that, not this stream.
+        child.stdin.on('error', () => undefined);
+        child.stdin.end(input ?? '');
+    }
+});
 function exec(file, args, options) {
     const impl = _execFileForTest ?? defaultExec;
     return impl(file, args, { encoding: 'utf-8', ...options });
@@ -166,6 +179,41 @@ function readFileTrimmed(path) {
 // ---------------------------------------------------------------------------
 /** `undefined` = not yet probed; `boolean` = cached probe outcome. */
 let _secretToolProbeCache;
+/**
+ * True when `secret-tool` never started, as opposed to starting and exiting
+ * non-zero.
+ *
+ * `execFile` reports the two differently: a process that ran and failed carries
+ * its numeric exit code, and a spawn that failed carries a STRING errno. Only
+ * `ENOENT` used to count as "missing", so every other spawn failure read as a
+ * working binary — and the probe then picked the libsecret tier, whose `store`
+ * cannot succeed either, which disables the credential envelope and makes the CLI
+ * refuse to persist any credential at all.
+ *
+ * The case that found it: a PATH entry the process may not search. execvp
+ * reports EACCES rather than ENOENT once it has met one, and a systemd unit that
+ * makes /snap inaccessible while PATH still lists /snap/bin (the Dedicated Runtime
+ * daemon sandbox did) turns every missing binary into EACCES.
+ */
+function secretToolDidNotRun(err) {
+    const { code, status } = err;
+    return (typeof code === 'string' && SECRET_TOOL_UNRUNNABLE.has(code)) || status === 127;
+}
+/**
+ * Spawn errnos that mean the binary cannot be executed from here, permanently
+ * for this process. Deliberately NOT every string errno: EAGAIN, EMFILE or ENOMEM
+ * are transient, and caching "absent" on one of those would move a machine whose
+ * libsecret works onto the machine-id tier for the rest of the process — where the
+ * existing wrapped key cannot be opened and would be re-enrolled over.
+ */
+const SECRET_TOOL_UNRUNNABLE = new Set([
+    'ENOENT',
+    'EACCES',
+    'ENOTDIR',
+    'ELOOP',
+    'ENOEXEC',
+    'EPERM',
+]);
 /**
  * Probe secret-tool availability. Two checks:
  *   1. `secret-tool --version` — ENOENT or exit 127 means binary missing.
@@ -183,9 +231,7 @@ async function probeSecretTool() {
         await exec('secret-tool', ['--version']);
     }
     catch (err) {
-        const code = err.code;
-        const status = err.status;
-        if (code === 'ENOENT' || status === 127) {
+        if (secretToolDidNotRun(err)) {
             _secretToolProbeCache = false;
             return false;
         }
@@ -199,6 +245,10 @@ async function probeSecretTool() {
         _secretToolProbeCache = true;
     }
     catch (err) {
+        if (secretToolDidNotRun(err)) {
+            _secretToolProbeCache = false;
+            return false;
+        }
         const stderr = err.stderr ?? '';
         const isTransportError = DBUS_TRANSPORT_ERRORS.some((s) => stderr.includes(s));
         if (isTransportError) {

package/dist/node_modules/@skrr-ai/auth-core/dist/esm/kek/linux.js

@@ -54,7 +54,6 @@
  * cleaning up the corresponding Secret Service entry when finished.
  */
 import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
 import crypto from 'node:crypto';
 import os from 'node:os';
 import fs from 'node:fs';
@@ -94,7 +93,6 @@ const HKDF_INFO = Buffer.from('oversky-cred-kek-v1');
 /** Filesystem paths for Tier-3 IKM components. */
 const PATH_LOGINUID = '/proc/self/loginuid';
 const PATH_MACHINE_ID = '/etc/machine-id';
-const execFileAsync = promisify(execFile);
 let _execFileForTest = null;
 /**
  * @internal Test seam — inject a mock execFile for hermetic tests so the
@@ -108,23 +106,38 @@ export function __setExecFileForTest(fn) {
     _secretToolProbeCache = undefined;
     _tierSelection = null;
 }
-/** Default execFile wrapper used when no test override is installed. */
-const defaultExec = async (file, args, options) => {
-    const result = await execFileAsync(file, args, {
-        encoding: 'utf-8',
-        ...(options ?? {}),
+/**
+ * Default execFile wrapper used when no test override is installed.
+ *
+ * `input` is WRITTEN to the child's stdin here, and stdin is always closed. The
+ * previous version forwarded `input` as an execFile option — but only the SYNC
+ * child_process functions honour `input`; async `execFile` ignores it. So
+ * `secret-tool store`, which reads the secret from stdin, got neither the secret
+ * nor EOF and waited forever: Tier-2 enrollment could not complete on any Linux
+ * desktop with a working Secret Service. Closing stdin also means no other call
+ * can block on a tool that unexpectedly reads it.
+ */
+const defaultExec = (file, args, options) => new Promise((resolve, reject) => {
+    const { input, ...execOptions } = options ?? {};
+    const child = execFile(file, args, { encoding: 'utf-8', ...execOptions }, (err, stdout, stderr) => {
+        // Defensive coercion — when callers override the encoding, output may
+        // surface as Buffer; normalize both shapes.
+        const out = typeof stdout === 'string' ? stdout : Buffer.from(stdout).toString('utf-8');
+        const errOut = typeof stderr === 'string' ? stderr : Buffer.from(stderr).toString('utf-8');
+        if (err) {
+            // Same shape promisify(execFile) produced, which the probe reads.
+            reject(Object.assign(err, { stdout: out, stderr: errOut }));
+            return;
+        }
+        resolve({ stdout: out, stderr: errOut });
     });
-    // Defensive coercion — when callers override the encoding, stdout may
-    // surface as Buffer/Uint8Array; the typeof guard keeps both shapes safe.
-    return {
-        stdout: typeof result.stdout === 'string'
-            ? result.stdout
-            : Buffer.from(result.stdout).toString('utf-8'),
-        stderr: typeof result.stderr === 'string'
-            ? result.stderr
-            : Buffer.from(result.stderr).toString('utf-8'),
-    };
-};
+    if (child.stdin) {
+        // A child that exits without reading stdin makes the write fail with EPIPE;
+        // the exit status is what reports that, not this stream.
+        child.stdin.on('error', () => undefined);
+        child.stdin.end(input ?? '');
+    }
+});
 function exec(file, args, options) {
     const impl = _execFileForTest ?? defaultExec;
     return impl(file, args, { encoding: 'utf-8', ...options });
@@ -156,6 +169,41 @@ function readFileTrimmed(path) {
 // ---------------------------------------------------------------------------
 /** `undefined` = not yet probed; `boolean` = cached probe outcome. */
 let _secretToolProbeCache;
+/**
+ * True when `secret-tool` never started, as opposed to starting and exiting
+ * non-zero.
+ *
+ * `execFile` reports the two differently: a process that ran and failed carries
+ * its numeric exit code, and a spawn that failed carries a STRING errno. Only
+ * `ENOENT` used to count as "missing", so every other spawn failure read as a
+ * working binary — and the probe then picked the libsecret tier, whose `store`
+ * cannot succeed either, which disables the credential envelope and makes the CLI
+ * refuse to persist any credential at all.
+ *
+ * The case that found it: a PATH entry the process may not search. execvp
+ * reports EACCES rather than ENOENT once it has met one, and a systemd unit that
+ * makes /snap inaccessible while PATH still lists /snap/bin (the Dedicated Runtime
+ * daemon sandbox did) turns every missing binary into EACCES.
+ */
+function secretToolDidNotRun(err) {
+    const { code, status } = err;
+    return (typeof code === 'string' && SECRET_TOOL_UNRUNNABLE.has(code)) || status === 127;
+}
+/**
+ * Spawn errnos that mean the binary cannot be executed from here, permanently
+ * for this process. Deliberately NOT every string errno: EAGAIN, EMFILE or ENOMEM
+ * are transient, and caching "absent" on one of those would move a machine whose
+ * libsecret works onto the machine-id tier for the rest of the process — where the
+ * existing wrapped key cannot be opened and would be re-enrolled over.
+ */
+const SECRET_TOOL_UNRUNNABLE = new Set([
+    'ENOENT',
+    'EACCES',
+    'ENOTDIR',
+    'ELOOP',
+    'ENOEXEC',
+    'EPERM',
+]);
 /**
  * Probe secret-tool availability. Two checks:
  *   1. `secret-tool --version` — ENOENT or exit 127 means binary missing.
@@ -173,9 +221,7 @@ async function probeSecretTool() {
         await exec('secret-tool', ['--version']);
     }
     catch (err) {
-        const code = err.code;
-        const status = err.status;
-        if (code === 'ENOENT' || status === 127) {
+        if (secretToolDidNotRun(err)) {
             _secretToolProbeCache = false;
             return false;
         }
@@ -189,6 +235,10 @@ async function probeSecretTool() {
         _secretToolProbeCache = true;
     }
     catch (err) {
+        if (secretToolDidNotRun(err)) {
+            _secretToolProbeCache = false;
+            return false;
+        }
         const stderr = err.stderr ?? '';
         const isTransportError = DBUS_TRANSPORT_ERRORS.some((s) => stderr.includes(s));
         if (isTransportError) {

package/dist/node_modules/@skrr-ai/auth-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skrr-ai/auth-core",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "main": "dist/cjs/index.js",
   "types": "dist/esm/index.d.ts",
   "exports": {