@rogatio/cli 5.16.0 → 5.18.0

package/dist/editor/index.js

@@ -1844,9 +1844,6 @@ var CREATABLE_RULE_FIELDS = /* @__PURE__ */ new Set([
   ...ACTION_PAYLOAD_FIELDS,
   "redactSensitiveInLogs"
 ]);
-function isBodyRuleType(type) {
-  return type === "request-body" || type === "response-body";
-}
 function setValueAtPath(root, path, value) {
   const segments = decodePointer(path);
   if (!segments || segments.length === 0) return false;
@@ -3937,25 +3934,23 @@ var EditorControllerImpl = class {
     this.renderField(matcherGrid, "Method", `${rulePath}/method`, method);
     matcherFields.append(matcherGrid);
     card.append(matcherFields);
-    if (!isBodyRuleType(rule.type)) {
-      const redactFieldset = this.document.createElement("fieldset");
-      const redactLegend = this.document.createElement("legend");
-      redactLegend.textContent = "Match logging";
-      redactFieldset.append(redactLegend);
-      const redactGrid = this.document.createElement("div");
-      redactGrid.dataset.editorFields = "true";
-      const redactCheckbox = this.document.createElement("input");
-      redactCheckbox.type = "checkbox";
-      redactCheckbox.checked = rule.redactSensitiveInLogs === true;
-      this.renderField(
-        redactGrid,
-        "Redact sensitive fields in logs",
-        `${rulePath}/redactSensitiveInLogs`,
-        redactCheckbox
-      );
-      redactFieldset.append(redactGrid);
-      card.append(redactFieldset);
-    }
+    const redactFieldset = this.document.createElement("fieldset");
+    const redactLegend = this.document.createElement("legend");
+    redactLegend.textContent = "Match logging";
+    redactFieldset.append(redactLegend);
+    const redactGrid = this.document.createElement("div");
+    redactGrid.dataset.editorFields = "true";
+    const redactCheckbox = this.document.createElement("input");
+    redactCheckbox.type = "checkbox";
+    redactCheckbox.checked = rule.redactSensitiveInLogs === true;
+    this.renderField(
+      redactGrid,
+      "Redact sensitive fields in logs",
+      `${rulePath}/redactSensitiveInLogs`,
+      redactCheckbox
+    );
+    redactFieldset.append(redactGrid);
+    card.append(redactFieldset);
     if (this.extensions.length > 0) {
       const currentType = this.extensions.find(
         (e) => e.matches(rule)

package/dist/node/index.js

@@ -20608,6 +20608,404 @@ function createAIClient(config) {
     }
   };
 }
+var RESOURCE_TYPES2 = [
+  "main_frame",
+  "sub_frame",
+  "stylesheet",
+  "script",
+  "image",
+  "font",
+  "object",
+  "xmlhttprequest",
+  "fetch",
+  "media",
+  "websocket",
+  "manifest",
+  "other"
+];
+var HTTP_METHODS2 = [
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "HEAD",
+  "OPTIONS",
+  "CONNECT",
+  "TRACE"
+];
+var FORBIDDEN_REQUEST_HEADERS2 = [
+  "accept-charset",
+  "accept-encoding",
+  "access-control-request-headers",
+  "access-control-request-method",
+  "connection",
+  "content-length",
+  "cookie",
+  "cookie2",
+  "date",
+  "dnt",
+  "expect",
+  "host",
+  "keep-alive",
+  "origin",
+  "referer",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade",
+  "via"
+];
+var FORBIDDEN_RESPONSE_HEADERS2 = ["set-cookie", "set-cookie2"];
+function formatResourceTypes() {
+  return RESOURCE_TYPES2.join(", ");
+}
+function formatHttpMethods() {
+  return HTTP_METHODS2.join(", ");
+}
+function formatForbiddenHeaders() {
+  return [
+    ...FORBIDDEN_REQUEST_HEADERS2.map((h) => `request: ${h}`),
+    ...FORBIDDEN_RESPONSE_HEADERS2.map((h) => `response: ${h}`)
+  ].join(", ");
+}
+function formatProjectContext(project) {
+  try {
+    return JSON.stringify(project, null, 2);
+  } catch {
+    return "{}";
+  }
+}
+function buildSystemPrompt(project) {
+  const projectJson = formatProjectContext(project);
+  return `You are an expert Rogatio rule author. Rogatio is a local-first browser request/response rule engine.
+
+## Schema Constraants
+
+### URL Regular Expression
+- Maximum 2048 characters
+- Case-sensitive, no flags
+- Must be valid ECMAScript regex
+- Used to match request URLs
+
+### Origins
+- Only explicit http:// and https:// origins with hostname
+- Optional port (e.g., https://example.com:8080)
+- No wildcards, credentials, paths, query strings, or fragments
+- Effective origins are union of project, group, and rule origins
+
+### Forbidden Headers
+Cannot set/remove these headers:
+${formatForbiddenHeaders()}
+
+### Resource Types
+${formatResourceTypes()}
+
+### HTTP Methods
+${formatHttpMethods()}
+
+### Bounds
+- Max 64 projects per profile
+- Max 100 groups per project
+- Max 500 rules per project
+- Max 10 origins per group/rule
+
+## Rule Types
+
+Each rule has: id, name, urlRegex, origins[], resourceTypes[], priority, method?, action
+
+### redirect
+Action: destination string. Use $1 through $9 for URL regex captures. $$ is a literal dollar sign. Existing redirect \\1 references remain compatible.
+
+### query
+Action: query parameters with name, operation, and value. Set values may use URL captures.
+
+### header
+Action: header direction, operation, name, and value. Set and append values may use URL captures.
+
+### response-body
+Replace-mode body may use URL captures. Regex-mode replacement strings use captures from the body pattern, not the URL pattern.
+
+### request-body
+Replace-mode body may use URL captures. Regex-mode replacement strings use captures from the body pattern, not the URL pattern.
+
+## Compiler Diagnostic Codes (stable)
+- schema.invalid-regex - Invalid regex syntax
+- schema.duplicate-id - Duplicate group/rule ID
+- schema.invalid-origin - Invalid origin format
+- schema.invalid-resource-type - Unknown resource type
+- schema.invalid-method - Unknown HTTP method
+- schema.regex-too-long - Regex exceeds 2048 chars
+- compiler.unsupported-operation - Operation kind not supported
+
+## Current Project
+${projectJson}
+
+## Output Format
+
+Return ONLY valid JSON matching this TypeScript interface:
+
+\`\`\`typescript
+interface RuleProposal {
+  kind: "redirect" | "query" | "header" | "response-body" | "request-body";
+  groupId: string;
+  name: string;
+  urlRegex: string;
+  origins?: string[];
+  resourceTypes?: string[];
+  priority?: number;
+  method?: string;
+  action: unknown;
+}
+
+interface AIProposal {
+  rules: RuleProposal[];
+  explanation: string;
+}
+\`\`\`
+
+## Instructions
+
+1. Propose MINIMAL changes - only what the user asked for
+2. Use existing groups when possible; create new only if needed
+3. All regex must be valid ECMAScript
+4. All origins must be valid http/https with hostname
+5. Resource types must be from the allowed list
+6. Methods must be from the allowed list
+7. Priority: higher = more specific (100 default)
+8. Action object must match the rule kind schema exactly
+9. Use $1\u2013$9 only when urlRegex defines those capture groups; use $$ for a literal dollar sign
+10. Before proposing, mentally validate against dry-run: would this rule match the intended URLs?
+11. Explanation should be 1-2 sentences describing what the rules do
+`;
+}
+var MAX_FIX_ATTEMPTS = 3;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function ownString(record, ...keys) {
+  for (const key of keys) {
+    if (!Object.hasOwn(record, key)) continue;
+    const value = record[key];
+    if (typeof value === "string") return value;
+  }
+  return void 0;
+}
+function ruleFromProposal(proposal, ruleId) {
+  const rule = {
+    id: ruleId,
+    name: proposal.name,
+    urlRegex: proposal.urlRegex,
+    origins: proposal.origins ? [...proposal.origins] : [],
+    resourceTypes: proposal.resourceTypes ? [...proposal.resourceTypes] : ["main_frame"],
+    priority: proposal.priority ?? 100
+  };
+  if (proposal.method !== void 0) {
+    rule.method = proposal.method;
+  }
+  switch (proposal.kind) {
+    case "redirect":
+      rule.type = "redirect";
+      rule.redirect = proposal.action;
+      break;
+    case "query":
+      rule.type = "query";
+      rule.action = proposal.action;
+      break;
+    case "header": {
+      rule.type = "header";
+      if (isRecord(proposal.action)) {
+        const direction = ownString(
+          proposal.action,
+          "headerDirection",
+          "direction"
+        );
+        const operation = ownString(
+          proposal.action,
+          "headerOperation",
+          "operation"
+        );
+        const name = ownString(proposal.action, "headerName", "name");
+        const value = ownString(proposal.action, "headerValue", "value");
+        if (direction !== void 0) rule.headerDirection = direction;
+        if (operation !== void 0) rule.headerOperation = operation;
+        if (name !== void 0) rule.headerName = name;
+        if (value !== void 0) rule.headerValue = value;
+      }
+      break;
+    }
+    case "response-body":
+      rule.type = "response-body";
+      rule.responseBody = proposal.action;
+      break;
+    case "request-body":
+      rule.type = "request-body";
+      rule.requestBody = proposal.action;
+      break;
+    default: {
+      const _exhaustive = proposal.kind;
+      void _exhaustive;
+    }
+  }
+  return rule;
+}
+function mergeProposalIntoProject(project, proposal) {
+  const groups = Array.isArray(project.groups) ? project.groups.map((group) => {
+    if (!isRecord(group)) {
+      return { id: "invalid", name: "invalid", origins: [], rules: [] };
+    }
+    return {
+      ...group,
+      rules: Array.isArray(group.rules) ? [...group.rules] : []
+    };
+  }) : [];
+  let seq = 0;
+  for (const ruleProposal of proposal.rules) {
+    let group = groups.find(
+      (candidate) => candidate.id === ruleProposal.groupId
+    );
+    if (!group) {
+      group = {
+        id: ruleProposal.groupId,
+        name: "AI Group",
+        origins: [],
+        rules: []
+      };
+      groups.push(group);
+    }
+    const rules = group.rules;
+    rules.push(ruleFromProposal(ruleProposal, `ai-${Date.now()}-${seq++}`));
+  }
+  return { ...project, groups };
+}
+function parseProposal(content) {
+  try {
+    const parsed = JSON.parse(content);
+    if (parsed.rules && parsed.explanation) {
+      return parsed;
+    }
+  } catch {
+  }
+  return null;
+}
+function buildMessages(systemPrompt, request, previousProposal, validationErrors) {
+  const messages = [{ role: "system", content: systemPrompt }];
+  if (previousProposal) {
+    messages.push({
+      role: "assistant",
+      content: JSON.stringify(previousProposal)
+    });
+  }
+  let userContent = "";
+  if (request.kind === "fix" && validationErrors) {
+    userContent = `The previous proposal failed validation. Fix the following errors:
+
+`;
+    for (const err of validationErrors) {
+      userContent += `- ${err.path}: ${err.message} (${err.code})
+`;
+    }
+    userContent += `
+Original request: ${request.prompt}`;
+  } else if (request.kind === "explain") {
+    userContent = `Explain this rule/project: ${request.prompt}`;
+  } else {
+    userContent = request.prompt;
+  }
+  if (request.context.dryRunCases && request.context.dryRunCases.length > 0) {
+    userContent += `
+
+Dry-run test cases:`;
+    for (const tc of request.context.dryRunCases) {
+      userContent += `
+- ${tc.url}${tc.method ? ` (${tc.method})` : ""}${tc.resourceType ? ` [${tc.resourceType}]` : ""}`;
+    }
+  }
+  messages.push({ role: "user", content: userContent });
+  return messages;
+}
+async function runComplete(client, options) {
+  const result = await client.complete(options);
+  return parseProposal(result.content);
+}
+async function runStream(client, options) {
+  let fullContent = "";
+  for await (const chunk of client.stream(options)) {
+    if (chunk.delta) {
+      fullContent += chunk.delta;
+    }
+    if (chunk.done) {
+      return parseProposal(fullContent);
+    }
+  }
+  return parseProposal(fullContent);
+}
+async function runAIAssist(request, config, validate, dryRun, client) {
+  const aiClient = client ?? createAIClient(config);
+  const systemPrompt = buildSystemPrompt(request.context.project);
+  let currentProposal = null;
+  let attempts = 0;
+  while (attempts < MAX_FIX_ATTEMPTS) {
+    attempts++;
+    const isFixAttempt = attempts > 1 || request.kind === "fix";
+    const validationErrors = (() => {
+      if (!isFixAttempt || !currentProposal) return [];
+      return validate(
+        mergeProposalIntoProject(request.context.project, currentProposal)
+      );
+    })();
+    const messages = buildMessages(
+      systemPrompt,
+      request,
+      currentProposal ?? void 0,
+      validationErrors
+    );
+    const completionOptions = {
+      messages,
+      model: config.model,
+      temperature: 0.2,
+      responseFormat: { type: "json_object" }
+    };
+    let proposal = null;
+    try {
+      proposal = await runStream(aiClient, {
+        ...completionOptions,
+        stream: true
+      });
+    } catch {
+      try {
+        proposal = await runComplete(aiClient, completionOptions);
+      } catch (e) {
+        throw new Error(`AI request failed: ${e}`);
+      }
+    }
+    if (!proposal) {
+      throw new Error("AI returned invalid proposal format");
+    }
+    currentProposal = proposal;
+    const testProject = mergeProposalIntoProject(
+      request.context.project,
+      proposal
+    );
+    const diagnostics = validate(testProject);
+    if (diagnostics.length === 0) {
+      if (dryRun && request.context.dryRunCases && request.context.dryRunCases.length > 0) {
+        dryRun(testProject, request.context.dryRunCases);
+      }
+      return proposal;
+    }
+    if (request.kind === "fix") {
+      continue;
+    }
+    if (attempts < MAX_FIX_ATTEMPTS) {
+      continue;
+    }
+    throw new Error(
+      `Max fix attempts (${MAX_FIX_ATTEMPTS}) reached. Remaining errors: ${diagnostics.map((d) => d.message).join(", ")}`
+    );
+  }
+  throw new Error(`Max fix attempts (${MAX_FIX_ATTEMPTS}) reached`);
+}
 function getConfigDir() {
   const platform = process.platform;
   if (platform === "win32") {
@@ -23780,7 +24178,7 @@ function toMatcherOperations(operations) {
     })
   );
 }
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function parseUrl(req) {
@@ -23802,6 +24200,25 @@ function parseDiagnostics(result) {
   }
   return [];
 }
+function schemaDiagnosticsForAssist(value) {
+  const result = validateProjectDetailed(value);
+  if (result.valid) return [];
+  return result.errors.map((error) => ({
+    code: `schema.${error.keyword}`,
+    severity: "error",
+    path: error.instancePath || "/",
+    message: error.message ?? "The project contains invalid data."
+  }));
+}
+function isAIAssistRequestBody(body) {
+  if (!isRecord2(body)) return false;
+  if (body.kind !== "generate" && body.kind !== "fix" && body.kind !== "explain") {
+    return false;
+  }
+  if (typeof body.prompt !== "string") return false;
+  if (!isRecord2(body.context) || !isRecord2(body.context.project)) return false;
+  return true;
+}
 function parseCompilerDiagnostics(result) {
   if (!result.ok) {
     return result.diagnostics.map((d) => ({
@@ -24029,7 +24446,7 @@ function createRoutes(context) {
         res.end(JSON.stringify(failure2.body));
         return;
       }
-      if (!isRecord(body) || !isRecord(body.project)) {
+      if (!isRecord2(body) || !isRecord2(body.project)) {
         res.writeHead(400, { "Content-Type": "application/json" });
         res.end(
           JSON.stringify({
@@ -24113,7 +24530,7 @@ function createRoutes(context) {
         res.end(JSON.stringify(failure2.body));
         return;
       }
-      if (!isRecord(body) || !Array.isArray(body.messages)) {
+      if (!isRecord2(body) || !Array.isArray(body.messages)) {
         res.writeHead(400, { "Content-Type": "application/json" });
         res.end(
           JSON.stringify({
@@ -24176,7 +24593,7 @@ function createRoutes(context) {
         res.end(JSON.stringify(failure2.body));
         return;
       }
-      if (!isRecord(body) || !Array.isArray(body.messages)) {
+      if (!isRecord2(body) || !Array.isArray(body.messages)) {
         res.writeHead(400, { "Content-Type": "application/json" });
         res.end(
           JSON.stringify({
@@ -24220,6 +24637,68 @@ function createRoutes(context) {
       }
       return;
     }
+    if (pathname === "/api/ai/assist" && method === "POST") {
+      if (!validateCsrf(req, context.csrfToken)) {
+        res.writeHead(403, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({
+            code: "csrf-invalid",
+            message: "Invalid CSRF token"
+          })
+        );
+        return;
+      }
+      if (!context.aiClient || !context.aiProviderConfig) {
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({
+            code: "ai-not-configured",
+            message: "AI provider not configured"
+          })
+        );
+        return;
+      }
+      let body;
+      try {
+        const bodyText = await getRequestBody(req);
+        body = JSON.parse(bodyText);
+      } catch (error) {
+        const failure2 = bodyErrorResponse(error);
+        res.writeHead(failure2.status, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(failure2.body));
+        return;
+      }
+      if (!isAIAssistRequestBody(body)) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({
+            code: "invalid-request",
+            message: "Missing or invalid AI Assist request"
+          })
+        );
+        return;
+      }
+      try {
+        const proposal = await runAIAssist(
+          body,
+          context.aiProviderConfig,
+          schemaDiagnosticsForAssist,
+          void 0,
+          context.aiClient
+        );
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ proposal }));
+      } catch (e) {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({
+            code: "ai-error",
+            message: e instanceof Error ? e.message : "AI Assist failed"
+          })
+        );
+      }
+      return;
+    }
     res.writeHead(404, { "Content-Type": "application/json" });
     res.end(JSON.stringify({ code: "not-found", message: "Not found" }));
   };
@@ -24713,7 +25192,8 @@ async function editCommand(args, options = {}) {
     editorBundlePath: "",
     editorCssPath: "",
     editorFontsPath: "",
-    aiClient
+    aiClient,
+    aiProviderConfig: providerConfig ?? void 0
   };
   let server;
   try {
@@ -24806,64 +25286,26 @@ async function ensureCivilizationProjectName(storage, filePath, data) {
 }
 function generateEditorHtml(apiBase, csrfToken, filePath, aiConfigured) {
   const aiAssistHandler = aiConfigured ? `
-    aiAssist: async function*(request) {
-      const res = await fetch(apiBase + '/api/ai/stream', {
+    aiAssist: async function(request) {
+      const res = await fetch(apiBase + '/api/ai/assist', {
         method: 'POST',
         headers: {
           'Content-Type': 'application/json',
           'X-CSRF-Token': csrfToken,
         },
-        body: JSON.stringify({
-          messages: request.context.project ? [
-            { role: 'system', content: 'You are an expert Rogatio rule author.' },
-            { role: 'user', content: request.prompt }
-          ] : [{ role: 'user', content: request.prompt }],
-          model: 'gpt-4o-mini',
-          stream: true,
-        }),
+        body: JSON.stringify(request),
       });
-      
+      const payload = await res.json().catch(function() { return null; });
       if (!res.ok) {
-        const error = await res.json();
-        yield { type: 'error', error: error.message };
-        return;
+        var message = payload && payload.message
+          ? payload.message
+          : 'AI Assist failed';
+        throw new Error(message);
       }
-      
-      const reader = res.body?.getReader();
-      const decoder = new TextDecoder();
-      if (!reader) {
-        yield { type: 'error', error: 'No response body' };
-        return;
-      }
-      
-      let buffer = '';
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split('\\n');
-        buffer = lines.pop() || '';
-        for (const line of lines) {
-          if (!line.startsWith('data: ')) continue;
-          const data = line.slice(6).trim();
-          if (data === '[DONE]') continue;
-          try {
-            const parsed = JSON.parse(data);
-            if (parsed.type === 'token' && parsed.content) {
-              yield { type: 'token', content: parsed.content };
-            } else if (parsed.done) {
-              yield { type: 'done', proposal: parsed.proposal };
-              return;
-            } else if (parsed.error) {
-              yield { type: 'error', error: parsed.error };
-              return;
-            }
-          } catch {
-            // Ignore parse errors
-          }
-        }
+      if (!payload || !payload.proposal) {
+        throw new Error('AI Assist returned no proposal');
       }
-      yield { type: 'done', proposal: null };
+      return { proposal: payload.proposal };
     },` : "";
   return `<!DOCTYPE html>
 <html lang="en">

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rogatio/cli",
-  "version": "5.16.0",
+  "version": "5.18.0",
   "private": false,
   "type": "module",
   "description": "Local-first browser request and response rules — editor host, file verification, test runner, and runtime dispatch.",