@cassiomc1/forgeloop 1.10.2 → 1.11.0

package/src/persistent-transport/server.js

@@ -0,0 +1,256 @@
+import { randomUUID } from "node:crypto";
+import net from "node:net";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { chmod, unlink } from "node:fs/promises";
+
+import { searchRepository } from "../repository-index/search.js";
+import { getPackageRoot } from "../core/templates.js";
+import { PERSISTENT_TRANSPORT_DEFAULTS, PERSISTENT_TRANSPORT_PROTOCOL_VERSION } from "./constants.js";
+import { encodeFrame, FrameDecoder, parseFrame } from "./framing.js";
+import { createErrorResponse, createSuccessResponse, validateRequest, assertSearchParams } from "./protocol.js";
+import { PERSISTENT_TRANSPORT_ERROR_CODES, persistentTransportError } from "./errors.js";
+import { getPersistentTransportPaths } from "./paths.js";
+import { writePersistentTransportState, removePersistentTransportState } from "./state.js";
+import { ensurePersistentTransportDirectory } from "./lifecycle.js";
+
+function argumentValue(name, fallback = null) {
+  const prefix = `${name}=`;
+  const argument = process.argv.find((value) => value.startsWith(prefix));
+  return argument ? argument.slice(prefix.length) : fallback;
+}
+
+function numberArgument(name, fallback) {
+  const value = Number(argumentValue(name, ""));
+  return Number.isSafeInteger(value) && value > 0 ? value : fallback;
+}
+
+function safeError(error) {
+  if (error?.code) return error;
+  return persistentTransportError(PERSISTENT_TRANSPORT_ERROR_CODES.INVALID_REQUEST, error?.message ?? "Transport request failed");
+}
+
+function publicSearchRequest(query) {
+  return {
+    pattern: query.pattern,
+    globs: query.globs,
+    types: query.types,
+    context: query.context,
+    beforeContext: query.beforeContext,
+    afterContext: query.afterContext,
+    maxCount: query.maxCount,
+    filesWithMatches: query.filesWithMatches,
+    stats: query.stats,
+    fixedStrings: query.fixedStrings,
+    ignoreCase: query.ignoreCase,
+    smartCase: query.smartCase,
+    wordRegexp: query.wordRegexp,
+    packageRoot: getPackageRoot(),
+  };
+}
+
+class PersistentSearchHost {
+  #homeDirectory;
+  #paths;
+  #idleTimeoutMs;
+  #server = null;
+  #state = null;
+  #connections = new Set();
+  #inflight = 0;
+  #idleTimer = null;
+  #closing = false;
+  #repositoryQueues = new Map();
+
+  constructor({ homeDirectory, idleTimeoutMs }) {
+    this.#homeDirectory = homeDirectory;
+    this.#paths = getPersistentTransportPaths({ homeDirectory });
+    this.#idleTimeoutMs = idleTimeoutMs;
+  }
+
+  async start() {
+    await ensurePersistentTransportDirectory({ homeDirectory: this.#homeDirectory });
+    this.#state = {
+      pid: process.pid,
+      protocolVersion: PERSISTENT_TRANSPORT_PROTOCOL_VERSION,
+      forgeLoopVersion: await this.#packageVersion(),
+      scopeId: this.#paths.scopeId,
+      nonce: randomUUID(),
+      endpoint: this.#paths.endpoint,
+      entrypoint: path.resolve(fileURLToPath(import.meta.url)),
+      startedAt: new Date().toISOString(),
+    };
+    this.#server = net.createServer((socket) => this.#handleConnection(socket));
+    await new Promise((resolve, reject) => {
+      const onError = (error) => {
+        this.#server.off("listening", onListening);
+        reject(error);
+      };
+      const onListening = () => {
+        this.#server.off("error", onError);
+        resolve();
+      };
+      this.#server.once("error", onError);
+      this.#server.once("listening", onListening);
+      this.#server.listen(this.#paths.endpoint);
+    });
+    if (process.platform !== "win32") await chmod(this.#paths.endpoint, 0o600);
+    await writePersistentTransportState(this.#paths.statePath, this.#state);
+    this.#scheduleIdleShutdown();
+    return this.#state;
+  }
+
+  async #packageVersion() {
+    const { readFile } = await import("node:fs/promises");
+    const packageJson = JSON.parse(await readFile(path.join(getPackageRoot(), "package.json"), "utf8"));
+    return packageJson.version ?? null;
+  }
+
+  #handleConnection(socket) {
+    this.#connections.add(socket);
+    const decoder = new FrameDecoder({ maxFrameBytes: PERSISTENT_TRANSPORT_DEFAULTS.maxRequestFrameBytes });
+    const seenIds = new Set();
+    let handshaken = false;
+    let queue = Promise.resolve();
+    const close = () => {
+      this.#connections.delete(socket);
+      this.#scheduleIdleShutdown();
+    };
+    socket.on("close", close);
+    socket.on("error", close);
+    socket.on("data", (chunk) => {
+      try {
+        for (const frame of decoder.push(chunk)) {
+          let raw;
+          try {
+            raw = parseFrame(frame);
+          } catch (error) {
+            this.#write(socket, createErrorResponse(null, safeError(error)));
+            socket.destroy();
+            return;
+          }
+          queue = queue
+            .then(async () => {
+              let request;
+              try {
+                request = validateRequest(raw);
+                if (seenIds.has(request.id)) throw persistentTransportError(PERSISTENT_TRANSPORT_ERROR_CODES.INVALID_REQUEST, "Transport request id was reused on one connection");
+                seenIds.add(request.id);
+                const result = await this.#dispatch(request, () => { handshaken = true; }, () => handshaken);
+                this.#write(socket, createSuccessResponse(request.id, result));
+              } catch (error) {
+                this.#write(socket, createErrorResponse(typeof raw?.id === "string" ? raw.id : null, safeError(error)));
+              }
+            })
+            .catch(() => {
+              socket.destroy();
+            });
+        }
+      } catch (error) {
+        this.#write(socket, createErrorResponse(null, safeError(error)));
+        socket.destroy();
+      }
+    });
+    socket.on("end", () => {
+      try { decoder.end(); } catch { socket.destroy(); }
+    });
+  }
+
+  #write(socket, value) {
+    if (!socket.destroyed) {
+      try { socket.write(encodeFrame(value)); } catch { socket.destroy(); }
+    }
+  }
+
+  async #dispatch(request, markHandshake, isHandshaken) {
+    if (request.method === "handshake") {
+      if (request.params.scopeId !== this.#paths.scopeId) throw persistentTransportError(PERSISTENT_TRANSPORT_ERROR_CODES.OWNERSHIP_UNVERIFIED, "Transport scope does not match the host");
+      markHandshake();
+      return {
+        protocolVersion: PERSISTENT_TRANSPORT_PROTOCOL_VERSION,
+        forgeLoopVersion: this.#state.forgeLoopVersion,
+        pid: this.#state.pid,
+        nonce: this.#state.nonce,
+        scopeId: this.#state.scopeId,
+      };
+    }
+    if (!isHandshaken()) throw persistentTransportError(PERSISTENT_TRANSPORT_ERROR_CODES.INVALID_REQUEST, "Transport handshake is required before this method");
+    if (request.method === "transport.status") {
+      return { status: "READY", protocolVersion: this.#state.protocolVersion, forgeLoopVersion: this.#state.forgeLoopVersion };
+    }
+    if (request.method === "transport.shutdown") {
+      if (request.params.nonce !== this.#state.nonce) throw persistentTransportError(PERSISTENT_TRANSPORT_ERROR_CODES.OWNERSHIP_UNVERIFIED, "Transport shutdown nonce does not match the host");
+      globalThis.setImmediate(() => this.shutdown());
+      return { status: "SHUTTING_DOWN" };
+    }
+    if (request.method === "repository.search") {
+      const params = assertSearchParams(request.params);
+      const repositoryRoot = params.repository;
+      return this.#enqueueRepository(repositoryRoot, () => searchRepository(repositoryRoot, publicSearchRequest(params.query)));
+    }
+    throw persistentTransportError(PERSISTENT_TRANSPORT_ERROR_CODES.INVALID_REQUEST, `Unsupported transport method: ${request.method}`);
+  }
+
+  #enqueueRepository(repositoryRoot, callback) {
+    const previous = this.#repositoryQueues.get(repositoryRoot) ?? Promise.resolve();
+    const next = previous.catch(() => {}).then(async () => {
+      this.#inflight += 1;
+      this.#idleTimer && clearTimeout(this.#idleTimer);
+      try {
+        return await callback();
+      } finally {
+        this.#inflight -= 1;
+        if (this.#repositoryQueues.get(repositoryRoot) === next) this.#repositoryQueues.delete(repositoryRoot);
+        this.#scheduleIdleShutdown();
+      }
+    });
+    this.#repositoryQueues.set(repositoryRoot, next);
+    return next;
+  }
+
+  #scheduleIdleShutdown() {
+    if (this.#closing || this.#idleTimeoutMs <= 0) return;
+    if (this.#inflight > 0 || this.#connections.size > 0) return;
+    if (this.#idleTimer) clearTimeout(this.#idleTimer);
+    this.#idleTimer = setTimeout(() => {
+      this.#idleTimer = null;
+      if (this.#inflight === 0 && this.#connections.size === 0) this.shutdown().catch(() => {});
+      else this.#scheduleIdleShutdown();
+    }, this.#idleTimeoutMs);
+    this.#idleTimer.unref?.();
+  }
+
+  async shutdown() {
+    if (this.#closing) return;
+    this.#closing = true;
+    if (this.#idleTimer) clearTimeout(this.#idleTimer);
+    await removePersistentTransportState(this.#paths.statePath, this.#state?.nonce ?? null);
+    for (const socket of this.#connections) socket.end();
+    await new Promise((resolve) => {
+      if (!this.#server) return resolve();
+      this.#server.close(() => resolve());
+      setTimeout(resolve, 1_000).unref?.();
+    });
+    if (process.platform !== "win32") {
+      try { await unlink(this.#paths.endpoint); } catch (error) { if (error.code !== "ENOENT") throw error; }
+    }
+  }
+}
+
+export async function runPersistentSearchHost({ homeDirectory, idleTimeoutMs = PERSISTENT_TRANSPORT_DEFAULTS.idleTimeoutMs } = {}) {
+  const host = new PersistentSearchHost({ homeDirectory, idleTimeoutMs });
+  await host.start();
+  const stop = () => { host.shutdown().catch(() => {}); };
+  process.once("SIGTERM", stop);
+  process.once("SIGINT", stop);
+  return host;
+}
+
+if (process.argv.includes("--persistent-transport-server")) {
+  runPersistentSearchHost({
+    homeDirectory: argumentValue("--home-directory", process.env.FORGELOOP_PERSISTENT_TRANSPORT_HOME),
+    idleTimeoutMs: numberArgument("--idle-timeout-ms", PERSISTENT_TRANSPORT_DEFAULTS.idleTimeoutMs),
+  }).catch((error) => {
+    process.stderr.write(`${error.message}\n`);
+    process.exitCode = 1;
+  });
+}

package/src/persistent-transport/state.js

@@ -0,0 +1,49 @@
+import { lstat, readFile, unlink } from "node:fs/promises";
+
+import { writeFileAtomic } from "../core/filesystem.js";
+import { PERSISTENT_TRANSPORT_SCHEMA_VERSION } from "./constants.js";
+
+export async function readPersistentTransportState(statePath) {
+  try {
+    const info = await lstat(statePath);
+    if (!info.isFile() || info.isSymbolicLink()) return { state: null, invalid: true };
+    const state = JSON.parse(await readFile(statePath, "utf8"));
+    if (!state || typeof state !== "object" || state.schemaVersion !== PERSISTENT_TRANSPORT_SCHEMA_VERSION) return { state: null, invalid: true };
+    return { state, invalid: false };
+  } catch (error) {
+    if (error.code === "ENOENT") return { state: null, invalid: false };
+    if (error instanceof SyntaxError) return { state: null, invalid: true };
+    throw error;
+  }
+}
+
+export async function writePersistentTransportState(statePath, state) {
+  const record = {
+    schemaVersion: PERSISTENT_TRANSPORT_SCHEMA_VERSION,
+    pid: state.pid,
+    protocolVersion: state.protocolVersion,
+    forgeLoopVersion: state.forgeLoopVersion,
+    scopeId: state.scopeId,
+    nonce: state.nonce,
+    endpoint: state.endpoint,
+    entrypoint: state.entrypoint,
+    startedAt: state.startedAt,
+    lastActivityAt: state.lastActivityAt ?? state.startedAt,
+  };
+  await writeFileAtomic(statePath, `${JSON.stringify(record)}\n`);
+  return record;
+}
+
+export async function removePersistentTransportState(statePath, expectedNonce = null) {
+  if (expectedNonce !== null) {
+    const current = await readPersistentTransportState(statePath);
+    if (current.state?.nonce !== expectedNonce) return false;
+  }
+  try {
+    await unlink(statePath);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT") return true;
+    throw error;
+  }
+}

package/src/repository-index/args.js

@@ -0,0 +1,59 @@
+import { REPOSITORY_INDEX_DEFAULTS } from "./constants.js";
+
+function pushPair(args, flag, value) {
+  args.push(flag, String(value));
+}
+
+export function getCanonicalRepositoryIndexArgs({ mode, indexPath, config = {} } = {}) {
+  if (!["index", "serve", "search", "status"].includes(mode)) {
+    throw new Error(`Unknown Repository Index command mode: ${mode}`);
+  }
+  if (typeof indexPath !== "string" || indexPath.trim() === "") {
+    throw new Error("Repository Index indexPath is required");
+  }
+
+  const effective = {
+    ...REPOSITORY_INDEX_DEFAULTS,
+    ...config,
+  };
+  const args = [];
+  pushPair(args, "--index-path", indexPath);
+  pushPair(args, "--max-filesize", effective.maxFileSize);
+  if (["index", "serve"].includes(mode)) {
+    args.push("--exclude", ".forgeloop/repository-index");
+  }
+  args.push("--no-require-git");
+
+  if (mode === "index") {
+    args.push("--index-strategy", "external");
+  }
+  if (mode === "serve") {
+    pushPair(args, "--max-cpu", effective.maxCpuPercent);
+    pushPair(args, "--watcher-queue-cap", effective.watcherQueueCap);
+    pushPair(args, "--auto-save-mutations", effective.autoSaveMutations);
+  }
+  return Object.freeze(args);
+}
+
+export function getCanonicalRepositorySearchArgs({ indexPath, pattern, options = {}, config = {} } = {}) {
+  const args = ["--regexp", pattern];
+  if (options.fixedStrings) args.push("--fixed-strings");
+  if (options.ignoreCase) args.push("--ignore-case");
+  if (options.smartCase) args.push("--smart-case");
+  if (options.wordRegexp) args.push("--word-regexp");
+  if (options.context !== undefined && options.context !== null) pushPair(args, "--context", options.context);
+  if (options.beforeContext !== undefined && options.beforeContext !== null) pushPair(args, "--before-context", options.beforeContext);
+  if (options.afterContext !== undefined && options.afterContext !== null) pushPair(args, "--after-context", options.afterContext);
+  if (options.maxCount !== undefined && options.maxCount !== null) pushPair(args, "--max-count", options.maxCount);
+  if (options.filesWithMatches) args.push("--files-with-matches");
+  if (options.stats) args.push("--stats");
+  args.push("--json");
+  args.push(...getCanonicalRepositoryIndexArgs({ mode: "search", indexPath, config }));
+  return Object.freeze(args);
+}
+
+export function appendSearchFilters(args, { globs = [], types = [] } = {}) {
+  for (const glob of globs) args.push("--glob", glob);
+  for (const type of types) args.push("--type", type);
+  return args;
+}