moflo 4.9.29 → 4.9.30

package/dist/src/cli/spells/core/credential-validation.js

@@ -0,0 +1,89 @@
+/**
+ * Credential Validation
+ *
+ * Lightweight, no-config shape checks applied to values pulled from the
+ * encrypted credential store before they are promoted to `process.env`.
+ *
+ * Two heuristics, both conservative — only invalidate when there is
+ * positive evidence the stored value is bad. Anything we can't classify
+ * passes through unchanged.
+ *
+ *   - JWT-shaped values (3 base64url segments) get their `exp` claim
+ *     parsed and compared to "now". An expired JWT is reported as such.
+ *   - Env keys ending in `_URL` must parse via the WHATWG `URL`
+ *     constructor and have a non-empty host.
+ *
+ * Story #1007: avoid silently reusing stale stored credentials (e.g.
+ * Microsoft Graph access tokens, which expire in ~1h) so the resolver
+ * can fall through to the prompt path and the user understands why.
+ */
+const VALID_JWT_SEGMENT = /^[A-Za-z0-9_-]+$/;
+export function validateStoredCredential(envKey, value) {
+    if (envKey.endsWith('_URL')) {
+        return validateUrlValue(value);
+    }
+    if (looksLikeJwt(value)) {
+        return validateJwtExpiry(value);
+    }
+    return { valid: true };
+}
+function validateUrlValue(value) {
+    try {
+        const parsed = new URL(value);
+        if (!parsed.host) {
+            return { valid: false, reason: 'stored value is not a valid URL (missing host)' };
+        }
+        return { valid: true };
+    }
+    catch {
+        return { valid: false, reason: 'stored value is not a valid URL' };
+    }
+}
+function looksLikeJwt(value) {
+    const parts = value.split('.');
+    if (parts.length !== 3)
+        return false;
+    return parts.every(p => p.length > 0 && VALID_JWT_SEGMENT.test(p));
+}
+function validateJwtExpiry(value) {
+    const exp = readJwtExp(value);
+    if (exp == null)
+        return { valid: true };
+    const expiryMs = exp * 1000;
+    const now = Date.now();
+    if (expiryMs >= now)
+        return { valid: true };
+    return { valid: false, reason: `JWT expired ${formatDuration(now - expiryMs)} ago` };
+}
+function readJwtExp(value) {
+    try {
+        const payload = value.split('.')[1];
+        const padLen = (4 - (payload.length % 4)) % 4;
+        const b64 = payload.replace(/-/g, '+').replace(/_/g, '/') + '='.repeat(padLen);
+        const decoded = Buffer.from(b64, 'base64').toString('utf-8');
+        const parsed = JSON.parse(decoded);
+        if (typeof parsed === 'object' && parsed !== null) {
+            const exp = parsed.exp;
+            if (typeof exp === 'number' && Number.isFinite(exp))
+                return exp;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+function formatDuration(ms) {
+    const s = Math.floor(ms / 1000);
+    if (s < 60)
+        return `${s}s`;
+    const m = Math.floor(s / 60);
+    if (m < 60)
+        return `${m}m`;
+    const h = Math.floor(m / 60);
+    if (h < 24)
+        return `${h}h ${m % 60}m`;
+    const d = Math.floor(h / 24);
+    return `${d}d ${h % 24}h`;
+}
+//# sourceMappingURL=credential-validation.js.map

package/dist/src/cli/spells/core/prerequisite-checker.js

@@ -18,6 +18,7 @@ import { access } from 'node:fs/promises';
 import { promisify } from 'node:util';
 import { acquireTTYLock } from './tty-lock.js';
 import { readLineFromStdin } from './stdin-reader.js';
+import { validateStoredCredential } from './credential-validation.js';
 const execFileAsync = promisify(execFile);
 /**
  * Check whether a CLI command is available on the system PATH.
@@ -190,19 +191,28 @@ export async function resolveUnmetPrerequisites(prerequisites, options = {}) {
     // lets us skip a re-check of the cheap env detector.
     // `forceCredentialReprompt` bypasses this step so users can rotate or
     // correct stored credentials by re-running through the prompt path.
+    // Stored values are shape-validated (#1007): expired JWTs and malformed
+    // _URL values are rejected and surface in the preflight banner, so the
+    // resolver re-prompts instead of silently feeding garbage to the spell.
     const resolvedFromStoreNames = [];
     const storeResolved = new Set();
+    const rejectedFromStore = [];
     if (credentials && !options.forceCredentialReprompt) {
         await Promise.all(unmetIndices.map(async (i) => {
             const prereq = prerequisites[i];
             if (!prereq.envKey)
                 return;
             const stored = await credentials.get(prereq.envKey);
-            if (typeof stored === 'string' && stored.length > 0) {
-                process.env[prereq.envKey] = stored;
-                storeResolved.add(i);
-                resolvedFromStoreNames.push(prereq.name);
+            if (typeof stored !== 'string' || stored.length === 0)
+                return;
+            const validation = validateStoredCredential(prereq.envKey, stored);
+            if (!validation.valid) {
+                rejectedFromStore.push({ envKey: prereq.envKey, reason: validation.reason });
+                return;
             }
+            process.env[prereq.envKey] = stored;
+            storeResolved.add(i);
+            resolvedFromStoreNames.push(prereq.name);
         }));
     }
     const stillUnmetIdx = unmetIndices.filter(i => !storeResolved.has(i));
@@ -218,7 +228,7 @@ export async function resolveUnmetPrerequisites(prerequisites, options = {}) {
         if (promptableEnvKeys.length > 0) {
             return {
                 ok: false,
-                message: formatMissingCredentialMessage(promptableEnvKeys, stillUnmet),
+                message: formatMissingCredentialMessage(promptableEnvKeys, stillUnmet, rejectedFromStore),
                 resolvedNames: resolvedFromStoreNames,
                 errorCode: 'MISSING_CREDENTIAL',
                 missingCredentials: promptableEnvKeys,
@@ -231,6 +241,12 @@ export async function resolveUnmetPrerequisites(prerequisites, options = {}) {
         };
     }
     printPreflightBanner(log, stillUnmet.length);
+    if (rejectedFromStore.length > 0) {
+        for (const r of rejectedFromStore) {
+            log(`  Stored ${r.envKey} rejected — ${r.reason}. Re-enter below.`);
+        }
+        log('');
+    }
     const promptLine = options.promptLine ?? readLineFromStdin;
     const promptedNames = [];
     const promptableSet = new Set(promptable);
@@ -309,13 +325,20 @@ export async function resolveUnmetPrerequisites(prerequisites, options = {}) {
     }
     return { ok: true, resolvedNames: [...resolvedFromStoreNames, ...promptedNames] };
 }
-function formatMissingCredentialMessage(envKeys, prereqs) {
+function formatMissingCredentialMessage(envKeys, prereqs, rejectedFromStore) {
     const lines = ['Missing credentials (cannot prompt — non-interactive run):'];
     for (const key of envKeys) {
         const prereq = prereqs.find(p => p.envKey === key);
         const label = `${prereq?.name ?? key} (${key})`;
         appendPrereqLine(lines, label, prereq?.installHint, prereq?.url);
     }
+    if (rejectedFromStore.length > 0) {
+        lines.push('');
+        lines.push('Stored value(s) rejected as stale or invalid:');
+        for (const r of rejectedFromStore) {
+            lines.push(`  - ${r.envKey}: ${r.reason}`);
+        }
+    }
     lines.push('');
     lines.push('Prime these by casting the spell once interactively, or run:');
     lines.push('  flo spell credentials set <name>');

package/dist/src/cli/version.js

@@ -2,5 +2,5 @@
  * Auto-generated by build. Do not edit manually.
  * Source of truth: root package.json → scripts/sync-version.mjs
  */
-export const VERSION = '4.9.29';
+export const VERSION = '4.9.30';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moflo",
-  "version": "4.9.29",
+  "version": "4.9.30",
   "description": "MoFlo — AI agent orchestration for Claude Code. A standalone, opinionated toolkit with semantic memory, learned routing, gates, spells, and the /flo issue-execution skill.",
   "main": "dist/src/cli/index.js",
   "type": "module",
@@ -84,7 +84,7 @@
     "@typescript-eslint/eslint-plugin": "^7.18.0",
     "@typescript-eslint/parser": "^7.18.0",
     "eslint": "^8.0.0",
-    "moflo": "^4.9.28",
+    "moflo": "^4.9.29",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
     "vitest": "^4.0.0"