kifaru 1.0.201 → 1.0.202

package/kifaru-pi.js

@@ -51515,52 +51515,27 @@ ${result.stderr}`.trim().split(/\r?\n/).find((line) => line.trim().length > 0)?.
   })(PythonRuntime ||= {});
 });
 
-// ../execution-runtime/src/python-helpers.ts
-import { createHash as createHash4 } from "crypto";
-import fs9 from "fs/promises";
-import path12 from "path";
-var PythonHelpers;
-var init_python_helpers = __esm(() => {
-  init_python();
-  init_paths();
-  ((PythonHelpers) => {
-    PythonHelpers.HUNT_MODULE_SOURCE = `"""kifaru hunt helpers - stdlib-only HTTP / crypto / recon utilities.
+// ../execution-runtime/src/hunt-modules.ts
+var HUNT_MODULE_FILES;
+var init_hunt_modules = __esm(() => {
+  HUNT_MODULE_FILES = {
+    "hunt.py": `"""Kifaru's stdlib-only hunt helpers.
 
-The API mirrors requests, so your usual idioms work unchanged:
     import hunt
-    r = hunt.post("https://target/api/login", json={"user": "a", "pass": "b"})
-    print(r.status_code, r.text)          # .status / .body also work
-    tok = r.json()["token"]
-    me = hunt.get("https://target/api/me", token=tok)
-    print(me.status_code, me.ok, hunt.jwt_decode(tok)["payload"])
-
-Response fields: .status_code / .status, .text / .body, .content, .json(), .ok, .headers.
-Request kwargs: json= (JSON body, requests-style), body= (alias), data= (form/raw),
-token= (Authorization), headers=, timeout=, allow_redirects=.
-
-Or use it as a CLI:
-    python -m hunt GET https://target/api -H "Authorization: Bearer ey..."
-
-No third-party packages required and no need to match a custom API - it behaves like
-requests. When the managed venv is active you also have requests/httpx/PyJWT/dnspython,
-but everything here works on the standard library alone; prefer it over urllib boilerplate.
+    r = hunt.post("https://target/api/login", json={"user": "a"})
+    print(r.status_code, r.text, r.json())
+
+Request kwargs: json=, body=, data=, token=, headers=, timeout=,
+allow_redirects=. Response fields: .status_code/.status, .text/.body,
+.content, .json(), .ok, .headers.
 """
 from __future__ import annotations
 
-import base64
-import hashlib
-import hmac
-import json as _json
-import os
-import random
-import socket
-import ssl
-import string
 import sys
-import time
-import urllib.error
-import urllib.parse
-import urllib.request
+
+from hunt_http import DEFAULT_UA, Resp, get, post, req
+from hunt_crypto import b64d, b64e, jwt_decode, sign
+from hunt_recon import now_ms, rand, rand_email, resolve
 
 __all__ = [
     "req", "get", "post", "Resp",
@@ -51568,10 +51543,58 @@ __all__ = [
     "rand", "rand_email", "resolve", "sign", "now_ms",
 ]
 
+
+def _cli(argv):
+    args = list(argv)
+    if len(args) < 2 or args[0] in ("-h", "--help"):
+        print("usage: python -m hunt METHOD URL [-H 'K: V']... [-d BODY] [-t TOKEN] [--no-redirect]")
+        return 0 if not args or args[0] in ("-h", "--help") else 2
+    method, url = args[0], args[1]
+    headers, body, token, redirects = {}, None, None, True
+    i = 2
+    while i < len(args):
+        arg = args[i]
+        if arg in ("-H", "--header") and i + 1 < len(args):
+            key, _, value = args[i + 1].partition(":")
+            headers[key.strip()] = value.strip()
+            i += 2
+        elif arg in ("-d", "--data") and i + 1 < len(args):
+            body = args[i + 1]
+            i += 2
+        elif arg in ("-t", "--token") and i + 1 < len(args):
+            token = args[i + 1]
+            i += 2
+        elif arg == "--no-redirect":
+            redirects = False
+            i += 1
+        else:
+            i += 1
+    response = req(method, url, data=body, token=token, headers=headers or None,
+                   allow_redirects=redirects)
+    print("HTTP %s  %s" % (response.status, response.url))
+    for key, value in response.headers.items():
+        print("%s: %s" % (key, value))
+    print()
+    print(response.error if response.error else response.body)
+    return 0 if response.ok else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(_cli(sys.argv[1:]))
+`,
+    "hunt_http.py": `"""Small requests-like HTTP surface for hunt."""
+from __future__ import annotations
+
+import json as _json
+import os
+import ssl
+import urllib.error
+import urllib.parse
+import urllib.request
+
 _CTX = ssl.create_default_context()
 _CTX.check_hostname = False
 _CTX.verify_mode = ssl.CERT_NONE
-
 DEFAULT_UA = os.environ.get("HUNT_UA", "kifaru-research")
 
 
@@ -51596,7 +51619,6 @@ class Resp:
         except Exception:
             return default
 
-    # requests/httpx-compatible aliases so existing muscle memory just works.
     @property
     def status_code(self):
         return self.status
@@ -51622,16 +51644,9 @@ class Resp:
 
 def req(method, url, body=None, json=None, data=None, token=None, headers=None,
         read=200000, timeout=20, allow_redirects=True):
-    """One HTTP request via urllib. Never raises on HTTP status.
-
-    body / json -> JSON-encoded payload (json= is the requests-style alias);
-    data -> dict(form) / str / bytes.
-    token -> Authorization header (adds 'Bearer ' if no scheme given).
-    Returns Resp with requests-compatible fields: .status_code/.status,
-    .text/.body, .json(), .ok, .headers.
-    """
+    """One HTTP request. HTTP status errors return Resp rather than raising."""
     if body is None:
-        body = json  # accept requests-style json= kwarg
+        body = json
     h = {"User-Agent": DEFAULT_UA}
     payload = None
     if body is not None:
@@ -51656,13 +51671,14 @@ def req(method, url, body=None, json=None, data=None, token=None, headers=None,
         handlers.append(_NoRedirect())
     opener = urllib.request.build_opener(*handlers)
     try:
-        with opener.open(request, timeout=timeout) as resp:
-            return Resp(resp.status, dict(resp.headers),
-                        resp.read(read).decode("utf-8", "ignore"), resp.geturl())
-    except urllib.error.HTTPError as e:
-        return Resp(e.code, dict(e.headers), e.read(read).decode("utf-8", "ignore"), url)
-    except Exception as e:
-        return Resp(0, {}, "", url, error="%s: %s" % (type(e).__name__, e))
+        with opener.open(request, timeout=timeout) as response:
+            return Resp(response.status, dict(response.headers),
+                        response.read(read).decode("utf-8", "ignore"), response.geturl())
+    except urllib.error.HTTPError as error:
+        return Resp(error.code, dict(error.headers),
+                    error.read(read).decode("utf-8", "ignore"), url)
+    except Exception as error:
+        return Resp(0, {}, "", url, error="%s: %s" % (type(error).__name__, error))
 
 
 def get(url, **kw):
@@ -51671,30 +51687,38 @@ def get(url, **kw):
 
 def post(url, body=None, **kw):
     return req("POST", url, body=body, **kw)
+`,
+    "hunt_crypto.py": `"""Encoding, JWT inspection, and HMAC helpers for hunt."""
+from __future__ import annotations
+
+import base64
+import hashlib
+import hmac
+import json as _json
 
 
-def b64d(s, urlsafe=True):
-    s = s if isinstance(s, str) else s.decode()
-    s += "=" * (-len(s) % 4)
-    return (base64.urlsafe_b64decode if urlsafe else base64.b64decode)(s)
+def b64d(value, urlsafe=True):
+    value = value if isinstance(value, str) else value.decode()
+    value += "=" * (-len(value) % 4)
+    return (base64.urlsafe_b64decode if urlsafe else base64.b64decode)(value)
 
 
-def b64e(b, urlsafe=True):
-    if isinstance(b, str):
-        b = b.encode()
-    out = (base64.urlsafe_b64encode if urlsafe else base64.b64encode)(b)
-    return out.decode().rstrip("=")
+def b64e(value, urlsafe=True):
+    if isinstance(value, str):
+        value = value.encode()
+    encoded = (base64.urlsafe_b64encode if urlsafe else base64.b64encode)(value)
+    return encoded.decode().rstrip("=")
 
 
 def jwt_decode(token):
-    """Decode a JWT without verifying. Returns {"header":..., "payload":..., "signature":str}."""
+    """Decode a JWT without verifying its signature."""
     parts = token.split(".")
     if len(parts) < 2:
         raise ValueError("not a JWT")
     header = _json.loads(b64d(parts[0]))
     payload = _json.loads(b64d(parts[1]))
-    sig = parts[2] if len(parts) > 2 else ""
-    return {"header": header, "payload": payload, "signature": sig}
+    signature = parts[2] if len(parts) > 2 else ""
+    return {"header": header, "payload": payload, "signature": signature}
 
 
 def sign(key, msg, alg="sha256"):
@@ -51704,14 +51728,22 @@ def sign(key, msg, alg="sha256"):
     if isinstance(msg, str):
         msg = msg.encode()
     return hmac.new(key, msg, getattr(hashlib, alg)).hexdigest()
+`,
+    "hunt_recon.py": `"""DNS, random test data, and timing helpers for hunt."""
+from __future__ import annotations
+
+import random
+import socket
+import string
+import time
 
 
 def resolve(host):
     """All A/AAAA addresses for host (DNS)."""
     try:
-        return sorted({ai[4][0] for ai in socket.getaddrinfo(host, None)})
-    except Exception as e:
-        return ["__error__ %s: %s" % (type(e).__name__, e)]
+        return sorted({address[4][0] for address in socket.getaddrinfo(host, None)})
+    except Exception as error:
+        return ["__error__ %s: %s" % (type(error).__name__, error)]
 
 
 def rand(n=8, alphabet=string.ascii_lowercase + string.digits):
@@ -51724,46 +51756,24 @@ def rand_email(domain="example.com"):
 
 def now_ms():
     return int(time.time() * 1000)
+`
+  };
+});
 
-
-def _cli(argv):
-    args = list(argv)
-    if not args or args[0] in ("-h", "--help"):
-        print("usage: python -m hunt METHOD URL [-H 'K: V']... [-d BODY] [-t TOKEN] [--no-redirect]")
-        return 0
-    method, url = args[0], args[1]
-    headers, body, token, redirects = {}, None, None, True
-    i = 2
-    while i < len(args):
-        a = args[i]
-        if a in ("-H", "--header") and i + 1 < len(args):
-            k, _, v = args[i + 1].partition(":")
-            headers[k.strip()] = v.strip()
-            i += 2
-        elif a in ("-d", "--data") and i + 1 < len(args):
-            body = args[i + 1]
-            i += 2
-        elif a in ("-t", "--token") and i + 1 < len(args):
-            token = args[i + 1]
-            i += 2
-        elif a == "--no-redirect":
-            redirects = False
-            i += 1
-        else:
-            i += 1
-    r = req(method, url, data=body, token=token, headers=headers or None, allow_redirects=redirects)
-    print("HTTP %s  %s" % (r.status, r.url))
-    for k, v in r.headers.items():
-        print("%s: %s" % (k, v))
-    print()
-    print(r.error if r.error else r.body)
-    return 0 if r.ok else 1
-
-
-if __name__ == "__main__":
-    raise SystemExit(_cli(sys.argv[1:]))
-`;
-    PythonHelpers.HUNT_MODULE_VERSION = createHash4("sha256").update(PythonHelpers.HUNT_MODULE_SOURCE).digest("hex").slice(0, 12);
+// ../execution-runtime/src/python-helpers.ts
+import { createHash as createHash4 } from "crypto";
+import fs9 from "fs/promises";
+import path12 from "path";
+var PythonHelpers;
+var init_python_helpers = __esm(() => {
+  init_hunt_modules();
+  init_python();
+  init_paths();
+  ((PythonHelpers) => {
+    PythonHelpers.HUNT_MODULE_SOURCE = HUNT_MODULE_FILES["hunt.py"];
+    PythonHelpers.HUNT_MODULE_VERSION = createHash4("sha256").update(Object.entries(HUNT_MODULE_FILES).sort(([a], [b]) => a.localeCompare(b)).map(([name21, source]) => `${name21}
+${source}`).join(`
+`)).digest("hex").slice(0, 12);
     function defaultDeps() {
       return {
         mkdir: (dir) => fs9.mkdir(dir, { recursive: true }).then(() => {
@@ -51784,24 +51794,27 @@ if __name__ == "__main__":
       if (cached3)
         return cached3;
       const task = (async () => {
-        const target = path12.join(dir, "hunt.py");
-        const stamp = path12.join(dir, ".hunt-version");
         try {
-          const [onDisk, current] = await Promise.all([
-            deps2.readFile(target).catch(() => {
+          const stamp = path12.join(dir, ".hunt-version");
+          const files = Object.entries(HUNT_MODULE_FILES);
+          const [current, ...onDisk] = await Promise.all([
+            deps2.readFile(stamp).catch(() => ""),
+            ...files.map(([name21]) => deps2.readFile(path12.join(dir, name21)).catch(() => {
               return;
-            }),
-            deps2.readFile(stamp).catch(() => "")
+            }))
           ]);
-          if (onDisk === PythonHelpers.HUNT_MODULE_SOURCE && current.trim() === PythonHelpers.HUNT_MODULE_VERSION)
+          const changed = files.filter(([, source], index) => onDisk[index] !== source);
+          if (changed.length === 0 && current.trim() === PythonHelpers.HUNT_MODULE_VERSION)
             return dir;
           await deps2.mkdir(dir);
-          await deps2.writeFile(target, PythonHelpers.HUNT_MODULE_SOURCE);
+          for (const [name21, source] of changed)
+            await deps2.writeFile(path12.join(dir, name21), source);
           await deps2.writeFile(stamp, PythonHelpers.HUNT_MODULE_VERSION);
         } catch {}
         return dir;
       })();
       ensureTasks.set(dir, task);
+      task.then(() => ensureTasks.delete(dir), () => ensureTasks.delete(dir));
       return task;
     }
     PythonHelpers.ensure = ensure;
@@ -52893,7 +52906,7 @@ async function inspectExecutionRuntime(cwd, env = process.env, options) {
     managedVenvPath: environment.selection.managedVenvPath,
     discovered,
     missing: expected.filter((command) => !discovered.includes(command)),
-    helperAvailable: await Bun.file(path15.join(helperDir, "hunt.py")).exists(),
+    helperAvailable: (await Promise.all(Object.keys(HUNT_MODULE_FILES).map((name21) => Bun.file(path15.join(helperDir, name21)).exists()))).every(Boolean),
     helperDir
   };
 }
@@ -52902,6 +52915,7 @@ var init_inspect = __esm(() => {
   init_environment();
   init_python();
   init_python_helpers();
+  init_hunt_modules();
 });
 
 // ../execution-runtime/src/index.ts
@@ -62183,7 +62197,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.201");
+    console.log("1.0.202");
     process.exit(0);
   }
   if (args[0] === "dashboard") {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "kifaru",
-  "version": "1.0.201",
-  "gitHead": "f34d6f06db9f2e0011e4d2925046342d0ecbe330",
+  "version": "1.0.202",
+  "gitHead": "f0ed02a29c377ac2fb3f4fadac922f37302c5992",
   "description": "Kifaru security agent on the Pi runtime",
   "type": "module",
   "license": "MIT",