@fiodos/cli 0.1.23 → 0.1.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fiodos/cli",
-  "version": "0.1.23",
+  "version": "0.1.25",
   "description": "Fiodos CLI — analyzes your app's source code and generates the in-app voice-agent manifest, then wires the orb. Powers `npx @fiodos/cli analyze`.",
   "type": "commonjs",
   "bin": {
@@ -14,13 +14,14 @@
     "README.md"
   ],
   "scripts": {
-    "analyze": "node src/index.js"
+    "analyze": "node src/index.js",
+    "test": "node --test test/*.test.js"
   },
   "engines": {
     "node": ">=18"
   },
   "dependencies": {
-    "@fiodos/core": "^0.1.2",
+    "@fiodos/core": "^0.1.10",
     "esbuild": "^0.28.1",
     "jsdom": "^24.0.0",
     "typescript": "^5.6.0"

package/src/changeRegistry.js

@@ -214,8 +214,31 @@ function summarizeEnv(result) {
   return { ...base, applied: false };
 }
 
+function summarizeSession(result) {
+  if (!result) return { status: 'skipped', applied: false };
+  const base = { status: result.status, strategy: result.strategy || null };
+  switch (result.status) {
+    case 'applied':
+    case 'applied-untested':
+      return {
+        ...base,
+        applied: true,
+        what: 'Connected the orb to the app\'s real session state (isAuthenticated/getUserId) automatically.',
+        revert: 'Delete session.generated.* and remove the FYODOS:SESSION blocks + mount props.',
+      };
+    case 'review':
+      return { ...base, applied: false, note: `Session left for review: ${result.reason || ''}` };
+    case 'reverted':
+      return { ...base, applied: false, note: `Session wiring reverted: ${result.reason || ''}` };
+    case 'no-session':
+      return { ...base, applied: false, note: 'No login detected — session wiring not needed.' };
+    default:
+      return { ...base, applied: false };
+  }
+}
+
 function collectFileEntries(appRoot, ctx) {
-  const { orbResult, handlerResult, registryResult, envResult } = ctx;
+  const { orbResult, handlerResult, registryResult, sessionResult, envResult } = ctx;
   const created = [];
   const modified = [];
   const docs = [];
@@ -291,6 +314,36 @@ function collectFileEntries(appRoot, ctx) {
     });
   }
 
