@rogatio/cli 5.6.0 → 5.7.0

package/dist/node/index.js

@@ -23813,7 +23813,7 @@ function createRoutes(context) {
         return;
       }
       try {
-        await context.writeProject(context.filePath, body);
+        await context.storage.update(context.filePath, body);
         context.project = body;
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end(JSON.stringify({ ok: true }));
@@ -24135,28 +24135,78 @@ async function launchBrowser(url) {
   });
 }
 
-// packages/cli/src/utils/file.ts
+// packages/cli/src/utils/project-storage.ts
 import { randomBytes as randomBytes4 } from "node:crypto";
-import { mkdir as mkdir3, readFile as readFile5, rename as rename2, writeFile as writeFile3 } from "node:fs/promises";
+import {
+  access,
+  mkdir as mkdir3,
+  readdir,
+  readFile as readFile5,
+  rename as rename2,
+  stat as stat3,
+  unlink as unlink2,
+  writeFile as writeFile3
+} from "node:fs/promises";
 import { basename as basename3, dirname as dirname6, join as join5 } from "node:path";
-var ProjectFileError = class extends Error {
+var ProjectStorageError = class extends Error {
   code;
-  path;
-  constructor(code, path2, message, cause) {
+  id;
+  constructor(code, id2, message, cause) {
     super(message, { cause });
-    this.name = "ProjectFileError";
+    this.name = "ProjectStorageError";
     this.code = code;
-    this.path = path2;
+    this.id = id2;
+  }
+};
+var ProjectFileError = class extends ProjectStorageError {
+  constructor(code, path2, message, cause) {
+    super(code, path2, message, cause);
+    this.name = "ProjectFileError";
+  }
+  get path() {
+    return this.id;
   }
 };
-async function readProject(path2) {
+function emptyProjectDocument() {
+  return { version: 1, name: "", groups: [] };
+}
+function isRogatioProjectFilename(name) {
+  return name === ".rogatio.json" || name.endsWith(".rogatio.json");
+}
+function projectName(data) {
+  if (data === null || typeof data !== "object" || Array.isArray(data)) {
+    return "";
+  }
+  if (!Object.hasOwn(data, "name")) {
+    return "";
+  }
+  const name = data.name;
+  return typeof name === "string" ? name : "";
+}
+async function pathExists(path2) {
+  try {
+    await access(path2);
+    return true;
+  } catch (e) {
+    if (e.code === "ENOENT") {
+      return false;
+    }
+    throw new ProjectFileError(
+      "read-failed",
+      path2,
+      "Failed to access project path",
+      e
+    );
+  }
+}
+async function readDocument(id2) {
   try {
-    const content = await readFile5(path2, "utf-8");
+    const content = await readFile5(id2, "utf-8");
     const parsed = JSON.parse(content);
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
       throw new ProjectFileError(
         "invalid-format",
-        path2,
+        id2,
         "Project file must contain a JSON object"
       );
     }
@@ -24166,7 +24216,7 @@ async function readProject(path2) {
     if (e.code === "ENOENT") {
       throw new ProjectFileError(
         "not-found",
-        path2,
+        id2,
         "Project file not found",
         e
       );
@@ -24174,51 +24224,170 @@ async function readProject(path2) {
     if (e instanceof SyntaxError) {
       throw new ProjectFileError(
         "invalid-json",
-        path2,
+        id2,
         "Project file contains invalid JSON",
         e
       );
     }
     throw new ProjectFileError(
       "read-failed",
-      path2,
+      id2,
       "Failed to read project file",
       e
     );
   }
 }
-async function writeProject(path2, data) {
-  const tempName = `.${basename3(dirname6(path2))}.${randomBytes4(8).toString("hex")}.tmp`;
-  const tempPath = join5(dirname6(path2), tempName);
+async function isDirectoryPath(id2) {
+  try {
+    return (await stat3(id2)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function writeDocument(id2, data) {
+  const tempName = `.${basename3(dirname6(id2))}.${randomBytes4(8).toString("hex")}.tmp`;
+  const tempPath = join5(dirname6(id2), tempName);
   try {
-    await mkdir3(dirname6(path2), { recursive: true });
+    if (await isDirectoryPath(id2)) {
+      throw new ProjectFileError(
+        "is-directory",
+        id2,
+        "Target path is a directory"
+      );
+    }
+    await mkdir3(dirname6(id2), { recursive: true });
     await writeFile3(tempPath, JSON.stringify(data, null, 2), "utf-8");
-    await rename2(tempPath, path2);
+    await rename2(tempPath, id2);
   } catch (e) {
+    if (e instanceof ProjectFileError) throw e;
     try {
-      await import("node:fs/promises").then((fs2) => fs2.unlink(tempPath));
+      await unlink2(tempPath);
     } catch {
     }
-    if (e.code === "EISDIR") {
+    if (e.code === "EISDIR" || await isDirectoryPath(id2)) {
       throw new ProjectFileError(
         "is-directory",
-        path2,
+        id2,
         "Target path is a directory",
         e
       );
     }
     throw new ProjectFileError(
       "write-failed",
-      path2,
+      id2,
       "Failed to write project file",
       e
     );
   }
 }
+function createJsonFileProjectStorage() {
+  return {
+    async list(scope) {
+      if (scope === void 0 || scope === "") {
+        return [];
+      }
+      let entries;
+      try {
+        entries = await readdir(scope, { withFileTypes: true });
+      } catch (e) {
+        if (e.code === "ENOENT") {
+          return [];
+        }
+        throw new ProjectFileError(
+          "read-failed",
+          scope,
+          "Failed to list project files",
+          e
+        );
+      }
+      const refs = [];
+      for (const entry of entries) {
+        if (entry.isDirectory() || !isRogatioProjectFilename(entry.name)) {
+          continue;
+        }
+        const id2 = join5(scope, entry.name);
+        let name = "";
+        try {
+          const data = await readDocument(id2);
+          name = projectName(data);
+        } catch {
+          name = "";
+        }
+        refs.push({ id: id2, name });
+      }
+      return refs;
+    },
+    async get(id2) {
+      return readDocument(id2);
+    },
+    async create(options) {
+      const id2 = options?.id;
+      if (id2 === void 0 || id2 === "") {
+        throw new ProjectFileError(
+          "invalid-id",
+          id2 ?? "",
+          "JSON-file project storage requires an id (filesystem path)"
+        );
+      }
+      if (await pathExists(id2)) {
+        throw new ProjectFileError(
+          "already-exists",
+          id2,
+          "Project already exists"
+        );
+      }
+      const data = options?.data === void 0 ? emptyProjectDocument() : options.data;
+      await writeDocument(id2, data);
+      return { id: id2, name: projectName(data) };
+    },
+    async import(data, options) {
+      const id2 = options?.id;
+      if (id2 === void 0 || id2 === "") {
+        throw new ProjectFileError(
+          "invalid-id",
+          id2 ?? "",
+          "JSON-file project storage requires an id (filesystem path)"
+        );
+      }
+      await writeDocument(id2, data);
+      return { id: id2, name: projectName(data) };
+    },
+    async update(id2, data) {
+      if (!await pathExists(id2)) {
+        throw new ProjectFileError("not-found", id2, "Project file not found");
+      }
+      await writeDocument(id2, data);
+    },
+    async delete(id2) {
+      try {
+        await unlink2(id2);
+      } catch (e) {
+        if (e.code === "ENOENT") {
+          throw new ProjectFileError(
+            "not-found",
+            id2,
+            "Project file not found",
+            e
+          );
+        }
+        throw new ProjectFileError(
+          "delete-failed",
+          id2,
+          "Failed to delete project file",
+          e
+        );
+      }
+    }
+  };
+}
+
+// packages/cli/src/utils/file.ts
+var defaultStorage = createJsonFileProjectStorage();
 
 // packages/cli/src/commands/edit.ts
 async function editCommand(args, options = {}) {
   const customLaunchBrowser = options.launchBrowser;
+  const storage = options.storage ?? createJsonFileProjectStorage();
   const positionalArgs = [];
   let port;
   for (let i = 0; i < args.length; i++) {
@@ -24254,10 +24423,10 @@ async function editCommand(args, options = {}) {
     filePath = resolve4(process.cwd(), ".rogatio.json");
   }
   try {
-    const stat3 = await import("node:fs/promises").then(
+    const stat4 = await import("node:fs/promises").then(
       (fs2) => fs2.stat(filePath)
     );
-    if (stat3.isDirectory()) {
+    if (stat4.isDirectory()) {
       console.error("Error: Path is a directory");
       return { exitCode: Promise.resolve(2), shutdown: () => {
       } };
@@ -24270,28 +24439,24 @@ async function editCommand(args, options = {}) {
     }
   }
   let projectData;
-  let isNewFile = false;
   try {
-    projectData = await readProject(filePath);
+    projectData = await storage.get(filePath);
   } catch (e) {
-    if (e instanceof ProjectFileError && e.code === "not-found") {
-      projectData = { version: 1, name: "", groups: [] };
-      isNewFile = true;
+    if (e instanceof ProjectStorageError && e.code === "not-found") {
+      try {
+        await storage.create({ id: filePath });
+        projectData = emptyProjectDocument();
+      } catch (createError) {
+        console.error(`Error writing initial project: ${createError}`);
+        return { exitCode: Promise.resolve(2), shutdown: () => {
+        } };
+      }
     } else {
       console.error(`Error: ${e}`);
       return { exitCode: Promise.resolve(2), shutdown: () => {
       } };
     }
   }
-  if (isNewFile) {
-    try {
-      await writeProject(filePath, projectData);
-    } catch (e) {
-      console.error(`Error writing initial project: ${e}`);
-      return { exitCode: Promise.resolve(2), shutdown: () => {
-      } };
-    }
-  }
   let aiClient;
   const providerConfig = await readProviderConfig();
   if (providerConfig) {
@@ -24302,7 +24467,7 @@ async function editCommand(args, options = {}) {
     project: projectData,
     filePath,
     csrfToken,
-    writeProject,
+    storage,
     shutdown: () => {
       shutdown();
     },
@@ -24766,7 +24931,7 @@ async function trustRuntimeCommand(args) {
       return 2;
   }
 }
-async function runtimeHostCommand(args) {
+async function runtimeHostCommand(args, options = {}) {
   let root;
   let mockPort;
   const positional = [];
@@ -24811,6 +24976,7 @@ async function runtimeHostCommand(args) {
   }
   let filePath;
   let projectData;
+  const storage = options.storage ?? createJsonFileProjectStorage();
   try {
     if (inputPath === "-") {
       const chunks = [];
@@ -24821,7 +24987,7 @@ async function runtimeHostCommand(args) {
       projectData = JSON.parse(chunks.join(""));
     } else {
       filePath = resolve5(inputPath);
-      projectData = await readProject(filePath);
+      projectData = await storage.get(filePath);
     }
   } catch (error) {
     const message = error instanceof Error ? error.message : "Unknown error";
@@ -24873,7 +25039,7 @@ async function runtimeHostCommand(args) {
   });
   return 0;
 }
-async function runtimeCommand(args, _options = {}) {
+async function runtimeCommand(args, options = {}) {
   if (args.includes("--help") || args.includes("-h")) {
     showRuntimeHelp();
     return 0;
@@ -24881,7 +25047,7 @@ async function runtimeCommand(args, _options = {}) {
   const first = args[0];
   if (first === "install" || first === "trust" || first === "uninstall" || first === "verify")
     return trustRuntimeCommand(args);
-  if (first === "host") return runtimeHostCommand(args.slice(1));
+  if (first === "host") return runtimeHostCommand(args.slice(1), options);
   console.error(
     `Error: 'rogatio runtime' no longer starts or stops the runtime. Use 'rogatio runtime install|uninstall' to manage the host manifest and request-body trust, or 'rogatio runtime host [path]' to run the native-messaging host. Start/stop is driven from the extension's controls.`
   );
@@ -25016,7 +25182,7 @@ function testCommandNeedsStdin(args) {
   const positionalUrls = isUrl(positional[0] ?? "") ? positional : positional.slice(1);
   return !hasUrlSource && positionalUrls.length === 0;
 }
-async function testCommandImpl(args, stdinInput, captureOutput) {
+async function testCommandImpl(args, stdinInput, captureOutput, options = {}) {
   let filePath = resolve6(process.cwd(), ".rogatio.json");
   let jsonMode = false;
   let maxCases;
@@ -25025,6 +25191,7 @@ async function testCommandImpl(args, stdinInput, captureOutput) {
   let defaultMethod;
   let defaultResourceType;
   let argumentError;
+  const storage = options.storage ?? createJsonFileProjectStorage();
   const positionalArgs = [];
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
@@ -25118,7 +25285,7 @@ async function testCommandImpl(args, stdinInput, captureOutput) {
       if (!stdinInput) throw new Error("No stdin input provided");
       projectData = JSON.parse(stdinInput);
     } else {
-      projectData = await readProject(filePath);
+      projectData = await storage.get(filePath);
     }
   } catch (e) {
     const message = e instanceof Error ? e.message : "Unknown error";
@@ -25213,15 +25380,16 @@ ${error.code}: ${error.message}${error.index === void 0 ? "" : ` (case ${error.i
   }
   return dryRunResult.errors.length === 0 ? 0 : 1;
 }
-async function testCommand(args, stdinInput, captureOutput = false) {
-  return testCommandImpl(args, stdinInput, captureOutput);
+async function testCommand(args, stdinInput, captureOutput = false, options = {}) {
+  return testCommandImpl(args, stdinInput, captureOutput, options);
 }
 
 // packages/cli/src/commands/verify.ts
 import { resolve as resolve7 } from "node:path";
-async function verifyCommandImpl(args, stdinInput, captureOutput) {
+async function verifyCommandImpl(args, stdinInput, captureOutput, options = {}) {
   let filePath;
   let jsonOutput2 = false;
+  const storage = options.storage ?? createJsonFileProjectStorage();
   const positionalArgs = [];
   for (const arg of args) {
     if (arg === "--json") {
@@ -25254,7 +25422,7 @@ async function verifyCommandImpl(args, stdinInput, captureOutput) {
       if (!stdinInput) throw new Error("No stdin input provided");
       projectData = JSON.parse(stdinInput);
     } else {
-      projectData = await readProject(filePath);
+      projectData = await storage.get(filePath);
     }
   } catch (e) {
     const message = e instanceof Error ? e.message : "Unknown error";
@@ -25309,8 +25477,8 @@ async function verifyCommandImpl(args, stdinInput, captureOutput) {
   if (diagnostics.length === 0) return 0;
   return 1;
 }
-async function verifyCommand(args, stdinInput, captureOutput = false) {
-  return verifyCommandImpl(args, stdinInput, captureOutput);
+async function verifyCommand(args, stdinInput, captureOutput = false, options = {}) {
+  return verifyCommandImpl(args, stdinInput, captureOutput, options);
 }
 
 // packages/cli/src/index.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rogatio/cli",
-  "version": "5.6.0",
+  "version": "5.7.0",
   "private": false,
   "type": "module",
   "description": "Local-first browser request and response rules — editor host, file verification, test runner, and runtime dispatch.",
@@ -45,7 +45,7 @@
     "@rogatio/editor": "workspace:*",
     "@rogatio/runtime": "workspace:*",
     "@rogatio/schema": "workspace:*",
-    "@types/node": "26.4.1",
+    "@types/node": "26.5.0",
     "typescript": "7.0.2",
     "vitest": "4.1.11"
   }