job-pro 1.0.41 → 1.0.43

package/dist/index.js

@@ -143,6 +143,9 @@ USAGE
   job-pro list [--compact]            list all 50 companies + source family
   job-pro status [--compact]          survey profile / sessions / memory / chrome
   job-pro selftest [--compact]        end-to-end check: search → schema → echo-submit
+  job-pro recon [--companies a,b,c]   probe every adapter's submit_endpoint
+                                      (classifies as verified-real / 404 /
+                                      html-fallthrough / external)
   job-pro profile init [--interactive] [--force]
                                       write ~/.jobpro/profile.json
                                       --interactive fills it via prompts.
@@ -1212,6 +1215,124 @@ async function main() {
         printStatus(compact);
         return;
     }
+    if (cmd === "recon") {
+        // Probe every adapter's submit_endpoint anonymously and classify the
+        // response. Catches upstream URL drift (the path went 404 because
+        // upstream renamed it) and is the same probe routine I used by hand
+        // to populate endpoint_verified for the 15 verified adapters.
+        const compact = args.includes("--compact");
+        const { args: aCompanies, value: companiesStr } = popFlagValue(args, "--companies");
+        void aCompanies;
+        const scope = companiesStr
+            ? companiesStr.split(",").map((s) => s.trim()).filter(Boolean)
+            : Object.keys(ADAPTERS);
+        function classify(status, body, contentType) {
+            const isHTML = contentType.includes("html") || body.trim().startsWith("<");
+            if (status === 404)
+                return isHTML ? "html-fallthrough" : "speculative-404";
+            if (isHTML)
+                return "html-fallthrough";
+            // 401/403/200-with-error-body/405/4xx-with-business-error = real route
+            return "verified-real";
+        }
+        function withTimeout(p, ms) {
+            return Promise.race([
+                p,
+                new Promise((resolve) => setTimeout(() => resolve(null), ms)),
+            ]);
+        }
+        const results = await Promise.all(scope.map(async (company) => {
+            // lilith uses CDP (puppeteer launches Chrome) — its withTimeout
+            // returns but the browser handle keeps the event loop alive, so
+            // the process never exits. Skip it explicitly; users who want to
+            // recon lilith can scope --companies=lilith and accept the hang.
+            if (company === "lilith") {
+                return { company, classification: "probe-error", detail: "skipped — CDP adapter (puppeteer); pass --companies=lilith explicitly to probe" };
+            }
+            const adapter = ADAPTERS[company];
+            if (!adapter)
+                return { company, classification: "probe-error", detail: "unknown adapter" };
+            if (typeof adapter.fetchApplicationSchema !== "function") {
+                return { company, classification: "probe-error", detail: "no fetchApplicationSchema" };
+            }
+            // Use a placeholder post_id so we don't have to search.
+            // Per-step timeout protects against slow / hung adapters.
+            let schema = null;
+            try {
+                const r = await withTimeout(adapter.fetchApplicationSchema("recon-probe"), 10000);
+                if (r?.ok && r.schema)
+                    schema = r.schema;
+            }
+            catch { }
+            if (!schema) {
+                try {
+                    const list = await withTimeout(adapter.searchPositions({ pageSize: 1 }), 10000);
+                    const pid = list?.positions?.[0]?.post_id;
+                    if (pid) {
+                        const r = await withTimeout(adapter.fetchApplicationSchema(pid), 10000);
+                        if (r?.ok && r.schema)
+                            schema = r.schema;
+                    }
+                }
+                catch { }
+            }
+            if (!schema)
+                return { company, classification: "probe-error", detail: "schema unavailable" };
+            if (schema.submit_kind === "external") {
+                return { company, submit_kind: schema.submit_kind, classification: "external", detail: "structurally external (Liepin / WeChat)" };
+            }
+            const url = schema.submit_endpoint ?? "";
+            if (!url)
+                return { company, submit_kind: schema.submit_kind, classification: "no-endpoint", detail: "no submit_endpoint in schema" };
+            try {
+                const r = await fetch(url, { method: "POST", headers: { "content-type": "application/json" }, body: "{}" });
+                const body = await r.text();
+                const ct = r.headers.get("content-type") ?? "";
+                return {
+                    company,
+                    submit_kind: schema.submit_kind,
+                    submit_endpoint: url,
+                    status: r.status,
+                    classification: classify(r.status, body, ct),
+                    detail: body.slice(0, 80).replace(/\s+/g, " "),
+                    already_verified: schema.endpoint_verified === true,
+                };
+            }
+            catch (err) {
+                return { company, submit_kind: schema.submit_kind, submit_endpoint: url, classification: "probe-error", detail: err instanceof Error ? err.message : String(err) };
+            }
+        }));
+        if (compact) {
+            console.log(JSON.stringify({ probed: results.length, results }));
+            return;
+        }
+        const tally = new Map();
+        for (const r of results)
+            tally.set(r.classification, (tally.get(r.classification) ?? 0) + 1);
+        const width = Math.max(...results.map((r) => r.company.length));
+        const ICON = {
+            "verified-real": "✓",
+            "speculative-404": "✗",
+            "html-fallthrough": "✗",
+            "external": "⛔",
+            "no-endpoint": "·",
+            "probe-error": "?",
+        };
+        console.log(`\njob-pro recon — endpoint probe across ${results.length} adapters`);
+        console.log(`  (anon POST with {} body; schema-verified adapters tagged 🟢)\n`);
+        for (const r of results) {
+            const tag = r.status ? `${r.status}` : "—";
+            const vTag = r.already_verified ? " 🟢" : "";
+            console.log(`  ${ICON[r.classification]} ${r.company.padEnd(width)}  ${tag.padEnd(4)} ${r.classification.padEnd(17)}${vTag}  ${r.detail}`);
+        }
+        console.log(`\n  Tally:`);
+        for (const [k, v] of [...tally.entries()].sort()) {
+            console.log(`    ${k.padEnd(20)}  ${v}`);
+        }
+        // Some adapters (cdp/lilith via puppeteer) keep the event loop alive
+        // after their probe resolves. Explicit exit guarantees the CLI returns.
+        process.exit(0);
+    }
     if (cmd === "selftest") {
         // Three end-to-end checks against the easiest adapter (xpeng, anon-submit):
         // 1. searchPositions returns >0 hits

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "job-pro",
-  "version": "1.0.41",
+  "version": "1.0.43",
   "description": "Query Chinese big-tech campus recruiting from your terminal. 50 companies, all 50 live. 46 via each company's own API; the 4 with no public canonical feed (Hikvision, CICC, Cainiao, WeBank) surfaced via Liepin as a clearly-labeled third-party fallback. No signup, no token, no server.",
   "homepage": "https://job.ha7ch.com",
   "repository": "https://github.com/HA7CH/job-pro",