+  // Session wiring (auth awareness — automatic)
+  if (
+    sessionResult &&
+    (sessionResult.status === 'applied' || sessionResult.status === 'applied-untested')
+  ) {
+    if (sessionResult.sessionFile) {
+      created.push({
+        path: normRel(appRoot, sessionResult.sessionFile),
+        phase: 'session',
+        what: 'Generated session module (`session.generated.*`): isAuthenticated/getUserId for the orb.',
+        revert: 'Safe to delete; re-run the installer to regenerate.',
+      });
+    }
+    if (sessionResult.editedFile) {
+      modified.push({
+        path: sessionResult.editedFile,
+        phase: 'session',
+        what: 'Registered the live session in the bridge (reversible FYODOS:SESSION block).',
+        revert: 'Remove the FYODOS:SESSION blocks.',
+      });
+    }
+    if (sessionResult.docPath) {
+      docs.push({
+        path: normRel(appRoot, sessionResult.docPath),
+        phase: 'session',
+        what: 'Session wiring summary: strategy, honesty contract, security notes.',
+      });
+    }
+  }
+
   // Env (never record values)
   if (envResult?.status === 'written' && envResult.writePlan?.targetRel) {
     modified.push({
@@ -379,6 +432,7 @@ function buildRunRecord(appRoot, ctx) {
       orb: summarizeOrb(ctx.orbResult),
       handlers: summarizeHandlers(ctx.handlerResult, appRoot),
       registries: summarizeRegistries(ctx.registryResult),
+      session: summarizeSession(ctx.sessionResult),
       env: summarizeEnv(ctx.envResult),
     },
     files: collectFileEntries(appRoot, ctx),

package/src/index.js

@@ -94,10 +94,14 @@ const { collectFiles } = require('./collect');
 const { resolveAnalysisRoot } = require('./resolveAnalysisRoot');
 const { analyzeWithAI, correctActionWiring, generateGuardianWithAI, DEFAULT_MODEL, resolveModel } = require('./aiAnalyze');
 const { verifyManifest } = require('./verify');
-const { wireWebOrb, reportWireResult, connectOrbRegistries, reportRegistriesResult } = require('./wireWeb');
-const { wireReactNativeOrb, reportReactNativeWire } = require('./wireReactNative');
+const {
+  wireWebOrb, reportWireResult, connectOrbRegistries, reportRegistriesResult,
+  connectOrbSession, reportSessionConnectResult,
+} = require('./wireWeb');
+const { wireReactNativeOrb, reportReactNativeWire, connectRnSession } = require('./wireReactNative');
 const { wireFlutterOrb, writeFlutterEnv, reportFlutterWire } = require('./wireFlutter');
 const { wireHandlers, reportHandlerResult } = require('./wireHandlers');
+const { wireSession, reportSessionResult } = require('./wireSession');
 const { offerWriteEnv, printEnvManualReminder } = require('./writeEnv');
 const { scoreSurface, computeSurface } = require('./scoreSurface');
 const { buildRunRecord, writeChangeRegistry } = require('./changeRegistry');
@@ -113,6 +117,8 @@ function arg(flag, fallback) {
 const VALUE_FLAGS = new Set([
   '--out', '--model', '--max-input-tokens', '--platform', '--api-key', '--api-url',
   '--spec', '--analysis-root',
+  // from-odata (closed-software mode)
+  '--app-id', '--app-name', '--app-description', '--auth-ref', '--entities',
 ]);
 
 /**
@@ -251,6 +257,42 @@ async function withSpinner(label, work) {
 }
 
 async function main() {
+  // ── Closed-software mode: `fiodos from-odata <metadata.xml|url>` ────────────
+  // Generates the manifest from a third-party system's OData $metadata (schema,
+  // not source code), so the consent gate about code analysis does not apply.
+  {
+    const pos = positionalArgs();
+    if (pos[0] === 'from-odata') {
+      const target = pos[1];
+      if (!target) {
+        console.error('Usage: fiodos from-odata <metadata.xml | https://…/$metadata> --app-id <id> --app-name <name> [--entities a,b] [--auth-ref name] [--out dir] [--publish --api-key fyd_…]');
+        process.exit(1);
+      }
+      const { runFromOData } = require('./odata');
+      const safeName = path.basename(target).replace(/[^a-z0-9_-]/gi, '_') || 'odata';
+      const outDirOData = arg('--out', path.join(os.tmpdir(), 'fiodos', 'analysis', safeName));
+      const entitiesArg = arg('--entities', '');
+      await runFromOData({
+        target,
+        outDir: outDirOData,
+        opts: {
+          appId: arg('--app-id', `odata.${safeName}`),
+          appName: arg('--app-name', 'Third-party system'),
+          appDescription: arg('--app-description', ''),
+          authRef: arg('--auth-ref', 'default'),
+          entities: entitiesArg ? entitiesArg.split(',').map((s) => s.trim()).filter(Boolean) : [],
+          publish: process.argv.includes('--publish'),
+        },
+        io: {
+          logUser,
+          logDev,
+          publish: (manifest, meta) => publishManifest(manifest, meta),
+        },
+      });
+      return;
+    }
+  }
+
   // Consent gate: confirm before doing anything. `yes` continues; `no` (or any
   // other answer) cancels instantly — no analysis is run, the command just ends.
   const proceed = await askProceed();
@@ -353,11 +395,19 @@ async function main() {
   let provenance;
   let evidence = {};
   let wiring = {};
+  // The AI's "session" block: WHERE the app's auth/session state lives, so the
+  // orb's isAuthenticated/getUserId are wired automatically (no manual step).
+  let sessionWiring = null;
   let analysisMeta = { engine: 'auto-manifest-v3-ai-first', model: null, costUSD: 0 };
   // Signed proof returned by the hosted-analysis proxy: it tells the publish
   // step the quota was already consumed at /v1/developer/analyze (no double
   // count). Null in own-key / --no-llm mode.
   let analysisToken = null;
+  // Spec-requested content resets declared by the analysis AI: which dashboard
+  // context overrides (bubblePrompt/description/examples) the developer's
+  // --spec EXPLICITLY asked to regenerate, so the backend clears those (and
+  // ONLY those) masking overrides on publish. Null when the spec asked nothing.
+  let specResets = null;
 
   if (!useLLM) {
     // Static-only fallback: routes with mechanical naming, no actions.
@@ -410,6 +460,13 @@ async function main() {
     const proposed = parsed.manifest || {};
     evidence = parsed.evidence || {};
     wiring = parsed.wiring || {};
+    sessionWiring = parsed.session || null;
+    // Only meaningful when the developer passed --spec; the backend sanitizes
+    // (context fields only, real intents only) before touching any override.
+    specResets = (userSpec && parsed.specResets && typeof parsed.specResets === 'object')
+      ? parsed.specResets
+      : null;
+    if (specResets) logDev(`[ai] specResets=${JSON.stringify(specResets)}`);
     logDev(`[ai] model=${model} proposed routes=${(proposed.routes || []).length} ` +
       `actions=${(proposed.actions || []).length} in ${(elapsedMs / 1000).toFixed(1)}s`);
     logDev(`[ai] tokens in=${usage.prompt_tokens} out=${usage.completion_tokens} cost=$${costUSD.toFixed(4)}`);
@@ -427,7 +484,7 @@ async function main() {
     logUser('Analysis complete');
 
     fs.writeFileSync(path.join(outDir, 'evidence.json'), JSON.stringify({
-      evidence, wiring, uncertain: parsed.uncertain || [],
+      evidence, wiring, session: sessionWiring, uncertain: parsed.uncertain || [],
     }, null, 2));
     fs.writeFileSync(path.join(outDir, 'usage.json'), JSON.stringify({
       model, elapsedMs, usage,
@@ -524,6 +581,14 @@ async function main() {
       disabledRouteIntents: surfaceScore.disabledRouteIntents || [],
       disabledActionIntents: surfaceScore.disabledActionIntents || [],
     },
+    // Present ONLY when the developer's --spec explicitly asked to regenerate
+    // previously-edited content (e.g. "rewrite all bubble prompts"): the backend
+    // clears the matching dashboard overrides so the fresh values become live.
+    ...(specResets ? { specResets } : {}),
+    // Opt-out of the backend's continuity guard (which keeps intent ids and
+    // URL paths stable across re-analyses so dashboard customizations never
+    // break). Only for developers who explicitly want a clean slate.
+    ...(process.argv.includes('--fresh-intents') ? { freshIntents: true } : {}),
   };
 
   // Informative, non-blocking summary (the dashboard is where scope is managed).
@@ -552,6 +617,7 @@ async function main() {
     let orbWireResult = null;
     let handlerWireResult = null;
     let registryWireResult = null;
+    let sessionWireResult = null;
     const { runPostWireTest } = require('./postWireTest');
     const selfCorrect = !process.argv.includes('--no-self-correct');
     // Corrections follow the same key model as the analysis: hosted (proxy)
@@ -653,6 +719,52 @@ async function main() {
         report(() => reportRegistriesResult(connected, fyodosTermColors(), { quiet: !isVerbose() }));
       }
 
+      // Third pass — SESSION wiring. Connect the orb to the app's real auth
+      // state so the agent KNOWS whether the user is signed in (requiresAuth
+      // gate) and keys conversation memory per user. Fully automatic: same AI
+      // proposal + mechanical verification + reversible edits + build safety
+      // net as handler wiring. NO manual step.
+      //   · consent: the handler-wiring "yes" covers code edits, so we reuse
+      //     it. If the developer said NO to handler wiring, we respect that
+      //     and skip session edits too.
+      if (sessionWiring && !process.argv.includes('--no-orb-wire')) {
+        const handlerDeclined =
+          handlerResult &&
+          (handlerResult.status === 'declined' || handlerResult.status === 'declined-noninteractive');
+        if (!handlerDeclined) {
+          // Only an APPLIED handler wiring proves the developer said "yes" to
+          // code edits in every path; anything else makes wireSession ask its
+          // own single [yes/no] (or decline on a non-TTY) — never edit silently.
+          const handlerConsented =
+            handlerResult &&
+            (handlerResult.status === 'applied' || handlerResult.status === 'applied-untested');
+          const sessionResult = await wireSession(analysisRoot, {
+            session: sessionWiring,
+            colors: fyodosTermColors(),
+            quiet: !isVerbose(),
+            assumeYes: assumeYes || Boolean(handlerConsented),
+            noWire,
+            framework: 'web',
+            appName: manifest.appName,
+            runTest: !process.argv.includes('--no-wire-test'),
+            testRunner: runPostWireTest,
+          });
+          sessionWireResult = sessionResult;
+          report(() => reportSessionResult(sessionResult, fyodosTermColors(), { quiet: !isVerbose() }));
+          if (
+            orbMounted &&
+            (sessionResult.status === 'applied' || sessionResult.status === 'applied-untested')
+          ) {
+            const connectedSession = connectOrbSession(analysisRoot, {
+              sessionFileAbs: sessionResult.sessionFile,
+            });
+            report(() =>
+              reportSessionConnectResult(connectedSession, fyodosTermColors(), { quiet: !isVerbose() }),
+            );
+          }
+        }
+      }
+
       // Finalize the install proof: now that the (slow) action wiring is done,
       // tell the dashboard the terminal status so its "actions connected" tick
       // turns green for real — never before wiring actually finished. Only do
@@ -720,6 +832,7 @@ async function main() {
           orbResult: orbWireResult,
           handlerResult: handlerWireResult,
           registryResult: registryWireResult,
+          sessionResult: sessionWireResult,
           envResult: envWriteResult,
         });
         const paths = writeChangeRegistry(analysisRoot, record);
@@ -739,6 +852,7 @@ async function main() {
     const noWire = process.argv.includes('--no-wire');
     let orbWireResult = null;
     let envWriteResult = null;
+    let sessionWireResult = null;
 
     await withSpinner('Publishing to your project', async ({ setLabel, pause, resume }) => {
       await publishManifest(manifest, publishMeta, analysisToken, { skipSuccessLog: true });
@@ -771,6 +885,42 @@ async function main() {
             logDev(`[orb-wired] mobile install proof not recorded (${proof.status || proof.reason}); dashboard will rely on the runtime ping`);
           }
         }
+
+        // SESSION wiring (auth awareness) — same automatic pass as web. RN has
+        // no cheap full-build check, so the safety net is the mechanical symbol
+        // verification + the esbuild parse check on every edited file.
+        if (
+          sessionWiring &&
+          (orbWireResult.status === 'added' || orbWireResult.status === 'already')
+        ) {
+          const sessionResult = await wireSession(analysisRoot, {
+            session: sessionWiring,
+            colors: fyodosTermColors(),
+            quiet: !isVerbose(),
+            assumeYes: true, // the orb-mount consent already covered code edits on mobile
+            noWire,
+            framework: 'mobile',
+            appName: manifest.appName,
+            runTest: false,
+          });
+          sessionWireResult = sessionResult;
+          pause();
+          reportSessionResult(sessionResult, fyodosTermColors(), { quiet: !isVerbose() });
+          resume();
+          if (sessionResult.status === 'applied' || sessionResult.status === 'applied-untested') {
+            const connectedSession = connectRnSession(analysisRoot, {
+              sessionFileAbs: sessionResult.sessionFile,
+              colors: fyodosTermColors(),
+            });
+            if (connectedSession.status === 'connected') {
+              pause();
+              console.error(`${fyodosTermColors().cyan}◉${fyodosTermColors().reset} ${fyodosTermColors().blue}Fiodos${fyodosTermColors().reset} · session connected to the orb mount (${connectedSession.file})`);
+              resume();
+            } else {
+              logDev(`[session] RN mount connection: ${connectedSession.status}${connectedSession.reason ? ` (${connectedSession.reason})` : ''}`);
+            }
+          }
+        }
       }
     });
     logUser('Published to your project');
@@ -805,6 +955,7 @@ async function main() {
           manifest,
           publishMeta,
           orbResult: orbWireResult,
+          sessionResult: sessionWireResult,
           envResult: envWriteResult,
         });
         const paths = writeChangeRegistry(analysisRoot, record);
@@ -1377,6 +1528,21 @@ async function publishManifest(manifest, meta, analysisToken = null, opts = {})
   if (!opts.skipSuccessLog) {
     logUser('Published to your project');
   }
+  if (body.overridesCleared > 0) {
+    logUser(
+      `Your specifications asked to regenerate previously-edited content: ` +
+      `${body.overridesCleared} dashboard override(s) were cleared so the new values are live`,
+    );
+  }
+  // Continuity guard feedback: the backend kept the previous intent ids /
+  // repaired degraded route paths, so dashboard customizations keep working.
+  if (body.intentsPreserved > 0 || body.pathsRepaired > 0) {
+    logUser(
+      `Continuity with your previous analysis: ${body.intentsPreserved || 0} intent id(s) kept stable` +
+      (body.pathsRepaired ? `, ${body.pathsRepaired} route path(s) repaired` : '') +
+      ` — your dashboard customizations stay intact (use --fresh-intents to opt out)`,
+    );
+  }
   logDev(`[publish] OK — ${body.routes} routes, ${body.actions} actions received at ${body.receivedAt}`);
 
   // Self-check: confirm the orb will find this manifest (silent unless --verbose).