Job Card is an MCP server for managing trades/field-service job cards: one card per job, with hours, materials, status, totals, printing and summaries.
Open job cards with client, site, description, currency and scheduled date; returns a JC-YYYY-NNNN number.
Log labor hours per worker, date, hourly rate in cents and notes.
Log materials with item, quantity, unit cost in cents and notes.
Move cards one step through open, in_progress, done, invoiced, archived, recording date and note.
List cards newest first, filterable by status and client, with hours and per-currency totals.
Read a full card: every labor/material entry, hours per worker, and running totals in integer cents.
Print/render a card as markdown or self-contained HTML with a client signature line.
Delete only empty cards; cards with logged work are refused and should be archived instead.
Summarize a day or Monday–Sunday week: cards touched, hours per worker, and value per currency.
Check license status and activate a Pro key offline; free tier is limited to 10 active cards.
Keep all data local with no account, API key or network calls.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Job Card Log 4 hours at $75/hr for Mike on job JC-2025-0007"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
MCP server for job cards for trades and field service: hours and materials per job. One card per job: hours and materials logged against it, a status machine from open to invoiced, and the printed card for client sign-off.
Works with Claude Desktop, Claude Code, Cursor and any Model Context Protocol client. Runs on your own machine, or hosted with no install.
Product page: https://mcp.zovo.one/s/job-card - what it does, the tools it exposes, and a live token endpoint.
Hosted, nothing to install. Get a token from https://mcp.zovo.one/mcp/connect (the connect page) or https://mcp.zovo.one/mcp/token (the same token as JSON); a free anonymous one is issued on the spot and a Pro key works the same way. Then point an MCP client at https://mcp.zovo.one/mcp/job-card over streamable-http and send the token as Authorization: Bearer <token>.
If your client cannot set headers, put the token in the path instead: https://mcp.zovo.one/mcp/job-card/t/<token>. Both forms work. The bare URL with no token answers 401 on tools/call, so the token is not optional.
Claude Desktop, one click. Download job-card.mcpb from the latest release and double-click it.
From source. The mirror is self-contained: every @theluckystrike/* dependency is vendored, so a fresh clone builds with no extra setup.
git clone https://github.com/theluckystrike/mcp-job-card.git
cd mcp-job-card
npm install && npm run buildThen point your client at the built entry point:
{
"mcpServers": {
"job-card": {
"command": "node",
"args": ["/absolute/path/to/mcp-job-card/dist/index.js"]
}
}
}
@theluckystrike/mcp-job-cardis not published on npm yet, so annpx -y @theluckystrike/mcp-job-cardcommand will fail. The three paths above are the working ones and each is exercised by CI.
Read-only mirror of mcp-servers/servers/job-card. See MIRROR.md.
In the official MCP Registry (io.github.theluckystrike/job-card).
One card per job, the way the paper one on the dashboard works. Open a card for the client and the site, log the hours each worker puts in at their rate and the materials that go into the job, and the card keeps the running totals: labor, materials and the grand total, always in integer cents. Move the card along as the job moves, open, in progress, done, invoiced, archived, and when the client wants to see it, print the card with its signature line for sign-off. A daily or weekly summary answers where the crew's hours went and what the work is worth, per currency. Everything stays on this machine; there is no account and no network call.
Built by theluckystrike.
npm publish for @theluckystrike/mcp-job-card is pending, so npx -y @theluckystrike/mcp-job-card returns 404 today. Until then, a clone+build is the working path.
Related MCP server: time-tracker-ai-mcp
macOS ~/Library/Application Support/Claude/claude_desktop_config.json, Windows %APPDATA%\Claude\claude_desktop_config.json:
{
"mcpServers": {
"job-card": {
"command": "npx",
"args": ["-y", "@theluckystrike/mcp-job-card"]
}
}
}claude mcp add job-card -- npx -y @theluckystrike/mcp-job-card~/.cursor/mcp.json (global) or .cursor/mcp.json (project), same entry as Claude Desktop.
tool | what it does |
| Open a job card: client, site, what the job is, currency, scheduled date. Returns |
| Log hours on a job card: who did the work, the day, the hours, the hourly rate in cents, what was done |
| Log materials used on a job card: the item, the quantity, the unit cost in cents |
| Move the card exactly one step -- open, in_progress, done, invoiced, archived -- stamping date and note into its history |
| List cards newest first with hours and totals; filter by status and client; totals kept per currency |
| Read one card in full: every entry, hours per worker, and the running totals in integer cents |
| Render the card ready to print, with a signature line for client sign-off. Markdown or self-contained HTML |
| Delete a card entered by mistake. One holding labor or materials is refused; archive it instead |
| A day or a week: cards touched, hours per worker, labor and materials value per currency. A week runs Monday to Sunday |
| Free or Pro, and the key |
Free | Pro | |
Active job cards | 10 | Unlimited |
Labor and material entries per card | Unlimited | Unlimited |
Running totals, list and get | Yes | Yes |
Printable card, markdown and HTML | Yes | Yes |
Daily and weekly summary | Yes | Yes |
The record is never metered. Ten active cards is a real working board for a small crew, and a card stops counting the moment it is archived, so logging, totals, printing and summaries stay free for good. What Pro lifts is how many jobs are on the board at once.
Get Pro: https://mcp.zovo.one/buy/job-card, $19 one-time for this server, or $39 for the bundle.
Every amount is an integer number of cents (a cent is 1/100 of the currency unit). A labor line is hours times the hourly rate; a materials line is quantity times the unit cost; each line value is rounded half-up to the nearest cent once, at the moment it is logged, and stored on the entry. Totals are the sums of those stored line values, so a total can never drift from its lines. Hours are carried as integer hundredths and quantities as integer thousandths, so 2.5 hours at 4999 cents an hour is 12498 cents, never 12497.499999. Currencies are never added together: this server holds no exchange rate.
All data stays local, in ${XDG_DATA_HOME:-~/.local/share}/mcp-servers/job-card/. Two files: cards.json, counter.json. Nothing is sent anywhere, there is no account, no API key and no network call in this server at all. License keys are verified offline.
Built by theluckystrike. https://github.com/theluckystrike
Any MCP client (Claude, Cursor, Windsurf, VS Code) can read this repository's documentation directly via GitMCP - no install:
Docs MCP URL: https://gitmcp.io/theluckystrike/mcp-job-card
Open a job card for a job your crew is taking on and return its JC-YYYY-NNNN number: the client, the site, what the job is, the currency and when it is scheduled. Free tier: 10 active cards; archiving a finished job frees its slot.
Inputs: site (required), client (required), currency (required), description (required), +2 more.
Delete a job card entered by mistake. One with labor or materials logged is refused, naming what it holds, because deleting it would lose the record of work done: archive it instead. The JC number is never reissued.
Inputs: card (required).
Read one job card in full by JC number or client: every labor entry and every material used, the hours per worker, and the running totals -- labor, materials and grand total -- as integer cents with formatted amounts. Reads only.
Inputs: card (required).
List job cards newest first: client, site, status, hours logged, and the labor, materials and grand totals in cents. Filter by status and by client. Totals are kept per currency, never mixed.
Inputs: client, status.
Log hours worked on a job card: who did the work, the day, the hours and the hourly rate in whole cents, with a note on what was done. The line value is hours times rate, rounded half-up to the cent, fixed the moment it is logged.
Inputs: card (required), date (required), hours (required), worker (required), +2 more.
Log materials used on a job card: the item, the day it went in, the quantity and the unit cost in whole cents. The line value is quantity times unit cost, rounded half-up to the cent, fixed the moment it is logged.
Inputs: qty (required), card (required), date (required), item (required), +2 more.
Render a job card ready to print and hand to the client: the labor, the materials, the totals and a signature line for client sign-off. Markdown, or self-contained HTML that needs nothing from the network. Writes nothing.
Inputs: card (required), format.
Hours and value for a day or a week: the job cards touched, the hours per worker, and the labor, materials and total value, kept per currency. A week runs Monday to Sunday. Touched means a labor or material entry dated inside the window.
Inputs: date, span.
Move one job card exactly one step: open, in_progress, done, invoiced, archived, stamping the date and an optional note into its history. A skipped or backwards step is refused and nothing is written. Archiving a finished job frees a free-tier slot.
Inputs: card (required), status (required), date, note.
Activate a Pro key (MCPL1.xxx.yyy) from checkout: verified offline against a built-in public key, saved to your config file. A wrong, malformed or expired key is refused, unsaved. license_status reads it back.
Inputs: key (required).
Report this server's licence state: product, tier free or pro, licence id, expiry, the key source and the upgrade URL. No arguments, no network. Explains a free-tier refusal; license_activate installs a key.
Inputs: no named parameters.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 11 tools
Each tool maps to a distinct operation: license activation/status are separate from the job card lifecycle, and create, get, list, log, update, print, delete, and summary are clearly differentiated. There is no meaningful overlap or ambiguity between tools.
The naming is generally consistent with a job_card_ prefix and snake_case verb suffixes like create, log_labor, list, get, and delete. Two names, job_card_summary and license_status, use nouns instead of verbs, which is a minor deviation from a strict verb_noun pattern but still predictable.
Eleven tools is well-scoped for a job card management server: license handling, card lifecycle, labor/material logging, retrieval, summary, printing, and deletion are all covered without redundant tools. Each tool earns its place in the workflow.
The core job card lifecycle is well covered: create, read, list, update status, log labor and materials, print, summarize, and delete. The main gap is that logged labor/material entries cannot be edited, voided, or removed, and card details cannot be changed after creation, which can create a dead end if a mistake is made.
Job cards for on-site crews: labour hours and materials per job, client signature, totals.
Field service management for trades: clients, jobs, estimates, invoices, schedule and reports.
Manage jobs, customers, scheduling, estimates and invoices for a field service business.
Job management for trades: jobs, schedules, quotes, invoices, timesheets via OAuth.
