@flowriki/agent 0.1.0-beta.46 → 0.1.0-beta.48

package/dist/cli.js

@@ -1,21 +1,35 @@
 #!/usr/bin/env node
 import {
+  AGENT_LATEST_URL,
   AGENT_VERSION,
-  CLOUD_PROVIDERS,
-  CLOUD_PROVIDER_NAME,
-  MobileLane,
-  RecordedStepSchema,
+  agentUpdateFor,
   authenticationResolver,
   checkAssertion,
-  checkMobileAssertion,
   closeRunSession,
   connect,
   connectionFor,
+  dataDir,
   disconnect,
   doctor,
   executeStep,
   fieldNames,
   helperRunner,
+  openRunSession,
+  prepareBrowsers,
+  replayCase,
+  replayFlow,
+  resolveCheckouts,
+  resolveService,
+  runtimeValue,
+  start,
+  status
+} from "./chunk-JUAJABZC.js";
+import {
+  CLOUD_PROVIDERS,
+  CLOUD_PROVIDER_NAME,
+  MobileLane,
+  RecordedStepSchema,
+  checkMobileAssertion,
   isMobile,
   listDevices,
   locate,
@@ -24,24 +38,15 @@ import {
   mobileOf,
   mobileSetup,
   openMobileSession,
-  openRunSession,
   parseGherkin,
   performMobileStep,
   platformsOf,
-  prepareBrowsers,
-  replayCase,
-  replayFlow,
   replayMobileCase,
-  resolveCheckouts,
-  resolveService,
   runMobileSteps,
-  runtimeValue,
   screenLines,
-  start,
-  status,
   stepRefusedOn,
   targetFor
-} from "./chunk-LIURHWRP.js";
+} from "./chunk-7X54JYUL.js";
 
 // src/cli.ts
 import { parseArgs } from "util";
