job-pro 0.8.2 → 0.9.1

package/dist/apply.js

@@ -0,0 +1,272 @@
+// Phase 2 — auto-apply infrastructure.
+//
+// This module is intentionally read-only (dry-run) right now. The user
+// runs `job-pro <co> apply <postId>` and gets a fully-staged POST payload
+// printed to stdout. Actually firing the submission ("--really-submit")
+// is guarded: each adapter family must opt in by exporting an
+// `executeApplication` function. Out of the 50 adapters, only a handful
+// (Greenhouse boards / Lever boards) have well-documented public
+// submission APIs; the rest need session capture (Phase 2.1, separate
+// release).
+//
+// Profile shape — loaded from `~/.jobpro/profile.json` or via flags.
+// Fields beyond first_name / last_name / email / phone / resume are
+// passed through to whatever per-company custom question matches their
+// `name` (e.g. `linkedin_url`, `nationality`).
+import { readFileSync, existsSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, join } from "node:path";
+const PROFILE_PATH = process.env.JOB_PRO_PROFILE_PATH ?? join(homedir(), ".jobpro", "profile.json");
+const TEMPLATE = {
+    first_name: "",
+    last_name: "",
+    email: "",
+    phone: "",
+    resume_path: "",
+    cover_letter_text: "",
+    custom: {
+    // Common Greenhouse / Lever questions:
+    // question_<n>: "answer"
+    // linkedin_url: "https://www.linkedin.com/in/your-handle",
+    // nationality: "China",
+    },
+};
+export function loadProfile() {
+    if (!existsSync(PROFILE_PATH)) {
+        return {
+            ok: false,
+            message: `profile not found at ${PROFILE_PATH}. Run \`job-pro profile init\` to create a template, ` +
+                `or set $JOB_PRO_PROFILE_PATH to override.`,
+        };
+    }
+    let raw;
+    try {
+        raw = readFileSync(PROFILE_PATH, "utf8");
+    }
+    catch (err) {
+        return { ok: false, message: `could not read ${PROFILE_PATH}: ${err instanceof Error ? err.message : err}` };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (err) {
+        return { ok: false, message: `${PROFILE_PATH} is not valid JSON: ${err instanceof Error ? err.message : err}` };
+    }
+    for (const required of ["first_name", "last_name", "email", "phone"]) {
+        if (!parsed[required]) {
+            return { ok: false, message: `${PROFILE_PATH}: missing required field "${required}"` };
+        }
+    }
+    return { ok: true, profile: parsed };
+}
+export function profileTemplate() {
+    return { path: PROFILE_PATH, template: TEMPLATE };
+}
+/** Fill in known answers from the profile; flag any unanswered required fields. */
+export function stageApplication(schema, profile) {
+    const staged = [];
+    const unanswered_required = [];
+    for (const q of schema.questions) {
+        // The "primary" field is the first one; secondary fields are alternate
+        // formats (e.g. resume has both `resume` file + `resume_text` textarea).
+        const primary = q.fields[0];
+        if (!primary)
+            continue;
+        const filled = resolveAnswer(primary, profile);
+        const reason = filled.value || !q.required ? undefined : filled.reason;
+        const sf = {
+            name: primary.name,
+            type: primary.type,
+            value: filled.value,
+            required: q.required,
+            unanswered_reason: reason,
+        };
+        staged.push(sf);
+        if (q.required && !filled.value)
+            unanswered_required.push(sf);
+    }
+    return {
+        source: schema.source,
+        post_id: schema.post_id,
+        job_title: schema.job_title,
+        apply_url: schema.apply_url,
+        submit_endpoint: schema.submit_endpoint,
+        submit_method: schema.submit_method,
+        staged,
+        unanswered_required,
+        ready: unanswered_required.length === 0,
+    };
+}
+function resolveAnswer(field, profile) {
+    // Hard-coded standard mappings — these names are the canonical
+    // Greenhouse field names and are reused by Lever's submission form.
+    switch (field.name) {
+        case "first_name":
+            return { value: profile.first_name ?? "", reason: "profile.first_name missing" };
+        case "last_name":
+            return { value: profile.last_name ?? "", reason: "profile.last_name missing" };
+        case "email":
+            return { value: profile.email ?? "", reason: "profile.email missing" };
+        case "phone":
+            return { value: profile.phone ?? "", reason: "profile.phone missing" };
+        case "resume":
+            return {
+                value: profile.resume_path ?? "",
+                reason: "profile.resume_path missing — set to an absolute PDF/DOCX path",
+            };
+        case "resume_text":
+            // Optional companion field — leave empty if user supplies a file.
+            return { value: "", reason: "" };
+        case "cover_letter":
+            return { value: "", reason: "" };
+        case "cover_letter_text":
+            return { value: profile.cover_letter_text ?? "", reason: "" };
+        default:
+            // Custom passthroughs — match by question name (e.g. "question_36528765002").
+            const v = profile.custom?.[field.name];
+            if (typeof v === "string" && v.length > 0)
+                return { value: v, reason: "" };
+            return {
+                value: "",
+                reason: `unknown field "${field.name}" — add to profile.custom.${field.name} to auto-fill`,
+            };
+    }
+}
+// ---------- pretty-print for dry-run ----------
+export function formatStaged(s) {
+    const lines = [];
+    lines.push(`source:    ${s.source}`);
+    lines.push(`job:       ${s.post_id} — ${s.job_title}`);
+    lines.push(`apply_url: ${s.apply_url}`);
+    if (s.submit_endpoint) {
+        lines.push(`submit:    ${s.submit_method ?? "POST"} ${s.submit_endpoint}`);
+    }
+    lines.push("");
+    lines.push(`ready: ${s.ready ? "✓ all required fields filled" : `✗ ${s.unanswered_required.length} required field(s) unfilled`}`);
+    lines.push("");
+    lines.push("Staged payload:");
+    const widthName = Math.max(...s.staged.map((f) => f.name.length));
+    const widthType = Math.max(...s.staged.map((f) => f.type.length));
+    for (const f of s.staged) {
+        const flag = f.required ? "•" : " ";
+        const value = f.value
+            ? f.type === "input_file"
+                ? `<file: ${f.value}>`
+                : truncate(f.value, 60)
+            : f.unanswered_reason
+                ? `<unanswered: ${f.unanswered_reason}>`
+                : "<empty>";
+        lines.push(`  ${flag} ${f.name.padEnd(widthName)}  ${f.type.padEnd(widthType)}  ${value}`);
+    }
+    return lines.join("\n");
+}
+function truncate(s, n) {
+    return s.length > n ? s.slice(0, n - 1) + "…" : s;
+}
+export async function submitApplication(staged, target) {
+    if (!staged.submit_endpoint) {
+        return {
+            ok: false,
+            posted_to: "",
+            message: "no submit_endpoint on staged application — this adapter family doesn't expose a public submission API",
+        };
+    }
+    if (!staged.ready) {
+        return {
+            ok: false,
+            posted_to: "",
+            message: `${staged.unanswered_required.length} required field(s) still unanswered; fill them before submitting`,
+        };
+    }
+    if (target.kind === "dry-run") {
+        return {
+            ok: false,
+            posted_to: "dry-run (no network)",
+            message: "dry-run requested — no HTTP call fired",
+        };
+    }
+    const url = target.kind === "debug" ? target.url : staged.submit_endpoint;
+    const fd = await buildMultipartForm(staged);
+    let response;
+    try {
+        response = await fetch(url, {
+            method: staged.submit_method ?? "POST",
+            headers: {
+                // Don't set Content-Type — fetch/undici picks the correct
+                // multipart/form-data boundary for the FormData instance.
+                Accept: "application/json, text/plain, */*",
+                "User-Agent": "job-pro/0.9 (https://github.com/HA7CH/job-pro)",
+            },
+            body: fd,
+        });
+    }
+    catch (err) {
+        return {
+            ok: false,
+            posted_to: url,
+            message: `network error: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+    let preview = "";
+    try {
+        preview = (await response.text()).slice(0, 4000);
+    }
+    catch {
+        /* binary response is fine */
+    }
+    return {
+        ok: response.ok,
+        status: response.status,
+        posted_to: url,
+        response_preview: preview,
+        message: response.ok
+            ? `submission accepted (HTTP ${response.status})`
+            : `upstream rejected: HTTP ${response.status} ${response.statusText}`,
+    };
+}
+async function buildMultipartForm(staged) {
+    const fd = new FormData();
+    for (const field of staged.staged) {
+        if (!field.value)
+            continue;
+        if (field.type === "input_file") {
+            // Read the file synchronously — these are resumes, KB-range PDFs.
+            // For debug endpoints we still attach the actual file so the
+            // multipart wire format matches production exactly.
+            let stat;
+            try {
+                stat = statSync(field.value);
+            }
+            catch (err) {
+                throw new Error(`could not stat resume file ${field.value}: ${err instanceof Error ? err.message : err}`);
+            }
+            if (!stat.isFile()) {
+                throw new Error(`resume path is not a file: ${field.value}`);
+            }
+            const bytes = readFileSync(field.value);
+            const filename = basename(field.value);
+            // Best-effort content type from extension; ATS-side typically
+            // re-detects from magic bytes anyway.
+            const ext = filename.toLowerCase().split(".").pop() ?? "";
+            const mime = ext === "pdf"
+                ? "application/pdf"
+                : ext === "docx"
+                    ? "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+                    : ext === "doc"
+                        ? "application/msword"
+                        : "application/octet-stream";
+            // Node 20+ has a global File constructor; for older runtimes, fall
+            // back to a Blob. We bumped engines.node >=18 — Blob is universal.
+            const FileCtor = globalThis.File;
+            const part = typeof FileCtor === "function"
+                ? new FileCtor([new Uint8Array(bytes)], filename, { type: mime })
+                : new Blob([new Uint8Array(bytes)], { type: mime });
+            fd.append(field.name, part, filename);
+        }
+        else {
+            fd.append(field.name, field.value);
+        }
+    }
+    return fd;
+}

package/dist/greenhouse.js

@@ -356,6 +356,63 @@ export function createAdapter(cfg) {
                 "The only authority on selection is HR.",
         };
     }
+    async function fetchApplicationSchema(postId) {
+        const id = (postId ?? "").trim();
+        if (!id)
+            return { ok: false, source: SOURCE, message: "post_id is required" };
+        const url = `${API_ROOT}/jobs/${encodeURIComponent(id)}?questions=true`;
+        let response;
+        try {
+            response = await fetch(url, { headers: HEADERS });
+        }
+        catch (err) {
+            return {
+                ok: false,
+                source: SOURCE,
+                message: `network error: ${err instanceof Error ? err.message : String(err)}`,
+            };
+        }
+        if (!response.ok) {
+            return {
+                ok: false,
+                source: SOURCE,
+                message: `HTTP ${response.status}: ${response.statusText}`,
+            };
+        }
+        let job;
+        try {
+            job = (await response.json());
+        }
+        catch (err) {
+            return {
+                ok: false,
+                source: SOURCE,
+                message: `bad JSON: ${err instanceof Error ? err.message : String(err)}`,
+            };
+        }
+        const questions = (job.questions ?? []).map((q) => ({
+            label: q.label ?? "",
+            description: q.description ?? null,
+            required: q.required ?? false,
+            fields: (q.fields ?? []).map((f) => ({
+                name: f.name ?? "",
+                type: f.type ?? "input_text",
+                values: (f.values ?? []).map((v) => ({ value: v.value ?? "", label: v.label ?? "" })),
+            })),
+        }));
+        return {
+            ok: true,
+            schema: {
+                source: SOURCE,
+                post_id: id,
+                job_title: job.title ?? "",
+                apply_url: job.absolute_url ?? `${BOARD_URL}/jobs/${id}`,
+                submit_endpoint: `${API_ROOT}/jobs/${encodeURIComponent(id)}`,
+                submit_method: "POST",
+                questions,
+            },
+        };
+    }
     return {
         searchPositions,
         fetchAllPositions,
@@ -366,5 +423,6 @@ export function createAdapter(cfg) {
         findNoticesByQuestion,
         matchResume,
         checkResume,
+        fetchApplicationSchema,
     };
 }

package/dist/hoyoverse.js

@@ -23,3 +23,4 @@ export const getNotice = adapter.getNotice;
 export const findNoticesByQuestion = adapter.findNoticesByQuestion;
 export const matchResume = adapter.matchResume;
 export const checkResume = adapter.checkResume;
+export const fetchApplicationSchema = adapter.fetchApplicationSchema;

package/dist/index.js

@@ -50,8 +50,11 @@ import * as geely from "./geely.js";
 import * as webank from "./webank.js";
 import * as horizonrobotics from "./horizonrobotics.js";
 import * as cambricon from "./cambricon.js";
+import { loadProfile, profileTemplate, stageApplication, submitApplication, formatStaged, } from "./apply.js";
 import { memoryList, memoryGet, memorySet, memoryEvent, memoryClear, } from "./memory.js";
-const VERSION = "0.8.2";
+import { writeFileSync, mkdirSync, existsSync } from "node:fs";
+import { dirname } from "node:path";
+const VERSION = "0.9.1";
 const COMPANIES = [
     { key: "tencent", family: "Bespoke", source: "join.qq.com", label: "Tencent / 腾讯" },
     { key: "bytedance", family: "Bespoke", source: "jobs.bytedance.com", label: "ByteDance / 字节跳动" },
@@ -111,6 +114,8 @@ job-pro — query Chinese big-tech campus recruiting from your terminal
 USAGE
   job-pro <company> <verb> [options]
   job-pro list [--compact]            list all 50 companies + source family
+  job-pro profile init [--force]      write ~/.jobpro/profile.json template
+  job-pro profile show                print the loaded profile
   job-pro --version
   job-pro help
 
@@ -118,6 +123,12 @@ USAGE
 by ATS family (Bespoke / Feishu / Beisen Wecruit / Beisen iTalent / Moka
 / Greenhouse-Lever / Liepin). Coverage summary at job.ha7ch.com.
 
+PHASE 2 (auto-apply) is in early access. \`job-pro <co> apply <postId>\`
+prints the staged POST in dry-run mode. Today only Greenhouse +
+Lever boards (xpeng / hoyoverse / weride) expose the application
+schema; the rest return a "not yet wired" note. See docs/auto-apply.md
+for the rollout plan.
+
 VERBS (same surface for every company)
   search <kw>                       search openings (free text)
   detail <post_id>                  show full JD for one job
@@ -129,6 +140,9 @@ VERBS (same surface for every company)
   match <resume-text-or-->          rank jobs by overlap with resume text
                                     pass "-" to read resume from stdin
   resume-check <resume-text-or-->   structural sanity check on a resume
+  apply <post_id>                   stage an application (Phase 2 dry-run)
+                                    --really-submit is intentionally disabled
+                                    until per-ATS flows are validated.
   memory list | get <k> | set k=v | event <kind> [payload] | clear
 
 OUTPUT
@@ -375,6 +389,73 @@ async function runCompany(adapter, company, rawArgs) {
         const text = readResumeArg(args[0]);
         return emit(adapter.checkResume(text), compact);
     }
+    if (verb === "apply") {
+        const postId = args[0];
+        if (!postId)
+            die(`usage: job-pro ${company} apply <post_id> [--dry-run | --debug-submit-to <url> | --really-submit]`);
+        const reallySubmit = args.includes("--really-submit");
+        const { args: aDebug, value: debugUrl } = popFlagValue(args, "--debug-submit-to");
+        const fetchSchema = adapter.fetchApplicationSchema;
+        if (typeof fetchSchema !== "function") {
+            return emit({
+                ok: false,
+                source: company,
+                post_id: postId,
+                message: `apply: Phase 2 not yet wired for "${company}". Only Greenhouse + Lever ` +
+                    `boards (xpeng / hoyoverse / weride) expose an application schema today. ` +
+                    `See docs/auto-apply.md for the rollout plan.`,
+            }, compact);
+        }
+        if (reallySubmit) {
+            return emit({
+                ok: false,
+                source: company,
+                post_id: postId,
+                message: `--really-submit is intentionally disabled until per-ATS submission flows ` +
+                    `are validated end-to-end against live boards. Use --debug-submit-to <url> ` +
+                    `to verify the multipart wire format against your own echo server (e.g. ` +
+                    `https://httpbin.org/post) without spamming the real ATS.`,
+            }, compact);
+        }
+        const schemaResult = await fetchSchema.call(adapter, postId);
+        const sr = schemaResult;
+        if (!sr.ok || !sr.schema) {
+            return emit({ ok: false, source: company, post_id: postId, message: sr.message ?? "unknown error" }, compact);
+        }
+        const prof = loadProfile();
+        if (!prof.ok) {
+            return emit({
+                ok: false,
+                source: company,
+                post_id: postId,
+                schema: sr.schema,
+                message: prof.message,
+                hint: `run \`job-pro profile init\` to create a template.`,
+            }, compact);
+        }
+        const staged = stageApplication(sr.schema, prof.profile);
+        // Mode selection: --debug-submit-to <url> overrides dry-run.
+        if (debugUrl) {
+            const result = await submitApplication(staged, { kind: "debug", url: debugUrl });
+            return emit({ mode: "debug-submit", staged, result }, compact);
+        }
+        // Default: dry-run print, no network.
+        if (compact) {
+            return emit({ mode: "dry-run", staged }, compact);
+        }
+        console.log(formatStaged(staged));
+        if (!staged.ready) {
+            console.log(`\nFill the unanswered required fields in ${profileTemplate().path} ` +
+                `(profile.custom.<name> for unknown fields), then re-run.`);
+        }
+        else {
+            console.log(`\nDry-run complete. Use --debug-submit-to https://httpbin.org/post to ` +
+                `verify the multipart wire format. --really-submit will be enabled per-ATS ` +
+                `once each family's submission flow has been validated end-to-end.`);
+        }
+        void aDebug; // silence "unused" — `args` flow goes through popFlagValue
+        return;
+    }
     if (verb === "memory") {
         const [sub, ...subArgs] = args;
         if (!sub)
@@ -463,6 +544,30 @@ async function main() {
         printCompanyList(compact);
         return;
     }
+    if (cmd === "profile") {
+        const sub = args[1];
+        if (sub === "init") {
+            const { path, template } = profileTemplate();
+            if (existsSync(path) && !args.includes("--force")) {
+                console.error(`profile already exists at ${path}; pass --force to overwrite.`);
+                process.exit(1);
+            }
+            mkdirSync(dirname(path), { recursive: true });
+            writeFileSync(path, JSON.stringify(template, null, 2) + "\n", "utf8");
+            console.log(`Wrote ${path}. Fill in first_name / last_name / email / phone / resume_path before running \`job-pro <co> apply\`.`);
+            return;
+        }
+        if (sub === "show") {
+            const r = loadProfile();
+            if (!r.ok) {
+                console.error(r.message);
+                process.exit(1);
+            }
+            console.log(JSON.stringify(r.profile, null, 2));
+            return;
+        }
+        die(`usage: job-pro profile <init [--force] | show>`);
+    }
     const adapter = ADAPTERS[cmd];
     if (adapter) {
         await runCompany(adapter, cmd, args.slice(1));

package/dist/lever.js

@@ -361,6 +361,80 @@ export function createAdapter(cfg) {
                 "The only authority on selection is HR.",
         };
     }
+    async function fetchApplicationSchema(postId) {
+        const id = (postId ?? "").trim();
+        if (!id)
+            return { ok: false, source: SOURCE, message: "post_id is required" };
+        let response;
+        try {
+            response = await fetch(API_DETAIL(id), { headers: HEADERS });
+        }
+        catch (err) {
+            return {
+                ok: false,
+                source: SOURCE,
+                message: `network error: ${err instanceof Error ? err.message : String(err)}`,
+            };
+        }
+        if (!response.ok) {
+            return {
+                ok: false,
+                source: SOURCE,
+                message: `HTTP ${response.status}: ${response.statusText}`,
+            };
+        }
+        let job;
+        try {
+            job = (await response.json());
+        }
+        catch (err) {
+            return {
+                ok: false,
+                source: SOURCE,
+                message: `bad JSON: ${err instanceof Error ? err.message : String(err)}`,
+            };
+        }
+        // Lever's standard contact-info block.
+        const standard = [
+            { label: "First Name", required: true, fields: [{ name: "first_name", type: "input_text" }] },
+            { label: "Last Name", required: true, fields: [{ name: "last_name", type: "input_text" }] },
+            { label: "Email", required: true, fields: [{ name: "email", type: "input_text" }] },
+            { label: "Phone", required: true, fields: [{ name: "phone", type: "input_text" }] },
+            { label: "Resume", required: true, fields: [{ name: "resume", type: "input_file" }] },
+        ];
+        // Custom-question fields keyed by their human label so the staging
+        // step can match them via profile.custom["…"].
+        const custom = (job.customQuestions ?? []).flatMap((cq) => (cq.fields ?? []).map((f) => ({
+            label: f.text ?? cq.text ?? "",
+            description: cq.description ?? null,
+            required: f.required ?? false,
+            fields: [
+                {
+                    name: (f.text ?? cq.text ?? "").slice(0, 60).replace(/\s+/g, "_").toLowerCase(),
+                    type: f.type === "multiple-choice"
+                        ? "single_select"
+                        : f.type === "multi-choice"
+                            ? "multi_select"
+                            : f.type === "textarea"
+                                ? "textarea"
+                                : "input_text",
+                    values: (f.options ?? []).map((o) => ({ value: o.text ?? "", label: o.text ?? "" })),
+                },
+            ],
+        })));
+        return {
+            ok: true,
+            schema: {
+                source: SOURCE,
+                post_id: id,
+                job_title: job.text ?? "",
+                apply_url: job.applyUrl ?? job.hostedUrl ?? `${BOARD_URL}/${id}/apply`,
+                submit_endpoint: `${BOARD_URL}/${id}/apply`,
+                submit_method: "POST",
+                questions: [...standard, ...custom],
+            },
+        };
+    }
     return {
         searchPositions,
         fetchAllPositions,
@@ -371,5 +445,6 @@ export function createAdapter(cfg) {
         findNoticesByQuestion,
         matchResume,
         checkResume,
+        fetchApplicationSchema,
     };
 }

package/dist/weride.js

@@ -26,3 +26,4 @@ export const getNotice = adapter.getNotice;
 export const findNoticesByQuestion = adapter.findNoticesByQuestion;
 export const matchResume = adapter.matchResume;
 export const checkResume = adapter.checkResume;
+export const fetchApplicationSchema = adapter.fetchApplicationSchema;

package/dist/xpeng.js

@@ -31,3 +31,4 @@ export const getNotice = adapter.getNotice;
 export const findNoticesByQuestion = adapter.findNoticesByQuestion;
 export const matchResume = adapter.matchResume;
 export const checkResume = adapter.checkResume;
+export const fetchApplicationSchema = adapter.fetchApplicationSchema;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "job-pro",
-  "version": "0.8.2",
+  "version": "0.9.1",
   "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",