job-pro 1.0.0 → 1.0.2

package/dist/apply.js

@@ -202,6 +202,164 @@ export function formatStaged(s) {
 function truncate(s, n) {
     return s.length > n ? s.slice(0, n - 1) + "…" : s;
 }
+export function buildFormTemplate(schema, profile) {
+    const out = [];
+    for (const q of schema.questions) {
+        for (const f of q.fields) {
+            const resolved = resolveAnswer(f, profile);
+            out.push({
+                name: f.name,
+                type: f.type,
+                required: q.required,
+                label: q.label,
+                description: q.description,
+                options: f.values && f.values.length > 0 ? f.values : undefined,
+                value: resolved.value,
+                unanswered_reason: resolved.value ? undefined : resolved.reason || undefined,
+            });
+        }
+    }
+    return {
+        source: schema.source,
+        post_id: schema.post_id,
+        job_title: schema.job_title,
+        apply_url: schema.apply_url,
+        submit_kind: schema.submit_kind,
+        fields: out,
+    };
+}
+/**
+ * Walk an ApplyFormSchema and prompt for each unanswered required field
+ * on stdin (via readline). Returns the new overrides as a flat
+ * `{ name: value }` map ready to merge into profile.custom.
+ *
+ * Behaviour:
+ *   - Fields already resolved from profile (name/email/phone/resume/etc.)
+ *     are skipped silently.
+ *   - For `*_select` field types, options are presented as a numbered
+ *     list — user can type the index or the literal value.
+ *   - User can hit Enter to skip a non-required field.
+ *   - User can type `q` / Ctrl-D to abort; we return what we've got so far.
+ *
+ * This function intentionally lives in apply.ts (not index.ts) so it
+ * stays unit-testable and so a future TUI can swap it out.
+ */
+export async function promptUnansweredFields(schema, profile, io) {
+    const overrides = {};
+    for (const q of schema.questions) {
+        // Only prompt for the primary field of each question. Secondary
+        // alternates (e.g. `resume_text` alongside `resume`) get the same
+        // resolution as the primary and don't need a separate prompt.
+        const f = q.fields[0];
+        if (!f)
+            continue;
+        const resolved = resolveAnswer(f, profile);
+        if (resolved.value)
+            continue; // already filled
+        if (!q.required)
+            continue; // skip optional fields entirely
+        while (true) {
+            // Build the prompt.
+            const lines = [];
+            lines.push(`\n${q.label} (required) [${f.name}]`);
+            if (q.description)
+                lines.push(`  ${q.description}`);
+            if (f.values && f.values.length > 0) {
+                lines.push("  Options:");
+                f.values.forEach((opt, i) => {
+                    const label = opt.label && opt.label !== opt.value ? `${opt.value} — ${opt.label}` : opt.value;
+                    lines.push(`    [${i + 1}] ${label}`);
+                });
+                lines.push("  Enter number or value:");
+            }
+            else if (f.type === "input_file") {
+                lines.push("  Enter absolute file path:");
+            }
+            else if (f.type === "textarea") {
+                lines.push("  Enter text (single line; \\n for newlines):");
+            }
+            else {
+                lines.push("  Enter value:");
+            }
+            lines.push("> ");
+            io.write(lines.join("\n"));
+            const answer = await io.read();
+            if (answer === null) {
+                // Ctrl-D / EOF — bail with what we have.
+                return overrides;
+            }
+            const trimmed = answer.trim();
+            if (trimmed === "q")
+                return overrides;
+            if (!trimmed) {
+                // Empty input for a required field — re-prompt unless user wants to skip.
+                io.write("  (required — type a value, `q` to abort, or `skip` to leave blank)\n");
+                continue;
+            }
+            if (trimmed === "skip")
+                break;
+            let resolvedAnswer = trimmed;
+            if (f.values && f.values.length > 0) {
+                const asIdx = Number.parseInt(trimmed, 10);
+                if (Number.isFinite(asIdx) && asIdx >= 1 && asIdx <= f.values.length) {
+                    // Coerce — Greenhouse sometimes ships numeric values that JSON.parse
+                    // hands back as numbers, breaking .replace below.
+                    resolvedAnswer = String(f.values[asIdx - 1].value ?? "");
+                }
+            }
+            overrides[f.name] = resolvedAnswer.replace(/\\n/g, "\n");
+            break;
+        }
+    }
+    return overrides;
+}
+/** Merge a `{ field_name: value }` map into the profile's custom overrides. */
+export function applyFormFile(profile, formFilePath) {
+    if (!existsSync(formFilePath)) {
+        return { ok: false, message: `form file not found: ${formFilePath}` };
+    }
+    let raw;
+    try {
+        raw = readFileSync(formFilePath, "utf8");
+    }
+    catch (err) {
+        return { ok: false, message: `read ${formFilePath} failed: ${err instanceof Error ? err.message : err}` };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (err) {
+        return { ok: false, message: `${formFilePath} is not valid JSON: ${err instanceof Error ? err.message : err}` };
+    }
+    // Accept either:
+    //   (a) a flat { name: value } map, or
+    //   (b) the full FormTemplate shape (fields:[{ name, value }, …])
+    const overrides = {};
+    if (parsed && typeof parsed === "object" && Array.isArray(parsed.fields)) {
+        for (const f of parsed.fields) {
+            if (typeof f.name === "string" && typeof f.value === "string" && f.value.length > 0) {
+                overrides[f.name] = f.value;
+            }
+        }
+    }
+    else if (parsed && typeof parsed === "object") {
+        for (const [k, v] of Object.entries(parsed)) {
+            if (typeof v === "string" && v.length > 0)
+                overrides[k] = v;
+        }
+    }
+    else {
+        return { ok: false, message: "form file must be a JSON object or FormTemplate" };
+    }
+    return {
+        ok: true,
+        profile: {
+            ...profile,
+            custom: { ...(profile.custom ?? {}), ...overrides },
+        },
+    };
+}
 export function buildBespokeApplySchema(cfg) {
     const standard = [
         { label: "Name", required: true, fields: [{ name: "name", type: "input_text" }] },

package/dist/index.js

@@ -50,11 +50,12 @@ 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, loadSession, profileTemplate, stageApplication, submitApplication, executeFeishu3Step, executeMokaApply, executeBeisenWecruit, executeBeisenITalent, executeCdpRealBrowser, formatStaged, } from "./apply.js";
+import { loadProfile, loadSession, profileTemplate, stageApplication, submitApplication, executeFeishu3Step, executeMokaApply, executeBeisenWecruit, executeBeisenITalent, executeCdpRealBrowser, buildFormTemplate, applyFormFile, promptUnansweredFields, formatStaged, } from "./apply.js";
+import { createInterface } from "node:readline";
 import { memoryList, memoryGet, memorySet, memoryEvent, memoryClear, } from "./memory.js";
 import { writeFileSync, mkdirSync, existsSync } from "node:fs";
 import { dirname } from "node:path";
-const VERSION = "1.0.0";
+const VERSION = "1.0.2";
 const COMPANIES = [
     { key: "tencent", family: "Bespoke", source: "join.qq.com", label: "Tencent / 腾讯" },
     { key: "bytedance", family: "Bespoke", source: "jobs.bytedance.com", label: "ByteDance / 字节跳动" },
@@ -152,8 +153,11 @@ VERBS (same surface for every company)
                                     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.
+                                    --print-form               emit a fillable JSON template
+                                    --form-file <path>         merge per-job answers
+                                    --interactive              prompt for unanswered fields
+                                    --debug-submit-to <url>    verify wire format
+                                    --really-submit            actually fire (env-gated)
   memory list | get <k> | set k=v | event <kind> [payload] | clear
 
 OUTPUT
@@ -403,9 +407,13 @@ async function runCompany(adapter, company, rawArgs) {
     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]`);
+            die(`usage: job-pro ${company} apply <post_id> [--print-form | --form-file <path>] [--dry-run | --debug-submit-to <url> | --really-submit]`);
         const reallySubmit = args.includes("--really-submit");
+        const printForm = args.includes("--print-form");
+        const interactive = args.includes("--interactive");
         const { args: aDebug, value: debugUrl } = popFlagValue(args, "--debug-submit-to");
+        const { args: _aForm, value: formFilePath } = popFlagValue(aDebug, "--form-file");
+        void _aForm;
         const fetchSchema = adapter.fetchApplicationSchema;
         if (typeof fetchSchema !== "function") {
             return emit({
@@ -437,7 +445,49 @@ async function runCompany(adapter, company, rawArgs) {
                 hint: `run \`job-pro profile init\` to create a template.`,
             }, compact);
         }
-        const staged = stageApplication(sr.schema, prof.profile);
+        // --print-form short-circuits everything else: emit a fillable
+        // template specific to this job's schema and exit.
+        if (printForm) {
+            const template = buildFormTemplate(sr.schema, prof.profile);
+            return emit(template, compact);
+        }
+        // --form-file merges per-job overrides into profile.custom.
+        let effectiveProfile = prof.profile;
+        if (formFilePath) {
+            const merged = applyFormFile(effectiveProfile, formFilePath);
+            if (!merged.ok) {
+                return emit({
+                    ok: false,
+                    source: company,
+                    post_id: postId,
+                    message: merged.message,
+                }, compact);
+            }
+            effectiveProfile = merged.profile;
+        }
+        // --interactive: prompt stdin for each unanswered required field.
+        // Skipped in --compact mode (we'd be polluting JSON output with prompts).
+        if (interactive && !compact) {
+            const rl = createInterface({ input: process.stdin, output: process.stdout });
+            const io = {
+                write: (s) => process.stdout.write(s),
+                read: () => new Promise((resolve) => {
+                    rl.once("close", () => resolve(null));
+                    rl.question("", (a) => resolve(a));
+                }),
+            };
+            console.log(`\nInteractive mode — fill the required fields for "${sr.schema.job_title || postId}".`);
+            console.log(`Type \`q\` or Ctrl-D to abort. Hit Enter to skip an optional field.`);
+            const overrides = await promptUnansweredFields(sr.schema, effectiveProfile, io);
+            rl.close();
+            // Merge into effectiveProfile.custom for the rest of the flow.
+            effectiveProfile = {
+                ...effectiveProfile,
+                custom: { ...(effectiveProfile.custom ?? {}), ...overrides },
+            };
+            console.log(`\nCollected ${Object.keys(overrides).length} answer(s). Staging now…\n`);
+        }
+        const staged = stageApplication(sr.schema, effectiveProfile);
         const session = loadSession(company);
         // Mode selection: --debug-submit-to <url> overrides everything.
         if (debugUrl) {
@@ -572,8 +622,16 @@ async function runCompany(adapter, company, rawArgs) {
             console.log(`\nSession captured (~/.jobpro/${company}.session.json): ${session.cookies.length} cookies + ${Object.keys(session.headers).length} auth headers.`);
         }
         if (!staged.ready) {
-            console.log(`\nFill the unanswered required fields in ${profileTemplate().path} ` +
-                `(profile.custom.<name> for unknown fields), then re-run.`);
+            console.log(`\nFill the unanswered required fields. Easiest path:\n` +
+                `  1. job-pro ${company} apply ${postId} --print-form > form.json\n` +
+                `  2. Edit form.json — set each \`value\` for required fields.\n` +
+                `  3. job-pro ${company} apply ${postId} --form-file form.json\n` +
+                `Or paste the following into ${profileTemplate().path} under \`custom\`:`);
+            // Emit a copy-pasteable JSON snippet listing each unanswered required.
+            const snippet = {};
+            for (const f of staged.unanswered_required)
+                snippet[f.name] = "";
+            console.log(JSON.stringify({ custom: snippet }, null, 2));
         }
         else {
             const isAnon = staged.source.startsWith("boards-api.greenhouse.io/") ||

package/package.json

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