@@ -137,8 +142,8 @@ var ServiceClient = class {
   get origin() {
     return this.connection.service;
   }
-  async call(path, init = {}) {
-    const res = await this.fetcher(`${this.connection.service}${path}`, {
+  async call(path2, init = {}) {
+    const res = await this.fetcher(`${this.connection.service}${path2}`, {
       ...init,
       headers: {
         "x-flowriki-device": this.connection.deviceId,
@@ -280,9 +285,9 @@ var ServiceClient = class {
   }
   // ── Manual cycles and bugs: the dashboard's own routes, behind this
   // machine's credential, so the assistant can do what a person can. ──────
-  scoped(path, projectId, extra = {}) {
+  scoped(path2, projectId, extra = {}) {
     const query = new URLSearchParams({ projectId, ...extra });
-    return `/api/agent${path}?${query}`;
+    return `/api/agent${path2}?${query}`;
   }
   cycles(projectId) {
     return this.call(this.scoped("/cycles", projectId));
@@ -321,8 +326,8 @@ var ServiceClient = class {
   knowledgePages(projectId) {
     return this.call(this.scoped("/knowledge", projectId));
   }
-  knowledgePage(projectId, path) {
-    return this.call(this.scoped("/knowledge/page", projectId, { path }));
+  knowledgePage(projectId, path2) {
+    return this.call(this.scoped("/knowledge/page", projectId, { path: path2 }));
   }
   writeKnowledge(projectId, body) {
     return this.call(`/api/agent/knowledge?projectId=${encodeURIComponent(projectId)}`, { method: "POST", body: JSON.stringify(body) });
@@ -2003,7 +2008,7 @@ Use it with start_flow signIn {"profileId": "\u2026", "accountId": "${made.accou
       run: async (args) => {
         const projectId = await projectFor(args["projectId"]);
         const { pages } = await service.knowledgePages(projectId);
-        const read = async (path) => pages.some((p) => p.path === path) ? (await service.knowledgePage(projectId, path)).content : null;
+        const read = async (path2) => pages.some((p) => p.path === path2) ? (await service.knowledgePage(projectId, path2)).content : null;
         const [product, glossary, decisions] = await Promise.all(["product.md", "glossary.md", "memory/decisions.md"].map(read));
         const codebases = pages.filter((p) => p.path.startsWith("codebase/"));
         const headers = await Promise.all(codebases.map(async (p) => `- ${p.path}: ${(await read(p.path))?.split("\n").filter((l) => l.trim()).slice(0, 3).join(" \xB7 ") ?? ""}`));
@@ -2097,6 +2102,212 @@ ${pages.filter((p) => !shown.has(p.path)).map((p) => `- ${p.path}`).join("\n") |
   }));
 }
 
+// src/mcp/upgrade.ts
+import { spawn } from "child_process";
+import readline2 from "readline";
+var PRIVATE = "flowriki-upgrade";
+var startWithNpx = (version) => spawn(process.platform === "win32" ? "npx.cmd" : "npx", ["-y", `@flowriki/agent@${version}`, "mcp"], {
+  env: { ...process.env, FLOWRIKI_MCP_CHILD: "1" },
+  stdio: ["pipe", "pipe", "inherit"]
+});
+var toolShape = (tools) => JSON.stringify(tools.map((t) => [t.name, t.description ?? "", t.inputSchema ?? null]).sort());
+function serveWithUpgrades(tools, info, opts) {
+  const input = opts.input ?? process.stdin;
+  const output = opts.output ?? process.stdout;
+  const log = opts.log ?? ((line) => process.stderr.write(`flowriki: ${line}
+`));
+  const send = (m) => output.write(`${JSON.stringify(m)}
+`);
+  if (!opts.output) {
+    console.log = console.info = console.warn = console.debug = (...args) => {
+      process.stderr.write(`${args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ")}
+`);
+    };
+  }
+  let initialize = null;
+  let localCalls = 0;
+  let ready = null;
+  let active = null;
+  let preparing = false;
+  let notice = null;
+  const forwarded = /* @__PURE__ */ new Set();
+  let timer = null;
+  const withNotice = (answer) => {
+    if (!notice || !answer.result || typeof answer.result !== "object") return answer;
+    const result = answer.result;
+    if (!Array.isArray(result.content)) return answer;
+    const text2 = notice;
+    notice = null;
+    return { ...answer, result: { ...result, content: [{ type: "text", text: text2 }, ...result.content] } };
+  };
+  const prepare = async (version) => {
+    if (preparing || ready || active || !initialize) return;
+    preparing = true;
+    let child = null;
+    try {
+      child = (opts.start ?? startWithNpx)(version);
+      const c = child;
+      const lines2 = readline2.createInterface({ input: c.stdout, crlfDelay: Infinity });
+      const waiting = /* @__PURE__ */ new Map();
+      const exited = new Promise((_, reject) => c.once("exit", (code) => reject(new Error(`it stopped while starting (exit ${code})`))));
+      exited.catch(() => void 0);
+      c.once("error", (e) => waiting.forEach((resolve) => resolve({ jsonrpc: "2.0", error: { message: e.message } })));
+      lines2.on("line", (line) => {
+        let m;
+        try {
+          m = JSON.parse(line);
+        } catch {
+          return;
+        }
+        if (typeof m.id === "string" && m.id.startsWith(PRIVATE)) {
+          waiting.get(m.id)?.(m);
+          waiting.delete(m.id);
+          return;
+        }
+        if (active?.child !== c) return;
+        if (m.id !== void 0 && m.id !== null) forwarded.delete(m.id);
+        send(m.id !== void 0 && m.id !== null && "result" in m ? withNotice(m) : m);
+      });
+      const ask = (method, params, id) => new Promise((resolve, reject) => {
+        waiting.set(id, resolve);
+        c.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, method, ...params ? { params } : {} })}
+`);
+        setTimeout(() => reject(new Error("it did not answer in time")), opts.readyWithinMs ?? 18e4).unref();
+      });
+      const hello = await Promise.race([ask("initialize", initialize.params, `${PRIVATE}-init`), exited]);
+      if (hello.error) throw new Error(JSON.stringify(hello.error));
+      c.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" })}
+`);
+      const listed = await Promise.race([ask("tools/list", void 0, `${PRIVATE}-tools`), exited]);
+      const theirs = listed.result?.tools ?? [];
+      ready = { child: c, version, lines: lines2, toolsChanged: toolShape(theirs) !== toolShape(tools) };
+      c.once("exit", () => {
+        if (ready?.child === c) ready = null;
+        if (active?.child === c) {
+          active = null;
+          for (const id of forwarded) send({ jsonrpc: "2.0", id, error: { code: -32603, message: "the updated Flowriki stopped \u2014 ask again" } });
+          forwarded.clear();
+          notice = `The updated Flowriki (${version}) stopped, so this connection carries on with ${opts.current}.`;
+          log(`updated server ${version} exited; back on ${opts.current}`);
+        }
+      });
+      log(`${version} is ready to take over from ${opts.current}`);
+    } catch (error) {
+      child?.kill();
+      log(`could not start ${version}: ${error.message}`);
+      notice ??= `Flowriki ${version} is out (this connection runs ${opts.current}) and could not switch over by itself: ${error.message}. A new Claude session starts the new version.`;
+    } finally {
+      preparing = false;
+    }
+  };
+  const maybeSwitch = async (incomingTool) => {
+    if (!ready || active || localCalls > 0) return false;
+    if (!opts.idle() && incomingTool !== "start_flow") return false;
+    const next = ready;
+    ready = null;
+    await opts.handOff().catch(() => void 0);
+    active = next;
+    if (timer) clearInterval(timer);
+    notice = `Flowriki updated itself from ${opts.current} to ${next.version} \u2014 the new version is answering now.` + (next.toolsChanged ? " It brings new or changed tools; if Claude does not offer them yet, start a new Claude session (in the terminal version of Claude Code, /mcp then Reconnect also works)." : "");
+    send({ jsonrpc: "2.0", method: "notifications/tools/list_changed" });
+    log(`switched to ${next.version}`);
+    return true;
+  };
+  const look = async () => {
+    if (active || ready || preparing) return;
+    const version = await opts.check().catch(() => null);
+    if (version) {
+      await prepare(version);
+      await maybeSwitch();
+    }
+  };
+  setTimeout(() => void look(), opts.firstCheckMs ?? 15e3).unref();
+  timer = setInterval(() => void look(), opts.everyMs ?? 30 * 6e4);
+  timer.unref();
+  const lines = readline2.createInterface({ input, crlfDelay: Infinity });
+  const pending = /* @__PURE__ */ new Set();
+  lines.on("line", (line) => {
+    if (!line.trim()) return;
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      send({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "parse error" } });
+      return;
+    }
+    if (message.method === "initialize") initialize = message;
+    const task = (async () => {
+      const tool = message.method === "tools/call" ? String(message.params?.["name"] ?? "") : void 0;
+      if (!active && tool) await maybeSwitch(tool);
+      if (active) {
+        if (message.id !== void 0 && message.id !== null) forwarded.add(message.id);
+        active.child.stdin.write(`${line}
+`);
+        return;
+      }
+      if (tool) localCalls++;
+      try {
+        const answer = await handle(message, tools, info);
+        if (answer) send(tool ? withNotice(answer) : answer);
+        if (message.method === "notifications/initialized") send({ jsonrpc: "2.0", method: "notifications/tools/list_changed" });
+      } finally {
+        if (tool) localCalls--;
+      }
+      if (tool && ready) await maybeSwitch();
+    })();
+    pending.add(task);
+    void task.finally(() => pending.delete(task));
+  });
+  return new Promise((resolve) => lines.on("close", () => {
+    void Promise.allSettled([...pending]).then(() => {
+      if (timer) clearInterval(timer);
+      const child = active?.child ?? ready?.child;
+      if (!child) return resolve();
+      child.stdin?.end();
+      const done = () => resolve();
+      child.once("exit", done);
+      setTimeout(() => {
+        child.kill();
+        done();
+      }, 5e3).unref();
+    });
+  }));
+}
+
+// src/updates.ts
+import fs from "fs";
+import path from "path";
+var CACHE_MS = 30 * 60 * 1e3;
+async function latestPublished(opts = {}) {
+  const file = path.join(dataDir(), "latest-agent.json");
+  if (!opts.fresh) {
+    try {
+      const kept = JSON.parse(fs.readFileSync(file, "utf8"));
+      if (kept.version && kept.at && Date.now() - kept.at < CACHE_MS) return kept.version;
+    } catch {
+    }
+  }
+  try {
+    const res = await fetch(AGENT_LATEST_URL, { signal: AbortSignal.timeout(5e3), headers: { accept: "application/json" } });
+    if (!res.ok) return null;
+    const version = (await res.json()).version ?? null;
+    if (version) {
+      try {
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.writeFileSync(file, JSON.stringify({ version, at: Date.now() }));
+      } catch {
+      }
+    }
+    return version;
+  } catch {
+    return null;
+  }
+}
+async function updateFor(running) {
+  const latest = await latestPublished();
+  return agentUpdateFor(running, latest) ? latest : null;
+}
+
 // src/mcp/index.ts
 async function runMcp(opts) {
   let service;
@@ -2120,7 +2331,20 @@ async function runMcp(opts) {
   };
   process.on("SIGINT", () => void closing());
   process.on("SIGTERM", () => void closing());
-  await serve(tools, { name: "flowriki", version: opts.version, instructions: INSTRUCTIONS });
+  const info = { name: "flowriki", version: opts.version, instructions: INSTRUCTIONS };
+  if (process.env["FLOWRIKI_MCP_CHILD"] === "1" || process.env["FLOWRIKI_NO_UPDATE"] === "1" || !/^\d+\.\d+\.\d+/.test(opts.version)) {
+    await serve(tools, info);
+  } else {
+    await serveWithUpgrades(tools, info, {
+      current: opts.version,
+      check: () => updateFor(opts.version),
+      idle: () => !session?.open,
+      handOff: async () => {
+        await session?.close();
+        if (session) session.draft = null;
+      }
+    });
+  }
   await session?.close();
   return 0;
 }
@@ -2270,6 +2494,17 @@ Run \`flowriki-agent --help\`.`);
         console.log(dim(`  project  ${project.name}  (${project.root})`));
       }
       console.log(dim("\n  Running in the foreground. Ctrl-C to stop.\n"));
+      let told = null;
+      const tellIfBehind = async () => {
+        const newer = await updateFor(AGENT_VERSION).catch(() => null);
+        if (!newer || newer === told) return;
+        told = newer;
+        console.log(yellow(`  ! Flowriki agent ${newer} is out \u2014 this is ${AGENT_VERSION}.`));
+        console.log(dim(`    Update: npm install -g @flowriki/agent@latest   then stop (Ctrl-C) and start again
+`));
+      };
+      void tellIfBehind();
+      setInterval(() => void tellIfBehind(), 6 * 60 * 6e4).unref();
       let stopping = false;
       const shutdown = async (signal) => {
         if (stopping) return;
@@ -2349,7 +2584,7 @@ Run \`flowriki-agent --help\`.`);
         for (const [title, lines] of [["Appium", found.appium], ["Android", found.android], ["iOS", found.ios]]) {
           console.log(bold(title));
           for (const line of lines) {
-            console.log(`  ${line.ok ? green("\u2713") : red("\u2717")} ${line.item.padEnd(15)} ${line.ok ? dim(line.detail) : line.detail}`);
+            console.log(`  ${line.ok ? green("\u2713") : line.optional ? yellow("\u2013") : red("\u2717")} ${line.item.padEnd(15)} ${line.ok ? dim(line.detail) : line.detail}`);
             if (!line.ok && line.fix) console.log(`    ${yellow("\u2192")} ${line.fix}`);
           }
         }

package/dist/dist-CZEWUTXJ.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+import {
+  AGENT_HOME,
+  APPIUM_DIR,
+  AppiumMissing,
+  CLOUD_HUBS,
+  CheckError,
+  LocateError,
+  MOBILE_TIMEOUTS,
+  MobileLane,
+  MobileSession,
+  WebDriverError,
+  WebDriverSession,
+  adbPath,
+  androidHome,
+  appOf,
+  appiumPath,
+  appiumServer,
+  bootDevice,
+  centre,
+  checkMobileAssertion,
+  chooseDevice,
+  cloudDevices,
+  describeTarget,
+  filmsThis,
+  finishVideo,
+  javaHome,
+  listDevices,
+  locate,
+  mobileDoctor,
+  mobileSetup,
+  nodeAt,
+  openMobileSession,
+  performMobileStep,
+  readScreen,
+  replayMobileCase,
+  replayMobileFlow,
+  resolveOn,
+  run,
+  runMobileSteps,
+  screenLines,
+  stopAppium,
+  targetFor,
+  textOf,
+  toolEnv,
+  typesSecrets
+} from "./chunk-7X54JYUL.js";
+export {
+  AGENT_HOME,
+  APPIUM_DIR,
+  AppiumMissing,
+  CLOUD_HUBS,
+  CheckError,
+  LocateError,
+  MOBILE_TIMEOUTS,
+  MobileLane,
+  MobileSession,
+  WebDriverError,
+  WebDriverSession,
+  adbPath,
+  androidHome,
+  appOf,
+  appiumPath,
+  appiumServer,
+  bootDevice,
+  centre,
+  checkMobileAssertion,
+  chooseDevice,
+  cloudDevices,
+  describeTarget,
+  filmsThis,
+  finishVideo,
+  javaHome,
+  listDevices,
+  locate,
+  mobileDoctor,
+  mobileSetup,
+  nodeAt,
+  openMobileSession,
+  performMobileStep,
+  readScreen,
+  replayMobileCase,
+  replayMobileFlow,
+  resolveOn,
+  runMobileSteps,
+  run as runTool,
+  screenLines,
+  stopAppium,
+  targetFor,
+  textOf,
+  toolEnv,
+  typesSecrets
+};

package/dist/engine.js

@@ -9,7 +9,8 @@ import {
   resolveCheckouts,
   start,
   status
-} from "./chunk-LIURHWRP.js";
+} from "./chunk-JUAJABZC.js";
+import "./chunk-7X54JYUL.js";
 export {
   AGENT_VERSION,
   browsersReady,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flowriki/agent",
-  "version": "0.1.0-beta.46",
+  "version": "0.1.0-beta.48",
   "description": "Run Flowriki UI tests on your own computer. Connects this machine to your Flowriki account.",
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",