kifaru 1.0.182 → 1.0.183

package/extensions/kifaru-client-side-audit.ts

@@ -74,7 +74,7 @@ export function auditText(content: string): { routes: string[]; secrets: string[
   for (const regex of AUDIT_PATTERNS.LOGIC) {
     const matches = content.matchAll(regex)
     for (const m of matches) {
-      const val = (m[0]).trim().slice(0, 120)
+      const val = m[0].trim().slice(0, 120)
       if (val.length > 3) logicFlags.add(val)
     }
   }
@@ -184,18 +184,24 @@ export default function (pi: ExtensionAPI) {
     promptSnippet: "Perform client-side static forensics on HTML and JavaScript bundles",
     parameters: Type.Object({
       target: Type.String({ description: "Target HTTP URL or local file path to HTML/JS artifact" }),
-      depth: Type.Optional(Type.Union([Type.Literal("shallow"), Type.Literal("deep")], {
-        description: "Audit depth: 'shallow' (target only) or 'deep' (fetches and scans linked JS scripts)",
-      })),
+      depth: Type.Optional(
+        Type.Union([Type.Literal("shallow"), Type.Literal("deep")], {
+          description: "Audit depth: 'shallow' (target only) or 'deep' (fetches and scans linked JS scripts)",
+        }),
+      ),
       content: Type.Optional(Type.String({ description: "Optional raw string content to audit directly" })),
     }),
-    async execute(_toolCallId, params: { target: string; depth?: "shallow" | "deep"; content?: string }, signal?: AbortSignal): Promise<AgentToolResult<AuditResults>> {
+    async execute(
+      _toolCallId,
+      params: { target: string; depth?: "shallow" | "deep"; content?: string },
+      signal?: AbortSignal,
+    ): Promise<AgentToolResult<AuditResults>> {
       try {
         const result = await runClientSideAudit({ ...params, signal })
         const lines: string[] = [
           `Client-Side Audit: ${params.target} (${result.scriptsAnalyzed.length} asset(s) analyzed)`,
           "",
-          `Routes Discovered (${result.routes.length}):` ,
+          `Routes Discovered (${result.routes.length}):`,
           ...result.routes.slice(0, 20).map((r) => `  - ${r}`),
           result.routes.length > 20 ? `  ... (${result.routes.length - 20} more)` : "",
           "",

package/extensions/kifaru-payload-generator.ts

@@ -133,7 +133,9 @@ export function generateSanitizerBuild(opts: {
   return [compiler, ...flags, opts.target, "-o", output, ...extra].join(" ")
 }
 
-export function generateInvalidTransitions(transitions: Array<{ from: string; to: string }>): Array<{ from: string; to: string; reason: string }> {
+export function generateInvalidTransitions(
+  transitions: Array<{ from: string; to: string }>,
+): Array<{ from: string; to: string; reason: string }> {
   const states = new Set<string>()
   const validMap = new Map<string, Set<string>>()
 
@@ -171,40 +173,60 @@ export default function (pi: ExtensionAPI) {
       "Generate test configurations and payloads for dual-parser discrepancies (JSON vs form, CL.TE smuggling), fault injection (disk/memory/network), sanitizer build commands, or invalid business logic transitions.",
     promptSnippet: "Generate dual-parser discrepancy tests, fault injection, or sanitizer build commands",
     parameters: Type.Object({
-      category: Type.Union([
-        Type.Literal("dual_parser"),
-        Type.Literal("fault_injection"),
-        Type.Literal("sanitizer_build"),
-        Type.Literal("state_machine"),
-      ], { description: "Type of test generator to run" }),
+      category: Type.Union(
+        [
+          Type.Literal("dual_parser"),
+          Type.Literal("fault_injection"),
+          Type.Literal("sanitizer_build"),
+          Type.Literal("state_machine"),
+        ],
+        { description: "Type of test generator to run" },
+      ),
       url: Type.Optional(Type.String({ description: "Target URL for dual_parser tests" })),
       field: Type.Optional(Type.String({ description: "Parameter or body field name" })),
       value: Type.Optional(Type.String({ description: "Parameter value" })),
-      faultMode: Type.Optional(Type.Union([
-        Type.Literal("latency"),
-        Type.Literal("disk"),
-        Type.Literal("fd"),
-        Type.Literal("clock"),
-        Type.Literal("memory"),
-      ], { description: "Fault injection type" })),
-      level: Type.Optional(Type.Integer({ minimum: 1, maximum: 10, description: "Intensity level for fault injection" })),
-      sanitizer: Type.Optional(Type.Union([Type.Literal("asan"), Type.Literal("ubsan"), Type.Literal("tsan")], { description: "Compiler sanitizer" })),
-      compiler: Type.Optional(Type.Union([Type.Literal("clang"), Type.Literal("gcc")], { description: "Compiler binary" })),
-      sourceFile: Type.Optional(Type.String({ description: "Source code file to compile" })),
-      transitions: Type.Optional(Type.Array(
-        Type.Object({
-          from: Type.String({ description: "Starting state" }),
-          to: Type.String({ description: "Target state" }),
+      faultMode: Type.Optional(
+        Type.Union(
+          [
+            Type.Literal("latency"),
+            Type.Literal("disk"),
+            Type.Literal("fd"),
+            Type.Literal("clock"),
+            Type.Literal("memory"),
+          ],
+          { description: "Fault injection type" },
+        ),
+      ),
+      level: Type.Optional(
+        Type.Integer({ minimum: 1, maximum: 10, description: "Intensity level for fault injection" }),
+      ),
+      sanitizer: Type.Optional(
+        Type.Union([Type.Literal("asan"), Type.Literal("ubsan"), Type.Literal("tsan")], {
+          description: "Compiler sanitizer",
         }),
-        { description: "Valid transitions for state_machine analysis" }
-      )),
+      ),
+      compiler: Type.Optional(
+        Type.Union([Type.Literal("clang"), Type.Literal("gcc")], { description: "Compiler binary" }),
+      ),
+      sourceFile: Type.Optional(Type.String({ description: "Source code file to compile" })),
+      transitions: Type.Optional(
+        Type.Array(
+          Type.Object({
+            from: Type.String({ description: "Starting state" }),
+            to: Type.String({ description: "Target state" }),
+          }),
+          { description: "Valid transitions for state_machine analysis" },
+        ),
+      ),
     }),
     async execute(_toolCallId, params): Promise<AgentToolResult<PayloadGeneratorDetails>> {
       switch (params.category) {
         case "dual_parser": {
           const cases = generateDualParserCases(params.url || "https://example.com/api", params.field, params.value)
           return {
-            content: [{ type: "text", text: `Dual-Parser Cases (${cases.length}):\n` + JSON.stringify(cases, null, 2) }],
+            content: [
+              { type: "text", text: `Dual-Parser Cases (${cases.length}):\n` + JSON.stringify(cases, null, 2) },
+            ],
             details: { category: "dual_parser", cases },
           }
         }
@@ -212,7 +234,9 @@ export default function (pi: ExtensionAPI) {
           const mode = params.faultMode ?? "latency"
           const cmds = generateFaultInjection(mode, params.level ?? 1)
           return {
-            content: [{ type: "text", text: `Fault Injection Commands [${mode}]:\n` + cmds.map((c) => `  $ ${c}`).join("\n") }],
+            content: [
+              { type: "text", text: `Fault Injection Commands [${mode}]:\n` + cmds.map((c) => `  $ ${c}`).join("\n") },
+            ],
             details: { category: "fault_injection", mode, commands: cmds },
           }
         }
@@ -231,11 +255,14 @@ export default function (pi: ExtensionAPI) {
           const transitions = params.transitions ?? []
           const invalid = generateInvalidTransitions(transitions)
           return {
-            content: [{
-              type: "text",
-              text: `Invalid State Transitions (${invalid.length} potential logic bypasses):\n` +
-                invalid.map((t) => `  - [SKIP/BYPASS] ${t.from} -> ${t.to}: ${t.reason}`).join("\n"),
-            }],
+            content: [
+              {
+                type: "text",
+                text:
+                  `Invalid State Transitions (${invalid.length} potential logic bypasses):\n` +
+                  invalid.map((t) => `  - [SKIP/BYPASS] ${t.from} -> ${t.to}: ${t.reason}`).join("\n"),
+              },
+            ],
             details: { category: "state_machine", invalidTransitions: invalid },
           }
         }
@@ -248,7 +275,10 @@ export default function (pi: ExtensionAPI) {
     handler: async (args, ctx) => {
       const cat = (args ?? "").trim().toLowerCase()
       if (cat !== "dual_parser" && cat !== "fault_injection" && cat !== "sanitizer_build" && cat !== "state_machine") {
-        ctx.ui.notify("usage: /kifaru-payload <dual_parser | fault_injection | sanitizer_build | state_machine>", "warning")
+        ctx.ui.notify(
+          "usage: /kifaru-payload <dual_parser | fault_injection | sanitizer_build | state_machine>",
+          "warning",
+        )
         return
       }
       pi.sendMessage({

package/extensions/kifaru-poc-finder.ts

@@ -38,7 +38,10 @@ export function cveYear(id: string): string | undefined {
   return parts.length >= 2 ? parts[1] : undefined
 }
 
-export async function fetchNomiSecPoc(cveId: string, signal?: AbortSignal): Promise<{ repos: RepoResult[]; error?: string }> {
+export async function fetchNomiSecPoc(
+  cveId: string,
+  signal?: AbortSignal,
+): Promise<{ repos: RepoResult[]; error?: string }> {
   if (process.env.PI_OFFLINE === "1") return { repos: [] }
   const cve = normalizeCve(cveId)
   const year = cveYear(cve)
@@ -128,10 +131,7 @@ export async function searchPocs(cveId: string, customQuery?: string, signal?: A
   let exploitDbUrls: string[] = []
 
   if (isCve) {
-    const [nomi, edb] = await Promise.all([
-      fetchNomiSecPoc(norm, signal),
-      fetchExploitDb(norm, signal),
-    ])
+    const [nomi, edb] = await Promise.all([fetchNomiSecPoc(norm, signal), fetchExploitDb(norm, signal)])
     repos = nomi.repos
     exploitDbUrls = edb
   }

package/extensions/kifaru-prior-art.ts

@@ -190,8 +190,12 @@ export default function (pi: ExtensionAPI) {
       "Search for disclosed security reports, bug bounty writeups (HackerOne, Bugcrowd), and GitHub security advisories for a given target, framework, or vulnerability class.",
     promptSnippet: "Search prior vulnerability writeups and bug bounty disclosures",
     parameters: Type.Object({
-      query: Type.String({ description: "Target technology, endpoint, or vulnerability pattern (e.g. 'Next.js SSRF' or 'GraphQL IDOR')" }),
-      numResults: Type.Optional(Type.Integer({ minimum: 1, maximum: 20, description: "Maximum results to return (default: 6)" })),
+      query: Type.String({
+        description: "Target technology, endpoint, or vulnerability pattern (e.g. 'Next.js SSRF' or 'GraphQL IDOR')",
+      }),
+      numResults: Type.Optional(
+        Type.Integer({ minimum: 1, maximum: 20, description: "Maximum results to return (default: 6)" }),
+      ),
     }),
     async execute(_toolCallId, params: { query: string; numResults?: number }, signal?: AbortSignal) {
       const items = await searchPriorArt(params.query, params.numResults ?? 6, signal)
@@ -202,10 +206,7 @@ export default function (pi: ExtensionAPI) {
         }
       }
 
-      const lines: string[] = [
-        `Prior Art Results for: "${params.query}" (${items.length} records)`,
-        "",
-      ]
+      const lines: string[] = [`Prior Art Results for: "${params.query}" (${items.length} records)`, ""]
       for (const item of items) {
         lines.push(`[${item.source.toUpperCase()}] ${item.title} (${item.severity.toUpperCase()})`)
         lines.push(`  URL: ${item.url}`)

package/kifaru-pi.js

@@ -58212,7 +58212,7 @@ Ctrl+C stops the gateway.`);
 async function handleCli() {
   const args = process.argv.slice(2);
   if (args.includes("--version") || args.includes("-v")) {
-    console.log("1.0.182");
+    console.log("1.0.183");
     process.exit(0);
   }
   if (args[0] === "dashboard") {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "kifaru",
-  "version": "1.0.182",
-  "gitHead": "49cc69fa094e9c1008b9caad4100f0c135ecb1ed",
+  "version": "1.0.183",
+  "gitHead": "a470d168bc35a08eecad543456ac3ec82344877e",
   "description": "Kifaru security agent on the Pi runtime",
   "type": "module",
   "license": "MIT",