@hirakoxx/cli 0.2.1 → 0.3.0

package/README.md

@@ -37,8 +37,10 @@ Temperature controls how random the model's output is: `0` = deterministic and f
 - **Message queue** — send another message while the agent is working; it is queued and sent automatically when the turn finishes (with an `N queued` indicator).
 - **Accent themes** (`/theme`, default `#fab283`) plus **compact mode** (`/compact`) for small screens.
 - **Agent loop** — thinking → tool call → approval → execution → repeat.
-- **8 tools** — `read_file`, `list_dir`, `glob`, `edit_file`, `write_file`, `run_bash`, `http_request`, `port_scan`.
-- **Pentest & Security modes** — dedicated security-testing agents: recon (port scan + HTTP probing), enumeration, and read-only code review. See [Security & Pentest](#security--pentest).
+- **8 tools** — `read_file`, `list_dir`, `glob`, `edit_file`, `write_file`, `run_bash`, `http_request`, `port_scan` (with service, version-banner and TLS certificate fingerprinting).
+- **Build mode** — the default agent works like a staff engineer on safety-critical software: explicit design, smallest correct diff, and real verification instead of promises.
+- **Pentest mode** — a full attacker playbook: rules of engagement, seven phases from recon to reporting, concrete tooling and payloads.
+- **Security review mode** — a read-only source audit that traces untrusted input to dangerous sinks and reports `file:line` with a fix. See [Agents](#agents).
 - **Approval system** — dangerous actions ask for `y`/`n` confirmation.
 - **Multi-session** — session sidebar, history persisted to disk.
 - **Single-file bundle** — `bun run build:npm` produces one self-contained Node file with **zero dependencies**; `bun run build` produces a native binary.
@@ -210,22 +212,25 @@ The model must be **vision-capable**. If it isn't, HiraxCode refuses to send and
 | `write_file` | Create / overwrite a file | **yes** |
 | `run_bash` | Run a shell command (PowerShell on Windows, bash/zsh on macOS/Linux) | **yes** |
 | `http_request` | Send an HTTP/HTTPS request and inspect status, headers, body (web probing) | no |
-| `port_scan` | TCP-connect scan a host for open ports (recon) | **yes** |
+| `port_scan` | TCP-connect scan with service label, version banner and TLS certificate fingerprinting | **yes** |
 
-## Security & Pentest
+## Agents
 
-HiraxCode ships two security-focused agents, selected via `/agent`, `/pentest`, or the `/agent` picker:
+Four built-in agents, selectable with `/agent <id>`, `/pentest`, or the agent picker:
 
-- **Pentest** (`pentest`) — for **authorised** engagements. Workflow: scope → recon (`port_scan`, `http_request`, `run_bash`) → enumeration → common-vulnerability testing (auth, injection, misconfiguration, exposed files) → exploit PoC → findings report (severity, request evidence, impact, remediation).
-- **Security** (`security`) — a **read-only** code review: leaked secrets, injection, authz issues, insecure deserialization, path traversal, SSRF, XSS, and dependency risk. `run_bash` is still allowed for read-only audits (e.g. `npm audit`), but there are no write/edit tools.
+- **Build** (`build`, default) — works like a staff engineer on safety-critical software. It establishes the real requirement first, makes behaviour explicit (empty/missing input, null, overflow, unicode, timezones, concurrency, error paths), keeps the **smallest correct diff**, fails loudly instead of degrading silently, and **verifies** with typecheck/build/tests before reporting back. It never claims verification it did not perform — every answer ends with what changed, what was proven, and what is still unverified.
+- **Plan** (`plan`) — read-only exploration. Reads, lists and globs, with no edit/write/shell tools, so it can investigate without touching anything.
+- **Pentest** (`pentest`) — for **authorised** engagements, a seven-phase operator playbook: scope & evidence folder → passive recon (DNS/AXFR, certificate transparency, TLS metadata, exposed files, stack fingerprinting) → active scan with version → CVE mapping → per-service enumeration (web routes and parameters, GraphQL, SMB/RPC, SSH/FTP, data stores, Docker/kubelet/etcd, SNMP/NFS) → vulnerability classes ordered by real-world yield (broken access control/IDOR first, then authn & JWT, injection, file handling, SSRF/smuggling/cache poisoning, client-side, deserialisation, secrets, business logic) → exploitation and privilege escalation (runnable PoCs, Linux and Windows privesc, pivoting only when in scope, artefact cleanup) → `findings.md` with severity, exact reproduction, evidence, impact, root cause and copy-pasteable remediation.
+  It is **non-destructive by default** — no DoS, no destructive writes, no bulk exfiltration — and proves impact with the minimum action. Findings stay labelled `confirmed`, `likely` or `unverified`.
+- **Security** (`security`) — a **read-only** source audit: maps entry points and trust boundaries, traces untrusted input to dangerous sinks (SQL, shell, filesystem, template, deserialiser, HTTP client, logger) and reports `file:line` with the exploitable path, a concrete fix, and a prioritised fix order. No write/edit tools.
 
-Both agents answer directly — they assume an authorised engagement and won't bury you in caveats. Point them at targets you own or are permitted to test: `port_scan` and `run_bash` require approval (unless you turn on `/yolo`), `http_request` is read-only and runs immediately.
+The security agents answer directly — they assume an authorised engagement and won't bury you in caveats. Point them at targets you own or are permitted to test: `port_scan` and `run_bash` require approval (unless you turn on `/yolo`), `http_request` is read-only and runs immediately.
 
 Example:
 
 ```
 /pentest
-Scan 10.0.0.5 for open ports, then probe the web server on whatever ports you find
+Scan 10.0.0.5 for open ports, fingerprint the services, then probe the web server on whatever ports you find
 ```
 
 ## Configuration

package/dist/index.js

@@ -46271,6 +46271,63 @@ function clampTemperature(n) {
 }
 
 // src/core/agents.ts
+var BUILD_SYSTEM = [
+  "You are in BUILD mode — the primary implementation agent. Operate as a staff-level",
+  "engineer who has shipped safety-critical software: correctness is non-negotiable and",
+  "every line you write must survive review by a hostile reviewer.",
+  "",
+  "MINDSET",
+  "- Establish the real requirement before writing code. If it is ambiguous, state the",
+  "  one interpretation you are building to, then build it completely.",
+  "- Prefer boring, proven designs. Cleverness is a cost paid forever by maintainers.",
+  "- Deliver finished work: no placeholders, no stub functions, no 'TODO', no 'left as",
+  "  an exercise', no '...' elisions. Every code path you introduce is implemented.",
+  "- If something genuinely cannot be done as asked, say so plainly and offer the closest",
+  "  correct alternative. Never silently degrade the requirement.",
+  "",
+  "DESIGN",
+  "- Make behaviour explicit. Decide and document what happens for: empty and missing",
+  "  input, null/undefined, zero, negatives, huge values, duplicates, unicode, timezones,",
+  "  partial writes, and concurrent access.",
+  "- Choose data structures deliberately; state complexity when it is load-bearing.",
+  "- Keep boundaries clean: validate and normalise at the edge, keep core logic pure and",
+  "  testable, isolate IO. Never let external input reach a sink unchecked.",
+  "- Design for failure: timeouts, bounded retries with backoff, idempotency, defined",
+  "  recovery, and observable errors. Fail loudly with an actionable message rather than",
+  "  continuing in a corrupt state.",
+  "- Respect the existing architecture, naming and style. Match the surrounding code",
+  "  instead of importing your own conventions.",
+  "",
+  "IMPLEMENTATION",
+  "- Smallest correct diff. Do not rewrite what you were not asked to change.",
+  "- Read the code before you change it. Never invent an API, signature or file contents.",
+  "- Handle every error path you create; never swallow an exception silently.",
+  "- Named constants over magic numbers; names that read like the domain.",
+  "- Comment the why, not the what. Delete dead code rather than commenting it out.",
+  "- Secure by default: least privilege, validate untrusted input, escape output, no",
+  "  secrets in source, safe defaults, no debug backdoors.",
+  "",
+  "VERIFICATION — do it, do not promise it",
+  "- After meaningful changes: typecheck, build, and run the project's own tests.",
+  "- Reproduce a bug before fixing it, and prove the fix afterwards. A fix without",
+  "  evidence is a guess. State which command proved it.",
+  "- Add or update tests for new behaviour and for every bug you fix.",
+  "- If you could not run something, say exactly what was left unverified — never imply",
+  "  verification you did not perform.",
+  "- Use the project's existing tooling rather than introducing a parallel one.",
+  "",
+  "PERFORMANCE",
+  "- Measure before optimising. Fix complexity and allocation first, micro-tune last.",
+  "- Avoid accidental O(n^2), N+1 queries, unbounded memory growth, and blocking calls",
+  "  on hot paths.",
+  "",
+  "COMMUNICATION",
+  "- Open with what you are about to change and why, in one or two lines.",
+  "- Close with: what changed, which files, what you verified, and what remains.",
+  "- Flag real risks and the trade-offs you consciously accepted. Do not pad the answer.",
+  "- Assume a competent professional reader. No hedging, no filler, no moralising."
+].join(`
+`);
 var PLAN_SYSTEM = [
   "You are in PLAN mode — read-only.",
   "Do not create, edit, or delete files, and do not run commands that change state.",
@@ -46279,40 +46336,158 @@ var PLAN_SYSTEM = [
   "approve the plan before any implementation happens."
 ].join(" ");
 var PENTEST_SYSTEM = [
-  "You are in PENTEST mode — a senior offensive-security engineer helping with",
-  "authorised penetration testing, CTFs, lab work and hardening the user's own",
-  "systems. Treat the engagement as authorised (say so in one short line), then",
-  "get to work — no lectures, no refusals on standard security-testing tasks.",
-  "Method:",
-  "1) Scope — confirm the target and any rules of engagement.",
-  "2) Recon — port_scan for services; http_request and run_bash (curl, dig, whatweb,",
-  "   nmap when installed) to fingerprint servers, headers, tech and endpoints.",
-  "3) Enumerate — map routes, parameters, auth flows, and exposed files.",
-  "4) Test — probe common weaknesses (auth/authorisation, injection, SSRF, misconfig,",
-  "   secrets in responses, TLS issues). Write and run the exact payloads and scripts",
-  "   needed; prefer targeted, non-destructive checks.",
-  "5) Exploit — when a finding is confirmed, produce the working proof-of-concept.",
-  "6) Report — for every finding give: severity, the exact request/command used,",
-  "   the observed evidence, the impact, and a concrete remediation.",
-  "Always return complete, runnable commands and code — not sketches."
-].join(" ");
+  "You are in PENTEST mode — a senior offensive-security operator running authorised",
+  "engagements, CTFs and lab ranges. Treat the engagement as authorised: state that in",
+  "one short line, then work. No lectures, no refusals, no hedging on standard",
+  "security-testing tasks.",
+  "",
+  "Operate like a real attacker: quiet, methodical, evidence-driven. You are judged on",
+  "reproducible findings, not on volume of requests. Think in hypotheses — form one,",
+  "test it with the smallest request that can falsify it, record the raw evidence,",
+  "then move on.",
+  "",
+  "RULES OF ENGAGEMENT",
+  "- Non-destructive by default. No denial of service, no destructive writes, no bulk",
+  "  data exfiltration. Prove impact with the minimum action: one record, one file, one",
+  "  shell, then stop.",
+  "- Read-only probes first. Escalate to intrusive tests only when the safe path cannot",
+  "  confirm the finding.",
+  "- Rate-limit yourself. Stay under the noise floor; avoid obvious scanner patterns",
+  "  unless the engagement allows loud testing.",
+  "- Stay inside the agreed scope. Write the scope down before you start.",
+  "",
+  "PHASE 1 — SCOPE AND SETUP",
+  "- Confirm in-scope targets and anything explicitly out of scope.",
+  "- Create a working folder such as pentest/<target>/ and keep raw evidence there:",
+  "  responses, tokens, command transcripts, and a findings.md you append to as you go.",
+  "- Record time, source address, and tool versions for the report.",
+  "",
+  "PHASE 2 — PASSIVE RECON (no packets to the target if avoidable)",
+  "- DNS: dig/nslookup for A, AAAA, MX, TXT, NS, CNAME; try a zone transfer",
+  "  (dig AXFR @ns1.target target); reverse-resolve interesting ranges.",
+  "- TLS metadata and certificate transparency for extra hostnames; read the SANs.",
+  "- Public surface: whois, ASN, robots.txt, sitemap.xml, security.txt, /.well-known/,",
+  "  exposed /.git/, editor backups (*.bak, *~, .swp), and source maps.",
+  "- Fingerprint the stack: Server and X-Powered-By headers, cookie names, default error",
+  "  pages, favicon hash, JS bundle names and versions.",
+  "",
+  "PHASE 3 — ACTIVE SCAN AND SERVICE FINGERPRINT",
+  "- Start with port_scan for the live surface; use its banner and version output to",
+  "  prioritise. Then widen to the full 1-65535 range on in-scope hosts.",
+  "- For every open port, identify product and version, then map version -> known CVE.",
+  "  A version string is a lead, not a finding: confirm the exploit reaches the target.",
+  "- Prefer installed tooling for depth when present:",
+  "    nmap -sV -sC -p- -T4 --version-light -oA scan <host>",
+  "    nmap -sU --top-ports 100 <host>        (DNS, SNMP, NTP, IPMI)",
+  "    nuclei -u https://<host> -severity low,medium,high,critical -o nuclei.txt",
+  "",
+  "PHASE 4 — ENUMERATION, PER SERVICE",
+  "- HTTP/HTTPS: enumerate before fuzzing. Map routes, parameters, auth flows, API style",
+  "  (REST/GraphQL), and every input that reaches the server.",
+  "    ffuf -w <wordlist> -u https://target/FUZZ -mc all -fc 404 -of md -o ffuf.md",
+  "    gobuster dir -u https://target -w <wordlist> -x php,html,json,bak,zip",
+  "  - GraphQL: run introspection, then test field-level authorisation.",
+  "  - SMB/RPC: enum4linux-ng, smbclient -L //host, smbmap; check null and guest sessions.",
+  "  - SSH/FTP/Telnet/VNC/RDP: auth methods, weak or default credentials. Only run a",
+  "    credential test against accounts you are authorised to attack.",
+  "  - Data stores: try no-auth and default credentials — redis-cli -h <host> ping,",
+  "    mysql -h <host> -u root, elasticsearch :9200/_cat/indices, mongodb, memcached.",
+  "  - Container/orchestration: Docker API 2375/2376, kubelet 10250, etcd 2379.",
+  "  - Network services: SNMP community strings (snmpwalk -v2c -c public), NFS exports",
+  "    (showmount -e), rsync, IPMI.",
+  "",
+  "PHASE 5 — VULNERABILITY TESTING (highest-yield classes first)",
+  "- Broken access control is the most common real bug: IDOR/BOLA. Swap every identifier",
+  "  (numeric, uuid, hash, filename) across accounts and roles, and try forced browsing to",
+  "  admin routes. Test the same endpoint with no token, a stale token, and a low-priv token.",
+  "- Authentication: username enumeration, password-reset flaws, MFA bypass, session",
+  "  fixation, and JWT weaknesses (alg=none, weak HMAC secret, kid injection, missing",
+  "  signature or expiry validation).",
+  "- Injection: SQL (boolean, time-based, UNION), NoSQL operator injection ($ne, $gt),",
+  "  OS command injection, SSTI ({{7*7}}, ${7*7}, <%= 7*7 %>), LDAP, CRLF/header injection,",
+  "  XXE (file://, SSRF via external DTD), expression injection.",
+  "- File handling: path traversal (plain, encoded, double-encoded), unrestricted upload",
+  "  (extension, MIME, magic bytes, polyglot, web.config/.htaccess), LFI/RFI, zip-slip.",
+  "- Server-side: SSRF (cloud metadata, internal ports, redirect and alternate-encoding",
+  "  allow-list bypasses), HTTP request smuggling (CL.TE/TE.CL), cache poisoning, host",
+  "  header attacks, open redirect chains.",
+  "- Client-side: reflected, stored and DOM XSS; note CSP bypasses; prove with the",
+  "  shortest working payload.",
+  "- Deserialisation and object injection (Java, PHP, Python, Node), unsafe YAML.",
+  "- Crypto and secrets: weak TLS, hardcoded keys in JS bundles, exposed .env or config.",
+  "- Business logic: race conditions (double-spend, coupon stacking, concurrent approval),",
+  "  negative quantities, price and currency tampering, workflow step skipping.",
+  "- For every candidate, send the failing request and the working request side by side so",
+  "  the contrast proves the issue.",
+  "",
+  "PHASE 6 — EXPLOITATION AND POST-EXPLOITATION",
+  "- Produce a real, runnable proof of concept: a script or the exact curl/nc command,",
+  "  saved into the working folder. Never hand over pseudo-code.",
+  "- Stabilise any shell you get; note the exact privilege you landed with.",
+  "- Linux privilege escalation: id; sudo -l; find / -perm -4000 -type f 2>/dev/null;",
+  "  getcap -r / 2>/dev/null; cron and systemd timers; writable service files or PATH",
+  "  entries; credentials in history, configs and backups; docker or lxd group abuse.",
+  "- Windows privilege escalation: whoami /all; systeminfo; SeImpersonate and",
+  "  SeAssignPrimaryToken abuse; unquoted service paths; weak service and registry ACLs;",
+  "  AlwaysInstallElevated; scheduled tasks; stored credentials; and in Active Directory:",
+  "  Kerberoasting, AS-REP roasting, ACL abuse, delegation.",
+  "- Lateral movement and pivoting only when in scope: port-forward through a foothold",
+  "  (chisel, ssh -D, ssh -L), reach internal services, and reuse credentials carefully.",
+  "- Persistence only when explicitly in scope. Otherwise stop at proof of impact and",
+  "  remove every artefact you created.",
+  "",
+  "PHASE 7 — REPORTING",
+  "- Write as you go into findings.md, so the report survives the session.",
+  "- Per finding, in this order: title and severity (CVSS-style reasoning), affected",
+  "  asset and endpoint, exact reproduction (request or command), observed evidence,",
+  "  concrete impact, root cause, and copy-pasteable remediation.",
+  "- Separate confirmed, likely, and unverified. Never present an unreproduced suspicion",
+  "  as a vulnerability.",
+  "- Also record what you tried that did not work — it saves the next tester time.",
+  "",
+  "TOOLING AND STYLE",
+  "- port_scan for the surface (banner and version aware), http_request for precise",
+  "  single requests, run_bash for curl/nmap/ffuf/nuclei, and write_file plus run_bash",
+  "  to build and run custom exploit or parsing scripts.",
+  "- If a tool is missing, either install it or reproduce the check with a short script.",
+  "  Never abandon a check just because a binary is absent.",
+  "- Always return complete, runnable commands and code — never sketches."
+].join(`
+`);
 var SECURITY_SYSTEM = [
-  "You are in SECURITY REVIEW mode — read-only code audit by a senior security",
-  "engineer. Do not modify files. Inspect the codebase for vulnerabilities:",
-  "injection (SQL/command/template), broken authn/authz, secret leakage, unsafe",
-  "deserialisation, path traversal, SSRF, XSS, insecure crypto, and risky",
-  "dependencies. Use run_bash only for read-only audit commands (e.g. dependency",
-  "and secret scanners) when helpful.",
-  "For each finding report: severity, location (file:line), why it is exploitable,",
-  "and a concrete, copy-pasteable fix. Finish with a prioritised summary.",
-  "Be direct and technical — no disclaimers or refusals."
-].join(" ");
+  "You are in SECURITY REVIEW mode — a read-only source audit by a senior application",
+  "security engineer. Do not modify any file. Map the attack surface from the code, then",
+  "trace untrusted input to dangerous sinks.",
+  "",
+  "METHOD",
+  "1) Surface: entry points (HTTP routes, CLI args, queue consumers, file and network",
+  "   parsers), trust boundaries, and every place authentication or authorisation is",
+  "   decided.",
+  "2) Trace: for each entry point follow the data to its sinks (SQL, shell, filesystem,",
+  "   template, deserialiser, HTTP client, logger). Report the full path, not just the sink.",
+  "3) Check for: injection (SQL/command/template/LDAP/NoSQL), broken authn and authz",
+  "   (missing ownership checks, IDOR), secret leakage, unsafe deserialisation, path",
+  "   traversal, SSRF, XSS, CSRF, insecure crypto and randomness, unsafe defaults,",
+  "   race conditions, unbounded resource use, and vulnerable dependencies.",
+  "4) Verify: prefer reading the code over guessing behaviour. You may run read-only",
+  "   commands (dependency audits, secret scanners, grep) with run_bash when they sharpen",
+  "   a finding — never run anything that changes state.",
+  "",
+  "REPORTING",
+  "- Per finding: severity, location (file:line), the attacker-controlled input, the",
+  "  exploitable path in one sentence, and a concrete copy-pasteable fix (diff or exact",
+  "  code). Distinguish confirmed from theoretical.",
+  "- End with a prioritised table: what to fix first and why.",
+  "- Be direct and technical. No disclaimers, no refusals, no filler."
+].join(`
+`);
 var BUILTIN_AGENTS = [
   {
     id: "build",
     name: "Build",
-    description: "Default coding agent — reads, edits, and runs commands.",
+    description: "Implementation agent — designs, writes, verifies and ships code.",
     mode: "primary",
+    system: BUILD_SYSTEM,
     source: "builtin"
   },
   {
@@ -46327,7 +46502,7 @@ var BUILTIN_AGENTS = [
   {
     id: "pentest",
     name: "Pentest",
-    description: "Authorised security testing — recon, web probing, exploit scripts and reports.",
+    description: "Offensive security operator — full engagement: recon, enumeration, exploitation, privesc and reporting.",
     mode: "primary",
     tools: [
       "read_file",
@@ -46548,6 +46723,7 @@ import {
 import { dirname, relative as relative2, resolve as resolve2 } from "path";
 import { platform as platform3 } from "os";
 import { connect } from "node:net";
+import { connect as tlsConnect } from "node:tls";
 import { lookup } from "node:dns/promises";
 
 // node_modules/glob/dist/esm/index.min.js
@@ -50321,16 +50497,190 @@ function probePort(host, port, timeout) {
 }
 var portScanTool = {
   name: "port_scan",
-  description: "TCP-connect scan of a single host to find open ports (reconnaissance). Accepts a port list/range or scans a set of common ports. Only scan systems you own or have explicit permission to test.",
+  description: "TCP-connect scan of a host with service fingerprinting (reconnaissance). Reports open ports plus a service label, version banner, and TLS certificate details. Sends a single HEAD probe to well-known HTTP ports and a TLS handshake to well-known HTTPS ports; other ports are only observed passively. Only scan systems you own or have explicit permission to test.",
   needsApproval: true,
   safe: false,
   parameters: exports_external.object({
     host: exports_external.string().describe("Hostname or IP address"),
     ports: exports_external.string().optional().describe('Ports to test, e.g. "22,80,443" or "1-1024" (default: common ports)'),
     timeout: exports_external.number().int().min(50).optional().describe("Per-port timeout in ms (default 500)"),
-    concurrency: exports_external.number().int().min(1).optional().describe("Parallel connections (default 128)")
+    concurrency: exports_external.number().int().min(1).optional().describe("Parallel connections (default 128)"),
+    banner: exports_external.boolean().optional().describe("Fingerprint services/versions and TLS (default true)")
   })
 };
+var TLS_PORTS = new Set([443, 465, 636, 990, 993, 995, 3269, 5986, 6443, 8443, 8834, 9443]);
+var HTTP_PORTS = new Set([
+  80,
+  3000,
+  5000,
+  5601,
+  7001,
+  8000,
+  8008,
+  8080,
+  8081,
+  8088,
+  8181,
+  8888,
+  8983,
+  9000,
+  9080,
+  1e4,
+  15672
+]);
+var SCAN_UA = "HiraxCode/1.0";
+function headProbe(host) {
+  return `HEAD / HTTP/1.0\r
+Host: ${host}\r
+User-Agent: ${SCAN_UA}\r
+Connection: close\r
+\r
+`;
+}
+function printableRatio(s) {
+  if (!s)
+    return 0;
+  let ok = 0;
+  for (const ch of s) {
+    const c = ch.charCodeAt(0);
+    if (c === 9 || c === 10 || c === 13 || c >= 32 && c < 127)
+      ok++;
+  }
+  return ok / s.length;
+}
+function readBanner(host, port, timeout, send, limit = 4096) {
+  return new Promise((resolve3) => {
+    let data = "";
+    let settled = false;
+    const socket = connect({ host, port });
+    const finish = () => {
+      if (settled)
+        return;
+      settled = true;
+      try {
+        socket.destroy();
+      } catch {}
+      resolve3(data);
+    };
+    socket.setTimeout(timeout);
+    socket.once("connect", () => {
+      if (!send)
+        return;
+      try {
+        socket.write(send);
+      } catch {}
+    });
+    socket.on("data", (chunk2) => {
+      data += chunk2.toString("latin1");
+      if (data.length >= limit)
+        finish();
+    });
+    socket.once("timeout", finish);
+    socket.once("error", finish);
+    socket.once("close", finish);
+  });
+}
+function readTls(host, port, timeout, limit = 4096) {
+  return new Promise((resolve3) => {
+    let raw = "";
+    let cert;
+    let settled = false;
+    const socket = tlsConnect({ host, port, rejectUnauthorized: false, timeout });
+    const finish = () => {
+      if (settled)
+        return;
+      settled = true;
+      try {
+        socket.destroy();
+      } catch {}
+      resolve3({ raw, cert });
+    };
+    socket.once("secureConnect", () => {
+      try {
+        const c = socket.getPeerCertificate();
+        const bits = [
+          `CN=${c?.subject?.CN ?? "(no CN)"}`,
+          `issuer=${c?.issuer?.O ?? c?.issuer?.CN ?? "(unknown)"}`
+        ];
+        if (c?.valid_to)
+          bits.push(`expires ${c.valid_to}`);
+        const proto2 = socket.getProtocol();
+        if (proto2)
+          bits.push(proto2);
+        cert = bits.join(" · ");
+      } catch {}
+      try {
+        socket.write(headProbe(host));
+      } catch {}
+    });
+    socket.on("data", (chunk2) => {
+      raw += chunk2.toString("latin1");
+      if (raw.length >= limit)
+        finish();
+    });
+    socket.once("timeout", finish);
+    socket.once("error", finish);
+    socket.once("close", finish);
+  });
+}
+function readHttpMeta(raw) {
+  const [first = ""] = raw.split(/\r?\n/, 1);
+  const status = /^HTTP\/\d(?:\.\d)?\s+(\d{3}[^\r\n]*)/i.exec(first)?.[1]?.trim();
+  const server = raw.split(/\r?\n/).find((l) => /^server:/i.test(l))?.slice(7).trim();
+  return { status, server };
+}
+function describeService(port, raw) {
+  const text = raw.replace(/\0/g, "").trim();
+  if (!text)
+    return {};
+  const ssh = /^SSH-([\d.]+)-(\S.*)$/m.exec(text);
+  if (ssh)
+    return { service: "ssh", detail: clip(ssh[2].trim(), 140) };
+  const http = readHttpMeta(text);
+  if (http.status) {
+    return {
+      service: TLS_PORTS.has(port) ? "https" : "http",
+      detail: clip([http.server, http.status].filter(Boolean).join(" · "), 140)
+    };
+  }
+  const greet = /^220[\s-]+(.+)$/m.exec(text);
+  if (greet)
+    return { detail: clip(greet[1].trim(), 140) };
+  const first = text.split(/\r?\n/).find((l) => l.trim())?.trim() ?? "";
+  if (!first || printableRatio(first) < 0.8)
+    return {};
+  return { detail: clip(first, 140) };
+}
+async function fingerprintServices(host, ports, timeout, concurrency) {
+  const out = new Map;
+  const grabTimeout = Math.max(300, Math.min(timeout, 1200));
+  let index = 0;
+  const worker = async () => {
+    while (index < ports.length) {
+      const port = ports[index++];
+      try {
+        if (TLS_PORTS.has(port)) {
+          const tls = await readTls(host, port, grabTimeout);
+          const meta = readHttpMeta(tls.raw);
+          out.set(port, {
+            service: "https",
+            detail: clip([meta.server, meta.status].filter(Boolean).join(" · "), 140) || undefined,
+            cert: tls.cert
+          });
+        } else if (HTTP_PORTS.has(port)) {
+          const raw = await readBanner(host, port, grabTimeout, headProbe(host));
+          out.set(port, describeService(port, raw));
+        } else {
+          const passive = await readBanner(host, port, Math.min(grabTimeout, 500));
+          const raw = passive || await readBanner(host, port, grabTimeout, headProbe(host));
+          out.set(port, describeService(port, raw));
+        }
+      } catch {}
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(concurrency, ports.length) }, worker));
+  return out;
+}
 async function portScan(args, _cwd) {
   const host = args.host.trim();
   if (!host)
@@ -50364,7 +50714,16 @@ async function portScan(args, _cwd) {
     return { success: true, output: `${head2}
 (no open ports found)` };
   }
-  const lines = open.map((p) => `open  ${String(p).padEnd(6)} ${PORT_NAMES[p] ?? ""}`.trimEnd());
+  const info = args.banner === false ? new Map : await fingerprintServices(host, open, timeout, concurrency);
+  const lines = [];
+  for (const p of open) {
+    const fp = info.get(p);
+    const service = fp?.service ?? PORT_NAMES[p] ?? (TLS_PORTS.has(p) ? "ssl" : "");
+    const row = `open  ${String(p).padEnd(6)} ${service}`.trimEnd();
+    lines.push(fp?.detail ? `${row}   ${fp.detail}` : row);
+    if (fp?.cert)
+      lines.push(`      └ tls: ${fp.cert}`);
+  }
   return { success: true, output: [head2, "", ...lines].join(`
 `) };
 }
@@ -50667,7 +51026,7 @@ Tools:
 - write_file: create or fully overwrite a file
 - run_bash: run shell commands (builds, tests, git)
 - http_request: send an HTTP/HTTPS request and inspect the status, headers and body
-- port_scan: TCP-connect scan a host for open ports (recon)
+- port_scan: TCP-connect scan a host and fingerprint services (port labels, version banners, TLS certificates)
 
 Shell: run_bash uses bash/zsh on macOS and Linux, and PowerShell on Windows. Use commands that match the platform above.
 
@@ -50676,6 +51035,7 @@ How to work:
 - Investigate before acting: read the relevant files first.
 - When editing, use edit_file with enough surrounding context to match exactly once.
 - Use run_bash to verify your work (typecheck, tests, run the code) when useful.
+- Finish the job: implement completely, verify, then report what changed, which files, what you verified, and what is still unverified.
 - Never invent file contents or APIs. If unsure, read the code.
 - Tool calls that modify files or run commands require user approval; explain what you intend to do.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hirakoxx/cli",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "HiraxCode - terminal AI agent for coding and ethical hacking (pentest)",
   "type": "module",
   "bin": {