scanruler-mcp 0.2.0 → 0.4.0

package/src/config.js

@@ -3,7 +3,10 @@
 // has to present, made on the first run and kept in the user's config
 // folder so it is pasted into ScanRuler's Settings once, not every time —
 // and the commands the last page that connected had, so an agent that lists
-// the tools once, before a page is back, still sees all of them.
+// the tools once, before a page is back, still sees all of them — and the
+// folders the scans were opened from, where its files go. The command list
+// carries the page's version: a server shipped with a newer list of its own
+// lists that one (mcp.js).
 
 import { randomBytes } from 'node:crypto'
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
@@ -22,20 +25,49 @@ export function configDir(env = process.env, platform = process.platform) {
 /** A new token: 24 random bytes, URL-safe — it travels in a link. */
 const newToken = () => randomBytes(24).toString('base64url')
 
-/** The command list the last connected page sent, or null. */
+/** The command list the last connected page sent, with the page's version
+ *  and plugins and when it was kept — `{ commands, version, plugins, saved }`
+ *  — or null. A list kept by a server before 0.4.0 has no version. */
 export function loadRemembered(dir = configDir()) {
   try {
     const kept = JSON.parse(readFileSync(join(dir, 'tools.json'), 'utf8'))
-    return Array.isArray(kept.commands) && kept.commands.length > 0 ? kept.commands : null
+    if (!Array.isArray(kept.commands) || kept.commands.length === 0) return null
+    return {
+      commands: kept.commands,
+      version: typeof kept.version === 'string' ? kept.version : null,
+      plugins: Array.isArray(kept.plugins) ? kept.plugins.map(String) : null,
+      saved: typeof kept.saved === 'string' ? kept.saved : null,
+    }
+  } catch {
+    return null
+  }
+}
+
+/** Keep a page's command list for the next run: `{ commands, version,
+ *  plugins }` — the page's version, for the next run to tell whether the
+ *  list it was shipped with is newer — or the list alone. */
+export function saveRemembered(kept, dir = configDir()) {
+  const { commands, version = null, plugins = null } = Array.isArray(kept) ? { commands: kept } : kept
+  mkdirSync(dir, { recursive: true })
+  writeFileSync(join(dir, 'tools.json'), JSON.stringify({ saved: new Date().toISOString(), version, plugins, commands }) + '\n')
+}
+
+/** The folders scans and projects were opened from or saved into, the
+ *  latest first, or null — kept beside the command list, so a copy started
+ *  afresh still writes and lists where the last one did. */
+export function loadFolders(dir = configDir()) {
+  try {
+    const kept = JSON.parse(readFileSync(join(dir, 'folders.json'), 'utf8'))
+    return Array.isArray(kept.folders) && kept.folders.every((f) => typeof f === 'string') ? kept.folders : null
   } catch {
     return null
   }
 }
 
-/** Keep a page's command list for the next run. */
-export function saveRemembered(commands, dir = configDir()) {
+/** Keep the folders for the next run, and for the other copies. */
+export function saveFolders(folders, dir = configDir()) {
   mkdirSync(dir, { recursive: true })
-  writeFileSync(join(dir, 'tools.json'), JSON.stringify({ saved: new Date().toISOString(), commands }) + '\n')
+  writeFileSync(join(dir, 'folders.json'), JSON.stringify({ saved: new Date().toISOString(), folders }) + '\n')
 }
 
 /** The stored config, with a token made and saved if there was none. */

package/src/engine.js

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// The headless backend: ScanRuler itself run in this process, with no
+// browser — no scan, no viewport, nobody watching — in place of the page.
+// The engine is a build of the app for Node (npm run build:engine in a
+// ScanRuler checkout writes dist-engine/engine.mjs), found by its path and
+// loaded as it is: this package names nothing in it and imports nothing from
+// the app. It offers the commands that run without the page, with the same
+// names, inputs and answers as the page's; the rest answer `unavailable`,
+// naming the page mode. One engine to a process — its state is the app's
+// own — so two servers started headless share nothing.
+
+import { EventEmitter } from 'node:events'
+import { existsSync } from 'node:fs'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+import { toolName } from './tools.js'
+
+/** Where --headless looks: the engine built in the ScanRuler checkout this
+ *  package is part of. */
+export const CHECKOUT_ENGINE = fileURLToPath(new URL('../../dist-engine/engine.mjs', import.meta.url))
+
+/** Load and start the engine at `file`. Throws, saying what to do, when
+ *  there is none there or it is no engine. */
+export async function loadEngine(file) {
+  if (!existsSync(file)) throw new Error(`There is no ScanRuler engine at ${file}. Build one with "npm run build:engine" in the ScanRuler checkout, or give --engine the path of one.`)
+  const mod = await import(pathToFileURL(file).href)
+  if (typeof mod.startEngine !== 'function') throw new Error(`${file} is not a ScanRuler engine: it has no startEngine().`)
+  return mod.startEngine()
+}
+
+/** The engine, as the page link is to the server (link.js): always
+ *  connected, its commands what a page would say it has. */
+export class EngineLink extends EventEmitter {
+  /** @param {{ app: string, version: string, plugins: string[], listCommands(): object[], pageCommands(): string[], run(name: string, input: unknown, onProgress?: (text: string) => void): Promise<unknown>, stop(): Promise<void> }} engine */
+  constructor(engine, file) {
+    super()
+    this.engine = engine
+    this.file = file
+    this.backend = 'headless'
+    this.role = 'headless'
+    this.error = null
+    this.page = { app: engine.app, version: engine.version, origin: null, plugins: engine.plugins, viewport: false, commands: engine.listCommands() }
+  }
+
+  get connected() {
+    return true
+  }
+
+  /** A command run in the engine; refused with { code, message } as the
+   *  page refuses one. */
+  run(name, input, _binaryKey, onProgress) {
+    return this.engine.run(name, input, onProgress).catch((e) => Promise.reject({ code: e?.code ?? 'failed', message: e?.message ?? String(e) }))
+  }
+
+  /** The command behind a tool that needs the page, by the tool's name —
+   *  null for one the engine has not got at all. */
+  pageCommand(tool) {
+    return this.engine.pageCommands().find((name) => toolName({ name }) === tool) ?? null
+  }
+
+  waitForPage() {
+    return Promise.resolve(true)
+  }
+
+  start() {}
+
+  close() {
+    void this.engine.stop()
+  }
+}