techprufer-mcp 0.1.0

package/README.md

@@ -0,0 +1,40 @@
+# techprufer-mcp
+
+Local Agent (MCP) for [TechPrufer](https://techprufer.com) — tailor resumes from your AI tool using your own subscription. No Gemini API key required.
+
+## Install (any MCP host)
+
+```json
+{
+  "mcpServers": {
+    "techprufer": {
+      "command": "npx",
+      "args": ["-y", "techprufer-mcp"]
+    }
+  }
+}
+```
+
+## Login (once)
+
+```bash
+npx techprufer-mcp login
+```
+
+Opens TechPrufer in your browser. Approve the device code. Credentials are stored at `~/.techprufer/credentials.json`.
+
+## Use
+
+1. On techprufer.com, start a tailor with **Local Agent (MCP)**.
+2. In your AI tool, run the `/tailor` prompt (or ask: "process my pending TechPrufer tailor jobs").
+3. The agent pulls jobs one at a time, generates the tailored JSON with its own model, and saves it back after server-side validation.
+
+## Tools
+
+- `list_pending_tailor_jobs`
+- `get_tailor_job` — claim + exact prompt payload
+- `submit_tailor_result` — validate + store (retries with corrective feedback)
+
+## Env
+
+- `TECHPRUFER_API_URL` — override API base (default `https://techprufer.com`)

package/dist/api.d.ts

@@ -0,0 +1,8 @@
+export declare class ApiError extends Error {
+    status: number;
+    body: unknown;
+    constructor(status: number, body: unknown, message?: string);
+}
+export declare function apiFetch<T>(path: string, init?: RequestInit & {
+    token?: string | null;
+}): Promise<T>;

package/dist/api.js

@@ -0,0 +1,40 @@
+import { getApiUrl, loadCredentials } from './config.js';
+export class ApiError extends Error {
+    status;
+    body;
+    constructor(status, body, message) {
+        super(message || `API ${status}`);
+        this.status = status;
+        this.body = body;
+    }
+}
+export async function apiFetch(path, init = {}) {
+    const creds = loadCredentials();
+    const token = init.token === undefined ? creds?.token : init.token;
+    const base = creds?.apiUrl || getApiUrl();
+    const headers = new Headers(init.headers);
+    headers.set('Accept', 'application/json');
+    if (init.body && !headers.has('Content-Type')) {
+        headers.set('Content-Type', 'application/json');
+    }
+    if (token)
+        headers.set('Authorization', `Bearer ${token}`);
+    const res = await fetch(`${base}${path}`, { ...init, headers });
+    const text = await res.text();
+    let body = null;
+    if (text) {
+        try {
+            body = JSON.parse(text);
+        }
+        catch {
+            body = text;
+        }
+    }
+    if (!res.ok) {
+        const msg = body && typeof body === 'object' && body !== null && 'error' in body
+            ? String(body.error)
+            : `HTTP ${res.status}`;
+        throw new ApiError(res.status, body, msg);
+    }
+    return body;
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+import { runLogin, startStdioServer } from './server.js';
+import { loadCredentials, credentialsFilePath, getApiUrl } from './config.js';
+async function main() {
+    const args = process.argv.slice(2);
+    const cmd = args[0];
+    if (cmd === 'login') {
+        const nameIdx = args.indexOf('--name');
+        const deviceName = nameIdx >= 0 ? args[nameIdx + 1] : undefined;
+        await runLogin(deviceName);
+        return;
+    }
+    if (cmd === 'status' || cmd === 'whoami') {
+        const creds = loadCredentials();
+        if (!creds) {
+            console.error(`Not logged in. Credentials expected at ${credentialsFilePath()}`);
+            console.error('Run: npx techprufer-mcp login');
+            process.exit(1);
+        }
+        console.error(`API: ${creds.apiUrl || getApiUrl()}`);
+        console.error(`Token hint: …${creds.token.slice(-4)}`);
+        console.error(`Saved: ${creds.savedAt}`);
+        return;
+    }
+    if (cmd === 'help' || cmd === '--help' || cmd === '-h') {
+        console.error(`techprufer-mcp — TechPrufer Local Agent (MCP)
+
+Usage:
+  npx techprufer-mcp              Start stdio MCP server (for AI tools)
+  npx techprufer-mcp login        Device-code login (opens browser)
+  npx techprufer-mcp status       Show saved credentials
+
+Env:
+  TECHPRUFER_API_URL              Override API base (default https://techprufer.com)
+`);
+        return;
+    }
+    // Default: MCP stdio server
+    await startStdioServer();
+}
+main().catch((err) => {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+});

package/dist/config.d.ts

@@ -0,0 +1,11 @@
+export declare const DEFAULT_API_URL = "https://techprufer.com";
+export interface Credentials {
+    token: string;
+    apiUrl: string;
+    deviceId?: string;
+    savedAt: string;
+}
+export declare function getApiUrl(): string;
+export declare function loadCredentials(): Credentials | null;
+export declare function saveCredentials(creds: Omit<Credentials, 'savedAt'>): void;
+export declare function credentialsFilePath(): string;

package/dist/config.js

@@ -0,0 +1,43 @@
+import { homedir } from 'os';
+import { join } from 'path';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, chmodSync } from 'fs';
+export const DEFAULT_API_URL = 'https://techprufer.com';
+function configDir() {
+    return join(homedir(), '.techprufer');
+}
+function credentialsPath() {
+    return join(configDir(), 'credentials.json');
+}
+export function getApiUrl() {
+    return (process.env.TECHPRUFER_API_URL || DEFAULT_API_URL).replace(/\/$/, '');
+}
+export function loadCredentials() {
+    const path = credentialsPath();
+    if (!existsSync(path))
+        return null;
+    try {
+        const raw = JSON.parse(readFileSync(path, 'utf8'));
+        if (!raw?.token)
+            return null;
+        return raw;
+    }
+    catch {
+        return null;
+    }
+}
+export function saveCredentials(creds) {
+    const dir = configDir();
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const path = credentialsPath();
+    writeFileSync(path, JSON.stringify({ ...creds, savedAt: new Date().toISOString() }, null, 2), 'utf8');
+    try {
+        chmodSync(path, 0o600);
+    }
+    catch {
+        // Windows may ignore chmod — fine.
+    }
+}
+export function credentialsFilePath() {
+    return credentialsPath();
+}

package/dist/login.d.ts

@@ -0,0 +1 @@
+export declare function runLogin(deviceName?: string): Promise<void>;

package/dist/login.js

@@ -0,0 +1,59 @@
+import { spawn } from 'child_process';
+import { platform } from 'os';
+import { apiFetch } from './api.js';
+import { getApiUrl, saveCredentials } from './config.js';
+function openBrowser(url) {
+    const cmd = platform() === 'darwin' ? 'open' : platform() === 'win32' ? 'start' : 'xdg-open';
+    try {
+        const child = spawn(cmd, [url], { detached: true, stdio: 'ignore' });
+        child.unref();
+    }
+    catch {
+        // User can open manually.
+    }
+}
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+export async function runLogin(deviceName) {
+    const apiUrl = getApiUrl();
+    console.error(`TechPrufer Local Agent — logging in against ${apiUrl}`);
+    const start = await apiFetch('/api/agent/device/start', {
+        method: 'POST',
+        token: null,
+        body: JSON.stringify({ deviceName: deviceName || undefined }),
+    });
+    console.error('');
+    console.error(`  Code:  ${start.userCode}`);
+    console.error(`  Open:  ${start.verifyUrl}`);
+    console.error('');
+    console.error('Waiting for approval in the browser…');
+    openBrowser(start.verifyUrl);
+    const intervalMs = Math.max(3, start.interval || 5) * 1000;
+    const deadline = Date.now() + start.expiresIn * 1000;
+    while (Date.now() < deadline) {
+        await sleep(intervalMs);
+        const poll = await apiFetch('/api/agent/device/poll', {
+            method: 'POST',
+            token: null,
+            body: JSON.stringify({ deviceCode: start.deviceCode }),
+        });
+        if (poll.status === 'pending')
+            continue;
+        if (poll.status === 'expired') {
+            console.error('Code expired. Run login again.');
+            process.exit(1);
+        }
+        if (poll.status === 'ready' && poll.token) {
+            saveCredentials({
+                token: poll.token,
+                apiUrl,
+                deviceId: poll.deviceId,
+            });
+            console.error('Logged in. You can close this window and use /tailor in your AI tool.');
+            return;
+        }
+    }
+    console.error('Timed out waiting for approval.');
+    process.exit(1);
+}

package/dist/server.d.ts

@@ -0,0 +1,6 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { runLogin } from './login.js';
+export declare function createServer(): McpServer;
+export declare function startStdioServer(): Promise<void>;
+/** CLI entry when invoked as `npx techprufer-mcp login`. */
+export { runLogin };

package/dist/server.js

@@ -0,0 +1,135 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { apiFetch, ApiError } from './api.js';
+import { loadCredentials, credentialsFilePath } from './config.js';
+import { runLogin } from './login.js';
+function textResult(text, isError = false) {
+    return { content: [{ type: 'text', text }], isError };
+}
+function requireAuthMessage() {
+    return (`Not logged in. Run: npx techprufer-mcp login\n` +
+        `Credentials file: ${credentialsFilePath()}\n` +
+        `Then retry this tool.`);
+}
+async function ensureToken() {
+    const creds = loadCredentials();
+    return creds?.token ?? null;
+}
+export function createServer() {
+    const server = new McpServer({
+        name: 'techprufer',
+        version: '0.1.0',
+    });
+    server.tool('list_pending_tailor_jobs', 'List TechPrufer tailor jobs queued for Local Agent (MCP). Returns id, company, role, status.', {}, async () => {
+        const token = await ensureToken();
+        if (!token)
+            return textResult(requireAuthMessage(), true);
+        try {
+            const data = await apiFetch('/api/agent/jobs');
+            return textResult(JSON.stringify(data.jobs ?? [], null, 2));
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            return textResult(`Failed to list jobs: ${msg}`, true);
+        }
+    });
+    server.tool('get_tailor_job', 'Claim a pending TechPrufer tailor job and return the EXACT prompt messages (same as the Gemini path). ' +
+        'Execute the messages verbatim with your own model and output ONLY the tailored JSON object ' +
+        '(keys: experience, projects, skills, meta, linkedinMessage). Then call submit_tailor_result.', {
+        jobId: z
+            .string()
+            .optional()
+            .describe('Job id from list_pending_tailor_jobs. If omitted, uses the oldest QUEUED job.'),
+    }, async ({ jobId }) => {
+        const token = await ensureToken();
+        if (!token)
+            return textResult(requireAuthMessage(), true);
+        try {
+            let id = jobId;
+            if (!id) {
+                const list = await apiFetch('/api/agent/jobs');
+                const first = list.jobs.find((j) => j.status === 'QUEUED') ??
+                    list.jobs.find((j) => j.status === 'CLAIMED');
+                if (!first)
+                    return textResult('No pending tailor jobs.');
+                id = first.id;
+            }
+            const payload = await apiFetch(`/api/agent/jobs/${encodeURIComponent(id)}/payload`);
+            return textResult(JSON.stringify(payload, null, 2));
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            return textResult(`Failed to get job: ${msg}`, true);
+        }
+    });
+    server.tool('submit_tailor_result', 'Submit the tailored Profile JSON for a job. Server validates ALL attributes (schema, meta, layout fill). ' +
+        'On 422, read correctiveMessage, fix the JSON, and resubmit (max 2 attempts).', {
+        jobId: z.string().describe('Job id'),
+        profileJson: z
+            .union([z.string(), z.record(z.unknown())])
+            .describe('Tailored resume JSON object (or stringified JSON)'),
+        model: z
+            .string()
+            .optional()
+            .describe('Model name your agent used (for session history)'),
+    }, async ({ jobId, profileJson, model }) => {
+        const token = await ensureToken();
+        if (!token)
+            return textResult(requireAuthMessage(), true);
+        try {
+            const parsed = typeof profileJson === 'string' ? JSON.parse(profileJson) : profileJson;
+            const result = await apiFetch(`/api/agent/jobs/${encodeURIComponent(jobId)}/result`, {
+                method: 'POST',
+                body: JSON.stringify({ profileJson: parsed, model }),
+            });
+            return textResult(JSON.stringify(result, null, 2));
+        }
+        catch (e) {
+            if (e instanceof ApiError && e.status === 422) {
+                return textResult(JSON.stringify(e.body, null, 2), true);
+            }
+            const msg = e instanceof Error ? e.message : String(e);
+            return textResult(`Submit failed: ${msg}`, true);
+        }
+    });
+    server.prompt('tailor', 'Process pending TechPrufer Local Agent tailor jobs one at a time.', {
+        jobId: z
+            .string()
+            .optional()
+            .describe('Optional specific job id; otherwise process all pending jobs in order'),
+    }, async ({ jobId }) => ({
+        messages: [
+            {
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: [
+                        'Process TechPrufer Local Agent (MCP) tailor jobs.',
+                        jobId
+                            ? `Focus on jobId=${jobId}.`
+                            : 'Fetch pending jobs and process them ONE AT A TIME in order.',
+                        '',
+                        'For each job:',
+                        '1. Call get_tailor_job (with jobId if provided).',
+                        '2. Execute the returned messages verbatim with your own model.',
+                        '3. Produce ONLY the tailored JSON object (experience, projects, skills, meta, linkedinMessage).',
+                        '4. Call submit_tailor_result with that JSON.',
+                        '5. If the tool returns a correctiveMessage (validation / layout fill), fix the JSON and resubmit once.',
+                        '6. Proceed to the next pending job.',
+                        '',
+                        'Do not invent experience or metrics. Zero hallucination. Complete output only.',
+                    ].join('\n'),
+                },
+            },
+        ],
+    }));
+    return server;
+}
+export async function startStdioServer() {
+    const server = createServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+/** CLI entry when invoked as `npx techprufer-mcp login`. */
+export { runLogin };

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "techprufer-mcp",
+  "version": "0.1.0",
+  "description": "TechPrufer Local Agent (MCP) — tailor resumes from your AI tool without a Gemini API key",
+  "type": "module",
+  "bin": {
+    "techprufer-mcp": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "zod": "^3.24.2"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.2.0"
+  },
+  "keywords": [
+    "mcp",
+    "techprufer",
+    "resume",
+    "tailor"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
+  }
+}