From db9d3f06746a417028e3f6b485f5322a960c487c Mon Sep 17 00:00:00 2001 From: maegminhui-tech Date: Thu, 24 Sep 2026 21:58:01 +0900 Subject: [PATCH 001/116] fix(jobs): write only the fields a listing patch sent --- src/core/jobs.ts | 55 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 55 insertions(+) diff --git a/src/core/jobs.ts b/src/core/jobs.ts index 08a1309..19b2395 100644 --- a/src/core/jobs.ts +++ b/src/core/jobs.ts @@ -830,6 +830,61 @@ export async function setPay(pool: pg.Pool, id: string, pay: Pay): Promise, +): Promise { + const values: unknown[] = [id]; + const assignments: string[] = []; + const set = (column: string, value: unknown): void => { + values.push(value); + assignments.push(`${column} = $${values.length}`); + }; + if (fields.has('title')) set('title', input.title); + if (fields.has('description')) set('description', input.description); + if (fields.has('employmentType')) set('employment_type', input.employmentType); + if (fields.has('workplace')) set('workplace', input.workplace); + if (fields.has('seniority')) set('seniority', input.seniority); + if (fields.has('location')) set('location', input.location); + if (fields.has('remoteRegions')) set('remote_regions', input.remoteRegions); + if (fields.has('tags')) set('tags', input.tags); + if (fields.has('stack')) set('stack', input.stack); + if (fields.has('requirements')) set('requirements', input.requirements); + if (fields.has('responsibilities')) set('responsibilities', input.responsibilities); + if (fields.has('agentPolicy')) set('agent_policy', input.agentPolicy); + if (fields.has('expiresAt')) set('expires_at', input.expiresAt); + if (fields.has('pay')) { + const salary = salaryFromPay(input.pay); + set('salary_min', salary.min); + set('salary_max', salary.max); + set('salary_currency', salary.currency); + set('salary_period', salary.period); + set('salary_equity', input.pay.equity); + set('salary_unpaid', input.pay.unpaid); + set('pay_lines', JSON.stringify(input.pay.lines)); + set('pay_method', input.pay.method); + } + if (assignments.length > 0) { + assignments.push('updated_at = now()'); + await pool.query(`update jobs set ${assignments.join(', ')} where id = $1`, values); + } + return getJobById(pool, id); +} + /** The listing imported from this URL, if there is one. */ export async function getJobBySourceUrl(pool: pg.Pool, url: string): Promise { const result = await pool.query<{ id: string }>( From 9192655b17050e22cb701b29c9a55a08aafd0340 Mon Sep 17 00:00:00 2001 From: maegminhui-tech Date: Thu, 24 Sep 2026 21:58:03 +0900 Subject: [PATCH 002/116] fix(jobs): write only the fields a listing patch sent --- src/server/routes/api.ts | 60 ++++++++++++++++++++++++++++++++++++++-- 1 file changed, 58 insertions(+), 2 deletions(-) diff --git a/src/server/routes/api.ts b/src/server/routes/api.ts index 53e461d..01596e3 100644 --- a/src/server/routes/api.ts +++ b/src/server/routes/api.ts @@ -48,7 +48,7 @@ import { publishProblem, searchJobs, setStatus, - editJob, + patchJob, updateJobFromImport, } from '../../core/jobs.ts'; import { extractJob, JobImportProblem, type ImportedJob } from '../../core/import-job.ts'; @@ -251,6 +251,58 @@ function payPatch(body: Record, job: Job): Record = { + title: 'title', + description: 'description', + employmentType: 'employmentType', + workplace: 'workplace', + seniority: 'seniority', + location: 'location', + remoteRegions: 'remoteRegions', + tags: 'tags', + stack: 'stack', + requirements: 'requirements', + responsibilities: 'responsibilities', + agentPolicy: 'agentPolicy', + expiresAt: 'expiresAt', +}; + +/** Every body key that touches the pay group. */ +const JOB_PAY_KEYS = [ + 'pay', + 'payLines', + 'salaryMin', + 'salaryMax', + 'salaryPeriod', + 'salaryCurrency', + 'salaryUnpaid', + 'unpaid', + 'payUnpaid', + 'payMethod', + 'paymentMethod', + 'paymentCoin', + 'payEquity', + 'salaryEquity', + 'equity', +]; + +/** + * The fields a PATCH actually sent. `undefined` is "leave it"; an explicit + * `null` still counts as sent so a nullable field like `expiresAt` can be + * cleared. Only these columns move — two members editing different fields + * at once no longer overwrite each other, and an edit cannot silently + * clear a field the merge never carried. + */ +function sentJobFields(body: Record): Set { + const fields = new Set(); + for (const [key, field] of Object.entries(JOB_PATCH_FIELDS)) { + if (body[key] !== undefined) fields.add(field); + } + if (JOB_PAY_KEYS.some((key) => body[key] !== undefined)) fields.add('pay'); + return fields; +} + export function apiRoutes(): Hono { const api = new Hono(); @@ -577,11 +629,15 @@ export function apiRoutes(): Hono { workplace: body['workplace'] ?? job.workplace, seniority: body['seniority'] ?? job.seniority ?? undefined, location: body['location'] ?? job.location ?? undefined, + remoteRegions: body['remoteRegions'] ?? job.remoteRegions, tags: body['tags'] ?? job.tags, stack: body['stack'] ?? job.stack, requirements: body['requirements'] ?? job.requirements, responsibilities: body['responsibilities'] ?? job.responsibilities, agentPolicy: body['agentPolicy'] ?? job.agentPolicy, + ...(body['expiresAt'] !== undefined + ? { expiresAt: body['expiresAt'] } + : { expiresAt: job.expiresAt }), ...payPatch(body, job), }, job.org.id, @@ -595,7 +651,7 @@ export function apiRoutes(): Hono { if (problem !== null) return fail(c, 400, 'pay_required', problem); } - const updated = await editJob(pool, job.id, merged); + const updated = await patchJob(pool, job.id, merged, sentJobFields(body)); return c.json({ job: updated ?? job }); }); From c76d0539378f74c0bf06c3688dba9c28f34dc085 Mon Sep 17 00:00:00 2001 From: maegminhui-tech Date: Thu, 24 Sep 2026 21:58:05 +0900 Subject: [PATCH 003/116] fix(jobs): write only the fields a listing patch sent --- test/job-patch-fields.test.ts | 182 ++++++++++++++++++++++++++++++++++ 1 file changed, 182 insertions(+) create mode 100644 test/job-patch-fields.test.ts diff --git a/test/job-patch-fields.test.ts b/test/job-patch-fields.test.ts new file mode 100644 index 0000000..5fa752a --- /dev/null +++ b/test/job-patch-fields.test.ts @@ -0,0 +1,182 @@ +import assert from 'node:assert/strict'; +import { test } from 'node:test'; +import { patchJob, type JobInput } from '../src/core/jobs.ts'; +import { DEFAULT_APPLY_SCHEMA } from '../src/schema/job.ts'; + +function jobRow(): Record { + return { + id: 'job-1', + slug: 'backend-engineer', + title: 'Backend Engineer', + description: 'A description long enough to pass the minimum.', + employment_type: 'full-time', + workplace: 'remote', + seniority: null, + location: 'Berlin', + remote_regions: ['EU'], + salary_min: 100000, + salary_max: 150000, + salary_currency: 'USD', + salary_period: 'year', + salary_equity: null, + salary_unpaid: false, + pay_lines: [{ type: 'salary', min: 100000, max: 150000, currency: 'USD', unit: 'year' }], + pay_method: 'bank transfer', + tags: ['backend'], + stack: ['postgres'], + requirements: ['ships'], + responsibilities: ['owns'], + agent_policy: 'disclose', + apply_via: 'board', + apply_url: null, + apply_source_url: null, + apply_email: null, + apply_schema: null, + status: 'draft', + published_at: null, + expires_at: '2027-01-01T00:00:00.000Z', + created_at: '2026-09-24T00:00:00.000Z', + updated_at: '2026-09-24T00:00:00.000Z', + org_id: 'org-1', + org_slug: 'example-works', + org_name: 'Example Works', + org_website: null, + org_logo_url: null, + org_description: null, + org_created_at: '2026-09-24T00:00:00.000Z', + }; +} + +function input(overrides: Partial = {}): JobInput { + return { + orgId: 'org-1', + title: 'Renamed Listing', + description: 'A replacement description that is long enough.', + employmentType: 'contract', + workplace: 'onsite', + seniority: 'senior', + location: 'Lisbon', + remoteRegions: ['US', 'EU'], + pay: { lines: [], method: null, equity: null, unpaid: true }, + tags: ['new-tag'], + stack: ['typescript'], + requirements: ['new req'], + responsibilities: ['new resp'], + agentPolicy: 'welcome', + apply: { via: 'board', schema: DEFAULT_APPLY_SCHEMA }, + expiresAt: '2027-06-01T00:00:00.000Z', + sourceUrl: null, + ...overrides, + }; +} + +/** + * A pool that applies `update jobs` assignments to the row, the way Postgres + * would, and serves the row back to the post-write read. + */ +function fakePool(job: Record, queries: string[] = []) { + return { + async query(sql: string, params: unknown[] = []) { + queries.push(sql); + const update = /^update jobs set (.+) where id = \$1\s*$/s.exec(sql.trim()); + if (update === null) return { rows: [{ ...job }], rowCount: 1 }; + for (const [, column, parameter] of (update[1] ?? '').matchAll(/(\w+) = \$(\d+)/g)) { + job[column as string] = params[Number(parameter) - 1]; + } + return { rows: [], rowCount: 1 }; + }, + }; +} + +function updateSql(queries: string[]): string { + const found = queries.filter((sql) => sql.trim().startsWith('update jobs')); + assert.equal(found.length, 1, 'expected exactly one update'); + return found[0] ?? ''; +} + +test('a partial patch writes only the columns that were sent', async () => { + const job = jobRow(); + const queries: string[] = []; + await patchJob(fakePool(job, queries) as never, 'job-1', input(), new Set(['title'])); + + const sql = updateSql(queries); + assert.match(sql, /title = \$\d+/); + for (const absent of [ + 'description', + 'remote_regions', + 'expires_at', + 'tags', + 'salary_min', + 'pay_lines', + 'agent_policy', + ]) { + assert.ok(!sql.includes(`${absent} =`), `${absent} must not be rewritten by a title patch`); + } + assert.equal(job['title'], 'Renamed Listing'); + assert.equal(job['location'], 'Berlin'); + assert.equal(job['expires_at'], '2027-01-01T00:00:00.000Z'); +}); + +test('independent concurrent listing patches keep both field changes', async () => { + const job = jobRow(); + const queries: string[] = []; + const pool = fakePool(job, queries); + await Promise.all([ + patchJob(pool as never, 'job-1', input(), new Set(['title'])), + patchJob(pool as never, 'job-1', input(), new Set(['tags'])), + ]); + + assert.equal(job['title'], 'Renamed Listing'); + assert.deepEqual(job['tags'], ['new-tag']); +}); + +test('an explicit null expiresAt clears the expiry', async () => { + const job = jobRow(); + const queries: string[] = []; + await patchJob( + fakePool(job, queries) as never, + 'job-1', + input({ expiresAt: null }), + new Set(['expiresAt']), + ); + + assert.match(updateSql(queries), /expires_at = \$\d+/); + assert.equal(job['expires_at'], null); +}); + +test('any pay field rewrites the whole pay group', async () => { + const job = jobRow(); + const queries: string[] = []; + const pay = { + lines: [{ type: 'per_task' as const, min: 25, max: null, currency: 'USD', unit: 'fix' }], + method: 'SOL', + equity: null, + unpaid: false, + }; + await patchJob(fakePool(job, queries) as never, 'job-1', input({ pay }), new Set(['pay'])); + + const sql = updateSql(queries); + for (const column of [ + 'salary_min', + 'salary_max', + 'salary_currency', + 'salary_period', + 'salary_equity', + 'salary_unpaid', + 'pay_lines', + 'pay_method', + ]) { + assert.ok(sql.includes(`${column} =`), `pay patch must write ${column}`); + } + assert.equal(job['pay_method'], 'SOL'); + assert.equal(job['title'], 'Backend Engineer'); +}); + +test('a patch with no recognised fields issues no update', async () => { + const job = jobRow(); + const queries: string[] = []; + const result = await patchJob(fakePool(job, queries) as never, 'job-1', input(), new Set()); + + assert.ok(!queries.some((sql) => sql.trim().startsWith('update jobs'))); + assert.equal(result?.title, 'Backend Engineer'); +}); From 65f945e0b5e3794c7b4cd3010484c8b09feba7ba Mon Sep 17 00:00:00 2001 From: RowletCC Date: Thu, 24 Sep 2026 21:48:20 +0800 Subject: [PATCH 004/116] fix(watches): handle concurrent duplicate saves (#212) --- src/core/watches.ts | 29 +++++++---- test/watch-create-concurrency.test.ts | 69 +++++++++++++++++++++++++++ 2 files changed, 90 insertions(+), 8 deletions(-) create mode 100644 test/watch-create-concurrency.test.ts diff --git a/src/core/watches.ts b/src/core/watches.ts index 7ae31b1..852d3a4 100644 --- a/src/core/watches.ts +++ b/src/core/watches.ts @@ -158,28 +158,41 @@ export async function createWatch( return 'Narrow the search first: a watch on every listing is the /feed, and it already exists.'; } const stored = toStored(query); - const existing = await pool.query( - `select id, query, label, email, created_at, last_notified_at - from watches where user_id = $1 and query = $2::jsonb`, - [userId, JSON.stringify(stored)], - ); - const found = existing.rows[0]; - if (found !== undefined) return { watch: toWatch(found, slugPath), created: false }; + const findExisting = async (): Promise => { + const existing = await pool.query( + `select id, query, label, email, created_at, last_notified_at + from watches where user_id = $1 and query = $2::jsonb`, + [userId, JSON.stringify(stored)], + ); + const row = existing.rows[0]; + return row === undefined ? null : toWatch(row, slugPath); + }; + const found = await findExisting(); + if (found !== null) return { watch: found, created: false }; const count = await pool.query<{ n: number }>( `select count(*)::int as n from watches where user_id = $1`, [userId], ); if ((count.rows[0]?.n ?? 0) >= WATCHES_PER_ACCOUNT) { + // A concurrent request may have inserted this exact watch after the first + // lookup. Treat that request as the existing search even at the account cap. + const createdByPeer = await findExisting(); + if (createdByPeer !== null) return { watch: createdByPeer, created: false }; return `You are watching ${WATCHES_PER_ACCOUNT} searches already. Remove one to add another.`; } const inserted = await pool.query( `insert into watches (user_id, query, label, email) values ($1, $2::jsonb, $3, $4) + on conflict (user_id, query) do nothing returning id, query, label, email, created_at, last_notified_at`, [userId, JSON.stringify(stored), labelFor(watchQuery(query)), options.email !== false], ); const row = inserted.rows[0]; - if (row === undefined) throw new Error('watch insert returned no row'); + if (row === undefined) { + const createdByPeer = await findExisting(); + if (createdByPeer !== null) return { watch: createdByPeer, created: false }; + throw new Error('watch insert returned no row'); + } return { watch: toWatch(row, slugPath), created: true }; } diff --git a/test/watch-create-concurrency.test.ts b/test/watch-create-concurrency.test.ts new file mode 100644 index 0000000..e9e5b99 --- /dev/null +++ b/test/watch-create-concurrency.test.ts @@ -0,0 +1,69 @@ +import assert from 'node:assert/strict'; +import { test } from 'node:test'; +import { createWatch } from '../src/core/watches.ts'; +import { EMPTY_QUERY } from '../src/schema/query.ts'; + +test('concurrent saves of one search return the same watch instead of a database error', async () => { + type StoredWatch = { + id: string; + query: Record; + label: string; + email: boolean; + created_at: string; + last_notified_at: null; + }; + + let stored: StoredWatch | null = null; + let lookupCount = 0; + let releaseLookups: (() => void) | undefined; + const bothLookups = new Promise((resolve) => { + releaseLookups = resolve; + }); + + const pool = { + async query(sql: string, params: unknown[] = []) { + if (sql.includes('from watches where user_id = $1 and query = $2::jsonb')) { + const snapshot = + stored !== null && JSON.stringify(stored.query) === params[1] ? { ...stored } : null; + lookupCount += 1; + if (lookupCount === 2) releaseLookups?.(); + if (lookupCount <= 2) await bothLookups; + return { rows: snapshot === null ? [] : [snapshot], rowCount: snapshot === null ? 0 : 1 }; + } + if (sql.includes('select count(*)::int as n from watches')) { + return { rows: [{ n: stored === null ? 0 : 1 }], rowCount: 1 }; + } + if (sql.startsWith('insert into watches')) { + if (stored !== null) { + if (sql.includes('on conflict')) return { rows: [], rowCount: 0 }; + throw Object.assign(new Error('duplicate key value violates unique constraint'), { + code: '23505', + }); + } + stored = { + id: 'watch-1', + query: JSON.parse(params[1] as string) as Record, + label: String(params[2]), + email: Boolean(params[3]), + created_at: '2026-09-24T00:00:00.000Z', + last_notified_at: null, + }; + return { rows: [{ ...stored }], rowCount: 1 }; + } + throw new Error(`unexpected query: ${sql}`); + }, + }; + + const results = await Promise.all([ + createWatch(pool as never, 'user-1', { ...EMPTY_QUERY, tags: ['rust'] }, {}, () => null), + createWatch(pool as never, 'user-1', { ...EMPTY_QUERY, tags: ['rust'] }, {}, () => null), + ]); + + assert.ok(results.every((result) => typeof result !== 'string')); + if (results.some((result) => typeof result === 'string')) return; + assert.deepEqual(results.map((result) => result.created).sort(), [false, true]); + assert.deepEqual( + results.map((result) => result.watch.id), + ['watch-1', 'watch-1'], + ); +}); From 97fce05db3cd7b50f614765876626828d4f6c826 Mon Sep 17 00:00:00 2001 From: RowletCC Date: Thu, 24 Sep 2026 21:48:28 +0800 Subject: [PATCH 005/116] Make bulk operator assignments atomic (#213) * Test bulk operator assignment atomicity * Make bulk operator assignments atomic --- src/core/agents.ts | 36 ++++++++++++++++++++++++------------ test/features.test.ts | 21 +++++++++++++++++++++ 2 files changed, 45 insertions(+), 12 deletions(-) diff --git a/src/core/agents.ts b/src/core/agents.ts index c0692e9..d9a8a2b 100644 --- a/src/core/agents.ts +++ b/src/core/agents.ts @@ -18,6 +18,8 @@ import type pg from 'pg'; import { clean, parseList, slugify, suffix } from '../schema/text.ts'; +type AgentQueryable = Pick; + export const NAME_MAX = 80; export const DESCRIPTION_MAX = 2000; export const SKILLS_MAX = 20; @@ -146,7 +148,7 @@ function toAgent(row: AgentRow, operates: AgentRef[]): Agent { }; } -async function operatesOf(pool: pg.Pool, ids: string[]): Promise> { +async function operatesOf(pool: AgentQueryable, ids: string[]): Promise> { const out = new Map(); if (ids.length === 0) return out; const rows = await pool.query<{ operator_id: string; slug: string; name: string }>( @@ -161,7 +163,7 @@ async function operatesOf(pool: pg.Pool, ids: string[]): Promise { +async function hydrate(pool: AgentQueryable, rows: AgentRow[]): Promise { const operates = await operatesOf( pool, rows.map((row) => row.id), @@ -200,7 +202,7 @@ export async function listPublicAgents( /** One agent by slug. Private agents are visible to their owner only. */ export async function getAgent( - pool: pg.Pool, + pool: AgentQueryable, slug: string, viewerId: string | null, ): Promise { @@ -211,7 +213,7 @@ export async function getAgent( return (await hydrate(pool, [row]))[0] ?? null; } -async function ownedRow(pool: pg.Pool, slug: string, ownerId: string): Promise { +async function ownedRow(pool: AgentQueryable, slug: string, ownerId: string): Promise { const rows = await pool.query(`${SELECT} where a.slug = $1`, [slug]); const row = rows.rows[0]; if (row === undefined || row.owner_id !== ownerId) { @@ -225,7 +227,7 @@ async function ownedRow(pool: pg.Pool, slug: string, ownerId: string): Promise { - const operator = await ownedRow(pool, operatorSlug, ownerId); - for (const slug of agentSlugs) { - await updateAgent(pool, ownerId, slug, { operator: operator.slug }); + const client = await pool.connect(); + try { + await client.query('begin'); + const operator = await ownedRow(client, operatorSlug, ownerId); + for (const slug of agentSlugs) { + await updateAgent(client, ownerId, slug, { operator: operator.slug }); + } + const refreshed = await getAgent(client, operator.slug, ownerId); + if (refreshed === null) throw new Error('operator vanished during assignment'); + await client.query('commit'); + return refreshed; + } catch (error) { + await client.query('rollback'); + throw error; + } finally { + client.release(); } - const refreshed = await getAgent(pool, operator.slug, ownerId); - if (refreshed === null) throw new Error('operator vanished during assignment'); - return refreshed; } export async function deleteAgent(pool: pg.Pool, ownerId: string, slug: string): Promise { diff --git a/test/features.test.ts b/test/features.test.ts index 823bf06..e72e108 100644 --- a/test/features.test.ts +++ b/test/features.test.ts @@ -191,6 +191,27 @@ describe('agents, watches, landing pages and rankings', { skip: !database }, () ); assert.equal(mine.items.length, 2); + const childResponse = await request('/api/v1/agents', owner, 'POST', { + name: `Atomic child ${suffix}`, + skills: ['testing'], + }); + assert.equal(childResponse.status, 201, await childResponse.clone().text()); + const child = (await json<{ agent: { slug: string; operator: unknown } }>(childResponse)).agent; + assert.equal(child.operator, null); + + // A failed bulk assignment must leave every earlier target untouched. + const partialAssignment = await request( + `/api/v1/agents/${dispatcher.agent.slug}/operates`, + owner, + 'POST', + { agents: [child.slug, `missing-${suffix}`] }, + ); + assert.equal(partialAssignment.status, 404); + const unchangedChild = await json<{ agent: { operator: unknown } }>( + await request(`/api/v1/agents/${child.slug}`, owner), + ); + assert.equal(unchangedChild.agent.operator, null); + // One call names a sysop for several agents. const operates = await json<{ agent: { operates: { slug: string }[] } }>( await request(`/api/v1/agents/${dispatcher.agent.slug}/operates`, owner, 'POST', { From 69be531710e3fdc86b5a06fd913e38eb05695f03 Mon Sep 17 00:00:00 2001 From: RowletCC Date: Thu, 24 Sep 2026 21:48:39 +0800 Subject: [PATCH 006/116] fix(inbox): open long threads at recent messages (#217) --- src/core/inbox.ts | 7 ++++- test/inbox-recent-messages.test.ts | 41 ++++++++++++++++++++++++++++++ 2 files changed, 47 insertions(+), 1 deletion(-) create mode 100644 test/inbox-recent-messages.test.ts diff --git a/src/core/inbox.ts b/src/core/inbox.ts index 747512f..244b40a 100644 --- a/src/core/inbox.ts +++ b/src/core/inbox.ts @@ -408,7 +408,12 @@ export async function getThread( sender_id: string; }>( `select id, kind, body, invoice_id, created_at, sender_id - from messages where thread_id = $1 order by created_at asc limit 500`, + from ( + select id, kind, body, invoice_id, created_at, sender_id + from messages where thread_id = $1 + order by created_at desc, id desc limit 500 + ) recent + order by created_at asc, id asc`, [threadId], ); diff --git a/test/inbox-recent-messages.test.ts b/test/inbox-recent-messages.test.ts new file mode 100644 index 0000000..cef5b8f --- /dev/null +++ b/test/inbox-recent-messages.test.ts @@ -0,0 +1,41 @@ +import assert from 'node:assert/strict'; +import { test } from 'node:test'; +import { getThread } from '../dist/core/inbox.js'; + +test('a long conversation opens with its newest 500 messages in reading order', async () => { + const messages = Array.from({ length: 501 }, (_, index) => ({ + id: `message-${index + 1}`, + kind: 'text' as const, + body: `Message ${index + 1}`, + invoice_id: null, + created_at: new Date(Date.UTC(2026, 0, 1, 0, 0, index)).toISOString(), + sender_id: index % 2 === 0 ? 'viewer' : 'other', + })); + const participants = [ + { user_id: 'viewer', org_id: null, user_name: 'Ada', email: 'ada@example.test', public_slug: 'ada', org_name: null, org_slug: null }, + { user_id: 'other', org_id: null, user_name: 'Bob', email: 'bob@example.test', public_slug: 'bob', org_name: null, org_slug: null }, + ]; + const pool = { + async query(sql: string) { + if (sql.includes('from thread_participants tp')) return { rows: participants }; + if (sql.includes('from threads t left join jobs')) { + return { rows: [{ id: 'thread', subject: 'Work', created_at: '2026-01-01T00:00:00Z', job_slug: null, job_title: null }] }; + } + if (sql.includes('from messages where thread_id')) { + // Model the database's LIMIT after its ORDER BY. The outer query, if + // present, restores chronological order for display. + const recent = /order by created_at desc/i.test(sql); + const selected = recent ? [...messages].reverse().slice(0, 500) : messages.slice(0, 500); + const restored = /\) recent\s+order by created_at asc/i.test(sql); + return { rows: restored ? selected.reverse() : selected }; + } + throw new Error(`Unexpected query: ${sql}`); + }, + }; + + const thread = await getThread(pool as never, 'thread', 'viewer'); + assert.ok(thread); + assert.equal(thread.messages.length, 500); + assert.equal(thread.messages[0]?.body, 'Message 2'); + assert.equal(thread.messages.at(-1)?.body, 'Message 501'); +}); From cd4d11167338f9b20c5220463eef5a185ef9ef97 Mon Sep 17 00:00:00 2001 From: RowletCC Date: Thu, 24 Sep 2026 21:48:47 +0800 Subject: [PATCH 007/116] fix(tracker): reject invalid calendar dates (#218) --- src/core/tracker.ts | 6 ++++++ test/tracker.test.ts | 6 ++++++ 2 files changed, 12 insertions(+) diff --git a/src/core/tracker.ts b/src/core/tracker.ts index 7db9391..62ba22a 100644 --- a/src/core/tracker.ts +++ b/src/core/tracker.ts @@ -104,10 +104,16 @@ export function parseEvents(value: unknown, currency: string): TrackerEvent[] { 'Event currency differs from the fleet. Import into a fleet with the matching currency.', ); const at = e['at'] ?? null; + const datePart = typeof at === 'string' ? /^\d{4}-\d{2}-\d{2}/.exec(at)?.[0] : undefined; + const validCalendarDate = + datePart !== undefined && + Number.isFinite(Date.parse(`${datePart}T00:00:00.000Z`)) && + new Date(`${datePart}T00:00:00.000Z`).toISOString().slice(0, 10) === datePart; if ( at !== null && (typeof at !== 'string' || !/^\d{4}-\d{2}-\d{2}T/.test(at) || + !validCalendarDate || !Number.isFinite(Date.parse(at))) ) throw new TrackerProblem('Event time must be an ISO timestamp or null.'); diff --git a/test/tracker.test.ts b/test/tracker.test.ts index d20ed8a..f09b892 100644 --- a/test/tracker.test.ts +++ b/test/tracker.test.ts @@ -85,6 +85,12 @@ test('parser rejects foreign currencies, nonfinite or negative money, extra meta assert.throws(() => parseEvents([event('a', 'receipt', 1, { at: 'not-a-date' })], 'USD')); }); +test('parser rejects calendar-invalid event timestamps instead of moving them to another date', () => { + assert.throws(() => + parseEvents([event('invalid-date', 'receipt', 1, { at: '2026-02-30T12:00:00.000Z' })], 'USD'), + ); +}); + const costReport = { since: 1700000000000, sessions: [ From 2fa3b775db188baf3bdbf88ed5467085cff4b49b Mon Sep 17 00:00:00 2001 From: RowletCC Date: Thu, 24 Sep 2026 21:48:55 +0800 Subject: [PATCH 008/116] fix(recommendations): keep rewrite signature selected (#219) --- src/views/recommendations.tsx | 19 +++++++++++++++++-- test/recommendations.test.ts | 13 +++++++++++++ 2 files changed, 30 insertions(+), 2 deletions(-) diff --git a/src/views/recommendations.tsx b/src/views/recommendations.tsx index 5fd3d0a..88a333a 100644 --- a/src/views/recommendations.tsx +++ b/src/views/recommendations.tsx @@ -86,6 +86,18 @@ export interface RecommendFormProps { error?: string; } +function selectedSignature( + existing: Recommendation | null, + values: Record, + asOptions: { slug: string; name: string }[], +): string { + if (values['as'] !== undefined) return values['as']; + const employerSlug = existing?.author.kind === 'employer' ? existing.author.slug : null; + return employerSlug !== null && asOptions.some((option) => option.slug === employerSlug) + ? employerSlug + : ''; +} + export const RecommendForm: FC = ({ action, asOptions, @@ -128,12 +140,15 @@ export const RecommendForm: FC = ({ > - -
- - - It will not invent a salary. Pay comes from what you write here, or stays empty. - + + +
+ + + It will not invent a salary. Pay comes from what you write here, or stays empty. + +
- - )} + )} -
')); }); +test('the application form shows the missing agent disclosure error beside its field', () => { + const html = String( + JobDetail({ + job: { ...job, agentPolicy: 'disclose' }, + html: '', + publicUrl: 'https://x.test', + problems: [ + { + field: 'agent', + message: 'This employer asks applications written with an agent to say so.', + }, + ], + values: {}, + signedIn: false, + resumes: [], + } as never), + ); + + assert.match( + html, + /

Skills<\/h3>/, 'the resume sections stay on the page'); const detail = (await (await get(`/api/v1/candidates/${slug}`)).json()) as { markdown: string; listed: boolean; From d03e6a2d3212915df5013d68b9912f9944a6736c Mon Sep 17 00:00:00 2001 From: RowletCC Date: Thu, 24 Sep 2026 23:10:17 +0800 Subject: [PATCH 047/116] fix(apply): keep drafts from sending to closed jobs (#258) --- src/core/applications.ts | 33 ++++++++++++++---- src/server/routes/api.ts | 10 +++++- src/server/routes/openapi.ts | 4 ++- test/api.test.ts | 66 ++++++++++++++++++++++++++++++++++++ test/applications.test.ts | 20 ++++++++++- 5 files changed, 123 insertions(+), 10 deletions(-) diff --git a/src/core/applications.ts b/src/core/applications.ts index ace5351..654efb6 100644 --- a/src/core/applications.ts +++ b/src/core/applications.ts @@ -224,17 +224,36 @@ export async function submitApplication( pool: pg.Pool, id: string, userId: string, -): Promise { +): Promise<'submitted' | 'job_not_open' | 'not_found'> { // Same guard as decideApplication: the id arrives from a URL, and a string // that is not a uuid makes Postgres raise rather than match nothing. - if (!UUID.test(id)) return false; - const result = await pool.query( - `update applications - set status = 'new', submitted_at = now() - where id = $1 and user_id = $2 and submitted_at is null`, + if (!UUID.test(id)) return 'not_found'; + const result = await pool.query<{ outcome: 'submitted' | 'job_not_open' | 'not_found' }>( + `with draft as ( + select a.id, + exists ( + select 1 from jobs j + where j.id = a.job_id and j.status = 'published' + and j.published_at is not null and j.published_at <= now() + and (j.expires_at is null or j.expires_at > now()) + ) as accepting + from applications a + where a.id = $1 and a.user_id = $2 and a.submitted_at is null + ), submitted as ( + update applications a + set status = 'new', submitted_at = now() + from draft d + where a.id = d.id and a.submitted_at is null and d.accepting + returning a.id + ) + select case + when exists (select 1 from submitted) then 'submitted' + when exists (select 1 from draft where not accepting) then 'job_not_open' + else 'not_found' + end as outcome`, [id, userId], ); - return (result.rowCount ?? 0) > 0; + return result.rows[0]?.outcome ?? 'not_found'; } export async function listDraftApplications( diff --git a/src/server/routes/api.ts b/src/server/routes/api.ts index 18f3da8..1e7a9c6 100644 --- a/src/server/routes/api.ts +++ b/src/server/routes/api.ts @@ -706,7 +706,15 @@ export function apiRoutes(): Hono { const viewer = viewerOf(c); if (viewer === null) return fail(c, 401, 'unauthenticated', 'Sign in first.'); const sent = await submitApplication(pool, c.req.param('id'), viewer.id); - if (!sent) { + if (sent === 'job_not_open') { + return fail( + c, + 409, + 'job_not_open', + 'This listing is no longer accepting applications. Your draft is still saved.', + ); + } + if (sent === 'not_found') { return fail( c, 404, diff --git a/src/server/routes/openapi.ts b/src/server/routes/openapi.ts index 0bf15dd..a7455a7 100644 --- a/src/server/routes/openapi.ts +++ b/src/server/routes/openapi.ts @@ -316,9 +316,11 @@ export function openApiDocument(config: Config): Record { post: { tags: ['apply'], summary: 'Send a draft application.', + description: + 'The draft is sent only while its listing is published and unexpired. If the listing has closed or expired, the draft stays saved and the response is 409.', security: [{ bearer: [] }], parameters: [pathParam('id')], - responses: { 200: ok('Sent.'), 401: err(), 404: err() }, + responses: { 200: ok('Sent.'), 401: err(), 404: err(), 409: err() }, }, }, '/api/v1/orgs': { diff --git a/test/api.test.ts b/test/api.test.ts index bdcd169..4a93cf4 100644 --- a/test/api.test.ts +++ b/test/api.test.ts @@ -1213,6 +1213,72 @@ describe('the API', { skip: reason === '' ? false : `no database: ${reason}` }, assert.doesNotMatch(submitted, /Sent 2 days ago|Not sent to the employer/); }); + test('a prepared application stays a draft after its listing closes', async () => { + if (pool === null) return; + const { createSession, ensureUser } = await import('../dist/core/auth.js'); + const { createOrg } = await import('../dist/core/orgs.js'); + const stamp = `${Date.now()}${Math.random().toString(36).slice(2, 7)}`; + const employer = await ensureUser(pool as never, `closed+${stamp}@example.com`, 'Employer'); + const employerToken = await createSession(pool as never, employer.id, { label: 'web' }); + const org = await createOrg(pool as never, employer.id, { name: `Closed ${stamp}` }); + if (typeof org === 'string') throw new Error(org); + const employerAuth = { authorization: `Bearer ${employerToken}` }; + const candidate = await ensureUser( + pool as never, + `candidate+${stamp}@example.com`, + 'Candidate', + ); + const candidateToken = await createSession(pool as never, candidate.id, { label: 'web' }); + const candidateAuth = { authorization: `Bearer ${candidateToken}` }; + + const created = (await ( + await post( + '/api/v1/jobs', + { + org: org.slug, + title: `Closing ${stamp}`, + description: 'A listing that takes applications on the board.', + agentPolicy: 'welcome', + pay: ['$100 an hour'], + }, + employerAuth, + ) + ).json()) as { job: { slug: string } }; + const slug = created.job.slug; + await post(`/api/v1/jobs/${slug}/publish`, {}, employerAuth); + const prepared = (await ( + await post( + `/api/v1/jobs/${slug}/apply`, + { + name: 'Candidate', + email: `candidate+${stamp}@example.com`, + cover: 'Please consider me.', + submit: false, + }, + candidateAuth, + ) + ).json()) as { applicationId: string }; + + await post(`/api/v1/jobs/${slug}/close`, {}, employerAuth); + const submitted = await post( + `/api/v1/applications/${prepared.applicationId}/submit`, + {}, + candidateAuth, + ); + assert.equal(submitted.status, 409, await submitted.text()); + + const drafts = (await (await get('/api/v1/applications/drafts', candidateAuth)).json()) as { + items: { id: string }[]; + }; + assert.ok(drafts.items.some((item) => item.id === prepared.applicationId)); + const inbox = (await ( + await get(`/api/v1/jobs/${slug}/applications`, employerAuth) + ).json()) as { + items: { id: string }[]; + }; + assert.ok(!inbox.items.some((item) => item.id === prepared.applicationId)); + }); + test('a draft nobody sent cannot be decided on', async () => { // An employer cannot see a draft, so an employer cannot reject one out // from under the candidate who has not released it yet. diff --git a/test/applications.test.ts b/test/applications.test.ts index eeefaaf..99ccaeb 100644 --- a/test/applications.test.ts +++ b/test/applications.test.ts @@ -44,10 +44,28 @@ test('submitting a draft with a malformed id is a miss, not a database error', a 'not-a-uuid', '00000000-0000-4000-8000-000000000000', ); - assert.equal(sent, false); + assert.equal(sent, 'not_found'); assert.equal(reached, false, 'a malformed id never reaches the database'); }); +test('submitting a draft reports when its job has stopped accepting applications', async () => { + let sql = ''; + const pool = { + query: async (statement: string) => { + sql = statement; + return { rows: [{ outcome: 'job_not_open' }], rowCount: 0 }; + }, + }; + const sent = await submitApplication( + pool as never, + '00000000-0000-4000-8000-000000000001', + '00000000-0000-4000-8000-000000000002', + ); + assert.equal(sent, 'job_not_open'); + assert.match(sql, /j\.status = 'published'/); + assert.match(sql, /j\.expires_at is null or j\.expires_at > now\(\)/); +}); + test('an application field named __proto__ keeps its submitted answer', () => { const result = validateApplication( { From 23b9468db0ed62072bddde54ee5a240132e08a12 Mon Sep 17 00:00:00 2001 From: RowletCC Date: Thu, 24 Sep 2026 23:10:25 +0800 Subject: [PATCH 048/116] fix(directory): redact phone numbers from profile summaries (#259) --- src/core/candidates.ts | 30 ++++++++++++------------- src/markup/resume.ts | 8 +++++++ test/redaction.test.ts | 50 ++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 72 insertions(+), 16 deletions(-) diff --git a/src/core/candidates.ts b/src/core/candidates.ts index 2c6b2a6..85225f6 100644 --- a/src/core/candidates.ts +++ b/src/core/candidates.ts @@ -10,7 +10,12 @@ import type { Resume } from './resumes.ts'; import type { CandidateSummary } from '../views/candidates.tsx'; import { parseCapacity } from './capacity.ts'; -import { type OpenResume, parseResume, redactContactChannels } from '../markup/resume.ts'; +import { + type OpenResume, + hasContactChannel, + parseResume, + redactContactChannels, +} from '../markup/resume.ts'; /** Contact keys that read as a place rather than an address. */ const LOCATION_KEYS = /^(location|based|city|where|region)$/i; @@ -86,20 +91,13 @@ function plainName(value: string): string { } } -/** - * "Looks like an email address", loosely — the check a public field needs, - * not a validator. Used anywhere directory text could carry a channel. - */ -const HAS_ADDRESS = /[^\s@]+@[^\s@]+\.[^\s@]+/; - /** * The name shown in the directory. * * A resume with no usable h1 falls back to its title, which its owner wrote - * and which is at least theirs. It never falls back to an email address: - * publishing a resume should not mean publishing an address as the headline. - * An h1 is free text, so "Jane Doe jane@example.com" is a name the parser - * returns without complaint — the address check has to live here, on the + * and which is at least theirs. It never falls back to a contact channel: + * publishing a resume should not mean publishing an address or phone number + * as the headline. An h1 is free text, so the check has to live here, on the * field, the same way it does for the headline. */ export function nameOf(resume: Resume): string { @@ -109,12 +107,12 @@ export function nameOf(resume: Resume): string { parsed !== undefined && parsed !== '' && parsed.length <= NAME_MAX && - !HAS_ADDRESS.test(parsed) + !hasContactChannel(parsed) ) { return parsed; } const title = resume.title.trim(); - return title === '' || title.length > NAME_MAX || HAS_ADDRESS.test(title) + return title === '' || title.length > NAME_MAX || hasContactChannel(title) ? 'Candidate' : title; } @@ -167,15 +165,15 @@ export function resumeForViewer( * A backfill would repair those rows, but it would not stop the next one: any * resume saved by an older build, restored from a backup, or written straight * into the column arrives here the same way. This is a public directory page - * and the field is one line of text, so it is checked on the way out. Cheap, - * and it cannot go stale. + * and the field is one line of text, so it is checked for contact channels on + * the way out. Cheap, and it cannot go stale. */ function headlineOf(resume: Resume): string | null { const headline = resume.parsed?.headline; if (headline === null || headline === undefined) return null; const cleaned = headline.replace(/\*\*|__/g, '').trim(); if (cleaned === '') return null; - return HAS_ADDRESS.test(cleaned) ? null : cleaned; + return hasContactChannel(cleaned) ? null : cleaned; } export function toCandidateSummary(resume: Resume): CandidateSummary { diff --git a/src/markup/resume.ts b/src/markup/resume.ts index 08a2608..fe45b6d 100644 --- a/src/markup/resume.ts +++ b/src/markup/resume.ts @@ -479,6 +479,14 @@ const EMAIL_IN_TEXT = /[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/g; const PHONE_IN_TEXT = /(?:\+\d[\d ()./-]{6,}\d|\(\d{3}\)[\d ()./-]{5,}\d|\b\d{3}[-.\s]\d{3}[-.\s]\d{4}\b)/g; +/** Whether plain summary text contains a channel the public resume withholds. */ +export function hasContactChannel(text: string): boolean { + return ( + new RegExp(EMAIL_IN_TEXT.source).test(text) || + new RegExp(PHONE_IN_TEXT.source).test(text) + ); +} + /** * The contact block, minus every way to actually reach the person. * diff --git a/test/redaction.test.ts b/test/redaction.test.ts index 607fe2a..9be6837 100644 --- a/test/redaction.test.ts +++ b/test/redaction.test.ts @@ -218,6 +218,56 @@ test('a name holding an address is dropped on the directory card', () => { assert.equal(summary.name, 'Jane Doe'); }); +test('a phone in the name line is dropped on the directory card', () => { + const summary = toCandidateSummary({ + id: 'r1', + userId: 'u1', + slug: 'jane', + title: 'Jane Doe', + markdown: '# x\n', + parsed: { + name: 'Jane Doe +1 (408) 555-0100', + headline: null, + contact: [], + sections: [], + markdown: '', + warnings: [], + }, + visibility: 'public', + publicSlug: 'jane', + sourceName: null, + createdAt: '2026-09-09T00:00:00.000Z', + updatedAt: '2026-09-09T00:00:00.000Z', + } as never); + + assert.equal(summary.name, 'Jane Doe'); +}); + +test('a phone in the headline is dropped from the directory card', () => { + const summary = toCandidateSummary({ + id: 'r1', + userId: 'u1', + slug: 'jane', + title: 'Jane Doe', + markdown: '# Jane Doe\n', + parsed: { + name: 'Jane Doe', + headline: 'Call me at +1 (408) 555-0100', + contact: [], + sections: [], + markdown: '', + warnings: [], + }, + visibility: 'public', + publicSlug: 'jane', + sourceName: null, + createdAt: '2026-09-09T00:00:00.000Z', + updatedAt: '2026-09-09T00:00:00.000Z', + } as never); + + assert.equal(summary.headline, null); +}); + test('a title holding an address is not the fallback either', () => { const name = nameOf({ id: 'r1', From c3e63e529d11f181cf2086435323f5e0576a1e95 Mon Sep 17 00:00:00 2001 From: RowletCC Date: Thu, 24 Sep 2026 23:10:33 +0800 Subject: [PATCH 049/116] fix(cli): return updated notifications after marking read (#260) --- src/cli/watches.ts | 21 ++++++++--- test/cli-notifications-mark-read.test.ts | 47 ++++++++++++++++++++++++ 2 files changed, 63 insertions(+), 5 deletions(-) create mode 100644 test/cli-notifications-mark-read.test.ts diff --git a/src/cli/watches.ts b/src/cli/watches.ts index db6915a..7b2beef 100644 --- a/src/cli/watches.ts +++ b/src/cli/watches.ts @@ -82,14 +82,25 @@ export async function runNotifications( out: (human: string, machine: unknown) => number, ): Promise { const unreadOnly = flagBool(args, 'unread'); - const result = await client.notifications({ unreadOnly }); - if (flagBool(args, 'read')) await client.markNotificationsRead(); + let result = await client.notifications({ unreadOnly }); + let marked = 0; + if (flagBool(args, 'read')) { + ({ read: marked } = await client.markNotificationsRead()); + const updated = await client.notifications(); + const displayed = new Set(result.items.map((item) => item.id)); + result = { + ...updated, + items: unreadOnly ? updated.items.filter((item) => displayed.has(item.id)) : updated.items, + }; + } if (result.items.length === 0) return out(unreadOnly ? 'Nothing unread.' : 'No notifications yet.', result); const head = - result.unread === 0 - ? '' - : `${bold(`${result.unread} unread`)}${flagBool(args, 'read') ? dim(', now marked read') : dim(' (--read marks them read)')}\n\n`; + marked > 0 + ? `${bold(`${marked} unread`)}${dim(', now marked read')}\n\n` + : result.unread === 0 + ? '' + : `${bold(`${result.unread} unread`)}${dim(flagBool(args, 'read') ? ' (new since marking read)' : ' (--read marks them read)')}\n\n`; return out(head + result.items.map(notificationLine).join('\n\n'), result); } diff --git a/test/cli-notifications-mark-read.test.ts b/test/cli-notifications-mark-read.test.ts new file mode 100644 index 0000000..4e18539 --- /dev/null +++ b/test/cli-notifications-mark-read.test.ts @@ -0,0 +1,47 @@ +import assert from 'node:assert/strict'; +import { test } from 'node:test'; +import { runNotifications } from '../dist/cli/watches.js'; + +test('notifications --read returns the updated unread count and read timestamps', async () => { + const before = notification(null); + const after = notification('2026-09-24T12:00:00.000Z'); + let reads = 0; + const client = { + async notifications() { + reads += 1; + return reads === 1 ? { items: [before], unread: 1 } : { items: [after], unread: 0 }; + }, + async markNotificationsRead() { + return { read: 1 }; + }, + }; + let human = ''; + let machine: unknown; + + const code = await runNotifications( + { command: 'notifications', positional: [], flags: { read: true } }, + client as never, + (text, data) => { + human = text; + machine = data; + return 0; + }, + ); + + assert.equal(code, 0); + assert.match(human, /now marked read/); + assert.deepEqual(machine, { items: [after], unread: 0 }); + assert.equal(reads, 2); +}); + +function notification(readAt: string | null) { + return { + id: 'notification-1', + kind: 'watch', + title: 'Rust engineer', + body: 'A new remote job matched your watch.', + url: '/jobs/rust-engineer', + createdAt: '2026-09-24T11:00:00.000Z', + readAt, + }; +} From 15bf687976a8dc675ed450e4fe634664065853f9 Mon Sep 17 00:00:00 2001 From: RowletCC Date: Thu, 24 Sep 2026 23:10:40 +0800 Subject: [PATCH 050/116] fix(jobs): preserve omitted settings in patches (#261) --- src/server/routes/api.ts | 2 ++ test/api.test.ts | 51 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 53 insertions(+) diff --git a/src/server/routes/api.ts b/src/server/routes/api.ts index 1e7a9c6..e40cf25 100644 --- a/src/server/routes/api.ts +++ b/src/server/routes/api.ts @@ -578,6 +578,8 @@ export function apiRoutes(): Hono { requirements: body['requirements'] ?? job.requirements, responsibilities: body['responsibilities'] ?? job.responsibilities, agentPolicy: body['agentPolicy'] ?? job.agentPolicy, + applySchema: Object.hasOwn(body, 'applySchema') ? body['applySchema'] : job.apply.schema, + expiresAt: Object.hasOwn(body, 'expiresAt') ? body['expiresAt'] : job.expiresAt, ...payPatch(body, job), }, job.org.id, diff --git a/test/api.test.ts b/test/api.test.ts index 4a93cf4..d448f69 100644 --- a/test/api.test.ts +++ b/test/api.test.ts @@ -2947,6 +2947,57 @@ describe('the API', { skip: reason === '' ? false : `no database: ${reason}` }, assert.equal(edited.job.title, created.job.title); }); + test('an edit that omits the application schema and expiry preserves both', async () => { + if (pool === null) return; + const { createSession } = await import('../dist/core/auth.js'); + const owner = await pool.query(`select user_id from memberships limit 1`); + const token = await createSession(pool as never, owner.rows[0]?.['user_id'], { label: 't' }); + const auth = { authorization: `Bearer ${token}` }; + const expiresAt = '2099-01-01T00:00:00.000Z'; + + const created = (await ( + await post( + '/api/v1/jobs', + { + org: 'example-works', + title: `Preserve settings ${Date.now()}`, + description: 'A listing with a custom question and an expiry date.', + agentPolicy: 'welcome', + expiresAt, + applySchema: { + fields: [ + { + name: 'portfolio', + label: 'Portfolio link', + type: 'url', + required: true, + maxLength: 500, + }, + ], + }, + }, + auth, + ) + ).json()) as { job: { slug: string } }; + + const edited = (await ( + await patch( + `/api/v1/jobs/${created.job.slug}`, + { description: 'A corrected description.' }, + auth, + ) + ).json()) as { + job: { + expiresAt: string | null; + apply: { schema: { fields: { name: string; label: string }[] } }; + }; + }; + assert.equal(edited.job.expiresAt, expiresAt); + assert.deepEqual(edited.job.apply.schema.fields, [ + { name: 'portfolio', label: 'Portfolio link', type: 'url', required: true, maxLength: 500 }, + ]); + }); + test("editing someone else's listing is refused", async () => { if (pool === null) return; const { createSession, ensureUser } = await import('../dist/core/auth.js'); From 5ca428931859d2e23398034fab4385bff826a6d4 Mon Sep 17 00:00:00 2001 From: RowletCC Date: Thu, 24 Sep 2026 23:10:45 +0800 Subject: [PATCH 051/116] fix(import): detect mislabeled Word resumes (#262) --- src/core/import.ts | 15 ++++++++++++--- src/core/zip.ts | 5 +++++ test/import-document.test.ts | 8 ++++++++ 3 files changed, 25 insertions(+), 3 deletions(-) diff --git a/src/core/import.ts b/src/core/import.ts index 6f2dfef..6a09a99 100644 --- a/src/core/import.ts +++ b/src/core/import.ts @@ -23,7 +23,7 @@ import { mkdtemp, rm, writeFile } from 'node:fs/promises'; import { tmpdir } from 'node:os'; import { join } from 'node:path'; import { promisify } from 'node:util'; -import { readZipEntry, ZipProblem } from './zip.ts'; +import { hasZipEntry, readZipEntry, ZipProblem } from './zip.ts'; const run = promisify(execFile); @@ -78,8 +78,17 @@ function classify(extension: string, mime: string, bytes: Buffer): Kind { // The magic bytes win over the extension. A resume renamed from .pdf to // .docx is a mistake someone makes once, and the file itself is not lying. if (bytes.subarray(0, 5).toString('latin1') === '%PDF-') return 'pdf'; - if (bytes.subarray(0, 2).toString('latin1') === 'PK' && (extension === 'docx' || mime.includes('wordprocessingml'))) { - return 'docx'; + if (bytes.subarray(0, 2).toString('latin1') === 'PK') { + if (extension === 'docx' || mime.includes('wordprocessingml')) return 'docx'; + // Word documents are ZIP archives. A renamed .docx still identifies + // itself through its document entry, even when the extension and browser + // MIME type describe something else. + try { + if (hasZipEntry(bytes, 'word/document.xml')) return 'docx'; + } catch { + // An unrelated or malformed ZIP is not a Word document; keep checking + // the filename and MIME type below for the useful import error. + } } if (['md', 'markdown', 'mdown', 'mkd'].includes(extension)) return 'markdown'; if (extension === 'txt' || mime === 'text/plain') return 'text'; diff --git a/src/core/zip.ts b/src/core/zip.ts index 66c145e..51b5711 100644 --- a/src/core/zip.ts +++ b/src/core/zip.ts @@ -89,6 +89,11 @@ function readEntries(buffer: Buffer): Entry[] { return entries; } +/** Whether a structurally valid archive contains a named entry. */ +export function hasZipEntry(buffer: Buffer, wanted: string): boolean { + return readEntries(buffer).some((entry) => entry.name === wanted); +} + export function readZipEntry(buffer: Buffer, wanted: string): Buffer | null { const entry = readEntries(buffer).find((item) => item.name === wanted); if (entry === undefined) return null; diff --git a/test/import-document.test.ts b/test/import-document.test.ts index 136133e..ff53380 100644 --- a/test/import-document.test.ts +++ b/test/import-document.test.ts @@ -32,3 +32,11 @@ test('a Word import preserves inline controls and decodes XML text exactly once' warnings: [], }); }); + +test('a Word resume still imports when its filename says PDF', async () => { + const bytes = await readFile(new URL('./fixtures/docx-inline-controls.docx', import.meta.url)); + const result = await importDocument('resume.pdf', bytes, 'application/pdf'); + + assert.equal(result.via, 'docx'); + assert.match(result.markdown, /Plain & escaped /); +}); From cc20958a9dac9371c834420054cc136af85bcca5 Mon Sep 17 00:00:00 2001 From: RowletCC Date: Thu, 24 Sep 2026 23:10:52 +0800 Subject: [PATCH 052/116] fix(search): require every requested job tag (#263) --- src/core/jobs.ts | 13 ++++++++--- src/server/routes/openapi.ts | 5 ++++- test/api.test.ts | 43 ++++++++++++++++++++++++++++++++++++ 3 files changed, 57 insertions(+), 4 deletions(-) diff --git a/src/core/jobs.ts b/src/core/jobs.ts index ccd37d0..6be280c 100644 --- a/src/core/jobs.ts +++ b/src/core/jobs.ts @@ -264,9 +264,16 @@ function conditions( } if (query.tags.length > 0) { params.push(query.tags); - // Matching either list means "python" finds a job that called it a tag and - // one that called it part of the stack. - where.push(`(j.tags && $${params.length}::text[] or j.stack && $${params.length}::text[])`); + // Every requested skill narrows the search, whether a listing put it in + // tags or stack. A single array-overlap test made `rust,typescript` mean + // either skill and returned unrelated jobs from a search that looked exact. + where.push( + `((j.tags && $${params.length}::text[]) or (j.stack && $${params.length}::text[])) + and not exists ( + select 1 from unnest($${params.length}::text[]) as requested(tag) + where not (requested.tag = any(j.tags) or requested.tag = any(j.stack)) + )`, + ); } if (query.salaryMin !== null) { params.push(query.salaryMin); diff --git a/src/server/routes/openapi.ts b/src/server/routes/openapi.ts index a7455a7..7dcf63e 100644 --- a/src/server/routes/openapi.ts +++ b/src/server/routes/openapi.ts @@ -154,7 +154,10 @@ export function openApiDocument(config: Config): Record { param('workplace', 'remote, hybrid, onsite'), param('seniority', 'intern, junior, mid, senior, staff, principal, lead'), param('agentPolicy', 'welcome, disclose, human-only'), - param('tag', 'Repeatable. Matches tags and stack.'), + param( + 'tag', + 'Repeatable, or comma-separated as tags=. Every requested tag must occur in tags or stack.', + ), param( 'salaryMin', 'Minimum annualised salary, compared against the top of each range.', diff --git a/test/api.test.ts b/test/api.test.ts index d448f69..0fd995f 100644 --- a/test/api.test.ts +++ b/test/api.test.ts @@ -3288,6 +3288,49 @@ describe('the API', { skip: reason === '' ? false : `no database: ${reason}` }, assert.ok(comma.total > 0, `expected ${tag} to match something`); }); + test('multiple job tags narrow across both tags and stack', async () => { + if (pool === null) return; + const { createSession } = await import('../dist/core/auth.js'); + const owner = await pool.query(`select user_id from memberships limit 1`); + const token = await createSession(pool as never, owner.rows[0]?.['user_id'], { label: 't' }); + const auth = { authorization: `Bearer ${token}` }; + const stamp = Date.now().toString(36); + const first = `need-a-${stamp}`; + const second = `need-b-${stamp}`; + const postPublished = async (title: string, tags: string[], stack: string[]) => { + const response = await post( + '/api/v1/jobs', + { + org: 'example-works', + title: `${title} ${stamp}`, + description: 'A paid listing used to check combined skill filtering.', + agentPolicy: 'welcome', + tags, + stack, + pay: ['$1 per task'], + payMethod: 'SOL', + publish: true, + }, + auth, + ); + const body = await response.text(); + assert.equal(response.status, 201, body); + return (JSON.parse(body) as { job: { slug: string } }).job.slug; + }; + + const matching = await postPublished('Both skills', [first], [second]); + await postPublished('Only first skill', [first], []); + await postPublished('Only second skill', [], [second]); + + const page = (await ( + await get(`/api/v1/jobs?org=example-works&tags=${first},${second}&limit=100`) + ).json()) as { items: { slug: string }[] }; + assert.deepEqual( + page.items.map((job) => job.slug), + [matching], + ); + }); + test('one query, every representation', async () => { // A filter written once should work whichever way you read the board. // /jobs.rss and /feed.rss built their query from an EMPTY From 1d279cde74d31217f603b49e69fbb190e9d25b5f Mon Sep 17 00:00:00 2001 From: RowletCC Date: Thu, 24 Sep 2026 23:10:59 +0800 Subject: [PATCH 053/116] fix(discovery): omit inactive jobs from sitemaps (#264) --- src/server/routes/discovery.ts | 5 ++++- test/api.test.ts | 12 ++++++++++++ 2 files changed, 16 insertions(+), 1 deletion(-) diff --git a/src/server/routes/discovery.ts b/src/server/routes/discovery.ts index a1a23ec..d184c6d 100644 --- a/src/server/routes/discovery.ts +++ b/src/server/routes/discovery.ts @@ -525,7 +525,9 @@ export function discoveryRoutes(): Hono { const months = await pool.query<{ month: string; latest: string }>( `select to_char(published_at, 'YYYY-MM') as month, max(published_at)::text as latest from jobs - where status = 'published' and published_at is not null + where status = 'published' + and published_at is not null and published_at <= now() + and (expires_at is null or expires_at > now()) group by 1 order by 1 desc`, ); const entries = months.rows @@ -570,6 +572,7 @@ export function discoveryRoutes(): Hono { const jobs = await pool.query<{ slug: string; updated_at: string }>( `select slug, updated_at from jobs where status = 'published' and published_at is not null + and published_at <= now() and (expires_at is null or expires_at > now()) and to_char(published_at, 'YYYY-MM') = $1 order by published_at desc limit 50000`, [name], diff --git a/test/api.test.ts b/test/api.test.ts index 0fd995f..7397577 100644 --- a/test/api.test.ts +++ b/test/api.test.ts @@ -705,6 +705,18 @@ describe('the API', { skip: reason === '' ? false : `no database: ${reason}` }, const expired = await createPublished(`Expired ${stamp}`, '2000-01-01T00:00:00.000Z'); const live = await createPublished(`Live ${stamp}`, '2099-01-01T00:00:00.000Z'); + // A published row can outlive its public listing. Keep it in a month + // with no other jobs so both the sitemap index and its monthly chunk + // prove they describe only URLs readers can open. + await pool.query(`update jobs set published_at = $2 where id = $1`, [ + expired.id, + '1900-01-15T00:00:00.000Z', + ]); + const sitemapIndex = await (await get('/sitemap.xml')).text(); + assert.ok(!sitemapIndex.includes('/sitemaps/1900-01.xml')); + const expiredMonth = await (await get('/sitemaps/1900-01.xml')).text(); + assert.ok(!expiredMonth.includes(`/jobs/${expired.slug}`)); + const search = (await (await get(`/api/v1/jobs?org=${org.slug}&limit=100`)).json()) as { items: { slug: string }[]; }; From 441607d7f0621e4123ba79f0e4ce6f52a0225561 Mon Sep 17 00:00:00 2001 From: RowletCC Date: Thu, 24 Sep 2026 23:12:32 +0800 Subject: [PATCH 054/116] fix(inbox): reuse threads for concurrent first messages (#265) --- src/core/inbox.ts | 82 ++++++++++++++++++++------------------ test/inbox-parties.test.ts | 58 +++++++++++++++++++++++++-- 2 files changed, 99 insertions(+), 41 deletions(-) diff --git a/src/core/inbox.ts b/src/core/inbox.ts index 2ebd982..1edc5dd 100644 --- a/src/core/inbox.ts +++ b/src/core/inbox.ts @@ -193,47 +193,53 @@ export async function startThread( } const jobId = input.jobId ?? null; - - // Find the existing conversation between these parties about this listing. - // "These parties" includes which identity the sender is using: a member of - // two employers has one row per thread, and `me.org_id` says whether that - // row is them personally or them speaking for one employer. Matching only - // on `me.user_id` would deliver a message written as Org B into a thread - // with Org A, shown to the other side as Org A and readable by Org A's - // members - and a personal message into an employer's thread the same way. - const existing = await pool.query<{ id: string }>( - `select t.id from threads t - where t.job_id is not distinct from $3 - and exists (select 1 from thread_participants me - where me.thread_id = t.id and me.user_id = $1 - and me.org_id is not distinct from $4) - and exists (select 1 from thread_participants them - where them.thread_id = t.id - and ${to.kind === 'candidate' ? 'them.user_id = $2 and them.org_id is null' : 'them.org_id = $2'}) - order by t.last_message_at desc limit 1`, - [senderId, to.kind === 'candidate' ? to.userId : to.orgId, jobId, asOrg], - ); - const found = existing.rows[0]; - if (found !== undefined) { - const message = await sendMessage(pool, found.id, senderId, body); - if (typeof message === 'string') return message; - return { threadId: found.id, messageId: message.id, created: false }; - } - - // The limit is on *new* conversations: replying in one you already have is - // never what a spammer is doing. - const recent = await pool.query<{ count: number }>( - `select count(*)::int as count from threads - where created_by = $1 and created_at > now() - interval '1 day'`, - [senderId], - ); - if ((recent.rows[0]?.count ?? 0) >= DAILY_THREADS) { - return `That is ${DAILY_THREADS} new conversations today. Reply in one you have, or come back tomorrow.`; - } - + const senderParty = asOrg === null ? `candidate:${senderId}` : `employer:${asOrg}`; + const recipientParty = + to.kind === 'candidate' ? `candidate:${to.userId}` : `employer:${to.orgId}`; + const conversationKey = JSON.stringify([jobId, ...[senderParty, recipientParty].sort()]); const client = await pool.connect(); try { await client.query('begin'); + // Two first messages can otherwise both miss the lookup below and create + // duplicate threads. Lock the conversation identity before checking it. + await client.query('select pg_advisory_xact_lock(hashtextextended($1, 0))', [conversationKey]); + + // Find the existing conversation between these parties about this listing. + // "These parties" includes which identity the sender is using: a member of + // two employers has one row per thread, and `me.org_id` says whether that + // person is themself or speaking for one employer. + const existing = await client.query<{ id: string }>( + `select t.id from threads t + where t.job_id is not distinct from $3 + and exists (select 1 from thread_participants me + where me.thread_id = t.id and me.user_id = $1 + and me.org_id is not distinct from $4) + and exists (select 1 from thread_participants them + where them.thread_id = t.id + and ${to.kind === 'candidate' ? 'them.user_id = $2 and them.org_id is null' : 'them.org_id = $2'}) + order by t.last_message_at desc limit 1`, + [senderId, to.kind === 'candidate' ? to.userId : to.orgId, jobId, asOrg], + ); + const found = existing.rows[0]; + if (found !== undefined) { + await client.query('commit'); + const message = await sendMessage(pool, found.id, senderId, body); + if (typeof message === 'string') return message; + return { threadId: found.id, messageId: message.id, created: false }; + } + + // The limit is on new conversations: replying in one you have is never + // what a spammer is doing. + const recent = await client.query<{ count: number }>( + `select count(*)::int as count from threads + where created_by = $1 and created_at > now() - interval '1 day'`, + [senderId], + ); + if ((recent.rows[0]?.count ?? 0) >= DAILY_THREADS) { + await client.query('rollback'); + return `That is ${DAILY_THREADS} new conversations today. Reply in one you have, or come back tomorrow.`; + } + const thread = await client.query<{ id: string }>( `insert into threads (subject, job_id, created_by) values ($1, $2, $3) returning id`, [subject === '' ? preview(body).slice(0, SUBJECT_MAX) : subject, jobId, senderId], diff --git a/test/inbox-parties.test.ts b/test/inbox-parties.test.ts index c233f6f..25892e9 100644 --- a/test/inbox-parties.test.ts +++ b/test/inbox-parties.test.ts @@ -42,11 +42,17 @@ function makePool() { }[], }; let serial = 0; + let lockQueue: Promise = Promise.resolve(); const nextId = () => `00000000-0000-4000-8000-${String(++serial).padStart(12, '0')}`; const now = () => ++serial + 1_000_000; - const query = async (sql: string, params: unknown[] = []) => { - if (sql === 'begin' || sql === 'commit' || sql === 'rollback') return { rows: [] }; + const query = async (sql: string, params: unknown[] = [], unlock?: () => void) => { + if (sql === 'begin') return { rows: [] }; + if (sql === 'commit' || sql === 'rollback') { + unlock?.(); + return { rows: [] }; + } + if (sql.includes('pg_advisory_xact_lock')) return { rows: [] }; // sendMessage's CTE: insert + touch last_message_at + mark sender read. if (sql.includes('with m as (')) { @@ -180,7 +186,24 @@ function makePool() { const pool = { query, - connect: async () => ({ query, release: () => {} }), + connect: async () => { + let unlock: (() => void) | undefined; + return { + query: async (sql: string, params: unknown[] = []) => { + if (sql.includes('pg_advisory_xact_lock')) { + const previous = lockQueue; + let release!: () => void; + lockQueue = new Promise((resolve) => { + release = resolve; + }); + await previous; + unlock = release; + } + return query(sql, params, unlock); + }, + release: () => unlock?.(), + }; + }, }; return { pool, model }; } @@ -279,6 +302,35 @@ test('writing as the employer the thread is with still finds it', async () => { assert.equal(reply.threadId, first.threadId); }); +test('concurrent first messages for the same parties and job share one thread', async () => { + const { pool, model } = makePool(); + seed({ pool, model }); + + const results = await Promise.all([ + startThread(pool as never, carol, { kind: 'employer', orgId: orgA }, { + subject: 'About the platform role', + body: 'I would like to discuss this role.', + jobId: 'cccccccc-0000-4000-8000-000000000001', + }), + startThread(pool as never, carol, { kind: 'employer', orgId: orgA }, { + subject: 'About the platform role', + body: 'I would like to discuss this role.', + jobId: 'cccccccc-0000-4000-8000-000000000001', + }), + ]); + + assert.equal(model.threads.length, 1); + assert.equal( + new Set(results.map((result) => (typeof result === 'string' ? result : result.threadId))).size, + 1, + ); + assert.deepEqual( + results.map((result) => (typeof result === 'string' ? null : result.created)).sort(), + [false, true], + ); + assert.equal(model.messages.length, 2); +}); + test('a body-derived subject never carries a lone surrogate into the insert', async () => { const { pool, model } = makePool(); seed({ pool, model }); From 7b35e97ce6036b4c9b993ec61ef0c4f4e44c5d1e Mon Sep 17 00:00:00 2001 From: kepler-ops-maker Date: Fri, 25 Sep 2026 13:51:33 +0900 Subject: [PATCH 055/116] test: fix idempotency suite skip guard for empty Postgres error messages A failed pg connection can produce an error with an empty .message, so reason === '' and the no-database skip guard never engages; the four subtests then crash with "Cannot read properties of null (reading 'query')". Track readiness with an explicit flag instead: 741 pass / 0 fail / 4 skipped without a database (was 741/4/0), and all 745 pass with one. (#268) --- test/idempotency.test.ts | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/test/idempotency.test.ts b/test/idempotency.test.ts index 6da4b2b..0cef908 100644 --- a/test/idempotency.test.ts +++ b/test/idempotency.test.ts @@ -22,6 +22,7 @@ let pool: { } | null = null; let closePool: (() => Promise) | null = null; let reason = ''; +let ready = false; try { const db = await import('../dist/db/pool.js'); @@ -40,6 +41,7 @@ try { SECRET: 'test-secret', }); app = createApp(created, config, { send: async () => true }) as never; + ready = true; } catch (error) { reason = error instanceof Error ? error.message : String(error); } @@ -87,7 +89,7 @@ async function countJobs(orgId: string): Promise { return Number(rows.rows[0]?.['count'] ?? '0'); } -describe('idempotent posting', { skip: reason === '' ? false : `no database: ${reason}` }, () => { +describe('idempotent posting', { skip: ready ? false : `no database: ${reason || 'setup failed'}` }, () => { test('a repeat under the same key returns the listing already made, not a second one', async () => { const { org, stamp, auth } = await employer('Retry Co'); const listing = { From 93d0258afea4364d2780bd0245596796bd5ca4e1 Mon Sep 17 00:00:00 2001 From: Anthony Ettinger Date: Fri, 25 Sep 2026 01:57:24 -0700 Subject: [PATCH 056/116] Tracker: show zero and name what is missing instead of "Unknown" (#269) A fleet with only cost imports showed "Unknown" on five of six cards, which read as broken. The dashboard now shows 0 / USD 0 / 0.0% and says under each card what is missing (no work imported, no receipts/commissions/fees/affiliate payouts, cost entries with no amount). Incomplete profit shows zero with the costs imported so far as a note, not a negative number made of estimates. Adds a "How to improve" list: apply to more jobs, post jobs, list on the leaderboard, raise a rate below cost + target, bill hours that have costs, invoice tracked hours, and close a gap to the retained target. summarize() is unchanged, so the API and CLI still report null for no data. Co-authored-by: Claude Opus 5.5 (1M context) --- src/views/tracker.tsx | 157 ++++++++++++++++++++++++++++++--- test/tracker-dashboard.test.ts | 92 +++++++++++++++++++ test/tracker.test.ts | 3 +- web/public/app.css | 2 + web/public/sw.js | 2 +- 5 files changed, 243 insertions(+), 13 deletions(-) create mode 100644 test/tracker-dashboard.test.ts diff --git a/src/views/tracker.tsx b/src/views/tracker.tsx index d9acf27..a3527d1 100644 --- a/src/views/tracker.tsx +++ b/src/views/tracker.tsx @@ -2,15 +2,109 @@ import type { FC } from 'hono/jsx'; import type { Fleet, fleetReport, leaderboard } from '../core/tracker.ts'; type Report = Awaited>; +type Summary = Report['summary']; +// The dashboard shows nothing-imported-yet as zero and names what is missing +// beside it. The summary itself keeps null, so the API still tells "no data" +// apart from a reported zero. const money = (amount: number | null, currency: string): string => - amount === null - ? 'Unknown' - : `${currency} ${amount.toLocaleString('en-US', { maximumFractionDigits: 6 })}`; -const Metric: FC<{ label: string; value: string; note?: string }> = ({ label, value, note }) => ( + `${currency} ${(amount ?? 0).toLocaleString('en-US', { maximumFractionDigits: 6 })}`; +const LEDGER = ['cost', 'receipt', 'commission', 'fee', 'affiliate'] as const; +const NOUN = { + cost: ['costs', 'Cost'], + receipt: ['receipts', 'Receipt'], + commission: ['commissions', 'Commission'], + fee: ['fees', 'Fee'], + affiliate: ['affiliate payouts', 'Affiliate payout'], +} as const; +const either = (items: string[]) => + items.length < 2 ? items.join('') : `${items.slice(0, -1).join(', ')} or ${items.at(-1)}`; + +/** What keeps the billable-hours figure from being complete, or null. */ +export function hoursGap(s: Summary): string | null { + if (s.categories.work.count === 0) return 'No work imported yet.'; + if (s.missingWorkEntries > 0) + return `Billable work entries missing time or agent counts: ${s.missingWorkEntries}.`; + if (s.billableAgentHours === null) return 'No billable work imported yet.'; + return null; +} + +/** What keeps profit from being complete: feeds never imported, then entries without an amount. */ +export function ledgerGaps(s: Summary): string[] { + const none = LEDGER.filter((k) => s.categories[k].count === 0).map((k) => NOUN[k][0]); + const gaps = none.length ? [`No ${either(none)} imported yet.`] : []; + for (const k of LEDGER) { + const c = s.categories[k]; + if (c.count > c.known) gaps.push(`${NOUN[k][1]} entries with no amount: ${c.count - c.known}.`); + else if (c.partial) gaps.push(`${NOUN[k][1]} entries marked partial: ${c.partial}.`); + } + return gaps; +} + +export interface Tip { + text: string; + href?: string; + link?: string; +} + +/** Ways to improve this fleet's numbers, most direct first. */ +export function improvements({ fleet, summary: s }: Pick): Tip[] { + const tips: Tip[] = [ + { + text: 'Apply to more jobs. Every accepted job is billable agent-hours your fleet is not earning yet.', + href: '/', + link: 'Browse open jobs', + }, + { + text: 'Post jobs. When you have more work than your fleet can take, hire other agents for it and keep the margin.', + href: '/post-a-job', + link: 'Post a job', + }, + ]; + if (!fleet.publicListing) + tips.push({ + text: 'List your fleet on the public capacity leaderboard so employers can find it. Only its name, operator, agent count and rate are shown.', + href: '/tracker/leaderboard', + link: 'See the leaderboard', + }); + const floor = fleet.assumedDirectCost + fleet.retainedTarget; + if (fleet.rate < floor) + tips.push({ + text: `Raise your rate to at least ${money(floor, fleet.currency)}/agent-hour. At ${money(fleet.rate, fleet.currency)} it does not cover your ${money(fleet.assumedDirectCost, fleet.currency)} assumed cost plus your ${money(fleet.retainedTarget, fleet.currency)} retained target.`, + }); + const hours = s.billableAgentHours ?? 0; + const cost = s.categories.cost.amount ?? 0; + if (hours === 0 && cost > 0) + tips.push({ + text: `You have ${money(cost, fleet.currency)} of costs and no billable hours. Assign your Moshcode timers to a client and import them so that work gets billed.`, + }); + else if (hours > 0 && cost / hours > fleet.assumedDirectCost) + tips.push({ + text: `Your costs run ${money(cost / hours, fleet.currency)} per billable agent-hour against ${money(fleet.assumedDirectCost, fleet.currency)} assumed. Move routine work to cheaper models or raise your rate.`, + }); + if (s.categories.receipt.count === 0 && hours > 0) + tips.push({ + text: 'Invoice the hours you have tracked, then import the payments as receipts so profit reflects money received.', + href: '/inbox', + link: 'Open your inbox', + }); + if (s.retainedPerAgentHour !== null && s.retainedPerAgentHour < fleet.retainedTarget) + tips.push({ + text: `You retain ${money(s.retainedPerAgentHour, fleet.currency)} per billable agent-hour against a ${money(fleet.retainedTarget, fleet.currency)} target. Raise your rate or cut cost per hour.`, + }); + return tips; +} + +const Metric: FC<{ label: string; value: string; missing?: string | null; note?: string }> = ({ + label, + value, + missing, + note, +}) => (

{label}

{value}

+ {missing &&

{missing}

} {note &&

{note}

}
@@ -184,25 +278,35 @@ const FleetDashboard: FC<{ report: Report }> = ({
= ({ />
+
+

How to improve

+ +

Coverage and reported amounts

- Known amounts are subtotals of imported events, not proof of complete business accounting. - Missing feeds stay unknown; import an explicit zero only when the source confirms zero. + Known amounts are subtotals of imported events, not proof of complete business accounting. A + category with nothing imported shows zero; the imported count tells it apart from a reported + zero.

diff --git a/test/tracker-dashboard.test.ts b/test/tracker-dashboard.test.ts new file mode 100644 index 0000000..afdbae4 --- /dev/null +++ b/test/tracker-dashboard.test.ts @@ -0,0 +1,92 @@ +import assert from 'node:assert/strict'; +import { test } from 'node:test'; +import { parseEvents, summarize } from '../dist/core/tracker.js'; +import { hoursGap, improvements, ledgerGaps, TrackerPage } from '../dist/views/tracker.js'; + +const fleet = { + id: 'f1', + slug: 'demo', + ownerId: 'u1', + operatorSlug: 'op', + agents: 10, + currency: 'USD', + rate: 100, + retainedTarget: 50, + assumedDirectCost: 100, + publicListing: false, + updatedAt: '2026-09-25T00:00:00Z', +}; +const report = (events: unknown[]) => { + const parsed = parseEvents(events, 'USD'); + return { fleet, summary: summarize(fleet, parsed), sources: ['s'], eventCount: parsed.length }; +}; +const render = (r: ReturnType) => + String(TrackerPage({ fleets: [fleet], report: r, profiles: [] })); + +test('a fleet with only costs shows zeros and names every missing feed', () => { + const r = report([ + { id: 'c1', kind: 'cost', currency: 'USD', amount: 12, provenance: 'estimated' }, + { + id: 'c2', + kind: 'cost', + currency: 'USD', + amount: null, + provenance: 'reported', + partial: true, + }, + ]); + assert.equal(hoursGap(r.summary), 'No work imported yet.'); + assert.deepEqual(ledgerGaps(r.summary), [ + 'No receipts, commissions, fees or affiliate payouts imported yet.', + 'Cost entries with no amount: 1.', + ]); + const html = render(r); + assert.doesNotMatch(html, /Unknown/); + assert.match(html, /

0\.00<\/h2>/); + assert.match(html, /

USD 0<\/h2>/); + assert.doesNotMatch(html, /

USD -/, 'incomplete profit is shown as zero, not as costs alone'); + assert.match(html, /Costs imported so far: USD 12\./); + assert.match(html, /No work imported yet\./); +}); + +test('improvement tips always point at applying to and posting jobs', () => { + const tips = improvements(report([])); + assert.deepEqual( + tips.slice(0, 2).map((t) => t.href), + ['/', '/post-a-job'], + ); + assert.ok( + tips.some((t) => /leaderboard/.test(t.text)), + 'private fleets are told to list', + ); + assert.ok( + tips.some((t) => /at least USD 150\/agent-hour/.test(t.text)), + 'a rate below cost plus target is called out', + ); + const html = render(report([])); + assert.match(html, /How to improve/); + assert.match(html, /href="\/post-a-job"/); +}); + +test('costs without billable hours get a billing tip, and billable work without time is named', () => { + const tips = improvements( + report([{ id: 'c1', kind: 'cost', currency: 'USD', amount: 30, provenance: 'engine' }]), + ); + assert.ok(tips.some((t) => /USD 30 of costs and no billable hours/.test(t.text))); + const r = report([{ id: 'w1', kind: 'work', currency: 'USD', billable: true }]); + assert.equal(hoursGap(r.summary), 'Billable work entries missing time or agent counts: 1.'); +}); + +test('a complete, on-target fleet shows no missing notes', () => { + const r = report([ + { id: 'w1', kind: 'work', currency: 'USD', billable: true, seconds: 3600, agents: 1 }, + { id: 'c', kind: 'cost', currency: 'USD', amount: 10, provenance: 'engine' }, + { id: 'r', kind: 'receipt', currency: 'USD', amount: 100, provenance: 'reported' }, + { id: 'm', kind: 'commission', currency: 'USD', amount: 0, provenance: 'reported' }, + { id: 'f', kind: 'fee', currency: 'USD', amount: 0, provenance: 'reported' }, + { id: 'a', kind: 'affiliate', currency: 'USD', amount: 0, provenance: 'reported' }, + ]); + assert.equal(hoursGap(r.summary), null); + assert.deepEqual(ledgerGaps(r.summary), []); + assert.doesNotMatch(render(r), /tracker-missing/); +}); diff --git a/test/tracker.test.ts b/test/tracker.test.ts index f09b892..edf73c5 100644 --- a/test/tracker.test.ts +++ b/test/tracker.test.ts @@ -320,7 +320,8 @@ describe('tracker API and CLI against Postgres', { skip: !database }, () => { assert.match(page.headers.get('cache-control') ?? '', /no-store/); const html = await page.text(); assert.match(html, /Tracked billable agent-hours/); - assert.match(html, /Unknown/); + assert.match(html, /How to improve/); + assert.doesNotMatch(html, />Unknown Date: Fri, 25 Sep 2026 01:59:22 -0700 Subject: [PATCH 057/116] 0.21.1 (#270) Co-authored-by: Claude Opus 5.5 (1M context) --- package.json | 2 +- src/config.ts | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/package.json b/package.json index 4440844..9f24313 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "@profullstack/agenticjobs", - "version": "0.21.0", + "version": "0.21.1", "description": "An agent-friendly job board you self-host. It posts its own jobs, never scrapes anyone else's, and answers on every surface: web, API, MCP, CLI, TUI, desktop and PWA. Instances find each other through an open directory.", "license": "MIT", "type": "module", diff --git a/src/config.ts b/src/config.ts index 97280fa..8ac1a8d 100644 --- a/src/config.ts +++ b/src/config.ts @@ -187,7 +187,7 @@ export function loadConfig(env: NodeJS.ProcessEnv = process.env): Config { } /** Kept in step with package.json by the release script. */ -export const VERSION = '0.21.0'; +export const VERSION = '0.21.1'; export const SOFTWARE_NAME = 'agenticjobs'; /** From 4b4bdceea4d339e41a98aad85c0a7cfd3fe03881 Mon Sep 17 00:00:00 2001 From: Anthony Ettinger Date: Fri, 25 Sep 2026 02:13:05 -0700 Subject: [PATCH 058/116] New logo, favicon and the w3bs.org look (#271) The mark is a briefcase in orbit with an agent riding the ring: the same orbit family as w3bs.org's, in this board's green with w3bs orange for the agent. favicon.svg is a heavier cut of it that holds at 16px, and logo.svg is the mark with a heavy "agenticjobs." wordmark. PNGs are generated by the fav CLI: icon-192/512, apple-touch-icon, favicon-16/32 and favicon.ico. The manifest had named icon-192.png and icon-512.png while neither existed, so install prompts got a 404; /favicon.ico and /apple-touch-icon.png now answer at the root too. The site takes w3bs.org's paper-and-ink palette, light serif headlines with an orange italic accent, and its wordmark style in the header, in both themes. A test fails if a manifest icon ever 404s again. Co-authored-by: Claude Opus 5.5 (1M context) --- src/server/routes/discovery.ts | 25 ++++++- src/views/layout.tsx | 58 +++++++++++++++-- test/brand-icons.test.ts | 68 +++++++++++++++++++ web/public/app.css | 49 +++++++++----- web/public/apple-touch-icon.png | Bin 0 -> 1925 bytes web/public/favicon-16.png | Bin 0 -> 358 bytes web/public/favicon-32.png | Bin 0 -> 545 bytes web/public/favicon.ico | Bin 0 -> 941 bytes web/public/favicon.svg | 8 +++ web/public/icon-192.png | Bin 0 -> 1964 bytes web/public/icon-512.png | Bin 0 -> 5019 bytes web/public/icon.svg | 10 ++- web/public/logo.svg | 10 +++ web/public/sw.js | 2 +- web/public/tokens.css | 111 +++++++++++++++++--------------- 15 files changed, 260 insertions(+), 81 deletions(-) create mode 100644 test/brand-icons.test.ts create mode 100644 web/public/apple-touch-icon.png create mode 100644 web/public/favicon-16.png create mode 100644 web/public/favicon-32.png create mode 100644 web/public/favicon.ico create mode 100644 web/public/favicon.svg create mode 100644 web/public/icon-192.png create mode 100644 web/public/icon-512.png create mode 100644 web/public/logo.svg diff --git a/src/server/routes/discovery.ts b/src/server/routes/discovery.ts index d184c6d..f340a0f 100644 --- a/src/server/routes/discovery.ts +++ b/src/server/routes/discovery.ts @@ -45,6 +45,7 @@ const MIME: Record = { '.js': 'text/javascript; charset=utf-8', '.svg': 'image/svg+xml', '.png': 'image/png', + '.ico': 'image/x-icon', '.webmanifest': 'application/manifest+json', '.txt': 'text/plain; charset=utf-8', '.json': 'application/json', @@ -184,6 +185,25 @@ export function discoveryRoutes(): Hono { } }); + // Browsers and iOS ask the root for these whatever the page declares, so a + // missing one is a 404 in every access log and a blank tile on a home screen. + for (const [path, file] of [ + ['/favicon.ico', 'favicon.ico'], + ['/apple-touch-icon.png', 'apple-touch-icon.png'], + ['/apple-touch-icon-precomposed.png', 'apple-touch-icon.png'], + ] as const) { + routes.get(path, async (c) => { + try { + return c.body(await readFile(join(publicDir(), file)), 200, { + 'content-type': MIME[extname(file)]!, + 'cache-control': 'public, max-age=86400', + }); + } catch { + return c.notFound(); + } + }); + } + /** * The installer, at the root so the curl line is short enough to read aloud. * @@ -881,12 +901,13 @@ export function discoveryRoutes(): Hono { start_url: '/', scope: '/', display: 'standalone', - background_color: '#ffffff', - theme_color: '#111318', + background_color: '#f6f4ed', + theme_color: '#1f5c45', icons: [ { src: '/assets/icon.svg', sizes: 'any', type: 'image/svg+xml', purpose: 'any' }, { src: '/assets/icon-192.png', sizes: '192x192', type: 'image/png' }, { src: '/assets/icon-512.png', sizes: '512x512', type: 'image/png' }, + { src: '/assets/apple-touch-icon.png', sizes: '180x180', type: 'image/png' }, ], shortcuts: [ { name: 'Post a job', url: '/post' }, diff --git a/src/views/layout.tsx b/src/views/layout.tsx index ceaebd9..a1f0059 100644 --- a/src/views/layout.tsx +++ b/src/views/layout.tsx @@ -39,6 +39,48 @@ export interface PageProps { skills?: SkillCount[]; } +/** + * The mark from web/public/icon.svg, inlined so the header costs no request. + * A briefcase in orbit with an agent on the ring: the same orbit family as + * w3bs.org's mark, in this board's green. Keep the two in step. + */ +const BrandMark: FC = () => ( + +); + export const Layout: FC> = (props) => { const { title, @@ -79,11 +121,14 @@ export const Layout: FC> = (props) => { {/* The theme meta is duplicated per scheme so the browser chrome matches whichever palette the page actually painted. */} - - + + - + + + + > = (props) => {
-
From 9f0d41a5839e5b9b81d3cce746542d3908c9582f Mon Sep 17 00:00:00 2001 From: Anthony Ettinger Date: Sun, 4 Oct 2026 01:23:20 -0700 Subject: [PATCH 073/116] 0.22.4 (#288) Co-authored-by: Claude Opus 5.5 --- package.json | 2 +- src/config.ts | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/package.json b/package.json index 99b2a9a..2ac2c75 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "@profullstack/agenticjobs", - "version": "0.22.3", + "version": "0.22.4", "description": "An agent-friendly job board you self-host. It posts its own jobs, never scrapes anyone else's, and answers on every surface: web, API, MCP, CLI, TUI, desktop and PWA. Instances find each other through an open directory.", "license": "MIT", "type": "module", diff --git a/src/config.ts b/src/config.ts index fa97747..8d29976 100644 --- a/src/config.ts +++ b/src/config.ts @@ -187,7 +187,7 @@ export function loadConfig(env: NodeJS.ProcessEnv = process.env): Config { } /** Kept in step with package.json by the release script. */ -export const VERSION = '0.22.3'; +export const VERSION = '0.22.4'; export const SOFTWARE_NAME = 'agenticjobs'; /** From 6dea4fcaee31058afe01299a4e7bc7324c115f67 Mon Sep 17 00:00:00 2001 From: k1mtruth <56712246+k1mtruth@users.noreply.github.com> Date: Sun, 4 Oct 2026 04:21:06 -0700 Subject: [PATCH 074/116] Fix uppercase pay-period words being parsed as currencies (#289) * Fix uppercase pay-period suffix parsing * Add uppercase pay-period regression tests --- src/schema/pay.ts | 19 +++++++--- test/pay-uppercase-period.test.ts | 61 +++++++++++++++++++++++++++++++ 2 files changed, 74 insertions(+), 6 deletions(-) create mode 100644 test/pay-uppercase-period.test.ts diff --git a/src/schema/pay.ts b/src/schema/pay.ts index 6fe6eef..213c3b7 100644 --- a/src/schema/pay.ts +++ b/src/schema/pay.ts @@ -205,7 +205,7 @@ function codeFrom(raw: string | undefined): string | null { return null; } -function readMoney(text: string, at: number): Money | null { +function readMoney(text: string, at: number, allowSuffixWords = false): Money | null { MONEY.lastIndex = at; const match = MONEY.exec(text); if (match === null) return null; @@ -225,7 +225,12 @@ function readMoney(text: string, at: number): Money | null { currency ??= code; } if (codeAfter !== undefined) { - const code = codeFrom(codeAfter); + // Only retry ambiguous uppercase words as prose after the ordinary + // currency interpretation failed, and only for a complete pay suffix. + const suffix = text.slice(end - codeAfter.length).trim(); + const suffixWord = allowSuffixWords && + (FLAT.test(suffix) || PERIOD_ONLY.test(suffix) || PER.test(suffix)); + const code = suffixWord ? null : codeFrom(codeAfter); if (code !== null) { // Every symbol or code attached to one amount must agree. // Otherwise "USD 100 EUR" or "$100 EUR" silently loses a currency. @@ -342,7 +347,9 @@ export function readPayLine(input: unknown): { line: PayLine; method: string | n text = raw.slice(0, settled.index).trim(); } } - const line = parseLine(text); + const ordinary = parseLine(text); + const retry = typeof ordinary === 'string' ? parseLine(text, true) : ordinary; + const line = typeof retry === 'string' ? ordinary : retry; return typeof line === 'string' ? line : { line, method }; } @@ -354,7 +361,7 @@ function isRail(value: string): boolean { ); } -function parseLine(text: string): PayLine | string { +function parseLine(text: string, allowSuffixWords = false): PayLine | string { const share = parseRevenueShare(text); if (share !== null) return share; @@ -367,7 +374,7 @@ function parseLine(text: string): PayLine | string { cursor = leadMatch[0].length; } - const first = readMoney(text, cursor); + const first = readMoney(text, cursor, allowSuffixWords); if (first === null) { return `Could not find an amount in "${text}". Write it like ${PAY_LINE_EXAMPLES}.`; } @@ -378,7 +385,7 @@ function parseLine(text: string): PayLine | string { dash.lastIndex = cursor; const dashMatch = dash.exec(text); if (dashMatch !== null) { - second = readMoney(text, cursor + dashMatch[0].length); + second = readMoney(text, cursor + dashMatch[0].length, allowSuffixWords); if (second !== null) cursor = second.end; } diff --git a/test/pay-uppercase-period.test.ts b/test/pay-uppercase-period.test.ts new file mode 100644 index 0000000..737f0a7 --- /dev/null +++ b/test/pay-uppercase-period.test.ts @@ -0,0 +1,61 @@ +import assert from 'node:assert/strict'; +import { test } from 'node:test'; +import { normalisePay, parsePayLine } from '../src/schema/pay.ts'; + +test('uppercase pay-period words are not mistaken for currency tickers', () => { + for (const text of [ + '$100 per task', '$100 per hour', '$100 for each task', '$100 each task', + '$100 every week', '$100 fixed', '$100 flat', '$100 total', + '$100 one-off', '$100 lump sum', '100 daily', '$100 - $200 per task', + ]) { + const expected = parsePayLine(text); + assert.equal(typeof expected, 'object', text); + assert.deepEqual(parsePayLine(text.toUpperCase()), expected, text); + assert.deepEqual(normalisePay({ pay: text.toUpperCase() }), normalisePay({ pay: text }), text); + } +}); + +test('uppercase periods retain real currencies and reject contradictory currencies', () => { + for (const text of ['100 EUR PER TASK', '0.01 SOL PER TASK', '100 XYZ PER TASK']) { + const parsed = parsePayLine(text); + assert.equal(typeof parsed, 'object', text); + if (typeof parsed === 'string') throw new Error(parsed); + assert.equal(parsed.currency, text.split(' ')[1]); + } + for (const text of ['$100 EUR PER TASK', 'USD 100 EUR FIXED']) { + assert.equal(typeof parsePayLine(text), 'string', text); + } +}); + + +test('currency tickers that overlap prose retain their successful interpretation', () => { + for (const currency of ['PER', 'FOR', 'EACH', 'EVERY', 'FIXED', 'FLAT', 'TOTAL', 'ONE', 'LUMP', 'DAILY']) { + const parsed = parsePayLine(`100 ${currency} per task`); + assert.equal(typeof parsed, 'object', currency); + if (typeof parsed === 'string') throw new Error(parsed); + assert.equal(parsed.currency, currency); + assert.equal(parsed.type, 'per_task'); + } +}); + +test('incomplete suffixes are not accepted as pay periods', () => { + for (const suffix of ['PER', 'FOR', 'EACH', 'EVERY', 'ONE', 'LUMP', 'FOR EACH', 'FOR EVERY']) { + assert.equal(typeof parsePayLine(`$100 ${suffix}`), 'string', suffix); + } +}); + + +test('existing ambiguous ticker parses and ticker ranges keep their denomination', () => { + for (const [text, currency] of [ + ['100 FOR EACH TASK', 'FOR'], + ['100 PER PER TASK', 'PER'], + ['100 ONE - 200 ONE per task', 'ONE'], + ['ONE 100 per task', 'ONE'], + ]) { + const parsed = parsePayLine(text); + assert.equal(typeof parsed, 'object', text); + if (typeof parsed === 'string') throw new Error(parsed); + assert.equal(parsed.currency, currency, text); + assert.equal(parsed.type, 'per_task', text); + } +}); From b49e0bde76d4a086b308910b13def96b15128567 Mon Sep 17 00:00:00 2001 From: zelumi Date: Mon, 5 Oct 2026 03:41:29 +0800 Subject: [PATCH 075/116] fix(sync): persist metadata filled into existing boards (#290) --- src/client/sync.ts | 4 ++- test/settings-sync-load.test.ts | 54 +++++++++++++++++++++++++++++++++ 2 files changed, 57 insertions(+), 1 deletion(-) create mode 100644 test/settings-sync-load.test.ts diff --git a/src/client/sync.ts b/src/client/sync.ts index 202ab00..7c492e1 100644 --- a/src/client/sync.ts +++ b/src/client/sync.ts @@ -15,6 +15,7 @@ * API is the cloud. */ import { hostname } from 'node:os'; +import { isDeepStrictEqual } from 'node:util'; import { dirname } from 'node:path'; import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'; import { @@ -165,7 +166,8 @@ export async function syncLoad( if (synced) { const before = loadConfig(); const applied = applySettings(synced, before); - if (applied.added.length || applied.directoriesAdded.length || applied.current !== before.current) saveConfig(applied.config); + // Existing boards may gain missing metadata even when no board or directory is added. + if (!isDeepStrictEqual(applied.config, before)) saveConfig(applied.config); added = applied.added; directoriesAdded = applied.directoriesAdded; } diff --git a/test/settings-sync-load.test.ts b/test/settings-sync-load.test.ts new file mode 100644 index 0000000..484031d --- /dev/null +++ b/test/settings-sync-load.test.ts @@ -0,0 +1,54 @@ +import assert from 'node:assert/strict'; +import { mkdtempSync, rmSync } from 'node:fs'; +import { tmpdir } from 'node:os'; +import { join } from 'node:path'; +import { test } from 'node:test'; + +const { loadConfig, saveConfig } = await import('../dist/client/config.js'); +const { syncLoad } = await import('../dist/client/sync.js'); + +test('sync load persists metadata filled into an existing board', async (t) => { + for (const field of ['email', 'name'] as const) { + await t.test(field, async () => { + const dir = mkdtempSync(join(tmpdir(), 'agenticjobs-sync-load-')); + const previous = process.env['AGENTICJOBS_CONFIG_DIR']; + process.env['AGENTICJOBS_CONFIG_DIR'] = dir; + try { + const server = 'https://board.example'; + const local = { + current: server, + boards: { [server]: { server, token: 'local-test-token', ...(field === 'email' ? { name: 'Local board' } : { email: 'local@example.com' }) } }, + directories: ['https://directory.example'], + }; + saveConfig(local); + const remote = { + current: server, + boards: { [server]: { server, email: 'remote@example.com', name: 'Remote board' } }, + directories: local.directories, + }; + const fetch: typeof globalThis.fetch = async () => Response.json({ + ok: true, + revision: 1, + snapshot: { version: 1, host: 'other-machine', app: 'agenticjobs', files: { 'boards.json': { content: JSON.stringify(remote) } } }, + }); + + const planned = await syncLoad({ fetch, dryRun: true }); + assert.equal(planned.status, 'planned'); + assert.deepEqual(loadConfig(), local, 'dry run must not change the config'); + + const result = await syncLoad({ fetch, force: true }); + assert.equal(result.status, 'loaded'); + assert.deepEqual(result.added, []); + assert.deepEqual(result.directoriesAdded, []); + assert.deepEqual(loadConfig(), { + ...local, + boards: { [server]: { ...local.boards[server], [field]: remote.boards[server][field] } }, + }, 'filled metadata must reach config.json without replacing local values or credentials'); + } finally { + if (previous === undefined) delete process.env['AGENTICJOBS_CONFIG_DIR']; + else process.env['AGENTICJOBS_CONFIG_DIR'] = previous; + rmSync(dir, { recursive: true, force: true }); + } + }); + } +}); From ce57c26c9b20d92fdf637108762a67071509988b Mon Sep 17 00:00:00 2001 From: ilanvkn Date: Tue, 6 Oct 2026 12:53:36 +0800 Subject: [PATCH 076/116] fix(client): preserve the fanout timeout budget (#291) * feat(client): allow shared-deadline callers to disable timeout retries * fix(client): do not retry an exhausted fanout deadline * test(client): cover exhausted fanout retries and healthy peers --- src/client/client.ts | 11 ++++++- src/client/fanout.ts | 3 ++ test/client-fanout-timeout-retry.test.ts | 38 ++++++++++++++++++++++++ 3 files changed, 51 insertions(+), 1 deletion(-) create mode 100644 test/client-fanout-timeout-retry.test.ts diff --git a/src/client/client.ts b/src/client/client.ts index 741c3e7..45d0c6b 100644 --- a/src/client/client.ts +++ b/src/client/client.ts @@ -102,6 +102,8 @@ export interface ClientOptions { token?: string | null; fetch?: typeof fetch; timeoutMs?: number; + /** Disable timeout retries when a caller manages a shared overall deadline. */ + retryTimeouts?: boolean; userAgent?: string; } @@ -167,6 +169,7 @@ export class BoardClient { private token: string | null; private readonly doFetch: typeof fetch; private readonly timeoutMs: number; + private readonly retryTimeouts: boolean; private readonly userAgent: string; constructor(server: string, options: ClientOptions = {}) { @@ -174,6 +177,7 @@ export class BoardClient { this.token = options.token ?? null; this.doFetch = options.fetch ?? fetch; this.timeoutMs = options.timeoutMs ?? 20_000; + this.retryTimeouts = options.retryTimeouts ?? true; this.userAgent = options.userAgent ?? 'agenticjobs-client'; } @@ -217,7 +221,12 @@ export class BoardClient { // carries an idempotency key: then the board answers a repeat with // the row the first attempt made, and repeating is the point. const repeatable = method === 'GET' || options.idempotencyKey !== undefined; - if (repeatable && error instanceof ApiError && error.code === 'timeout') { + if ( + this.retryTimeouts && + repeatable && + error instanceof ApiError && + error.code === 'timeout' + ) { return this.requestOnce(method, path, body, options); } throw error; diff --git a/src/client/fanout.ts b/src/client/fanout.ts index 6a047aa..93ca719 100644 --- a/src/client/fanout.ts +++ b/src/client/fanout.ts @@ -89,6 +89,9 @@ export async function searchEverywhere( const client = new BoardClient(board.server, { token: board.token, timeoutMs: remainingMs, + // This attempt already has the board's entire remaining budget. + // A cold-start retry would reset its timer and exceed that deadline. + retryTimeouts: false, }); const page = await client.search({ ...query, limit: pageLimit, offset: sourceOffset }); if (Date.now() - started >= budgetMs) { diff --git a/test/client-fanout-timeout-retry.test.ts b/test/client-fanout-timeout-retry.test.ts new file mode 100644 index 0000000..1c3204c --- /dev/null +++ b/test/client-fanout-timeout-retry.test.ts @@ -0,0 +1,38 @@ +import assert from 'node:assert/strict'; +import { test } from 'node:test'; +import { searchEverywhere } from '../dist/client/fanout.js'; + +test('fanout does not restart an exhausted board timeout budget', async (t) => { + let slowCalls = 0; + t.mock.method(globalThis, 'fetch', async (input: string | URL | Request, init?: RequestInit) => { + if (new URL(String(input)).hostname === 'healthy.test') { + return Response.json({ items: [{ slug: 'healthy-job', createdAt: '2026-01-01' }], total: 1 }); + } + slowCalls++; + return new Promise((_resolve, reject) => { + const signal = init?.signal; + const abort = () => reject(new DOMException('Aborted', 'AbortError')); + if (signal?.aborted) abort(); + else signal?.addEventListener('abort', abort, { once: true }); + }); + }); + + const result = await searchEverywhere( + [ + { server: 'https://slow.test', token: null }, + { server: 'https://healthy.test', token: null }, + ], + {}, + { timeoutMs: 50 }, + ); + + assert.equal(slowCalls, 1, 'a timed-out board must not receive a new full timeout budget'); + assert.equal(result.sources[0]?.ok, false); + assert.match(result.sources[0]?.error ?? '', /did not answer in time/); + assert.equal(result.sources[1]?.ok, true); + assert.deepEqual( + result.jobs.map((hit) => hit.job.slug), + ['healthy-job'], + ); + assert.equal(result.total, 1); +}); From c2a1e247ff43f89266557a9c48a408449ccdebc0 Mon Sep 17 00:00:00 2001 From: Anthony Ettinger Date: Tue, 6 Oct 2026 11:40:35 -0700 Subject: [PATCH 077/116] Add GET /api/health for the status page (#292) Returns {status:ok, db:ok} with Cache-Control: no-store after a select 1 against the pool, or 503 {status:error, db:down} if the database does not answer within 3s. No error details leave the process. Co-authored-by: Claude Opus 5.5 --- src/server/app.tsx | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/src/server/app.tsx b/src/server/app.tsx index 14011e5..844e72a 100644 --- a/src/server/app.tsx +++ b/src/server/app.tsx @@ -52,6 +52,26 @@ export function createApp( ); app.use('/api/*', apiCors()); + // Liveness for the status page: the process answers and the database + // answers within three seconds. Nothing about why it failed leaves the box. + app.get('/api/health', async (c) => { + c.header('Cache-Control', 'no-store'); + let timer: ReturnType | undefined; + try { + await Promise.race([ + pool.query('select 1'), + new Promise((_, reject) => { + timer = setTimeout(() => reject(new Error('timeout')), 3000); + }), + ]); + return c.json({ status: 'ok', db: 'ok' }); + } catch { + return c.json({ status: 'error', db: 'down' }, 503); + } finally { + clearTimeout(timer); + } + }); + // Settings sync (@profullstack/synconfig): the boards a member uses, on // every machine. Mounted before the API router, whose catch-all answers // 404 for any /api/v1 path it does not know, this one included. From 8b3b718b1477d91c39daa9f5eb067a459268c264 Mon Sep 17 00:00:00 2001 From: ilanvkn Date: Wed, 7 Oct 2026 16:04:37 +0800 Subject: [PATCH 078/116] fix(client): preserve defaults for optional network search filters (#293) --- src/client/client.ts | 18 +++----- test/client-network-search-undefined.test.ts | 48 ++++++++++++++++++++ 2 files changed, 55 insertions(+), 11 deletions(-) create mode 100644 test/client-network-search-undefined.test.ts diff --git a/src/client/client.ts b/src/client/client.ts index 45d0c6b..8cc8999 100644 --- a/src/client/client.ts +++ b/src/client/client.ts @@ -698,18 +698,14 @@ export class BoardClient { async searchNetwork(query: Partial): Promise { const params = queryToParams({ - q: null, - employmentType: null, - workplace: null, - seniority: null, - agentPolicy: null, - tags: [], - salaryMin: null, - org: null, - sort: 'recent', - limit: 25, - offset: 0, + ...EMPTY_QUERY, ...query, + // Match search(): explicitly undefined filters must not erase defaults. + tags: query.tags ?? EMPTY_QUERY.tags, + salaryMin: query.salaryMin ?? EMPTY_QUERY.salaryMin, + sort: query.sort ?? EMPTY_QUERY.sort, + limit: query.limit ?? EMPTY_QUERY.limit, + offset: query.offset ?? EMPTY_QUERY.offset, }); const search = params.toString(); return this.request('GET', `/api/v1/directory/search${search === '' ? '' : `?${search}`}`); diff --git a/test/client-network-search-undefined.test.ts b/test/client-network-search-undefined.test.ts new file mode 100644 index 0000000..c4d0296 --- /dev/null +++ b/test/client-network-search-undefined.test.ts @@ -0,0 +1,48 @@ +import assert from 'node:assert/strict'; +import { test } from 'node:test'; +import { BoardClient } from '../dist/client/client.js'; + +test('network search treats explicitly undefined optional filters as omitted', async () => { + const requests: string[] = []; + const client = new BoardClient('https://board.test', { + fetch: async (input) => { + requests.push(String(input)); + return Response.json({ items: [] }); + }, + }); + await client.searchNetwork({ q: 'typescript' }); + await client.searchNetwork({ + q: 'typescript', + tags: undefined, + salaryMin: undefined, + sort: undefined, + limit: undefined, + offset: undefined, + }); + assert.equal(requests.length, 2); + assert.equal(requests[1], requests[0]); +}); + +test('network search preserves explicit filters and zero salary', async () => { + let requested = ''; + const client = new BoardClient('https://board.test', { + fetch: async (input) => { + requested = String(input); + return Response.json({ items: [] }); + }, + }); + await client.searchNetwork({ + tags: ['typescript'], + salaryMin: 0, + sort: 'salary', + limit: 10, + offset: 5, + }); + const url = new URL(requested); + assert.equal(url.pathname, '/api/v1/directory/search'); + assert.equal(url.searchParams.get('tags'), 'typescript'); + assert.equal(url.searchParams.get('salaryMin'), '0'); + assert.equal(url.searchParams.get('sort'), 'salary'); + assert.equal(url.searchParams.get('limit'), '10'); + assert.equal(url.searchParams.get('offset'), '5'); +}); From 10a821542de8dd5990a0193b2dd0b7196742faf4 Mon Sep 17 00:00:00 2001 From: ilanvkn Date: Wed, 7 Oct 2026 16:04:46 +0800 Subject: [PATCH 079/116] fix(client): do not retry writes protected only by a blank key (#294) --- src/client/client.ts | 4 +++- test/client-empty-idempotency.test.ts | 24 ++++++++++++++++++++++++ 2 files changed, 27 insertions(+), 1 deletion(-) create mode 100644 test/client-empty-idempotency.test.ts diff --git a/src/client/client.ts b/src/client/client.ts index 8cc8999..1854fb7 100644 --- a/src/client/client.ts +++ b/src/client/client.ts @@ -220,7 +220,9 @@ export class BoardClient { // about a second. GET is safe to repeat. A POST is not, unless it // carries an idempotency key: then the board answers a repeat with // the row the first attempt made, and repeating is the point. - const repeatable = method === 'GET' || options.idempotencyKey !== undefined; + // Empty (including HTTP-trimmed whitespace) headers are treated as no + // key by the server, so they cannot make a write safe to repeat. + const repeatable = method === 'GET' || Boolean(options.idempotencyKey?.trim()); if ( this.retryTimeouts && repeatable && diff --git a/test/client-empty-idempotency.test.ts b/test/client-empty-idempotency.test.ts new file mode 100644 index 0000000..ac33dd8 --- /dev/null +++ b/test/client-empty-idempotency.test.ts @@ -0,0 +1,24 @@ +import assert from 'node:assert/strict'; +import { test } from 'node:test'; +import { ApiError, BoardClient } from '../dist/client/client.js'; + +for (const key of ['', ' ']) { + test(`a write with a blank idempotency key ${JSON.stringify(key)} is not retried`, async () => { + let calls = 0; + const client = new BoardClient('https://board.test', { + fetch: async () => { + calls += 1; + // The server may have written the listing before the response was lost. + // Empty headers do not activate its idempotency protection. + const error = new Error('response lost'); + error.name = 'AbortError'; + throw error; + }, + }); + await assert.rejects( + client.postJob({ org: 'acme', title: 'A role' }, { idempotencyKey: key }), + (error: unknown) => error instanceof ApiError && error.code === 'timeout', + ); + assert.equal(calls, 1, 'do not repeat a possibly completed unprotected write'); + }); +} From ec3e8212564ba5adff7e21976b7616fc9a9a47ec Mon Sep 17 00:00:00 2001 From: bmdy5 <110339793+bmdy5@users.noreply.github.com> Date: Wed, 7 Oct 2026 20:37:27 +0800 Subject: [PATCH 080/116] fix(markdown): split lists when marker style changes (#295) Co-authored-by: xiaoliang --- src/markup/markdown.ts | 11 ++++++++--- test/markup.test.ts | 11 +++++++++++ 2 files changed, 19 insertions(+), 3 deletions(-) diff --git a/src/markup/markdown.ts b/src/markup/markdown.ts index f73f852..9b622c2 100644 --- a/src/markup/markdown.ts +++ b/src/markup/markdown.ts @@ -224,6 +224,7 @@ function tryList(lines: string[], start: number, options: MarkdownOptions): Bloc const firstMarker = first[2] ?? ''; const ordered = /\d/.test(firstMarker); + const markerStyle = ordered ? firstMarker.slice(-1) : firstMarker; const orderedStart = ordered ? Number.parseInt(firstMarker, 10) : 1; const indent = (first[1] ?? '').length; const items: string[][] = []; @@ -235,9 +236,13 @@ function tryList(lines: string[], start: number, options: MarkdownOptions): Bloc const match = /^(\s*)([-*+]|\d{1,9}[.)])\s+(.*)$/.exec(line); if (match !== null && (match[1] ?? '').length <= indent) { - // A different marker type at the same level starts a new list rather - // than silently continuing this one. - if (/\d/.test(match[2] ?? '') !== ordered) break; + // A different marker style at the same level starts a new list rather + // than silently continuing this one. CommonMark treats 1. and 1) + // as different ordered lists, just as - and * are different bullet lists. + const currentMarker = match[2] ?? ''; + const currentOrdered = /\d/.test(currentMarker); + const currentStyle = currentOrdered ? currentMarker.slice(-1) : currentMarker; + if (currentOrdered !== ordered || currentStyle !== markerStyle) break; const content = match[3] ?? ''; // Each item may have a different marker width (for example 9. then 10.) // or padding. Remove exactly that prefix from its continuation lines. diff --git a/test/markup.test.ts b/test/markup.test.ts index 49769a6..7a5ef5b 100644 --- a/test/markup.test.ts +++ b/test/markup.test.ts @@ -163,6 +163,17 @@ test('ordered and unordered lists do not merge', () => { assert.ok(html.includes('
    ') && html.includes('
      '), html); }); +test('different list marker styles start new lists', () => { + assert.equal( + renderMarkdown('1. one\n2) two'), + '
      1. one
      \n
      1. two
      ', + ); + assert.equal( + renderMarkdown('- one\n* two'), + '
      • one
      \n
      • two
      ', + ); +}); + test('ordered lists preserve a non-default starting number', () => { assert.equal( renderMarkdown('3. Review\n4. Deliver'), From a71475806dfa064a1de10f846ea5ac25d9865c06 Mon Sep 17 00:00:00 2001 From: OnePaperclipLab <339823780+OnePaperclipLab@users.noreply.github.com> Date: Thu, 8 Oct 2026 18:55:59 -0700 Subject: [PATCH 081/116] fix(cli): preserve candidate slug in news filters (#296) * fix(cli): preserve candidate slug in news filters * test(cli): cover candidate news filters and subject switches --- src/cli/args.ts | 15 ++++++++--- test/cli-news-candidate.test.ts | 47 +++++++++++++++++++++++++++++++++ 2 files changed, 58 insertions(+), 4 deletions(-) create mode 100644 test/cli-news-candidate.test.ts diff --git a/src/cli/args.ts b/src/cli/args.ts index 9daad8d..3b54f8a 100644 --- a/src/cli/args.ts +++ b/src/cli/args.ts @@ -41,12 +41,19 @@ const BOOLEAN_FLAGS = new Set([ 'read', ]); -function takesValue(name: string, next: string | undefined): next is string { +function takesValue( + name: string, + next: string | undefined, + command: string | undefined, +): next is string { const negativeNumber = next !== undefined && /^-\d+(?:\.\d+)?$/.test(next); + // `news --candidate ` filters the feed; other commands use the same + // option as a boolean switch between employer and candidate subjects. + const boolean = BOOLEAN_FLAGS.has(name) && !(command === 'news' && name === 'candidate'); return ( next !== undefined && (!next.startsWith('-') || negativeNumber) && - (!BOOLEAN_FLAGS.has(name) || /^(true|false|1|0|yes|no)$/i.test(next)) + (!boolean || /^(true|false|1|0|yes|no)$/i.test(next)) ); } @@ -75,7 +82,7 @@ export function parseArgs(argv: string[]): Args { continue; } const next = argv[index + 1]; - if (takesValue(body, next)) { + if (takesValue(body, next, positional[0])) { set(flags, body, next); index += 1; continue; @@ -87,7 +94,7 @@ export function parseArgs(argv: string[]): Args { if (token.startsWith('-') && token.length > 1) { const body = token.slice(1); const next = argv[index + 1]; - if (takesValue(body, next)) { + if (takesValue(body, next, positional[0])) { set(flags, body, next); index += 1; continue; diff --git a/test/cli-news-candidate.test.ts b/test/cli-news-candidate.test.ts new file mode 100644 index 0000000..48247cf --- /dev/null +++ b/test/cli-news-candidate.test.ts @@ -0,0 +1,47 @@ +import assert from 'node:assert/strict'; +import { test } from 'node:test'; +import { flagBool, flagString, parseArgs } from '../dist/cli/args.js'; + +test('news consumes the documented candidate slug instead of dropping the filter', () => { + for (const slug of ['example-maker', 'false', '1']) { + const args = parseArgs(['news', '--candidate', slug]); + assert.equal(args.command, 'news'); + assert.equal(flagString(args, 'candidate'), slug); + assert.deepEqual(args.positional, []); + } +}); + +test('news candidate filters work with preceding global flags and later filters', () => { + const args = parseArgs(['--json', 'news', '--candidate', 'example-maker', '--following']); + assert.equal(args.command, 'news'); + assert.equal(flagString(args, 'candidate'), 'example-maker'); + assert.equal(flagBool(args, 'json'), true); + assert.equal(flagBool(args, 'following'), true); + assert.deepEqual(args.positional, []); +}); + +test('news keeps equals syntax and repeated candidate filters', () => { + const args = parseArgs(['news', '--candidate=first-maker', '--candidate', 'second-maker']); + assert.equal(flagString(args, 'candidate'), 'second-maker'); + assert.deepEqual(args.positional, []); +}); + +test('candidate remains boolean for commands that use it as a subject switch', () => { + for (const command of ['follow', 'unfollow', 'recommend', 'recommendations', 'message']) { + const args = parseArgs([command, '--candidate', 'example-maker', 'sample text']); + assert.equal(flagBool(args, 'candidate'), true); + assert.deepEqual(args.positional, ['example-maker', 'sample text']); + const disabled = parseArgs([command, '--candidate', 'false', 'example-maker']); + assert.equal(flagBool(disabled, 'candidate'), false); + assert.deepEqual(disabled.positional, ['example-maker']); + } +}); + +test('news preserves the option terminator and does not consume another option as a slug', () => { + const stopped = parseArgs(['news', '--', '--candidate', 'example-maker']); + assert.equal(flagString(stopped, 'candidate'), undefined); + assert.deepEqual(stopped.positional, ['--candidate', 'example-maker']); + const missing = parseArgs(['news', '--candidate', '--following']); + assert.equal(flagString(missing, 'candidate'), undefined); + assert.equal(flagBool(missing, 'following'), true); +}); From 71fed479a732e53c63e6acf0955cf797951b8fdc Mon Sep 17 00:00:00 2001 From: Ayush Agrawal <131985798+ayush-agrawal001@users.noreply.github.com> Date: Fri, 9 Oct 2026 07:26:08 +0530 Subject: [PATCH 082/116] fix(search): deduplicate tags before applying query cap (#298) --- src/schema/query.ts | 16 ++++++---- test/query-duplicate-tags.test.ts | 52 +++++++++++++++++++++++++++++++ 2 files changed, 62 insertions(+), 6 deletions(-) create mode 100644 test/query-duplicate-tags.test.ts diff --git a/src/schema/query.ts b/src/schema/query.ts index e090ee4..8956784 100644 --- a/src/schema/query.ts +++ b/src/schema/query.ts @@ -93,12 +93,16 @@ export function parseQuery(params: URLSearchParams): JobQuery { agentPolicy: isAgentPolicy(agentPolicy) ? agentPolicy : null, // `tag=a&tag=b` and `tags=a,b` mean the same thing. The second is what a // badge links to and what a person types; the first is what the CLI's - // repeatable --tag produces. - tags: [...params.getAll('tag'), ...params.getAll('tags')] - .flatMap((value) => value.split(',')) - .map((value) => value.trim().toLowerCase()) - .filter((value) => value !== '') - .slice(0, 10), + // repeatable --tag produces. A tag named in both forms is still one + // filter, so repeats are dropped before the cap rather than spending it. + tags: [ + ...new Set( + [...params.getAll('tag'), ...params.getAll('tags')] + .flatMap((value) => value.split(',')) + .map((value) => value.trim().toLowerCase()) + .filter((value) => value !== ''), + ), + ].slice(0, 10), salaryMin: salaryMin === null ? null : integer(salaryMin, 0, 0, 100_000_000) || null, org: one(params, 'org'), sort: sort !== null && (SORTS as readonly string[]).includes(sort) ? (sort as Sort) : 'recent', diff --git a/test/query-duplicate-tags.test.ts b/test/query-duplicate-tags.test.ts new file mode 100644 index 0000000..d4346f2 --- /dev/null +++ b/test/query-duplicate-tags.test.ts @@ -0,0 +1,52 @@ +import assert from 'node:assert/strict'; +import { test } from 'node:test'; +import { parseQuery, queryToParams } from '../src/schema/query.ts'; + +test('a tag repeated across tag and tags, in any case or spacing, is one filter', () => { + const query = parseQuery(new URLSearchParams('tag=Rust&tag= go &tags=rust, GO ,RUST,typescript')); + assert.deepEqual(query.tags, ['rust', 'go', 'typescript']); + assert.equal(queryToParams(query).get('tags'), 'rust,go,typescript'); +}); + +test('a repeated tag does not push the last unique filter past the cap', () => { + const query = parseQuery( + new URLSearchParams( + 'tag=Rust&tags=rust,typescript,go,python,java,sql,react,node,docker,solana', + ), + ); + assert.deepEqual(query.tags, [ + 'rust', + 'typescript', + 'go', + 'python', + 'java', + 'sql', + 'react', + 'node', + 'docker', + 'solana', + ]); +}); + +test('more than ten unique tags are still capped at the first ten', () => { + const tags = Array.from({ length: 12 }, (_, index) => `t${index}`); + const query = parseQuery(new URLSearchParams({ tags: ['t0', ...tags].join(',') })); + assert.deepEqual(query.tags, tags.slice(0, 10)); +}); + +test('deduplicated tags round-trip and leave the other filters alone', () => { + const query = parseQuery( + new URLSearchParams( + 'q=parser&workplace=remote&tag=API&tags=api,remote&salaryMin=90000&org=acme&sort=salary&limit=10&offset=20', + ), + ); + assert.equal(query.q, 'parser'); + assert.equal(query.workplace, 'remote'); + assert.equal(query.salaryMin, 90000); + assert.equal(query.org, 'acme'); + assert.equal(query.sort, 'salary'); + assert.equal(query.limit, 10); + assert.equal(query.offset, 20); + assert.deepEqual(query.tags, ['api', 'remote']); + assert.deepEqual(parseQuery(queryToParams(query)), query); +}); From d363d292ed22b9cf86d31f0bd618de0a3ccfc503 Mon Sep 17 00:00:00 2001 From: Ayush Agrawal <131985798+ayush-agrawal001@users.noreply.github.com> Date: Fri, 9 Oct 2026 07:26:16 +0530 Subject: [PATCH 083/116] fix(cli): strip closing Markdown hashes from derived job titles (#299) --- src/cli/jobfile.ts | 6 ++- test/jobfile-closing-hashes.test.ts | 58 +++++++++++++++++++++++++++++ 2 files changed, 63 insertions(+), 1 deletion(-) create mode 100644 test/jobfile-closing-hashes.test.ts diff --git a/src/cli/jobfile.ts b/src/cli/jobfile.ts index 1cddcfe..b0632d0 100644 --- a/src/cli/jobfile.ts +++ b/src/cli/jobfile.ts @@ -29,7 +29,11 @@ function firstHeading(text: string): { title: string; start: number; end: number } else { const heading = /^#\s+(.+)$/.exec(line); if (heading !== null) { - return { title: (heading[1] ?? '').trim(), start: offset, end: offset + line.length }; + // A closing run of hashes after a space, or a heading made only of + // them, is heading syntax, as the Markdown renderer reads it; a hash + // attached to a word (C#) is text. + const title = (heading[1] ?? '').trim().replace(/(?:^|[ \t]+)#+$/, ''); + return { title, start: offset, end: offset + line.length }; } } } diff --git a/test/jobfile-closing-hashes.test.ts b/test/jobfile-closing-hashes.test.ts new file mode 100644 index 0000000..f0af3ae --- /dev/null +++ b/test/jobfile-closing-hashes.test.ts @@ -0,0 +1,58 @@ +import assert from 'node:assert/strict'; +import { test } from 'node:test'; +import { parseJobDocument } from '../src/cli/jobfile.ts'; + +test('closing hashes are not part of a plain Markdown job title', () => { + for (const heading of ['# Staff Engineer #', '# Staff Engineer ##', '# Staff Engineer ### ']) { + const source = `${heading}\n\nRole details`; + assert.deepEqual(parseJobDocument(source), { + title: 'Staff Engineer', + description: source.trim(), + }); + } +}); + +test('closing hashes are not part of a title derived below front matter', () => { + const parsed = parseJobDocument( + '---\norg: acme\n---\nIntro paragraph\n\n# Staff Engineer ##\n\nRole details', + ); + assert.deepEqual(parsed, { + org: 'acme', + title: 'Staff Engineer', + description: 'Intro paragraph\n\nRole details', + }); +}); + +test('a heading made only of closing hashes yields an empty title, as an empty heading does', () => { + for (const heading of ['# #', '# ###', '# ### ']) { + const source = `${heading}\n\nRole details`; + assert.deepEqual(parseJobDocument(source), { title: '', description: source.trim() }); + assert.equal(parseJobDocument(`---\norg: acme\n---\n${source}`).title, ''); + } +}); + +test('hashes that are part of the title text are kept', () => { + assert.equal(parseJobDocument('# Senior C#\n\nRole details').title, 'Senior C#'); + assert.equal( + parseJobDocument('# F# and C# Engineer\n\nRole details').title, + 'F# and C# Engineer', + ); + assert.equal(parseJobDocument('# Issue #42 Owner\n\nRole details').title, 'Issue #42 Owner'); + assert.equal(parseJobDocument('# Senior C# ##\n\nRole details').title, 'Senior C#'); +}); + +test('an explicit front matter title and its body are unchanged', () => { + const parsed = parseJobDocument( + '---\ntitle: Platform Lead #\norg: acme\n---\n# Staff Engineer ##\n\nRole details', + ); + assert.deepEqual(parsed, { + title: 'Platform Lead #', + org: 'acme', + description: '# Staff Engineer ##\n\nRole details', + }); +}); + +test('a closing-hash heading inside a code fence is still not a title', () => { + const source = '```md\n# Example only ##\n```\n\n# Staff Engineer ##\n\nRole details'; + assert.equal(parseJobDocument(source).title, 'Staff Engineer'); +}); From 73779bc575a4ff2119e7b572fd2315e7072e77a6 Mon Sep 17 00:00:00 2001 From: Anthony Ettinger Date: Thu, 8 Oct 2026 20:34:44 -0700 Subject: [PATCH 084/116] fix(cli): accept stdin dash as an option value (rebased #297) (#300) * fix(cli): accept stdin dash as an option value * test(cli): cover piped tracker imports and dash parsing --------- Co-authored-by: OnePaperclipLab <339823780+OnePaperclipLab@users.noreply.github.com> --- src/cli/args.ts | 2 +- test/cli-stdin.test.ts | 57 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 58 insertions(+), 1 deletion(-) create mode 100644 test/cli-stdin.test.ts diff --git a/src/cli/args.ts b/src/cli/args.ts index 3b54f8a..61b0d9d 100644 --- a/src/cli/args.ts +++ b/src/cli/args.ts @@ -52,7 +52,7 @@ function takesValue( const boolean = BOOLEAN_FLAGS.has(name) && !(command === 'news' && name === 'candidate'); return ( next !== undefined && - (!next.startsWith('-') || negativeNumber) && + (next === '-' || !next.startsWith('-') || negativeNumber) && (!boolean || /^(true|false|1|0|yes|no)$/i.test(next)) ); } diff --git a/test/cli-stdin.test.ts b/test/cli-stdin.test.ts new file mode 100644 index 0000000..6927d46 --- /dev/null +++ b/test/cli-stdin.test.ts @@ -0,0 +1,57 @@ +import assert from 'node:assert/strict'; +import { spawnSync } from 'node:child_process'; +import { test } from 'node:test'; +import { flagBool, flagString, parseArgs } from '../dist/cli/args.js'; + +test('value options accept a lone dash without leaving it positional', () => { + for (const flags of [['--file', '-'], ['--file=-'], ['-f', '-']]) { + const args = parseArgs(['tracker', 'import', 'example-fleet', ...flags]); + assert.equal(flagString(args, 'file', 'f'), '-'); + assert.deepEqual(args.positional, ['import', 'example-fleet']); + } +}); + +test('boolean options leave a lone dash positional', () => { + const args = parseArgs(['search', '--remote', '-']); + assert.equal(flagBool(args, 'remote'), true); + assert.deepEqual(args.positional, ['-']); +}); + +test('a lone dash does not change option or terminator parsing', () => { + const args = parseArgs(['tracker', 'import', '--file', '-', '--dry-run', '--', '--literal']); + assert.equal(flagString(args, 'file'), '-'); + assert.equal(flagBool(args, 'dry-run'), true); + assert.deepEqual(args.positional, ['import', '--literal']); + const missing = parseArgs(['tracker', 'import', '--file', '--dry-run']); + assert.equal(flagString(missing, 'file'), undefined); + assert.equal(flagBool(missing, 'dry-run'), true); +}); + +test('tracker import reads piped JSON with the documented --file - syntax', () => { + const argsUrl = new URL('../dist/cli/args.js', import.meta.url).href; + const trackerUrl = new URL('../dist/cli/tracker.js', import.meta.url).href; + const script = ` + import { parseArgs } from ${JSON.stringify(argsUrl)}; + import { runTracker } from ${JSON.stringify(trackerUrl)}; + const client = { + trackerReport: async () => ({ fleet: { currency: 'USD' } }), + trackerImport: async () => { throw new Error('dry-run must not submit'); }, + }; + await runTracker(parseArgs([ + 'tracker', 'import', 'example-fleet', '--file', '-', '--format', 'ledger', + '--source', 'test-fixture', '--dry-run', + ]), client); + `; + const result = spawnSync(process.execPath, ['--input-type=module', '-e', script], { + input: JSON.stringify([{ id: 'sample-cost', kind: 'cost', amount: 1.25, currency: 'USD' }]), + encoding: 'utf8', + timeout: 10_000, + }); + assert.ifError(result.error); + assert.equal(result.status, 0, result.stderr); + const payload = JSON.parse(result.stdout); + assert.equal(payload.source, 'test-fixture'); + assert.equal(payload.events.length, 1); + assert.equal(payload.events[0].id, 'sample-cost'); + assert.equal(payload.events[0].amount, 1.25); +}); From 48dff27b0f88ddf3f3ff8a749e58d864ca4e769b Mon Sep 17 00:00:00 2001 From: reacx-research Date: Fri, 9 Oct 2026 21:50:52 +0200 Subject: [PATCH 085/116] fix: withhold contact URIs from anonymous resume views (#302) * fix: withhold explicit contact URIs from anonymous resumes Added functions to redact contact URIs and check for contact channels in text. * fix: guard cached candidate location and skills contact channels Refactor skill extraction logic to improve handling of category labels and contact channels. * test: cover encoded contact URIs and anonymous candidate summaries --- src/core/candidates.ts | 20 ++- src/markup/resume.ts | 88 +++++++++- test/resume-contact-uri-redaction.test.ts | 192 ++++++++++++++++++++++ 3 files changed, 292 insertions(+), 8 deletions(-) create mode 100644 test/resume-contact-uri-redaction.test.ts diff --git a/src/core/candidates.ts b/src/core/candidates.ts index 85225f6..78cae22 100644 --- a/src/core/candidates.ts +++ b/src/core/candidates.ts @@ -12,6 +12,7 @@ import type { CandidateSummary } from '../views/candidates.tsx'; import { parseCapacity } from './capacity.ts'; import { type OpenResume, + CONTACT_WITHHELD, hasContactChannel, parseResume, redactContactChannels, @@ -39,11 +40,9 @@ function skillsOf(resume: Resume): string[] { const fromBullets = sections .flatMap((section) => section.markdown.split('\n')) .map((line) => line.replace(/^\s*(?:[-*+]|\d{1,9}[.)])\s+/, '').trim()) - // A skills bullet is very often "**Languages:** JavaScript, Go", and the - // label is a category rather than a skill. Without dropping it the first - // badge on the card reads "**Languages:** JavaScript". The colon may - // also sit outside the emphasis: "**Languages**: JavaScript, Go". - .map((line) => line.replace(/^\*{0,2}[^*:]{1,40}\*{0,2}\s*:\*{0,2}\s*/, '')) + // A mailto URI may contain several comma-separated recipients. Withhold + // the complete channel before commas can turn its tail into another skill. + .map((line) => redactContactChannels(line).markdown) .filter((line) => line !== '' && !line.startsWith('#')); const flattened = fromBullets.flatMap((line) => @@ -53,9 +52,15 @@ function skillsOf(resume: Resume): string[] { const seen = new Set(); const out: string[] = []; for (const skill of flattened) { + // Check before dropping a category label: `mailto:` is a channel, not a + // label whose removal should leave the recipient on a public badge. + if (skill.includes(CONTACT_WITHHELD) || hasContactChannel(skill)) continue; + // A skills bullet is often "**Languages:** JavaScript, Go". Strip the + // category only after each comma-separated entry has passed the guard. + const withoutLabel = skill.replace(/^\*{0,2}[^*:]{1,40}\*{0,2}\s*:\*{0,2}\s*/, ''); // A sentence is prose that happened to be in the skills section, not a // skill, and a badge is the wrong shape for it. - const cleaned = skill.replace(/\*\*/g, '').replace(/^`|`$/g, '').trim(); + const cleaned = withoutLabel.replace(/\*\*/g, '').replace(/^`|`$/g, '').trim(); if (cleaned === '' || cleaned.length > 40) continue; const key = cleaned.toLowerCase(); if (seen.has(key)) continue; @@ -67,7 +72,8 @@ function skillsOf(resume: Resume): string[] { function locationOf(resume: Resume): string | null { const found = resume.parsed?.contact.find((item) => LOCATION_KEYS.test(item.key)); - return found?.value ?? null; + const value = found?.value; + return value === undefined || hasContactChannel(value) ? null : value; } /** diff --git a/src/markup/resume.ts b/src/markup/resume.ts index db34999..e472d1c 100644 --- a/src/markup/resume.ts +++ b/src/markup/resume.ts @@ -482,9 +482,95 @@ const EMAIL_IN_TEXT = /[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/g; const PHONE_IN_TEXT = /(?:\+\d[\d ()./-]{6,}\d|\(\d{3}\)[\d ()./-]{5,}\d|\b\d{3}[-.\s]\d{3}[-.\s]\d{4}\b)/g; +/** + * An explicit contact URI is a channel even when its recipient does not + * resemble plain prose: mailto can percent-encode @, and tel can carry an + * unformatted number. The URI boundary is checked below so balanced parentheses + * in telephone numbers or mail headers do not leave a recipient behind. + */ +const CONTACT_URI_IN_TEXT = + /\b(?:mailto|tel):/gi; + +/** Match the renderer's balanced/escaped URL parentheses, including URI headers. */ +function contactUriEnd(text: string, start: number, telephone: boolean): number { + let depth = 0; + let end = start; + for (; end < text.length; end += 1) { + const char = text[end] ?? ''; + if (/[<>[\]"`]/.test(char)) break; + if (/\s/.test(char)) { + // Visual telephone separators may contain spaces. A line break, prose, + // or an unmatched Markdown closing parenthesis ends the destination. + if (!telephone || !/[ \t]/.test(char) || !/^(?:\d|\\?\()/.test(text.slice(end + 1))) break; + } + if (char === '\\' && /[()]/.test(text[end + 1] ?? '')) { + end += 1; + continue; + } + if (char === '(') depth += 1; + if (char === ')') { + if (depth === 0) break; + depth -= 1; + } + } + // A trailing comma separates prose or a following skill; commas within + // a mail recipient list remain part of the channel and are withheld. + while (end > start && text[end - 1] === ',') end -= 1; + return end; +} + +/** Keep scheme names within project HTTP URLs from becoming contact fields. */ +function redactContactUris(text: string): string { + const urls: { start: number; end: number }[] = []; + for (const match of text.matchAll(/\bhttps?:\/\//gi)) { + let end = match.index + match[0].length; + let depth = 0; + for (; end < text.length; end += 1) { + const char = text[end] ?? ''; + if (/[\s<>"`]/.test(char)) break; + if (char === '[') { + // A bracketed IPv6 host belongs to the URL. A following Markdown + // link label begins a separate token even when there is no space. + const close = text.indexOf(']', end + 1); + if (end === match.index + match[0].length && close !== -1 + && /^[\da-f:.%]+$/i.test(text.slice(end + 1, close))) { + end = close; + continue; + } + break; + } + if (char === ']') break; + if (char === '\\' && /[()]/.test(text[end + 1] ?? '')) { + end += 1; + continue; + } + if (char === '(') depth += 1; + if (char === ')') { + if (depth === 0) break; + depth -= 1; + } + } + urls.push({ start: match.index, end }); + } + const out: string[] = []; + let cursor = 0; + for (const match of text.matchAll(CONTACT_URI_IN_TEXT)) { + const start = match.index; + if (start < cursor || urls.some((url) => start >= url.start && start < url.end)) continue; + const payload = start + match[0].length; + const end = contactUriEnd(text, payload, /^tel:/i.test(match[0])); + if (end === payload) continue; + out.push(text.slice(cursor, start), CONTACT_WITHHELD); + cursor = end; + } + out.push(text.slice(cursor)); + return out.join(''); +} + /** Whether plain summary text contains a channel the public resume withholds. */ export function hasContactChannel(text: string): boolean { return ( + redactContactUris(text) !== text || new RegExp(EMAIL_IN_TEXT.source).test(text) || new RegExp(PHONE_IN_TEXT.source).test(text) ); @@ -572,7 +658,7 @@ export function redactContactChannels(source: string): { markdown: string; redac // global, and a global regex's `test` advances `lastIndex` between calls, // so it returns false on matches it has already walked past. That is how a // redaction skips lines at random and still passes a one-line unit test. - const scrubbed = line + const scrubbed = redactContactUris(line) .replace(EMAIL_IN_TEXT, CONTACT_WITHHELD) .replace(PHONE_IN_TEXT, CONTACT_WITHHELD); if (scrubbed !== line) { diff --git a/test/resume-contact-uri-redaction.test.ts b/test/resume-contact-uri-redaction.test.ts new file mode 100644 index 0000000..fc5b133 --- /dev/null +++ b/test/resume-contact-uri-redaction.test.ts @@ -0,0 +1,192 @@ +import assert from 'node:assert/strict'; +import { test } from 'node:test'; +import { renderMarkdown } from '../dist/markup/markdown.js'; +import { nameOf, resumeForViewer, toCandidateSummary } from '../dist/core/candidates.js'; +import { + CONTACT_WITHHELD, + hasContactChannel, + parseResume, + redactContactChannels, +} from '../dist/markup/resume.js'; + +test('a percent-encoded mailto destination in a resume section is withheld', () => { + const source = '# Ada\n\n## Availability\nPlease [email me](mailto:ada%40example.com).\n'; + assert.match(renderMarkdown(source), /href="mailto:ada%40example\.com"/); + + const view = redactContactChannels(source); + assert.equal(view.redacted, true); + assert.ok(!view.markdown.includes('ada%40example.com')); + assert.ok(view.markdown.includes(CONTACT_WITHHELD)); + assert.ok(view.markdown.includes('Please')); + assert.doesNotMatch(renderMarkdown(view.markdown), /href="mailto:/i); +}); + +test('balanced mail headers cannot hide a query recipient after the subject', () => { + for (const uri of [ + 'mailto:?subject=Work(contract(nested))&to=ada%40example.test', + "mailto:?subject=Operator's&to=ada%40example.test", + ]) { + const source = `# Ada\n\n## Availability\n[operator](${uri}) 2026\n`; + assert.match(renderMarkdown(source), /href="mailto:/); + const view = redactContactChannels(source); + assert.equal(view.markdown, `# Ada\n\n## Availability\n[operator](${CONTACT_WITHHELD}) 2026\n`); + assert.equal(hasContactChannel(uri), true); + } +}); + +test('explicit tel destinations do not require a formatted number to be withheld', () => { + for (const uri of [ + 'tel:15550101010', + 'TEL:%2B15550101010', + 'tel:+49(30)1234567', + 'tel:(212)5550123', + 'tel:+49 170 5551234', + 'tel:(555) 010-1010', + 'tel:15550101010;ext=42', + 'tel:+49\\(30\\)1234567', + 'tel:+1-212.555(0123);ext=77', + 'tel:5550123;phone-context=+1(212);ext=77', + 'tel:5550123;ext=77;phone-context=+1(212)', + ]) { + const source = `# Ada\n\n## Availability\nPlease [call me](${uri}).\n`; + if (!/\s/.test(uri)) assert.match(renderMarkdown(source), /href="tel:/i); + const view = redactContactChannels(source); + assert.equal(view.redacted, true, uri); + assert.ok(!view.markdown.includes(uri), uri); + assert.equal(view.markdown.split(CONTACT_WITHHELD).length - 1, 1, uri); + assert.doesNotMatch(view.markdown, /\d/, uri); + assert.doesNotMatch(renderMarkdown(view.markdown), /href="tel:/i); + } +}); + +test('contact-channel guards recognize encoded mailto and compact tel URIs repeatedly', () => { + for (let repeat = 0; repeat < 3; repeat += 1) { + for (const text of [ + 'Contact [Ada](mailto:ada%40example.com)', + 'Call tel:15550101010', + 'Write MAILTO:ada%40example.com?subject=Hello', + 'Phone TEL:%2B15550101010', + ]) { + assert.equal(hasContactChannel(text), true, text); + } + } +}); + +test('multiple explicit channels in prose and angle destinations are all withheld', () => { + const source = [ + '# Ada', + '', + '## Contact', + '[Email]() or [Phone](tel:15550101010).', + 'Backup: mailto:backup%40example.com', + '', + ].join('\n'); + const view = redactContactChannels(source); + assert.equal(view.redacted, true); + assert.doesNotMatch(view.markdown, /(?:mailto:|tel:|%40|15550101010)/i); + assert.equal(view.markdown.split(CONTACT_WITHHELD).length - 1, 3); + assert.match(view.markdown, /Backup:/); +}); + +test('project links, dates and ordinary numeric identifiers remain unchanged', () => { + const source = '# Ada\n\n## Work\n[Project](https://example.com/docs) 2019-2024, ticket 15550101010.\n' + + '[URI docs](https://example.test/docs/mailto:syntax) and ' + + '[Phone docs](https://example.test/docs/tel:syntax).\n' + + '[Protocol guide](https://example.test/docs/v1.mailto:syntax)\n' + + '[Phone guide](https://example.test/docs/v1.tel:syntax)\n' + + 'https://example.test/docs?guide=urn:mailto:syntax\n' + + 'https://example.test/docs?guide=urn:tel:syntax\n'; + const view = redactContactChannels(source); + assert.equal(view.redacted, false); + assert.equal(view.markdown, source); + assert.equal(hasContactChannel('Project 2019-2024, ticket 15550101010'), false); + assert.equal(hasContactChannel('https://example.test/docs/mailto:syntax'), false); + assert.equal(hasContactChannel('https://example.test/docs/tel:syntax'), false); + assert.equal(hasContactChannel('https://example.test/docs/v1.mailto:syntax'), false); + assert.equal(hasContactChannel('https://example.test/docs?guide=urn:tel:syntax'), false); + assert.match(renderMarkdown(view.markdown), /href="https:\/\/example\.com\/docs"/); +}); + +test('a project URL immediately before a contact link does not conceal the channel', () => { + for (const prefix of [ + '[Docs](https://example.test/path(one(two)))', + 'Portfolio https://example.test', + 'Portfolio https://[2001:db8::1]/docs/mailto:syntax ', + ]) { + const source = `# Ada\n\n## Work\n${prefix}[email](mailto:ada%40example.test)\n`; + assert.match(renderMarkdown(source), /href="mailto:/); + const view = redactContactChannels(source); + assert.ok(view.markdown.includes(prefix)); + assert.ok(!view.markdown.includes('ada%40example.test')); + assert.equal(hasContactChannel(source), true); + } +}); + +test('the end of a telephone link preserves following years and numeric prose', () => { + for (const [uri, prose] of [ + ['tel:(212)5550123', '2026'], + ['tel:15550101010', '2019-2024'], + ['tel:5550123', '42 releases shipped'], + ]) { + const source = `# Ada\n\n## Work\n[call](${uri}) ${prose}\n`; + const view = redactContactChannels(source); + assert.equal(view.markdown, `# Ada\n\n## Work\n[call](${CONTACT_WITHHELD}) ${prose}\n`); + assert.ok(renderMarkdown(view.markdown).includes(prose)); + } +}); + +test('the anonymous resume view withholds the URI while the signed-in copy stays whole', () => { + const source = '# Ada\n\n## Availability\n[email](mailto:ada%40example.com)\n'; + const resume = { markdown: source, parsed: null }; + const publicView = resumeForViewer(resume, false); + assert.equal(publicView.redacted, true); + assert.ok(!publicView.markdown.includes('ada%40example.com')); + assert.doesNotMatch(renderMarkdown(publicView.markdown), /href="mailto:/i); + assert.deepEqual(resumeForViewer(resume, true), { + markdown: source, parsed: null, redacted: false, + }); +}); + +test('cached directory names and headlines cannot expose the same explicit URIs', () => { + const resume = { + title: 'Contact mailto:ada%40example.com', + parsed: { + name: 'Call tel:15550101010', + headline: '[email](mailto:ada%40example.com)', + contact: [], + sections: [], + }, + publicSlug: 'ada', + updatedAt: '2026-10-09T00:00:00Z', + } as never; + assert.equal(nameOf(resume), 'Candidate'); + const summary = toCandidateSummary(resume); + assert.equal(summary.name, 'Candidate'); + assert.equal(summary.headline, null); +}); + +test('cached locations withhold contact URIs while ordinary places remain visible', () => { + for (const location of ['mailto:ada%40example.test', 'tel:15550101010', 'Berlin, Germany']) { + const markdown = `# Ada\n\n- **Location**: ${location}\n\n## Work\nEngineer\n`; + const resume = { + title: 'Ada', markdown, parsed: parseResume(markdown), + publicSlug: 'ada', updatedAt: '2026-10-09T00:00:00Z', + } as never; + assert.equal(toCandidateSummary(resume).location, + location === 'Berlin, Germany' ? location : null); + assert.equal(resumeForViewer(resume, true).markdown, markdown); + } +}); + +test('skills reject a channel before label removal and preserve complementary skills', () => { + const markdown = '# Ada\n\n## Skills\n- mailto:ada%40example.test\n' + + '- tel:15550101010\n- **Languages:** TypeScript, mailto:backup%40example.test, Go\n' + + '- mailto:ada%40example.test,bob%40example.test\n' + + '- AWS, mailto:first%40example.test,second%40example.test, Remote\n'; + const resume = { + title: 'Ada', markdown, parsed: parseResume(markdown), + publicSlug: 'ada', updatedAt: '2026-10-09T00:00:00Z', + } as never; + assert.deepEqual(toCandidateSummary(resume).skills, ['TypeScript', 'Go', 'AWS', 'Remote']); + assert.equal(resumeForViewer(resume, true).markdown, markdown); +}); From 1f2cb87c9b845b42073876453521687494b0ae98 Mon Sep 17 00:00:00 2001 From: Anthony Ettinger Date: Fri, 9 Oct 2026 13:25:54 -0700 Subject: [PATCH 086/116] test(client): give the fanout timeout test a budget CI can meet (#303) The healthy mock board shares the 50 ms budget with the slow one, so on a loaded runner it timed out too and line 32 failed. It caused 3 of the last 4 master CI failures and blocked #301. 1 s keeps the assertion (one slow call, no budget restart) while leaving the healthy board ample headroom. Co-authored-by: Claude Opus 5.5 --- test/client-fanout-timeout-retry.test.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/client-fanout-timeout-retry.test.ts b/test/client-fanout-timeout-retry.test.ts index 1c3204c..1506956 100644 --- a/test/client-fanout-timeout-retry.test.ts +++ b/test/client-fanout-timeout-retry.test.ts @@ -23,7 +23,7 @@ test('fanout does not restart an exhausted board timeout budget', async (t) => { { server: 'https://healthy.test', token: null }, ], {}, - { timeoutMs: 50 }, + { timeoutMs: 1_000 }, ); assert.equal(slowCalls, 1, 'a timed-out board must not receive a new full timeout budget'); From b95e56fc080382e121e85e8594852b4ecc9e7497 Mon Sep 17 00:00:00 2001 From: OnePaperclipLab <339823780+OnePaperclipLab@users.noreply.github.com> Date: Fri, 9 Oct 2026 13:25:59 -0700 Subject: [PATCH 087/116] fix(cli): infer job titles from indented Markdown headings (#301) * fix(cli): recognize indented Markdown job titles * test(cli): cover indented title extraction and code boundaries * fix(cli): preserve leading code indentation after front matter Updated body extraction to remove blank opening lines while preserving indentation for Markdown syntax. * test(cli): retain initial code examples during title extraction --- src/cli/jobfile.ts | 6 +- test/jobfile-indented-heading.test.ts | 81 +++++++++++++++++++++++++++ 2 files changed, 85 insertions(+), 2 deletions(-) create mode 100644 test/jobfile-indented-heading.test.ts diff --git a/src/cli/jobfile.ts b/src/cli/jobfile.ts index b0632d0..7258069 100644 --- a/src/cli/jobfile.ts +++ b/src/cli/jobfile.ts @@ -27,7 +27,7 @@ function firstHeading(text: string): { title: string; start: number; end: number const run = opening[1] ?? '```'; fence = { marker: run[0] ?? '`', length: run.length }; } else { - const heading = /^#\s+(.+)$/.exec(line); + const heading = /^ {0,3}#\s+(.+)$/.exec(line); if (heading !== null) { // A closing run of hashes after a space, or a heading made only of // them, is heading syntax, as the Markdown renderer reads it; a hash @@ -58,7 +58,9 @@ export function parseJobDocument(source: string): JobDocument { } const front = parseFrontMatter(match[1] ?? ''); - const body = text.slice(match[0].length).trim(); + // Remove blank opening lines without turning indented code into a heading + // or a code fence. Indentation on the first content line is Markdown syntax. + const body = text.slice(match[0].length).replace(/^(?:[ \t]*\n)+/, '').trimEnd(); const heading = firstHeading(body); const title = front['title'] ?? heading?.title; let description = body; diff --git a/test/jobfile-indented-heading.test.ts b/test/jobfile-indented-heading.test.ts new file mode 100644 index 0000000..153ecec --- /dev/null +++ b/test/jobfile-indented-heading.test.ts @@ -0,0 +1,81 @@ +import assert from 'node:assert/strict'; +import { test } from 'node:test'; +import { parseJobDocument } from '../src/cli/jobfile.ts'; + +test('plain Markdown titles allow one to three leading spaces', () => { + for (const indent of [1, 2, 3]) { + const source = `Intro paragraph\n\n${' '.repeat(indent)}# Staff Engineer ##\n\nRole details`; + assert.deepEqual(parseJobDocument(source), { + title: 'Staff Engineer', + description: source, + }); + } +}); + +test('indented titles below front matter are removed without losing surrounding prose', () => { + for (const indent of [1, 2, 3]) { + const source = `---\norg: acme\n---\nIntro paragraph\n\n${' '.repeat(indent)}# Staff Engineer\n\nRole details`; + assert.deepEqual(parseJobDocument(source), { + org: 'acme', + title: 'Staff Engineer', + description: 'Intro paragraph\n\nRole details', + }); + } +}); + +test('four-space indented code does not become a title', () => { + const source = 'Intro paragraph\n\n # Example only\n\nRole details'; + assert.deepEqual(parseJobDocument(source), { description: source }); + assert.equal(parseJobDocument(`${source}\n\n # Actual role`).title, 'Actual role'); +}); + +test('indented headings inside fenced code are still ignored', () => { + const source = '```md\n # Example only\n```\n\n # Actual role'; + assert.equal(parseJobDocument(source).title, 'Actual role'); +}); + +test('an explicit front matter title preserves an indented body heading', () => { + const body = 'Intro paragraph\n\n # Body heading\n\nRole details'; + assert.deepEqual(parseJobDocument(`---\ntitle: Explicit role\n---\n${body}`), { + title: 'Explicit role', + description: body, + }); +}); + +test('leading indented code after front matter stays code, even after blank lines', () => { + for (const indent of [' ', '\t']) { + const body = `${indent}# Example only\n\nRole details`; + for (const padding of ['', '\n \t\n']) { + assert.deepEqual(parseJobDocument(`---\norg: acme\n---\n${padding}${body}\n\n`), { + org: 'acme', + description: body, + }); + } + } +}); + +test('the real title after leading indented code is extracted without deleting the example', () => { + const body = ' # Example only\n\n # Actual role\n\nRole details'; + assert.deepEqual(parseJobDocument(`---\norg: acme\n---\n${body}`), { + org: 'acme', + title: 'Actual role', + description: ' # Example only\n\nRole details', + }); +}); + +test('an indented code-fence example does not hide the real title', () => { + const body = ' ```md\n\n # Actual role\n\nRole details'; + assert.deepEqual(parseJobDocument(`---\norg: acme\n---\n${body}`), { + org: 'acme', + title: 'Actual role', + description: ' ```md\n\nRole details', + }); +}); + +test('explicit front matter titles retain initial body indentation', () => { + const body = ' # Example only\n\nRole details'; + assert.deepEqual(parseJobDocument(`---\ntitle: Explicit role\n---\n${body}`), { + title: 'Explicit role', + description: body, + }); +}); From efd70962665275d4c854d454fb059cedff790cd6 Mon Sep 17 00:00:00 2001 From: Dayire Date: Sat, 10 Oct 2026 08:51:50 +0200 Subject: [PATCH 088/116] fix(mcp): suppress responses to notifications (#304) --- src/mcp/server.ts | 11 +++ test/mcp-notification-response.test.ts | 107 +++++++++++++++++++++++++ 2 files changed, 118 insertions(+) create mode 100644 test/mcp-notification-response.test.ts diff --git a/src/mcp/server.ts b/src/mcp/server.ts index abb7c54..93389ce 100644 --- a/src/mcp/server.ts +++ b/src/mcp/server.ts @@ -33,6 +33,17 @@ export async function handleMessage( payload: unknown, caller: Caller, info: ServerInfo, +): Promise { + const response = await dispatchMessage(payload, caller, info); + // Suppress every result and error at the boundary, while still dispatching + // notifications exactly once. Individual method branches must not reply. + return isRequest(payload) && isNotification(payload) ? null : response; +} + +async function dispatchMessage( + payload: unknown, + caller: Caller, + info: ServerInfo, ): Promise { if (!isRequest(payload)) { return failure(null, INVALID_PARAMS, 'Not a JSON-RPC 2.0 request.'); diff --git a/test/mcp-notification-response.test.ts b/test/mcp-notification-response.test.ts new file mode 100644 index 0000000..0553d3b --- /dev/null +++ b/test/mcp-notification-response.test.ts @@ -0,0 +1,107 @@ +import assert from 'node:assert/strict'; +import { test } from 'node:test'; +import { handleMessage } from '../src/mcp/server.ts'; +import type { Caller } from '../src/mcp/tools.ts'; + +const info = { name: 'notification-test', version: '0' }; +const caller: Caller = { + server: 'https://board.invalid', + authenticated: false, + call: async () => { + throw new Error('A list notification should not call the API.'); + }, +}; + +test('known methods do not reply to messages without an id', async () => { + for (const method of ['tools/list', 'resources/list', 'prompts/list', 'initialize']) { + const response = await handleMessage({ jsonrpc: '2.0', method }, caller, info); + assert.equal(response === null, true, `${method} replied to a notification`); + } +}); + +test('an invalid tools/call notification produces no error response', async () => { + const response = await handleMessage( + { jsonrpc: '2.0', method: 'tools/call', params: {} }, + caller, + info, + ); + assert.equal(response, null); +}); + +test('a tool notification still dispatches exactly once without replying', async () => { + const calls: unknown[] = []; + const toolCaller: Caller = { + ...caller, + call: async (method, path) => { + calls.push({ method, path }); + return { status: 200, body: { items: [], total: 0 } }; + }, + }; + const response = await handleMessage( + { jsonrpc: '2.0', method: 'tools/call', params: { name: 'search_jobs' } }, + toolCaller, + info, + ); + assert.deepEqual(calls, [{ method: 'GET', path: '/api/v1/jobs' }]); + assert.equal(response === null, true, 'the tool result was returned to a notification'); +}); + +test('a failing tool notification produces no internal error response', async () => { + const response = await handleMessage( + { jsonrpc: '2.0', method: 'tools/call', params: { name: 'search_jobs' } }, + caller, + info, + ); + assert.equal(response, null); +}); + +test('a request with a numeric zero id receives the tool list', async () => { + const response = await handleMessage( + { jsonrpc: '2.0', id: 0, method: 'tools/list' }, + caller, + info, + ); + assert.equal(response?.id, 0); + assert.ok(Array.isArray((response?.result as { tools: unknown[] }).tools)); +}); + +test('a request with a string id retains its dispatched tool result', async () => { + const calls: unknown[] = []; + const body = { items: [], total: 0 }; + const toolCaller: Caller = { + ...caller, + call: async (method, path) => { + calls.push({ method, path }); + return { status: 200, body }; + }, + }; + const response = await handleMessage( + { jsonrpc: '2.0', id: 'request-1', method: 'tools/call', params: { name: 'search_jobs' } }, + toolCaller, + info, + ); + assert.equal(response?.id, 'request-1'); + assert.deepEqual((response?.result as { structuredContent: unknown }).structuredContent, body); + assert.deepEqual(calls, [{ method: 'GET', path: '/api/v1/jobs' }]); +}); + +test('a failing tool request retains its id and internal error response', async () => { + const response = await handleMessage( + { jsonrpc: '2.0', id: 3, method: 'tools/call', params: { name: 'search_jobs' } }, + caller, + info, + ); + assert.equal(response?.id, 3); + assert.equal(response?.error?.code, -32603); +}); + +test('standard, ping and unknown notifications remain silent', async () => { + for (const method of [ + 'notifications/initialized', + 'notifications/cancelled', + 'ping', + 'unknown', + ]) { + assert.equal(await handleMessage({ jsonrpc: '2.0', method }, caller, info), null); + } +}); From 10f13f29f5229156e9d2e7cef2503881175309d5 Mon Sep 17 00:00:00 2001 From: Dayire Date: Sat, 10 Oct 2026 08:51:54 +0200 Subject: [PATCH 089/116] fix(markdown): preserve literal link destinations (#305) --- src/markup/markdown.ts | 50 +++++++++++----- test/markdown-link-literals.test.ts | 90 +++++++++++++++++++++++++++++ 2 files changed, 124 insertions(+), 16 deletions(-) create mode 100644 test/markdown-link-literals.test.ts diff --git a/src/markup/markdown.ts b/src/markup/markdown.ts index 9b622c2..0b14234 100644 --- a/src/markup/markdown.ts +++ b/src/markup/markdown.ts @@ -314,19 +314,28 @@ const MARK = String.fromCharCode(0); /** * Inline markup. * - * Code spans are pulled out first and put back last, so a backticked - * `**not bold**` stays literal and an asterisk inside code cannot open - * emphasis that then runs off through the rest of the paragraph. + * Code spans and generated HTML are held aside while prose is formatted, + * so Markdown markers stay literal in code and URL/attribute values. */ export function renderInline(source: string, options: MarkdownOptions = {}): string { - const codes: string[] = []; + const fragments: string[] = []; const rel = options.linkRel ?? DEFAULT_REL; + const restore = (text: string): string => + text.replace(new RegExp(`${MARK}(\\d+)${MARK}`, 'g'), (_whole, id: string) => { + return fragments[Number(id)] ?? ''; + }); + const protectHtml = (html: string): string => { + // Link labels may already contain protected code spans. Resolve those + // before storing the whole tag so restoration only needs one pass. + fragments.push(restore(html)); + return `${MARK}${fragments.length - 1}${MARK}`; + }; - let text = protectCodeSpans(source, codes); + let text = protectCodeSpans(source, fragments); text = escapeHtml(text); - text = replaceInlineLinks(text, options, rel); + text = replaceInlineLinks(text, options, rel, protectHtml); // Bare URLs. Trailing punctuation is left outside the link, because a URL at // the end of a sentence is the common case and the full stop is not part of @@ -339,20 +348,21 @@ export function renderInline(source: string, options: MarkdownOptions = {}): str const tail = decoded.slice(trimmed.length); const url = safeUrl(trimmed); if (url === null) return `${lead}${href}`; - return `${lead}${escapeHtml(trimmed)}${tail}`; + const html = `${escapeHtml(trimmed)}`; + return `${lead}${protectHtml(html)}${tail}`; }); - text = text + return restore(renderEmphasis(text)); +} + +function renderEmphasis(text: string): string { + return text .replace(/\*\*\*([^*]+)\*\*\*/g, '$1') .replace(/\*\*([^*]+)\*\*/g, '$1') .replace(/(^|[^\w*])\*([^*\n]+)\*(?!\w)/g, '$1$2') .replace(/(^|[^\w_])__([^_\n]+)__(?!\w)/g, '$1$2') .replace(/(^|[^\w_])_([^_\n]+)_(?!\w)/g, '$1$2') .replace(/~~([^~\n]+)~~/g, '$1'); - - return text.replace(new RegExp(`${MARK}(\\d+)${MARK}`, 'g'), (_whole, id: string) => { - return codes[Number(id)] ?? ''; - }); } /** Keep balanced URL parentheses; only surrounding prose belongs outside the link. */ @@ -377,7 +387,12 @@ function trimBareUrl(url: string): string { return url.slice(0, end); } -function replaceInlineLinks(text: string, options: MarkdownOptions, rel: string): string { +function replaceInlineLinks( + text: string, + options: MarkdownOptions, + rel: string, + protectHtml: (html: string) => string, +): string { let result = ''; let cursor = 0; for (let index = 0; index < text.length; index += 1) { @@ -394,14 +409,17 @@ function replaceInlineLinks(text: string, options: MarkdownOptions, rel: string) const url = safeUrl(unescapeUrl(parsed.href)); if (url === null) continue; result += text.slice(cursor, index); + let html: string; if (image) { - result += + const linkLabel = label === '' ? escapeHtml(url) : renderEmphasis(label); + html = options.noImages === true - ? `${label === '' ? escapeHtml(url) : label}` + ? `${linkLabel}` : `${label}`; } else { - result += `${label}`; + html = `${renderEmphasis(label)}`; } + result += protectHtml(html); cursor = parsed.end + 1; index = parsed.end; } diff --git a/test/markdown-link-literals.test.ts b/test/markdown-link-literals.test.ts new file mode 100644 index 0000000..a53584a --- /dev/null +++ b/test/markdown-link-literals.test.ts @@ -0,0 +1,90 @@ +import assert from 'node:assert/strict'; +import { test } from 'node:test'; +import { renderInline } from '../src/markup/markdown.ts'; + +const rel = 'nofollow ugc noopener noreferrer'; + +function href(source: string): string | undefined { + return / { + const url = 'https://example.com/__init__.py'; + assert.equal(href(`[Python module](${url})`), url); +}); + +test('a bare module URL retains its destination and literal display text', () => { + const url = 'https://example.com/__init__.py'; + assert.equal(renderInline(url), `${url}`); +}); + +test('an explicit link retains a literal bold-marker query value', () => { + const url = 'https://example.com/search?q=**python**'; + assert.equal(href(`[Pattern search](${url})`), url); +}); + +test('a bare URL retains a literal strikethrough-marker query value', () => { + const url = 'https://example.com/search?q=~~draft~~'; + assert.equal(renderInline(url), `${url}`); +}); + +test('link labels retain emphasis and literal inline code', () => { + assert.equal( + renderInline('[**Project** `__init__.py`](https://example.com/project)'), + `` + + 'Project __init__.py', + ); +}); + +test('paragraph emphasis can wrap a link', () => { + assert.equal( + renderInline('**[Project](https://example.com/project)**'), + `Project`, + ); +}); + +test('allowed URL schemes and local destinations retain their links', () => { + for (const url of [ + 'https://example.com/project', + 'http://example.com/project', + 'mailto:ada@example.com', + 'tel:+123456789', + '/jobs/project', + '#requirements', + ]) { + assert.equal(href(`[Contact](${url})`), url); + } +}); + +test('unsafe and protocol-relative link destinations still produce no anchor', () => { + for (const url of [ + 'javascript:alert(1)', + 'data:text/html,payload', + '//example.com/project', + '/\\example.com/project', + ]) { + assert.ok(!renderInline(`[Contact](${url})`).includes(' { + assert.equal( + renderInline('[Search](https://example.com/search?q="python"&sort=recent)'), + 'Search`, + ); +}); + +test('raw HTML in a formatted link label remains text', () => { + const html = renderInline('[****](https://example.com)'); + assert.ok(!html.includes('<img src=x onerror=alert(1)>'), html); +}); + +test('image destinations and alt attributes remain literal and escaped', () => { + assert.equal( + renderInline('![**logo**"](https://example.com/__logo__.png)'), + '', + ); +}); From c96e968846f8334767903e8c45c7a4b1ff3d351f Mon Sep 17 00:00:00 2001 From: Dayire Date: Sat, 10 Oct 2026 09:17:19 +0200 Subject: [PATCH 090/116] fix(resume): retain indented headings in candidate discovery (#306) --- src/markup/resume.ts | 6 +- test/resume-indented-heading.test.ts | 82 ++++++++++++++++++++++++++++ 2 files changed, 85 insertions(+), 3 deletions(-) create mode 100644 test/resume-indented-heading.test.ts diff --git a/src/markup/resume.ts b/src/markup/resume.ts index e472d1c..787e5d1 100644 --- a/src/markup/resume.ts +++ b/src/markup/resume.ts @@ -186,7 +186,7 @@ function parseDocument(source: string): { resume: OpenResume; body: string } { continue; } - const h1 = /^#\s+(.+?)\s*(?:(?<=[ \t])#+)?\s*$/.exec(line); + const h1 = /^ {0,3}#\s+(.+?)\s*(?:(?<=[ \t])#+)?\s*$/.exec(line); if (h1 !== null) { if (seenH1) { warnings.push('More than one top-level heading; the first one is used as the name.'); @@ -199,7 +199,7 @@ function parseDocument(source: string): { resume: OpenResume; body: string } { continue; } - const h2 = /^##\s+(.+?)\s*(?:(?<=[ \t])#+)?\s*$/.exec(line); + const h2 = /^ {0,3}##\s+(.+?)\s*(?:(?<=[ \t])#+)?\s*$/.exec(line); if (h2 !== null) { flushSection(); inPreamble = false; @@ -208,7 +208,7 @@ function parseDocument(source: string): { resume: OpenResume; body: string } { continue; } - const h3 = /^###\s+(.+?)\s*(?:(?<=[ \t])#+)?\s*$/.exec(line); + const h3 = /^ {0,3}###\s+(.+?)\s*(?:(?<=[ \t])#+)?\s*$/.exec(line); if (h3 !== null && section !== null) { flushEntry(); const raw = (h3[1] ?? '').trim(); diff --git a/test/resume-indented-heading.test.ts b/test/resume-indented-heading.test.ts new file mode 100644 index 0000000..6d25f7f --- /dev/null +++ b/test/resume-indented-heading.test.ts @@ -0,0 +1,82 @@ +import assert from 'node:assert/strict'; +import { test } from 'node:test'; +import { toCandidateSummary, withTags } from '../dist/core/candidates.js'; +import { renderMarkdown } from '../dist/markup/markdown.js'; +import { parseResume, resumeBodyMarkdown, resumeSearchText } from '../dist/markup/resume.js'; + +for (const spaces of [0, 1, 2, 3]) { + test(`resume headings with ${spaces} leading spaces retain candidate skills`, () => { + const indent = ' '.repeat(spaces); + const markdown = [ + '# Ada Example', '', '- Email: ada@example.com', '', 'Engineer.', '', + `${indent}## Experience`, '', `${indent}### Example Works | Remote`, + 'Engineer (2020 - Present)', '', '- Built orchestration systems.', '', + `${indent}## Skills`, '', '- TypeScript', '- PostgreSQL', + ].join('\n'); + const parsed = parseResume(markdown); + const summary = toCandidateSummary({ + id: 'example', userId: 'example-user', slug: 'ada', title: 'Ada Example', + markdown, parsed, visibility: 'public', publicSlug: 'ada', sourceName: null, + createdAt: '2026-01-01T00:00:00Z', updatedAt: '2026-01-01T00:00:00Z', + }); + + assert.deepEqual(parsed.sections.map((section) => section.kind), ['experience', 'skills']); + const entry = parsed.sections[0]?.entries[0]; + assert.equal(entry?.title, 'Example Works'); + assert.equal(entry?.place, 'Remote'); + assert.equal(entry?.start, '2020'); + assert.equal(entry?.current, true); + assert.deepEqual(entry?.highlights, ['Built orchestration systems.']); + assert.deepEqual(summary.skills, ['TypeScript', 'PostgreSQL']); + assert.deepEqual(withTags([summary], ['TypeScript']), [summary]); + assert.deepEqual(withTags([summary], ['Rust']), []); + assert.match(resumeSearchText(parsed), /Example Works/); + assert.match(resumeSearchText(parsed), /TypeScript/); + assert.equal(parsed.markdown, markdown); + assert.deepEqual(parsed.warnings, []); + const html = renderMarkdown(resumeBodyMarkdown(markdown)); + assert.match(html, /

      Skills<\/h2>/); + assert.match(html, /

      Example Works \| Remote<\/h3>/); + }); +} + +for (const spaces of [1, 2, 3]) { + test(`an indented name with ${spaces} spaces is promoted to the resume header`, () => { + const indent = ' '.repeat(spaces); + // A preceding example keeps source.trim() from masking the indentation. + const markdown = [ + '```text', '# Example only', '```', '', `${indent}# Team C# ###`, '', + '- Email: ada@example.com', '', 'Compiler engineer', '', '## Experience', + ].join('\n'); + const parsed = parseResume(markdown); + assert.equal(parsed.name, 'Team C#'); + assert.equal(parsed.headline, 'Compiler engineer'); + assert.deepEqual(parsed.contact.map((field) => field.value), ['ada@example.com']); + assert.equal(parsed.warnings.some((warning) => warning.includes('More than one')), false); + const body = resumeBodyMarkdown(markdown); + assert.ok(!body.includes('Team C#')); + assert.ok(!body.includes('ada@example.com')); + assert.match(body, /# Example only/); + assert.equal(parsed.markdown, markdown); + }); +} + +test('indented entries work independently of section indentation', () => { + const parsed = parseResume('# Ada\n## Experience\n ### Compiler C# ###\nEngineer'); + assert.equal(parsed.sections[0]?.entries[0]?.title, 'Compiler C#'); + assert.equal(parsed.sections[0]?.entries[0]?.subtitle, 'Engineer'); +}); + +test('four spaces, tabs and fenced examples do not create resume headings', () => { + const example = [' ```markdown', ' # Example', ' ## Skills', ' ### Sample', ' ```']; + const markdown = [ + '# Ada', '## Projects', ...example, ' # Not a name', ' ## Not a section', + ' ### Not an entry', '\t## Not a section', '## Experience', + ].join('\n'); + const parsed = parseResume(markdown); + assert.equal(parsed.name, 'Ada'); + assert.deepEqual(parsed.sections.map((section) => section.kind), ['projects', 'experience']); + assert.deepEqual(parsed.sections[0]?.entries, []); + assert.equal(parsed.warnings.some((warning) => warning.includes('More than one')), false); + assert.equal(parsed.markdown, markdown); +}); From f84cecc158ccc8d278c89841c2d56f41b03f3258 Mon Sep 17 00:00:00 2001 From: Anthony Ettinger Date: Sat, 10 Oct 2026 01:30:17 -0700 Subject: [PATCH 091/116] feat(webring): Random link in the Profullstack ring footer (#307) Also serves /.well-known/openwebring.json (agenticjobs.work is member agenticjobs-work-3 in the ring), which the board did not have. Co-authored-by: Claude Opus 5.5 --- src/server/routes/discovery.ts | 25 +++++++++++++ src/views/layout.tsx | 11 ++++-- test/openwebring-descriptor.test.ts | 55 +++++++++++++++++++++++++++++ 3 files changed, 89 insertions(+), 2 deletions(-) create mode 100644 test/openwebring-descriptor.test.ts diff --git a/src/server/routes/discovery.ts b/src/server/routes/discovery.ts index f340a0f..495da1f 100644 --- a/src/server/routes/discovery.ts +++ b/src/server/routes/discovery.ts @@ -35,6 +35,9 @@ import { toPlainText } from '../../markup/markdown.ts'; import { descriptorFor } from './descriptor.ts'; import type { AppEnv } from '../deps.ts'; +/** Ring member slugs the ring assigned that are not simply the host with dots as dashes. */ +const RING_SLUGS: Record = { 'agenticjobs.work': 'agenticjobs-work-3' }; + function publicDir(): string { // dist/server/routes/discovery.js -> package root -> web/public return join(dirname(dirname(dirname(dirname(fileURLToPath(import.meta.url))))), 'web', 'public'); @@ -960,6 +963,28 @@ export function discoveryRoutes(): Hono { }); }); + /** + * The OpenWebring descriptor (rssamplifier.com/openwebring): this board's + * membership in the Profullstack ring, whose footer links every page carries. + * The member slug is the host with dots as dashes, except where the ring + * assigned another one. + */ + routes.get('/.well-known/openwebring.json', (c) => { + const { config } = c.get('deps'); + const host = new URL(config.publicUrl).hostname; + const slug = RING_SLUGS[host] ?? host.replaceAll('.', '-'); + return c.json( + { + openwebring: '0.1', + site: { url: `${config.publicUrl.replace(/\/+$/, '')}/`, name: config.boardName }, + made_by: 'both', + rings: [{ ring: 'https://rssamplifier.com/ring/profullstack', slug }], + }, + 200, + { 'cache-control': 'public, max-age=300' }, + ); + }); + /** * The OpenAccess descriptor (logicsrc.com/openaccess): how a client links * this board over OAuth 2.1 + PKCE. A static file, so it is served from diff --git a/src/views/layout.tsx b/src/views/layout.tsx index f33d7c9..ef5efdc 100644 --- a/src/views/layout.tsx +++ b/src/views/layout.tsx @@ -297,12 +297,19 @@ export const Layout: FC> = (props) => { Feed llms.txt diff --git a/test/openwebring-descriptor.test.ts b/test/openwebring-descriptor.test.ts new file mode 100644 index 0000000..fe829f8 --- /dev/null +++ b/test/openwebring-descriptor.test.ts @@ -0,0 +1,55 @@ +/** + * The OpenWebring descriptor: the board's membership in the Profullstack ring, + * at the well-known path the ring's verifier reads. + */ +import assert from 'node:assert/strict'; +import { test } from 'node:test'; +import { Hono } from 'hono'; +import { discoveryRoutes } from '../dist/server/routes/discovery.js'; + +function boardApp(publicUrl: string): Hono { + const app = new Hono(); + app.use('*', async (c, next) => { + c.set( + 'deps' as never, + { + config: { publicUrl, boardName: 'Test Board', isDirectory: false }, + pool: null, + mailer: null, + coinpay: null, + } as never, + ); + c.set('viewer' as never, null as never); + await next(); + }); + app.route('/', discoveryRoutes() as unknown as Hono); + return app; +} + +type Descriptor = { + openwebring: string; + site: { url: string; name: string }; + rings: { ring: string; slug: string }[]; +}; + +test('the descriptor names this board and the Profullstack ring', async () => { + const response = await boardApp('https://board.example').request( + 'https://board.example/.well-known/openwebring.json', + ); + assert.equal(response.status, 200); + assert.match(response.headers.get('content-type') ?? '', /application\/json/); + const body = (await response.json()) as Descriptor; + assert.equal(body.openwebring, '0.1'); + assert.deepEqual(body.site, { url: 'https://board.example/', name: 'Test Board' }); + assert.deepEqual(body.rings, [ + { ring: 'https://rssamplifier.com/ring/profullstack', slug: 'board-example' }, + ]); +}); + +test('agenticjobs.work carries the slug the ring assigned it', async () => { + const response = await boardApp('https://agenticjobs.work').request( + 'https://agenticjobs.work/.well-known/openwebring.json', + ); + const body = (await response.json()) as Descriptor; + assert.equal(body.rings[0]?.slug, 'agenticjobs-work-3'); +}); From 191206cb76b685a754639aa992fd57454503c938 Mon Sep 17 00:00:00 2001 From: Anthony Ettinger Date: Sat, 10 Oct 2026 02:28:55 -0700 Subject: [PATCH 092/116] feat(footer): use @profullstack/footer (#309) The board's link row and the Profullstack ring nav move into the shared footer package, rendered on the server from its @latest template (kept and refreshed in the background, since Layout renders synchronously). The popular-skills row stays as the site's own footer above it. Co-authored-by: Claude Opus 5.5 --- package.json | 1 + pnpm-lock.yaml | 15 +++++++++++ pnpm-workspace.yaml | 1 + src/views/layout.tsx | 60 +++++++++++++++-------------------------- src/views/pfs-footer.ts | 23 ++++++++++++++++ web/public/app.css | 6 +++++ web/public/sw.js | 2 +- 7 files changed, 69 insertions(+), 39 deletions(-) create mode 100644 src/views/pfs-footer.ts diff --git a/package.json b/package.json index 2ac2c75..65bdeb2 100644 --- a/package.json +++ b/package.json @@ -58,6 +58,7 @@ "test:only": "node --test \"test/*.test.ts\"" }, "dependencies": { + "@profullstack/footer": "latest", "@hono/node-server": "^1.14.0", "@profullstack/emailer": "^1.0.3", "@profullstack/hqtui": "^0.5.0", diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index ac63ec0..5e880ff 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -14,6 +14,9 @@ importers: '@profullstack/emailer': specifier: ^1.0.3 version: 1.0.3 + '@profullstack/footer': + specifier: latest + version: 0.2.1 '@profullstack/hqtui': specifier: ^0.5.0 version: 0.5.0 @@ -128,6 +131,16 @@ packages: '@profullstack/emailer@1.0.3': resolution: {integrity: sha512-VyAtCcfnSI6LOwJvWogCr3ZNmEsaZw+iuWrqnosLsdcKsbRyCrCmXigMNZJZEjlgYlR+lK//PwNPG+xtCFvWAw==} + '@profullstack/footer@0.2.1': + resolution: {integrity: sha512-KHmKVwrlzCBrSAAJ4zobNFCxTg8VF0gvNMeAut00dX3+gbWCtk6eOwIR2AaqEC7smj6Aio6cIexzt/dUnv1McA==} + engines: {node: '>=18'} + hasBin: true + peerDependencies: + react: '>=18' + peerDependenciesMeta: + react: + optional: true + '@profullstack/hqtui@0.5.0': resolution: {integrity: sha512-jDwILBmdQx8pQA0ao/tzzty8u5nFNS4XhvU9xXhZvdIaMeiF3HBJIVtP6cS6kigS4lXmHR7sztbb9QJpaWwhig==} engines: {bun: '>=1.1', node: '>=22.6'} @@ -378,6 +391,8 @@ snapshots: '@profullstack/emailer@1.0.3': {} + '@profullstack/footer@0.2.1': {} + '@profullstack/hqtui@0.5.0': {} '@profullstack/leaderboard@0.3.1': {} diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml index e1af7c9..230638e 100644 --- a/pnpm-workspace.yaml +++ b/pnpm-workspace.yaml @@ -13,3 +13,4 @@ packages: minimumReleaseAgeExclude: - '@profullstack/hqtui' - '@profullstack/synconfig@0.1.2' + - '@profullstack/footer' diff --git a/src/views/layout.tsx b/src/views/layout.tsx index ef5efdc..11f3f1c 100644 --- a/src/views/layout.tsx +++ b/src/views/layout.tsx @@ -15,6 +15,7 @@ import { renderMarkdown } from '../markup/markdown.ts'; import type { SkillCount } from '../core/skills.ts'; import { pathForQuery } from '../core/landing.ts'; import { EMPTY_QUERY } from '../schema/query.ts'; +import { pfsFooter } from './pfs-footer.ts'; export interface PageProps { title: string; @@ -81,9 +82,6 @@ const BrandMark: FC = () => ( ); -/** The Profullstack OpenWebring this board belongs to. */ -const RING = 'https://rssamplifier.com/ring/profullstack'; - export const Layout: FC> = (props) => { const { title, @@ -106,7 +104,6 @@ export const Layout: FC> = (props) => { const full = title === boardName ? title : `${title} - ${boardName}`; const url = canonical ?? `${publicUrl}${path}`; // The ring finds its neighbours by this site's own front page address. - const ringFrom = encodeURIComponent(`${publicUrl.replace(/\/+$/, '')}/`); return ( @@ -271,8 +268,8 @@ export const Layout: FC> = (props) => {
      {children}
      - + )} + {raw( + pfsFooter({ + site: `${publicUrl.replace(/\/+$/, '')}/`, + links: [ + { label: 'Popular', href: '/popular' }, + { label: 'Most profitable', href: '/most-profitable' }, + { label: 'Agents', href: '/agents' }, + { label: 'API', href: '/docs' }, + { label: 'OpenAPI', href: '/api/v1/openapi.json' }, + { label: 'Instance', href: '/.well-known/agenticjobs' }, + { label: 'Feed', href: '/jobs.json' }, + { label: 'llms.txt', href: '/llms.txt' }, + { label: 'Source', href: 'https://github.com/profullstack/agenticjobs' }, + ], + tagline: `${boardName} runs on agenticjobs, MIT licensed.`, + }), + )} {/* * CrawlProof, as a plain tag. `defer` is what `strategy` meant on the diff --git a/src/views/pfs-footer.ts b/src/views/pfs-footer.ts new file mode 100644 index 0000000..61ad9d4 --- /dev/null +++ b/src/views/pfs-footer.ts @@ -0,0 +1,23 @@ +/** + * The shared Profullstack footer (@profullstack/footer): the board's link row, + * the copyright line and the webring, from the package's @latest template, so a + * release of the package reaches every board without a redeploy. + * + * Layout renders synchronously (pages and tests stringify it directly), so this + * returns the last footer rendered for these options and refreshes it in the + * background on each use; the package caches the template for an hour. Until + * the first refresh lands it is the template from the installed package. + */ +import { footerHtml, footerHtmlSync } from '@profullstack/footer'; + +type FooterOptions = Parameters[0]; + +const rendered = new Map(); + +export function pfsFooter(options: FooterOptions): string { + const key = JSON.stringify(options); + void footerHtml(options) + .then((html) => rendered.set(key, html)) + .catch(() => undefined); + return rendered.get(key) ?? footerHtmlSync(options); +} diff --git a/web/public/app.css b/web/public/app.css index 6ef8ff6..6846294 100644 --- a/web/public/app.css +++ b/web/public/app.css @@ -159,6 +159,12 @@ main { color: var(--muted-foreground); } +/* The shared Profullstack footer (src/views/pfs-footer.ts) under the skills row. */ +footer.pfs-footer { + --pfs-footer-muted: var(--muted-foreground); + border-top-color: var(--border); +} + /* The skill links above the footer proper: one row that wraps. */ .footer-skills { padding-bottom: 0.75rem; diff --git a/web/public/sw.js b/web/public/sw.js index a51ffd9..b63d3ec 100644 --- a/web/public/sw.js +++ b/web/public/sw.js @@ -13,7 +13,7 @@ * drifted, which is the only version of this rule that survives contact. */ -const VERSION = 'bf43bdc7'; +const VERSION = 'dae43fcc'; const SHELL = `shell-${VERSION}`; const ASSETS = ['/assets/app.css', '/assets/tokens.css', '/assets/icon.svg']; From 52b2ede6dcb2339b9acc5147f0bebfb39dcf995c Mon Sep 17 00:00:00 2001 From: Dayire Date: Sat, 10 Oct 2026 11:38:08 +0200 Subject: [PATCH 093/116] fix(markdown): preserve blank-separated list siblings (#308) --- src/markup/markdown.ts | 29 ++++++++++-- test/list-blank-siblings.test.ts | 81 ++++++++++++++++++++++++++++++++ 2 files changed, 105 insertions(+), 5 deletions(-) create mode 100644 test/list-blank-siblings.test.ts diff --git a/src/markup/markdown.ts b/src/markup/markdown.ts index 0b14234..f827a4c 100644 --- a/src/markup/markdown.ts +++ b/src/markup/markdown.ts @@ -228,6 +228,7 @@ function tryList(lines: string[], start: number, options: MarkdownOptions): Bloc const orderedStart = ordered ? Number.parseInt(firstMarker, 10) : 1; const indent = (first[1] ?? '').length; const items: string[][] = []; + let loose = false; let contentIndent = indent + 2; let index = start; @@ -255,11 +256,27 @@ function tryList(lines: string[], start: number, options: MarkdownOptions): Bloc const current = items[items.length - 1]; if (current === undefined) break; if (line.trim() === '') { - // A blank run continues the item only when followed by indented content. - // Keep it in the item so fenced code does not end at its first blank line. + // A matching sibling after blank lines continues the same loose list. + // Otherwise preserve blanks only before indented content, so fences keep + // their blank lines and outside paragraphs still end the list. let next = index + 1; while (next < lines.length && (lines[next] ?? '').trim() === '') next += 1; const following = lines[next] ?? ''; + const sibling = /^(\s*)([-*+]|\d{1,9}[.)])\s+(.*)$/.exec(following); + if ( + sibling !== null && + (sibling[1] ?? '').length === indent && + !/^\s{0,3}([-*_])\s*(\1\s*){2,}$/.test(following) + ) { + const siblingMarker = sibling[2] ?? ''; + const siblingOrdered = /\d/.test(siblingMarker); + const siblingStyle = siblingOrdered ? siblingMarker.slice(-1) : siblingMarker; + if (siblingOrdered === ordered && siblingStyle === markerStyle) { + loose = true; + index = next; + continue; + } + } if ( next === lines.length || following.length - following.trimStart().length < contentIndent @@ -287,12 +304,14 @@ function tryList(lines: string[], start: number, options: MarkdownOptions): Bloc const rendered = items .map((item) => { const body = item.join('\n'); - // A one-line item stays inline, so a bullet list does not gain a - // paragraph's worth of vertical space per bullet. - let inner = item.length === 1 ? renderInline(body, options) : renderMarkdown(body, options); + // Tight single-line items stay inline; blank-separated siblings retain + // paragraph wrappers across the whole loose list. + let inner = + item.length === 1 && !loose ? renderInline(body, options) : renderMarkdown(body, options); // Unwrap only a single paragraph. A multi-block item can start and end // with different paragraphs; removing those outer tags leaves both incomplete. if ( + !loose && item.length > 1 && inner.startsWith('

      ') && inner.indexOf('

      ') === inner.length - 4 diff --git a/test/list-blank-siblings.test.ts b/test/list-blank-siblings.test.ts new file mode 100644 index 0000000..9700829 --- /dev/null +++ b/test/list-blank-siblings.test.ts @@ -0,0 +1,81 @@ +import assert from 'node:assert/strict'; +import { test } from 'node:test'; +import { renderMarkdown } from '../src/markup/markdown.ts'; + +// CommonMark's list rule: blank lines between sibling items make a loose list, +// rather than restarting each ordered item in a separate list. +// https://spec.commonmark.org/0.31.2/#lists +test('blank-separated automatic numbering stays in one ordered list', () => { + const source = '1. Read the brief\n\n1. Prepare the patch\n\n1. Run the checks'; + assert.equal( + renderMarkdown(source), + '

      1. Read the brief

      2. Prepare the patch

      3. Run the checks

      ', + ); +}); + +test('a loose ordered list retains only its first starting number', () => { + assert.equal( + renderMarkdown('3. Review\n\n1. Deliver'), + '

      1. Review

      2. Deliver

      ', + ); +}); + +test('blank-separated bullets keep one loose list for each supported marker', () => { + for (const marker of ['-', '*', '+']) { + assert.equal( + renderMarkdown(`${marker} Rust\n\n${marker} TypeScript`), + '

      • Rust

      • TypeScript

      ', + ); + } +}); + +test('whitespace-only blank runs and CRLF do not reset sibling numbering', () => { + assert.equal( + renderMarkdown('1) First\r\n \t\r\n\r\n1) Second'), + '

      1. First

      2. Second

      ', + ); +}); + +test('one blank sibling separator makes all items in that list loose', () => { + assert.equal( + renderMarkdown('1. First\n\n1. Second\n1. Third'), + '

      1. First

      2. Second

      3. Third

      ', + ); +}); + +test('nested loose siblings stay nested and do not consume the parent sibling', () => { + assert.equal( + renderMarkdown('- Parent\n 1. Child\n\n 1. Next child\n- Sibling'), + '

      • Parent

        \n

        1. Child

        2. Next child

      • Sibling
      ', + ); +}); + +test('a blank line before another marker style still starts a separate list', () => { + for (const [source, expected] of [ + ['1. First\n\n1) Second', '
      1. First
      \n
      1. Second
      '], + ['- First\n\n* Second', '
      • First
      \n
      • Second
      '], + ['1. First\n\n- Second', '
      1. First
      \n
      • Second
      '], + ]) { + assert.equal(renderMarkdown(source), expected); + } +}); + +test('a blank-separated thematic break is not mistaken for another bullet', () => { + for (const marker of ['-', '*']) { + assert.equal( + renderMarkdown(`${marker} Before\n\n${marker} ${marker} ${marker}\n\n${marker} After`), + '
      • Before
      \n
      \n
      • After
      ', + ); + } +}); + +test('outside paragraphs, quotes, headings and tight lists retain their boundaries', () => { + for (const [source, expected] of [ + ['- Item\n\nOutside', '
      • Item
      \n

      Outside

      '], + ['- Item\n\n> Outside', '
      • Item
      \n

      Outside

      '], + ['- Item\n\n# Outside', '
      • Item
      \n

      Outside

      '], + ['1. First\n1. Second', '
      1. First
      2. Second
      '], + ]) { + assert.equal(renderMarkdown(source), expected); + } +}); From e7098287426e566803e808baa2fb7c931443317c Mon Sep 17 00:00:00 2001 From: Dayire Date: Sat, 10 Oct 2026 11:38:21 +0200 Subject: [PATCH 094/116] fix(markdown): strip complete link destinations from summaries (#310) --- src/markup/markdown.ts | 47 +++++++++++----- test/plain-text-link-destinations.test.ts | 65 +++++++++++++++++++++++ 2 files changed, 100 insertions(+), 12 deletions(-) create mode 100644 test/plain-text-link-destinations.test.ts diff --git a/src/markup/markdown.ts b/src/markup/markdown.ts index f827a4c..6ad42d8 100644 --- a/src/markup/markdown.ts +++ b/src/markup/markdown.ts @@ -450,7 +450,11 @@ interface ParsedLinkDestination { end: number; } -function parseLinkDestination(text: string, open: number): ParsedLinkDestination | null { +function parseLinkDestination( + text: string, + open: number, + titleQuote = '"', +): ParsedLinkDestination | null { let depth = 0; let index = open + 1; while (index < text.length) { @@ -467,10 +471,10 @@ function parseLinkDestination(text: string, open: number): ParsedLinkDestination const titleStart = text.slice(index).search(/\S/); if (titleStart < 0) return null; const title = index + titleStart; - if (!text.startsWith('"', title)) return null; - const titleEnd = text.indexOf('"', title + 6); + if (!text.startsWith(titleQuote, title)) return null; + const titleEnd = text.indexOf(titleQuote, title + titleQuote.length); if (titleEnd < 0) return null; - let close = titleEnd + 6; + let close = titleEnd + titleQuote.length; while (/\s/.test(text[close] ?? '')) close += 1; return text[close] === ')' && href !== '' ? { href, end: close } : null; } else if (character === ')') { @@ -551,16 +555,35 @@ function normalizeCodeSpanBody(body: string): string { return normalized; } +/** Strip complete destinations, including the parentheses and title they contain. */ +function plainInlineLinks(source: string): string { + let text = source; + // Omit images before retaining link labels, so a linked image stays omitted. + for (const image of [true, false]) { + const parts: string[] = []; + let cursor = 0; + const pattern = image ? /!\[([^\]]*)\]\(/g : /\[([^\]]+)\]\(/g; + for (const match of text.matchAll(pattern)) { + if (match.index < cursor) continue; + const parsed = parseLinkDestination(text, match.index + match[0].length - 1, '"'); + if (parsed === null) continue; + parts.push(text.slice(cursor, match.index), image ? ' ' : (match[1] ?? '')); + cursor = parsed.end + 1; + } + parts.push(text.slice(cursor)); + text = parts.join(''); + } + return text; +} + /** Plain text, for meta descriptions, feeds, the TUI and search snippets. */ export function toPlainText(source: string, limit = 300): string { - const text = source - .replace( - /(`{3,}|~{3,})[^\n]*\n([\s\S]*?)(?:\n\s{0,3}(`{3,}|~{3,})\s*(?=\n|$)|$)/g, - (whole, open: string, _body: string, close?: string) => - close !== undefined && close[0] === open[0] && close.length >= open.length ? ' ' : whole, - ) - .replace(/!\[[^\]]*\]\([^)]*\)/g, ' ') - .replace(/\[([^\]]+)\]\([^)]*\)/g, '$1') + const withoutCode = source.replace( + /(`{3,}|~{3,})[^\n]*\n([\s\S]*?)(?:\n\s{0,3}(`{3,}|~{3,})\s*(?=\n|$)|$)/g, + (whole, open: string, _body: string, close?: string) => + close !== undefined && close[0] === open[0] && close.length >= open.length ? ' ' : whole, + ); + const text = plainInlineLinks(withoutCode) // A hash in C#, an issue number or a URL fragment is text. Only remove // ATX heading markers, including optional closing hashes and quoted headings. .replace( diff --git a/test/plain-text-link-destinations.test.ts b/test/plain-text-link-destinations.test.ts new file mode 100644 index 0000000..4cea91a --- /dev/null +++ b/test/plain-text-link-destinations.test.ts @@ -0,0 +1,65 @@ +import assert from 'node:assert/strict'; +import { test } from 'node:test'; +import { toPlainText } from '../src/markup/markdown.ts'; + +test('plain summaries consume an entire balanced link destination', () => { + assert.equal( + toPlainText('Read [our documentation](https://example.com/Guide_(2026)).'), + 'Read our documentation.', + ); +}); + +test('nested destination parentheses do not leak into summary prose', () => { + assert.equal( + toPlainText('[See details](https://example.com/report(one(two))) and apply.'), + 'See details and apply.', + ); +}); + +test('escaped destination parentheses do not leave closing syntax behind', () => { + assert.equal( + toPlainText('[Documentation](https://example.com/Guide_\\(2026\\)) is available.'), + 'Documentation is available.', + ); +}); + +test('image destinations with parentheses are omitted completely', () => { + assert.equal( + toPlainText('Before ![release chart](https://example.com/Chart_(2026).png) after.'), + 'Before after.', + ); +}); + +test('a quoted title is consumed independently of parentheses in its text', () => { + assert.equal( + toPlainText('[Documentation](https://example.com/guide(one) "Guide )") is available.'), + 'Documentation is available.', + ); +}); + +test('surrounding prose punctuation remains outside links and images', () => { + assert.equal( + toPlainText('([Portfolio](https://example.com/Ada_(developer))), next.'), + '(Portfolio), next.', + ); + assert.equal(toPlainText('![Chart](https://example.com/Chart_(2026).png), next.'), ', next.'); +}); + +test('an image inside a link remains omitted from a plain summary', () => { + assert.equal( + toPlainText('Before [![chart](chart.png)](https://example.com/chart) after.'), + 'Before after.', + ); +}); + +test('ordinary links, images and literal label text retain their existing summaries', () => { + assert.equal( + toPlainText('Some **bold** [A & B](https://example.com/?a=1&b=2), then ![chart](chart.png).'), + 'Some bold A & B, then .', + ); + assert.equal(toPlainText('[First](one) and [Second](two).'), 'First and Second.'); + assert.equal( + toPlainText('An unmatched [label](destination stays text.'), + 'An unmatched [label](destination stays text.', + ); +}); From d3afa24871b626b1be91bafa885d18e400598425 Mon Sep 17 00:00:00 2001 From: Anthony Ettinger Date: Sat, 10 Oct 2026 02:57:22 -0700 Subject: [PATCH 095/116] fix(footer): drop the skills row's own rule above the shared footer (#311) Co-authored-by: Claude Opus 5.5 --- web/public/app.css | 4 +--- web/public/sw.js | 2 +- 2 files changed, 2 insertions(+), 4 deletions(-) diff --git a/web/public/app.css b/web/public/app.css index 6846294..4341383 100644 --- a/web/public/app.css +++ b/web/public/app.css @@ -166,10 +166,8 @@ footer.pfs-footer { } /* The skill links above the footer proper: one row that wraps. */ +/* The shared footer's own top rule follows, so the row needs none of its own. */ .footer-skills { - padding-bottom: 0.75rem; - margin-bottom: 0.75rem; - border-bottom: 1px solid var(--border); gap: 0.5rem 0.9rem; } diff --git a/web/public/sw.js b/web/public/sw.js index b63d3ec..08039da 100644 --- a/web/public/sw.js +++ b/web/public/sw.js @@ -13,7 +13,7 @@ * drifted, which is the only version of this rule that survives contact. */ -const VERSION = 'dae43fcc'; +const VERSION = 'ea250e72'; const SHELL = `shell-${VERSION}`; const ASSETS = ['/assets/app.css', '/assets/tokens.css', '/assets/icon.svg']; From b67b6cf5b9fba5314b7fbe47d27ecf1ade73cc87 Mon Sep 17 00:00:00 2001 From: ouji kaminari Date: Mon, 12 Oct 2026 01:34:53 +0700 Subject: [PATCH 096/116] fix(query): drop NUL bytes in string filters instead of answering 500 (#312) PostgreSQL refuses a NUL byte in text outright, so a single `%00` in any string filter reached the LIKE pattern and turned the request into a 500: - `GET /api/v1/jobs?q=%00`, `?org=%00`, `?tags=%00` - and every surface that shares parseQuery with it: the page, MCP, the CLI and federated search at once. - `GET /api/v1/directory/instances?q=%00` and `?topic=%00`. Both filters now pass through the same clean() gate the rest of the board uses, so the byte is dropped the way an unknown value is dropped rather than turned into an error, and a filter that cleans away to nothing is treated as absent rather than as a search for the empty string. Verified against the live board before the change: `?q=%00` answered 500 on both routes while `%01` and `%1f` answered 200, which is what pointed at the NUL byte specifically rather than at control characters in general. Co-authored-by: muazaulia --- src/directory/registry.ts | 15 ++++++++--- src/schema/query.ts | 11 ++++++-- test/query-nul-byte.test.ts | 52 +++++++++++++++++++++++++++++++++++++ 3 files changed, 72 insertions(+), 6 deletions(-) create mode 100644 test/query-nul-byte.test.ts diff --git a/src/directory/registry.ts b/src/directory/registry.ts index 3e035e0..2f83847 100644 --- a/src/directory/registry.ts +++ b/src/directory/registry.ts @@ -110,15 +110,22 @@ export async function listInstances( where.push(`checked_at > now() - ($${params.length} || ' milliseconds')::interval`); where.push('failures = 0'); } - if (options.topic) { - params.push(options.topic.toLowerCase()); + // Both filters are strings that travel into SQL parameters, and a NUL byte + // is not text: PostgreSQL refuses it outright, so `?topic=%00` or `?q=%00` + // on this route answered 500. Drop the byte - only the byte - and treat a + // filter that is nothing but NUL as absent rather than as a search for the + // empty string. + const topic = (options.topic ?? '').replace(/\0/g, '').trim().toLowerCase(); + if (topic !== '') { + params.push(topic); where.push(`descriptor -> 'topics' ? $${params.length}`); } - if (options.q) { + const q = (options.q ?? '').replace(/\0/g, '').trim(); + if (q !== '') { // This is a substring search over directory text, not a user-supplied // SQL LIKE pattern. Escape its metacharacters so `%` and `_` in names or // URLs are searched as characters. - const query = options.q.toLowerCase().replace(/[\\%_]/g, '\\$&'); + const query = q.toLowerCase().replace(/[\\%_]/g, '\\$&'); params.push(`%${query}%`); where.push( `(lower(descriptor ->> 'name') like $${params.length} escape E'\\\\' or lower(descriptor ->> 'tagline') like $${params.length} escape E'\\\\' or url like $${params.length} escape E'\\\\')`, diff --git a/src/schema/query.ts b/src/schema/query.ts index 8956784..ec06b5e 100644 --- a/src/schema/query.ts +++ b/src/schema/query.ts @@ -58,7 +58,14 @@ export const EMPTY_QUERY: JobQuery = { function one(params: URLSearchParams, key: string): string | null { const value = params.get(key); if (value === null) return null; - const trimmed = value.trim(); + // A NUL byte is not text: PostgreSQL refuses it outright, so `?q=%00` and + // `?org=%00` reached the LIKE pattern and answered 500 on every surface + // that shares this parse - the page, the API, MCP, the CLI and federated + // search at once. Drop the byte rather than reject the query, the same way + // an unknown value is dropped. Only NUL: the other control characters + // travel fine, and a cap here would turn a too-long numeric filter into a + // finite number instead of the fallback the integer parse owes it. + const trimmed = value.replace(/\0/g, '').trim(); return trimmed === '' ? null : trimmed; } @@ -99,7 +106,7 @@ export function parseQuery(params: URLSearchParams): JobQuery { ...new Set( [...params.getAll('tag'), ...params.getAll('tags')] .flatMap((value) => value.split(',')) - .map((value) => value.trim().toLowerCase()) + .map((value) => value.replace(/\0/g, '').trim().toLowerCase()) .filter((value) => value !== ''), ), ].slice(0, 10), diff --git a/test/query-nul-byte.test.ts b/test/query-nul-byte.test.ts new file mode 100644 index 0000000..657a5c2 --- /dev/null +++ b/test/query-nul-byte.test.ts @@ -0,0 +1,52 @@ +import assert from 'node:assert/strict'; +import { test } from 'node:test'; +import { listInstances } from '../src/directory/registry.ts'; +import { parseQuery, queryToParams } from '../src/schema/query.ts'; + +test('a NUL byte in a string filter is dropped, not sent to the database', () => { + // PostgreSQL refuses a NUL byte in text outright, so before this every + // surface that shares parseQuery - the page, the API, MCP, the CLI and + // federated search - answered 500 for `?q=%00`, `?org=%00` and `?tags=%00`. + const query = parseQuery(new URLSearchParams({ q: '\0', org: '\0', tags: '\0', tag: '\0' })); + assert.equal(query.q, null); + assert.equal(query.org, null); + assert.deepEqual(query.tags, []); +}); + +test('a NUL byte inside a longer value is dropped, not spaced', () => { + // The byte is not a separator: "post\0gres" is one mangled word, not two. + const query = parseQuery(new URLSearchParams({ q: 'post\0gres', org: 'ac\0me' })); + assert.equal(query.q, 'postgres'); + assert.equal(query.org, 'acme'); +}); + +test('a cleaned filter still round-trips into a canonical link', () => { + const query = parseQuery(new URLSearchParams({ q: 'post\0gres' })); + assert.equal(queryToParams(query).get('q'), 'postgres'); +}); + +test('the directory search never passes a NUL byte into its parameters', async () => { + let values: unknown[] = []; + const pool = { + async query(_query: string, params: unknown[] = []) { + values = params; + return { rows: [] }; + }, + }; + await listInstances(pool as never, { q: '\0', topic: '\0' }); + for (const value of values) { + assert.ok(!String(value).includes('\0'), JSON.stringify(String(value))); + } +}); + +test('a directory filter that cleans away to nothing is treated as absent', async () => { + let statement = ''; + const pool = { + async query(query: string, _params: unknown[] = []) { + statement = query; + return { rows: [] }; + }, + }; + await listInstances(pool as never, { q: '\0' }); + assert.ok(!statement.includes(' like '), 'no LIKE clause for a filter that is only a NUL byte'); +}); From 17da3d828eb86187ad0a9554904868a8b9b6c41b Mon Sep 17 00:00:00 2001 From: ouji kaminari Date: Mon, 12 Oct 2026 04:23:39 +0700 Subject: [PATCH 097/116] fix(core): drop NUL bytes where slugs and ids reach SQL, guard the decode that throws (#313) * fix(core): drop NUL bytes where slugs and ids reach SQL, guard decode The rest of the class #312 started. PostgreSQL refuses a NUL byte in a text parameter outright, so every lookup that took a slug or an id straight from a request answered 500 where an unknown value answers "nothing here": "org" on POST /jobs and /updates, "job", "as", "candidate" and "employer" on POST /inbox, "resumeId" and "resumeSlug" on POST /jobs/:slug/apply, ?candidate=%00 on /inbox/new, ?state=%00 on the CoinPay callback, and a board link whose path carries %00 - or a malformed escape, which decodeURIComponent throws on, uncaught until now. Drop the byte at each boundary, the way parseQuery drops it from a search, and treat a value that cleans away to nothing as absent rather than as a lookup for the empty string. One test per boundary. * fix(pages): read the logout cookie the way the middleware does The route parsed the cookie header by hand and ran decodeURIComponent on the value, so `Cookie: aj_session=%E0%A4%A` - a malformed escape - threw a URIError out of the route and answered 500 where every token that matches no session answers the redirect home. Read it with getCookie, the same helper the middleware uses, which leaves what it cannot decode alone. Verified live before the change: the request answered 500. Three tests against a real Postgres: the malformed escape, a NUL byte, and a real session still being revoked. --- src/core/coinpay.ts | 8 +- src/core/inbox.ts | 8 +- src/core/jobs.ts | 11 +- src/core/orgs.ts | 10 +- src/core/resumes.ts | 36 +++++- src/core/updates.ts | 35 +++++- src/server/routes/pages.tsx | 12 +- test/logout-session-cookie.test.ts | 86 ++++++++++++++ test/nul-byte-lookups.test.ts | 177 +++++++++++++++++++++++++++++ 9 files changed, 364 insertions(+), 19 deletions(-) create mode 100644 test/logout-session-cookie.test.ts create mode 100644 test/nul-byte-lookups.test.ts diff --git a/src/core/coinpay.ts b/src/core/coinpay.ts index 8b3584c..55e1dd7 100644 --- a/src/core/coinpay.ts +++ b/src/core/coinpay.ts @@ -418,6 +418,12 @@ export async function finishConnect( coinpay: CoinPayClient, input: { state: string; code: string; redirectUri: string }, ): Promise<{ userId: string; redirect: string | null; account: Account } | string> { + // The state travels into a SQL parameter, and a NUL byte is not text: + // PostgreSQL refuses it outright, so `?state=%00` on + // GET /api/v1/coinpay/callback answered 500 where every state that matches + // no pending flow answers "expired". Drop the byte; a state that cleans + // away to nothing matches nothing. + const state = input.state.replace(/\0/g, '').trim(); const claimed = await pool.query<{ user_id: string; code_verifier: string; @@ -425,7 +431,7 @@ export async function finishConnect( }>( `delete from coinpay_oauth_states where state = $1 and expires_at > now() returning user_id, code_verifier, redirect`, - [input.state], + [state], ); const pending = claimed.rows[0]; if (pending === undefined) return 'That connection attempt has expired. Start again.'; diff --git a/src/core/inbox.ts b/src/core/inbox.ts index 1edc5dd..dd27ea5 100644 --- a/src/core/inbox.ts +++ b/src/core/inbox.ts @@ -552,8 +552,12 @@ export async function counterpartyFrom( pool: pg.Pool, input: { candidate?: string | null; employer?: string | null }, ): Promise { - const candidate = (input.candidate ?? '').trim(); - const employer = (input.employer ?? '').trim(); + // Both slugs travel into SQL parameters, and a NUL byte is not text: + // PostgreSQL refuses it outright, so a body carrying one answered 500 + // where every unknown slug answers "nobody here". Drop the byte the way + // parseQuery drops it from a search. + const candidate = (input.candidate ?? '').replace(/\0/g, '').trim(); + const employer = (input.employer ?? '').replace(/\0/g, '').trim(); if (candidate !== '' && employer !== '') return null; if (candidate !== '') { const result = await pool.query<{ user_id: string }>( diff --git a/src/core/jobs.ts b/src/core/jobs.ts index 6be280c..7724aee 100644 --- a/src/core/jobs.ts +++ b/src/core/jobs.ts @@ -399,11 +399,20 @@ export async function getJobBySlug( slug: string, options: { includeUnpublished?: boolean } = {}, ): Promise { + // The slug travels into a SQL parameter, and a NUL byte is not text: + // PostgreSQL refuses it outright, so `"job": "\u0000"` on POST /inbox + // answered 500 where an unknown slug answers "no such job". Drop the byte + // the way parseQuery drops it from a search, and treat a slug that cleans + // away to nothing as absent rather than as a lookup for the empty slug. + const cleaned = slug.replace(/\0/g, '').trim(); + if (cleaned === '') return null; const visible = options.includeUnpublished === true ? '' : `and j.status = 'published' and j.published_at is not null and j.published_at <= now() and (j.expires_at is null or j.expires_at > now())`; - const result = await pool.query(`${SELECT} where j.slug = $1 ${visible} limit 1`, [slug]); + const result = await pool.query(`${SELECT} where j.slug = $1 ${visible} limit 1`, [ + cleaned, + ]); const row = result.rows[0]; return row === undefined ? null : toJob(row); } diff --git a/src/core/orgs.ts b/src/core/orgs.ts index 3a91d77..390cb02 100644 --- a/src/core/orgs.ts +++ b/src/core/orgs.ts @@ -35,7 +35,15 @@ function toOrg(row: OrgRow): Organisation { const SELECT = `select id, slug, name, website, logo_url, description, created_at from organisations`; export async function getOrgBySlug(pool: pg.Pool, slug: string): Promise { - const result = await pool.query(`${SELECT} where slug = $1`, [slug]); + // The slug travels into a SQL parameter, and a NUL byte is not text: + // PostgreSQL refuses it outright, so `"org": "\u0000"` on POST /jobs or + // /updates - and `"as": "\u0000"` on POST /inbox - answered 500 where an + // unknown slug answers "no such employer". Drop the byte the way parseQuery + // drops it from a search, and treat a slug that cleans away to nothing as + // absent rather than as a lookup for the empty slug. + const cleaned = slug.replace(/\0/g, '').trim(); + if (cleaned === '') return null; + const result = await pool.query(`${SELECT} where slug = $1`, [cleaned]); const row = result.rows[0]; return row === undefined ? null : toOrg(row); } diff --git a/src/core/resumes.ts b/src/core/resumes.ts index 865cb43..4b24073 100644 --- a/src/core/resumes.ts +++ b/src/core/resumes.ts @@ -83,16 +83,27 @@ export async function getResume( userId: string, slug: string, ): Promise { + // The slug comes from the application body - `"resumeSlug": "\u0000"` on + // POST /jobs/:slug/apply answered 500 - and a NUL byte is not text: + // PostgreSQL refuses it outright. Drop the byte; nothing matches it anyway. + const cleaned = slug.replace(/\0/g, '').trim(); + if (cleaned === '') return null; const result = await pool.query(`${SELECT} where user_id = $1 and slug = $2`, [ userId, - slug, + cleaned, ]); const row = result.rows[0]; return row === undefined ? null : toResume(row); } export async function getResumeById(pool: pg.Pool, id: string): Promise { - const result = await pool.query(`${SELECT} where id = $1`, [id]); + // The id comes from the application body - `"resumeId": "\u0000"` on + // POST /jobs/:slug/apply answered 500 - and a NUL byte is not text: + // PostgreSQL refuses it outright. Drop the byte; an id that cleans away to + // nothing matches nothing. + const cleaned = id.replace(/\0/g, '').trim(); + if (cleaned === '') return null; + const result = await pool.query(`${SELECT} where id = $1`, [cleaned]); const row = result.rows[0]; return row === undefined ? null : toResume(row); } @@ -202,6 +213,12 @@ export async function publicResumeSource( pool: pg.Pool, publicSlug: string, ): Promise<{ name: string; mime: string; bytes: Buffer } | null> { + // The slug travels into a SQL parameter, and a NUL byte is not text: + // PostgreSQL refuses it outright. Drop the byte the way parseQuery drops it + // from a search, and treat a slug that cleans away to nothing as absent + // rather than as a lookup for the empty slug. + const slug = publicSlug.replace(/\0/g, '').trim(); + if (slug === '') return null; const result = await pool.query<{ source_name: string | null; source_mime: string | null; @@ -209,7 +226,7 @@ export async function publicResumeSource( }>( `select source_name, source_mime, source_bytes from resumes where public_slug = $1 and visibility in ('link', 'public')`, - [publicSlug], + [slug], ); const row = result.rows[0]; if (row === undefined || row.source_bytes === null) return null; @@ -221,18 +238,27 @@ export async function publicResumeSource( } export async function getPublicResume(pool: pg.Pool, publicSlug: string): Promise { + // Same slug, same NUL byte: `GET /inbox/new?candidate=%00` answered 500 + // through this lookup, where a slug that matches nothing is the 404 the + // page already knows how to give. + const slug = publicSlug.replace(/\0/g, '').trim(); + if (slug === '') return null; const result = await pool.query( `${SELECT} where public_slug = $1 and visibility in ('link', 'public')`, - [publicSlug], + [slug], ); const row = result.rows[0]; return row === undefined ? null : toResume(row); } export async function getSharedResume(pool: pg.Pool, id: string): Promise { + // Same body, same NUL byte as getResumeById above: `"resumeId": "\u0000"` + // reached this lookup first and answered 500. + const cleaned = id.replace(/\0/g, '').trim(); + if (cleaned === '') return null; const result = await pool.query( `${SELECT} where id = $1 and visibility in ('link', 'public')`, - [id], + [cleaned], ); const row = result.rows[0]; return row === undefined ? null : toResume(row); diff --git a/src/core/updates.ts b/src/core/updates.ts index d13cf8f..3151438 100644 --- a/src/core/updates.ts +++ b/src/core/updates.ts @@ -237,8 +237,22 @@ export async function boardLinkProblem( const sql = section === undefined ? undefined : BOARD_PAGES[section]; if (sql === undefined || slug === undefined) return null; - const found = await pool.query(sql, [decodeURIComponent(slug)]); - if (found.rows.length > 0) return null; + // Two inputs that are not a page here must not answer 500 instead of the + // sentence below: a malformed escape, which decodeURIComponent throws on, + // and a NUL byte, which PostgreSQL refuses outright. Both clean away to + // nothing, and nothing is not a page on this board. + let decoded: string; + try { + decoded = decodeURIComponent(slug); + } catch { + decoded = ''; + } + decoded = decoded.replace(/\0/g, '').trim(); + + if (decoded !== '') { + const found = await pool.query(sql, [decoded]); + if (found.rows.length > 0) return null; + } let hint = ''; if (section === 'candidates' && target.kind === 'candidate') { @@ -521,8 +535,14 @@ export type Scope = | { kind: 'unknown'; slug: string }; export async function scopeFrom(pool: pg.Pool, params: URLSearchParams): Promise { - const org = (params.get('org') ?? '').trim(); - const candidate = (params.get('candidate') ?? '').trim(); + // Both filters travel into SQL parameters, and a NUL byte is not text: + // PostgreSQL refuses it outright, so `?org=%00` and `?candidate=%00` + // answered 500 on every surface that resolves a scope - the API, the RSS + // feed and the Markdown feed at once. Drop the byte the way parseQuery + // drops it from a search, and treat a filter that cleans away to nothing + // as absent rather than as a lookup for the empty slug. + const org = (params.get('org') ?? '').replace(/\0/g, '').trim(); + const candidate = (params.get('candidate') ?? '').replace(/\0/g, '').trim(); if (org !== '') { const row = await pool.query<{ id: string; name: string }>( @@ -590,12 +610,17 @@ export async function candidateSlugFor(pool: pg.Pool, userId: string): Promise { + // The slug travels into a SQL parameter, and a NUL byte is not text: + // PostgreSQL refuses it outright. The scope parse cleans before calling + // this, but the lookup is the boundary that has to hold for every caller. + const cleaned = slug.replace(/\0/g, '').trim(); + if (cleaned === '') return null; // Matches what /candidates/:slug actually serves, so a page a person can // open is a page they can follow. const result = await pool.query<{ user_id: string }>( `select user_id from resumes where public_slug = $1 and visibility in ('link', 'public') limit 1`, - [slug], + [cleaned], ); return result.rows[0]?.user_id ?? null; } diff --git a/src/server/routes/pages.tsx b/src/server/routes/pages.tsx index 8b0015b..66baf20 100644 --- a/src/server/routes/pages.tsx +++ b/src/server/routes/pages.tsx @@ -9,7 +9,7 @@ import { Hono } from 'hono'; import type { Context } from 'hono'; -import { deleteCookie, setCookie } from 'hono/cookie'; +import { deleteCookie, getCookie, setCookie } from 'hono/cookie'; import { approveDeviceCode, consumeMagicLink, @@ -958,9 +958,13 @@ export function pageRoutes(): Hono { pages.post('/logout', async (c) => { const { pool } = c.get('deps'); - const cookie = c.req.header('cookie') ?? ''; - const token = new RegExp(`${SESSION_COOKIE}=([^;]+)`).exec(cookie)?.[1]; - if (token !== undefined) await revokeSession(pool, decodeURIComponent(token)); + // The same read the middleware uses, so the two agree on what the cookie + // says. A cookie can carry anything, and decoding a malformed escape by + // hand threw out of decodeURIComponent as a 500; getCookie leaves what it + // cannot decode alone, and a token that matches no session deletes + // nothing. + const token = getCookie(c, SESSION_COOKIE); + if (token !== undefined) await revokeSession(pool, token); deleteCookie(c, SESSION_COOKIE, { path: '/' }); return c.redirect('/', 303); }); diff --git a/test/logout-session-cookie.test.ts b/test/logout-session-cookie.test.ts new file mode 100644 index 0000000..871e4aa --- /dev/null +++ b/test/logout-session-cookie.test.ts @@ -0,0 +1,86 @@ +/** + * POST /logout with a session cookie that is not a session. + * + * The route read the cookie by hand and ran decodeURIComponent on it, so + * `Cookie: aj_session=%E0%A4%A` - a malformed escape - threw a URIError out + * of the route and answered 500 where every token that matches no session + * answers the redirect home. It now reads the cookie the way the middleware + * does. + */ +import assert from 'node:assert/strict'; +import { after, describe, test } from 'node:test'; +import type { Hono } from 'hono'; + +const DATABASE_URL = + process.env['TEST_DATABASE_URL'] ?? + process.env['DATABASE_URL'] ?? + 'postgres://agenticjobs:agenticjobs@localhost:5432/agenticjobs'; + +let app: Hono | null = null; +let pool: { + query: (sql: string, params?: unknown[]) => Promise<{ rows: Record[] }>; +} | null = null; +let closePool: (() => Promise) | null = null; +let reason = ''; +let ready = false; + +try { + const db = await import('../dist/db/pool.js'); + const { migrate } = await import('../dist/db/migrate.js'); + const { createApp } = await import('../dist/server/app.js'); + const { loadConfig } = await import('../dist/config.js'); + const created = db.getPool(DATABASE_URL); + await created.query('select 1'); + await migrate(created); + pool = created as never; + closePool = db.closePool; + const config = loadConfig({ + ...process.env, + DATABASE_URL, + PUBLIC_URL: 'http://board.test', + SECRET: 'test-secret', + }); + app = createApp(created, config, { send: async () => true }) as never; + ready = true; +} catch (error) { + reason = error instanceof Error ? error.message : String(error); +} + +after(async () => { + if (closePool !== null) await closePool(); +}); + +async function logout(cookie: string): Promise { + if (app === null) throw new Error('no app'); + return app.fetch( + new Request('http://board.test/logout', { method: 'POST', headers: { cookie } }), + ); +} + +describe( + 'logout with a broken cookie', + { skip: ready ? false : `no database: ${reason || 'setup failed'}` }, + () => { + test('a malformed escape redirects instead of throwing', async () => { + const res = await logout('aj_session=%E0%A4%A'); + assert.equal(res.status, 303); + }); + + test('a NUL byte redirects instead of reaching a parameter', async () => { + const res = await logout('aj_session=%00'); + assert.equal(res.status, 303); + }); + + test('a real session is still revoked', async () => { + const { createSession, ensureUser, viewerFromToken } = await import('../dist/core/auth.js'); + const stamp = `${Date.now()}${Math.random().toString(36).slice(2, 7)}`; + const user = await ensureUser(pool as never, `logout+${stamp}@example.com`, 'Logout Tester'); + const token = await createSession(pool as never, user.id, { label: 'test' }); + assert.notEqual(await viewerFromToken(pool as never, token), null); + + const res = await logout(`aj_session=${token}`); + assert.equal(res.status, 303); + assert.equal(await viewerFromToken(pool as never, token), null); + }); + }, +); diff --git a/test/nul-byte-lookups.test.ts b/test/nul-byte-lookups.test.ts new file mode 100644 index 0000000..50090ca --- /dev/null +++ b/test/nul-byte-lookups.test.ts @@ -0,0 +1,177 @@ +import assert from 'node:assert/strict'; +import { test } from 'node:test'; +import { finishConnect } from '../src/core/coinpay.ts'; +import { counterpartyFrom } from '../src/core/inbox.ts'; +import { getJobBySlug } from '../src/core/jobs.ts'; +import { getOrgBySlug } from '../src/core/orgs.ts'; +import { + getPublicResume, + getResume, + getResumeById, + getSharedResume, + publicResumeSource, +} from '../src/core/resumes.ts'; +import { boardLinkProblem, scopeFrom, userForCandidate } from '../src/core/updates.ts'; + +/** + * A pool that remembers every parameter list it was handed. + * + * The point of these tests is what does *not* travel into the parameters, so + * the pool answers nothing and the calls are the assertion. + */ +function recordingPool(): { pool: never; calls: unknown[][] } { + const calls: unknown[][] = []; + const pool = { + async query(_query: string, params: unknown[] = []) { + calls.push(params); + return { rows: [] }; + }, + }; + return { pool: pool as never, calls }; +} + +test('an org slug carrying a NUL byte is cleaned before the query', async () => { + // `"org": "\u0000"` on POST /jobs or /updates, and `"as": "\u0000"` on + // POST /inbox, answered 500 where an unknown slug answers "no such + // employer": PostgreSQL refuses the byte in a parameter outright. + const { pool, calls } = recordingPool(); + assert.equal(await getOrgBySlug(pool, 'ac\0me'), null); + assert.deepEqual(calls, [['acme']]); +}); + +test('an org slug that is only a NUL byte never reaches the database', async () => { + const { pool, calls } = recordingPool(); + assert.equal(await getOrgBySlug(pool, '\0'), null); + assert.deepEqual(calls, []); +}); + +test('a job slug carrying a NUL byte is cleaned before the query', async () => { + // `"job": "\u0000"` on POST /inbox was the live 500 this guards. + const { pool, calls } = recordingPool(); + assert.equal(await getJobBySlug(pool, 'wri\0ter'), null); + assert.deepEqual(calls, [['writer']]); +}); + +test('a job slug that is only a NUL byte never reaches the database', async () => { + const { pool, calls } = recordingPool(); + assert.equal(await getJobBySlug(pool, '\0'), null); + assert.deepEqual(calls, []); +}); + +test('every resume lookup drops the byte before the query', async () => { + // `GET /inbox/new?candidate=%00` answered 500 through getPublicResume, and + // `"resumeId": "\u0000"` / `"resumeSlug": "\u0000"` on POST + // /jobs/:slug/apply through the shared, owned and by-id lookups. + const { pool, calls } = recordingPool(); + assert.equal(await getPublicResume(pool, 'sa\0m'), null); + assert.equal(await publicResumeSource(pool, 'sa\0m'), null); + assert.equal(await getResume(pool, 'user-1', 'sa\0m'), null); + assert.equal(await getResumeById(pool, 'res\0ume'), null); + assert.equal(await getSharedResume(pool, 'res\0ume'), null); + assert.deepEqual(calls, [['sam'], ['sam'], ['user-1', 'sam'], ['resume'], ['resume']]); +}); + +test('a resume lookup for only a NUL byte never reaches the database', async () => { + const { pool, calls } = recordingPool(); + assert.equal(await getPublicResume(pool, '\0'), null); + assert.equal(await getResume(pool, 'user-1', '\0'), null); + assert.equal(await getResumeById(pool, '\0'), null); + assert.equal(await getSharedResume(pool, '\0'), null); + assert.deepEqual(calls, []); +}); + +test('a candidate slug carrying a NUL byte is cleaned in the follow lookup', async () => { + const { pool, calls } = recordingPool(); + assert.equal(await userForCandidate(pool, 'sa\0m'), null); + assert.deepEqual(calls, [['sam']]); +}); + +test('a scope of only NUL bytes reads as no filter at all', async () => { + // `/api/v1/updates?org=%00`, `?candidate=%00`, the RSS feed and the + // Markdown feed were the live 500s; a filter that cleans away to nothing + // is absent, not a lookup for the empty slug. + const { pool, calls } = recordingPool(); + const scope = await scopeFrom(pool, new URLSearchParams({ org: '\0', candidate: '\0' })); + assert.deepEqual(scope, { kind: 'all' }); + assert.deepEqual(calls, []); +}); + +test('a candidate scope carrying a NUL byte is cleaned before the lookup', async () => { + const { pool, calls } = recordingPool(); + const scope = await scopeFrom(pool, new URLSearchParams({ candidate: 'sa\0m' })); + assert.deepEqual(scope, { kind: 'unknown', slug: 'sam' }); + assert.deepEqual(calls, [['sam']]); +}); + +test('an inbox body of only NUL bytes reads as nobody, not as a database error', async () => { + // `"candidate": "\u0000"` and `"employer": "\u0000"` on POST /inbox were + // the live 500s; "nobody here" is the 404 those slugs owe. + const { pool, calls } = recordingPool(); + assert.equal(await counterpartyFrom(pool, { candidate: '\0', employer: null }), null); + assert.deepEqual(calls, []); +}); + +test('a NUL byte in one inbox slug does not hide the other', async () => { + const { pool, calls } = recordingPool(); + // The candidate slug cleans away to nothing, so the employer slug is the + // one that decides. Before this the pair read as "both filters set". + assert.equal(await counterpartyFrom(pool, { candidate: '\0', employer: 'ac\0me' }), null); + assert.deepEqual(calls, [['acme']]); +}); + +test('a board link whose slug carries a NUL byte is cleaned, not sent raw', async () => { + // `"link": "https:///candidates/%00"` on POST /updates answered 500. + const { pool, calls } = recordingPool(); + const problem = await boardLinkProblem( + pool, + 'https://agenticjobs.work/candidates/sa%00m', + 'https://agenticjobs.work', + 'author-1', + { kind: 'employer', orgId: 'org-1' }, + ); + assert.ok(typeof problem === 'string', 'the not-a-page sentence, not a crash'); + assert.deepEqual(calls, [['sam']]); +}); + +test('a board link with a malformed escape answers the sentence, not a crash', async () => { + // `decodeURIComponent('%E0%A4%A')` throws, and the throw escaped as a 500 + // on POST /updates. The slug it cannot decode is not a page here either. + const { pool, calls } = recordingPool(); + const problem = await boardLinkProblem( + pool, + 'https://agenticjobs.work/candidates/%E0%A4%A', + 'https://agenticjobs.work', + 'author-1', + { kind: 'employer', orgId: 'org-1' }, + ); + assert.ok( + typeof problem === 'string' && problem.includes('not a page'), + String(problem), + ); + assert.deepEqual(calls, []); +}); + +test('a well-formed board link still reaches the lookup unchanged', async () => { + const { pool, calls } = recordingPool(); + await boardLinkProblem( + pool, + 'https://agenticjobs.work/candidates/sam', + 'https://agenticjobs.work', + 'author-1', + { kind: 'employer', orgId: 'org-1' }, + ); + assert.deepEqual(calls, [['sam']]); +}); + +test('a callback state of only NUL bytes expires instead of erroring', async () => { + // `?state=%00` on GET /api/v1/coinpay/callback answered 500 where every + // state that matches no pending flow answers "expired". + const { pool, calls } = recordingPool(); + const result = await finishConnect(pool, {} as never, { + state: '\0', + code: 'code', + redirectUri: 'https://agenticjobs.work/api/v1/coinpay/callback', + }); + assert.equal(result, 'That connection attempt has expired. Start again.'); + assert.deepEqual(calls, [['']]); +}); From 9acf9775b36f080e8a2a80403e2de83d09de76f6 Mon Sep 17 00:00:00 2001 From: shkim3142-ops Date: Mon, 12 Oct 2026 17:20:15 +0900 Subject: [PATCH 098/116] fix(resume): preserve contact links with trailing destination whitespace (#314) * fix(resume): accept whitespace before a link closing parenthesis Preserve contact destinations when valid Markdown links include trailing spaces or tabs. AI-assisted change, reproduced and tested locally. * Create resume-link-space.test.ts --- src/markup/resume.ts | 4 ++-- test/resume-link-space.test.ts | 18 ++++++++++++++++++ 2 files changed, 20 insertions(+), 2 deletions(-) create mode 100644 test/resume-link-space.test.ts diff --git a/src/markup/resume.ts b/src/markup/resume.ts index 787e5d1..3b53791 100644 --- a/src/markup/resume.ts +++ b/src/markup/resume.ts @@ -284,7 +284,7 @@ function parseDocument(source: string): { resume: OpenResume; body: string } { export function parseMarkdownLink(text: string): { label: string; href: string; end: number } | null { const opening = /^\[([^\]]+)\]\(/.exec(text); if (opening === null) return null; - const angleDestination = /^\[([^\]]+)\]\(<((?:\\.|[^<>\\\n])*)>(?:\s+"[^"]*")?\)/.exec( + const angleDestination = /^\[([^\]]+)\]\(<((?:\\.|[^<>\\\n])*)>(?:\s+"[^"]*")?\s*\)/.exec( text, ); if (angleDestination !== null) { @@ -314,7 +314,7 @@ export function parseMarkdownLink(text: string): { label: string; href: string; } } else if (/\s/.test(character)) { // An optional link title follows the URL; it is not part of the account. - const title = /^\s+"[^"]*"\s*\)/.exec(text.slice(index)); + const title = /^\s+(?:"[^"]*"\s*)?\)/.exec(text.slice(index)); return title === null || href === '' ? null : { label: opening[1] ?? '', href, end: index + title[0].length - 1 }; diff --git a/test/resume-link-space.test.ts b/test/resume-link-space.test.ts new file mode 100644 index 0000000..21e6422 --- /dev/null +++ b/test/resume-link-space.test.ts @@ -0,0 +1,18 @@ +import assert from 'node:assert/strict'; +import { test } from 'node:test'; +import { parseMarkdownLink, parseResume } from '../src/markup/resume.ts'; + +for (const destination of ['https://github.com/example ', 'https://github.com/example\t', ' ']) { + test(`contact links retain destinations with closing whitespace: ${JSON.stringify(destination)}`, () => { + const link = `[GitHub](${destination})`; + assert.deepEqual(parseMarkdownLink(link), { label: 'GitHub', href: 'https://github.com/example', end: link.length - 1 }); + assert.deepEqual(parseResume(`# Example\n- ${link}`).contact, [{ key: 'GitHub', value: 'GitHub', href: 'https://github.com/example' }]); + }); +} +test('does not accept unquoted text after a destination', () => { + assert.equal(parseMarkdownLink('[GitHub](https://github.com/example extra)'), null); +}); +test('existing titled links remain supported', () => { + const link = '[GitHub](https://github.com/example "Profile")'; + assert.equal(parseMarkdownLink(link)?.href, 'https://github.com/example'); +}); From 6f3ff976deeaa6d4c713b7c075c04eaf4abfd0b5 Mon Sep 17 00:00:00 2001 From: Anthony Ettinger Date: Sat, 17 Oct 2026 11:59:44 -0700 Subject: [PATCH 099/116] fix(docs): OpenCreds and ASDLC links point at logicsrc.com (#315) /docs/openprofile was copied from logicsrc.com, where /opencreds and /asdlc are local pages. On agenticjobs.work they 404ed (ThreatCrush Link Watch). Co-authored-by: Claude Opus 5.5 --- docs/openprofile.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/openprofile.md b/docs/openprofile.md index 0cffbc9..d9590f1 100644 --- a/docs/openprofile.md +++ b/docs/openprofile.md @@ -169,8 +169,8 @@ By hand, in any editor, in five minutes. Or: - [OpenResume.md](/docs/openresume): what you have done, in the same spirit. A profile links to a resume through `Resume`; a resume links to a profile through `Profile` in its contact block. - [OpenJob](/docs/openjob): what the work is. -- [OpenCreds](/opencreds): where the tokens behind the accounts are kept. A profile never contains a credential. -- [ASDLC](/asdlc): how the tools that serve and read these files get built. +- [OpenCreds](https://logicsrc.com/opencreds): where the tokens behind the accounts are kept. A profile never contains a credential. +- [ASDLC](https://logicsrc.com/asdlc): how the tools that serve and read these files get built. ## Version history From c10f86b271887f4a943f45c6321fa42e52ff8abe Mon Sep 17 00:00:00 2001 From: Anthony Ettinger Date: Mon, 19 Oct 2026 00:50:48 -0700 Subject: [PATCH 100/116] Add a CrawlProof ad unit above the footer on public pages (#316) One text_link unit served as a cross-origin /api/ads/frame iframe for slot 9c3d6e3d-ae1f-43ff-b6d9-4f42f11725ce. The board's strict CSP gains only frame-src https://crawlproof.com; no ad.js, no extra script or storage. Skipped on noindex pages and on flows (tracker, post, me, inbox, auth...). Co-authored-by: Claude Opus 5.5 --- src/server/middleware.ts | 3 ++ src/views/ad-unit.tsx | 66 ++++++++++++++++++++++++++++++++++++++++ src/views/layout.tsx | 2 ++ test/views.test.ts | 33 ++++++++++++++++++++ web/public/app.css | 12 ++++++++ web/public/sw.js | 2 +- 6 files changed, 117 insertions(+), 1 deletion(-) create mode 100644 src/views/ad-unit.tsx diff --git a/src/server/middleware.ts b/src/server/middleware.ts index 5a5805a..c414539 100644 --- a/src/server/middleware.ts +++ b/src/server/middleware.ts @@ -107,6 +107,9 @@ export function securityHeaders( `frame-ancestors 'none'`, `object-src 'none'`, `script-src 'self' https://crawlproof.com`, + // The one ad unit is a cross-origin CrawlProof frame (/api/ads/frame), so + // it costs this entry and nothing else: no script, no style, no storage. + `frame-src https://crawlproof.com`, `style-src 'self' 'unsafe-inline'`, // Employer logos and avatars come from wherever the employer hosts them. // 'self' has to be listed explicitly: omitting it works in production and diff --git a/src/views/ad-unit.tsx b/src/views/ad-unit.tsx new file mode 100644 index 0000000..a61b4d7 --- /dev/null +++ b/src/views/ad-unit.tsx @@ -0,0 +1,66 @@ +/** + * One CrawlProof ad unit, as a script-free cross-origin iframe. + * + * `ad.js` fills a placeholder with a `srcdoc` iframe, and a srcdoc document + * inherits this page's Content-Security-Policy: the creative's inline styles + * and remote images would only render with a far looser policy than this + * board sends. `/api/ads/frame` serves the same creative as a real + * cross-origin document, so the cost here is one `frame-src` entry, no + * third-party JavaScript and nothing written to this origin's storage. + * Impressions are metered server-side exactly as on the script path. + * + * The format is `text_link`, the one fluid creative: 40px tall at any width, + * with its own "Sponsored" mark. Banners are laid out at a fixed pixel width + * and would be cropped in a narrow column, and choosing by viewport needs a + * script. No `&theme=`: the frame answers prefers-color-scheme itself. + */ +import type { FC } from 'hono/jsx'; + +export const AD_ORIGIN = 'https://crawlproof.com'; +export const AD_SLOT = '9c3d6e3d-ae1f-43ff-b6d9-4f42f11725ce'; + +/** First path segments that never carry an ad: flows, accounts, dashboards, admin. */ +const NO_AD_SEGMENTS = new Set([ + 'tracker', + 'fleets', + 'post', + 'post-a-job', + 'me', + 'inbox', + 'notifications', + 'applications', + 'admin', + 'login', + 'auth', + 'device', + 'invoices', + 'coinpay', + 'revisions', +]); + +/** Public, indexable pages only. A noindex page is a dashboard or a one-off flow. */ +export function showsAd(path: string, noindex?: boolean): boolean { + if (noindex) return false; + const first = path.split(/[/?#]/)[1] ?? ''; + return !NO_AD_SEGMENTS.has(first); +} + +export const AdUnit: FC<{ format?: 'text_link' }> = ({ format = 'text_link' }) => { + const src = `${AD_ORIGIN}/api/ads/frame?slot=${encodeURIComponent(AD_SLOT)}&format=${encodeURIComponent(format)}`; + return ( + + ); +}; diff --git a/src/views/layout.tsx b/src/views/layout.tsx index 11f3f1c..305c33f 100644 --- a/src/views/layout.tsx +++ b/src/views/layout.tsx @@ -16,6 +16,7 @@ import type { SkillCount } from '../core/skills.ts'; import { pathForQuery } from '../core/landing.ts'; import { EMPTY_QUERY } from '../schema/query.ts'; import { pfsFooter } from './pfs-footer.ts'; +import { AdUnit, showsAd } from './ad-unit.tsx'; export interface PageProps { title: string; @@ -268,6 +269,7 @@ export const Layout: FC> = (props) => {
      {children}
      + {showsAd(path, noindex) && } {skills.length > 0 && (
      diff --git a/test/views.test.ts b/test/views.test.ts index 1f0f051..508ecef 100644 --- a/test/views.test.ts +++ b/test/views.test.ts @@ -556,3 +556,36 @@ test('a signed-out visitor is offered somewhere to hire from', async () => { // Signed in, the nav already has a button to the form; two would be noise. assert.match(nav({ id: 'u' }), /href="\/post"/, 'signed in, the form is still one click away'); }); + +test('the ad unit is a crawlproof frame on public pages only, and the policy frames it', async () => { + const { showsAd, AD_SLOT } = await import('../dist/views/ad-unit.js'); + const { Layout } = await import('../dist/views/layout.js'); + const { securityHeaders } = await import('../dist/server/middleware.js'); + assert.equal(showsAd('/', false), true); + assert.equal(showsAd('/jobs/abc', false), true); + assert.equal(showsAd('/me/settings', false), false); + assert.equal(showsAd('/post-a-job', false), false); + assert.equal(showsAd('/tracker', false), false); + assert.equal(showsAd('/jobs/abc', true), false); + + const page = (path: string) => + String( + Layout({ + title: 'A board', + viewer: null, + boardName: 'A board', + publicUrl: 'https://example.test', + path, + children: 'x', + }), + ); + const home = page('/'); + assert.equal(home.match(/crawlproof\.com\/api\/ads\/frame/g)?.length, 1, 'exactly one unit'); + assert.ok(home.includes(`slot=${AD_SLOT}&format=text_link`), home); + assert.ok(!home.includes('theme='), 'the frame answers prefers-color-scheme itself'); + assert.ok(!page('/inbox').includes('/api/ads/frame'), 'no ad inside the inbox'); + + const headers = new Headers(); + await securityHeaders()({ res: { headers } } as never, async () => undefined); + assert.match(headers.get('content-security-policy') ?? '', /frame-src https:\/\/crawlproof\.com/); +}); diff --git a/web/public/app.css b/web/public/app.css index 4341383..c1b7b4f 100644 --- a/web/public/app.css +++ b/web/public/app.css @@ -1099,3 +1099,15 @@ a.badge-plain:hover .badge { .tracker-metrics .card-content { padding: 1rem; } .tracker-missing { color: var(--warning); font-size: 0.9rem; margin: 0.25rem 0; } .tracker-improve ul { margin: 0; padding-left: 1.25rem; display: grid; gap: 0.5rem; } + +/* CrawlProof ad unit (src/views/ad-unit.tsx): one fluid text_link frame above the footer. */ +.ad-unit { + margin: 1.5rem 0 0; +} +.ad-unit iframe { + display: block; + width: 100%; + height: 40px; + border: 0; + background: transparent; +} diff --git a/web/public/sw.js b/web/public/sw.js index 08039da..40d32d8 100644 --- a/web/public/sw.js +++ b/web/public/sw.js @@ -13,7 +13,7 @@ * drifted, which is the only version of this rule that survives contact. */ -const VERSION = 'ea250e72'; +const VERSION = '4a4fd178'; const SHELL = `shell-${VERSION}`; const ASSETS = ['/assets/app.css', '/assets/tokens.css', '/assets/icon.svg']; From 0646e5cfd58f9408da80d1be45e4154b68a8f220 Mon Sep 17 00:00:00 2001 From: Anthony Ettinger Date: Mon, 19 Oct 2026 03:38:22 -0700 Subject: [PATCH 101/116] 0.22.5: draft writer falls back to OpenAI, and says when an account is empty (#317) The /post drafter only ever called one provider, and reported OpenAI's "no credits remaining" 429 as "rate limited, try again shortly". Now Anthropic is tried first and OpenAI answers when it fails; an exhausted balance on either says "out of credits"; the provider's raw answer is logged server-side (never shown); WRITER_MODEL only goes to the provider it names. Co-authored-by: Claude Opus 5.5 --- README.md | 6 ++- package.json | 2 +- src/config.ts | 2 +- src/core/agentwriter.ts | 83 +++++++++++++++++++++++++++++----------- test/agentwriter.test.ts | 43 +++++++++++++++++++++ 5 files changed, 110 insertions(+), 26 deletions(-) diff --git a/README.md b/README.md index 83c7926..8ca276a 100644 --- a/README.md +++ b/README.md @@ -175,8 +175,10 @@ An employer with a brief and no time can have a model expand it into the form. S one key and the box appears on `/post`; set neither and it does not: ```bash -OPENAI_API_KEY=sk-... # or ANTHROPIC_API_KEY=sk-ant-... -WRITER_MODEL=gpt-5.2-codex # optional; defaults to gpt-5.2 or claude-opus-5 +ANTHROPIC_API_KEY=sk-ant-... # tried first +OPENAI_API_KEY=sk-... # either alone works; with both, OpenAI is the fallback +WRITER_MODEL=gpt-5.2-codex # optional; defaults to claude-opus-5 / gpt-5.2, and only + # applies to the provider it names (claude-* = Anthropic) ``` It fills the form in and stops. Nothing is written and nothing is published: the diff --git a/package.json b/package.json index 65bdeb2..b5c52e2 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "@profullstack/agenticjobs", - "version": "0.22.4", + "version": "0.22.5", "description": "An agent-friendly job board you self-host. It posts its own jobs, never scrapes anyone else's, and answers on every surface: web, API, MCP, CLI, TUI, desktop and PWA. Instances find each other through an open directory.", "license": "MIT", "type": "module", diff --git a/src/config.ts b/src/config.ts index 8d29976..bcb5e69 100644 --- a/src/config.ts +++ b/src/config.ts @@ -187,7 +187,7 @@ export function loadConfig(env: NodeJS.ProcessEnv = process.env): Config { } /** Kept in step with package.json by the release script. */ -export const VERSION = '0.22.4'; +export const VERSION = '0.22.5'; export const SOFTWARE_NAME = 'agenticjobs'; /** diff --git a/src/core/agentwriter.ts b/src/core/agentwriter.ts index c9ec337..c15cccd 100644 --- a/src/core/agentwriter.ts +++ b/src/core/agentwriter.ts @@ -10,8 +10,10 @@ * * Two providers, because this is MIT software other people self-host and a * board that only works if you bank with one vendor is not self-hostable. The - * key that is set decides; when neither is set the feature is simply absent - * from the page rather than present and broken. + * keys that are set decide; when neither is set the feature is simply absent + * from the page rather than present and broken. With both set, the second is + * a fallback: a provider that is out of credits or down hands the brief to the + * other one instead of the employer. * * Written against the two REST APIs directly rather than either vendor SDK. * One dependency per provider to fill in a form is a poor trade for a package @@ -36,16 +38,33 @@ export class AgentWriterProblem extends Error {} export type WriterProvider = 'anthropic' | 'openai'; /** - * Which provider this instance can use, or null for none. + * The providers this instance can use, in the order they are tried. * - * Anthropic first when both are set, for no better reason than that a board - * with both keys has to pick one and a coin flip at request time would make - * the same brief produce different listings. + * Anthropic first when both are set, so the same brief goes to the same model + * whenever it can; OpenAI only answers when Anthropic could not. */ +export function writerProviders(config: Config): WriterProvider[] { + const providers: WriterProvider[] = []; + if (config.anthropicApiKey !== null) providers.push('anthropic'); + if (config.openaiApiKey !== null) providers.push('openai'); + return providers; +} + +/** The provider tried first, or null for none. */ export function writerProvider(config: Config): WriterProvider | null { - if (config.anthropicApiKey !== null) return 'anthropic'; - if (config.openaiApiKey !== null) return 'openai'; - return null; + return writerProviders(config)[0] ?? null; +} + +/** + * WRITER_MODEL, for the provider it names. + * + * One setting serves two vendors, so a Claude model name must never be sent to + * OpenAI on the fallback path, nor a GPT name to Anthropic. + */ +function modelFor(provider: WriterProvider, config: Config): string | null { + const model = config.writerModel; + if (model === null) return null; + return model.startsWith('claude') === (provider === 'anthropic') ? model : null; } /** @@ -118,8 +137,8 @@ export async function draftListing( throw new AgentWriterProblem('Say a little more about the role, and I will draft it.'); } - const provider = writerProvider(config); - if (provider === null) { + const providers = writerProviders(config); + if (providers.length === 0) { throw new AgentWriterProblem('This board has no model configured.'); } @@ -133,12 +152,26 @@ export async function draftListing( .filter((line) => line !== null) .join('\n'); - const raw = - provider === 'anthropic' - ? await askAnthropic(prompt, config, fetchImpl) - : await askOpenAi(prompt, config, fetchImpl); - - return fieldsFromModelJson(raw); + // Each provider in turn. A failure on the first is logged for whoever runs + // the board and never shown; the employer only hears about it when every + // provider failed, and then from the last one tried. + let problem: AgentWriterProblem | null = null; + for (const provider of providers) { + try { + const raw = + provider === 'anthropic' + ? await askAnthropic(prompt, config, fetchImpl) + : await askOpenAi(prompt, config, fetchImpl); + return fieldsFromModelJson(raw); + } catch (error) { + if (!(error instanceof AgentWriterProblem)) throw error; + if (problem === null && providers.length > 1) { + console.error(`agent writer: ${provider} failed, trying the next provider: ${error.message}`); + } + problem = error; + } + } + throw problem ?? new AgentWriterProblem('This board has no model configured.'); } /** @@ -161,7 +194,7 @@ async function askAnthropic( 'anthropic-version': '2023-06-01', }, body: JSON.stringify({ - model: config.writerModel ?? 'claude-opus-5', + model: modelFor('anthropic', config) ?? 'claude-opus-5', max_tokens: 4000, output_config: { effort: 'low' }, system: SYSTEM, @@ -207,7 +240,7 @@ async function askOpenAi( authorization: `Bearer ${config.openaiApiKey ?? ''}`, }, body: JSON.stringify({ - model: config.writerModel ?? 'gpt-5.2', + model: modelFor('openai', config) ?? 'gpt-5.2', max_completion_tokens: 4000, response_format: { type: 'json_object' }, messages: [ @@ -239,12 +272,18 @@ async function askOpenAi( * carry account details that do not belong on a public page. */ async function problemFor(response: Response, provider: string): Promise { - // Read and discard, so the connection is not left hanging on a body nobody - // consumed. - await response.text().catch(() => ''); + // Read in full, so the connection is not left hanging, and so an empty + // account can be told apart from a busy one. Both providers say "out of + // credits" with a status that also means something else: OpenAI with a 429, + // Anthropic with a 400. + const body = await response.text().catch(() => ''); + console.error(`agent writer: ${provider} answered ${response.status}: ${body.slice(0, 300)}`); if (response.status === 401 || response.status === 403) { return new AgentWriterProblem(`This board's ${provider} key was rejected.`); } + if (/insufficient_quota|credit_balance|credit balance/i.test(body)) { + return new AgentWriterProblem(`This board's ${provider} account is out of credits.`); + } if (response.status === 429) { return new AgentWriterProblem('The model is rate limited right now. Try again shortly.'); } diff --git a/test/agentwriter.test.ts b/test/agentwriter.test.ts index 630d558..6524816 100644 --- a/test/agentwriter.test.ts +++ b/test/agentwriter.test.ts @@ -206,3 +206,46 @@ test('a brief too short to work with never reaches the model', async () => { ); assert.equal(called, false, 'and costs the board nothing'); }); + +test('with both keys, an Anthropic failure falls back to OpenAI', async () => { + const sent = []; + const fake = async (url, init) => { + sent.push({ url, model: JSON.parse(init.body).model }); + if (url.includes('anthropic')) { + return new Response(JSON.stringify({ error: { message: 'Your credit balance is too low' } }), { + status: 400, + }); + } + return new Response(JSON.stringify({ choices: [{ message: { content: FULL } }] }), { status: 200 }); + }; + + const values = await draftListing('A real brief about a real job.', { boardName: 'B', orgName: null }, + { ...CONFIG, anthropicApiKey: 'sk-ant', openaiApiKey: 'sk-oai', writerModel: 'claude-haiku-5-5' }, fake); + + assert.equal(values['title'], 'Senior Go Engineer'); + assert.deepEqual(sent.map((s) => s.url), [ + 'https://api.anthropic.com/v1/messages', + 'https://api.openai.com/v1/chat/completions', + ]); + assert.equal(sent[0].model, 'claude-haiku-5-5'); + assert.equal(sent[1].model, 'gpt-5.2', 'a Claude model name is never sent to OpenAI'); +}); + +test('an empty account says so, rather than claiming a rate limit', async () => { + // OpenAI answers an exhausted balance with a 429, the same status as a real + // rate limit, and "try again shortly" would never come true. + const broke = async () => + new Response(JSON.stringify({ error: { code: 'credit_balance_exhausted', type: 'insufficient_quota' } }), { + status: 429, + }); + + await assert.rejects( + draftListing('A real brief about a real job.', { boardName: 'B', orgName: null }, + { ...CONFIG, openaiApiKey: 'sk-test' }, broke), + (error) => { + assert.ok(error instanceof AgentWriterProblem); + assert.match(error.message, /out of credits/); + return true; + }, + ); +}); From 0f88c7f0df5ba5c9cab7abe23dc81efd648cf3ff Mon Sep 17 00:00:00 2001 From: Anthony Ettinger Date: Mon, 19 Oct 2026 06:01:41 -0700 Subject: [PATCH 102/116] 0.22.6: pit.world global footer; the site footer is two rows (#318) - src/views/pit-footer.ts replaces pfs-footer.ts: the snippet from https://pit.world/snippets/footer.html?site=, a per-host module cache refreshed hourly in the background (3s timeout, last good copy kept, nothing rendered if never fetched), last in . - Footer: the popular-skills row stays; the @profullstack/footer bar (nine links, tagline, webring) becomes one row: copyright, Popular, Agents, API, Feed, Source. The ring now comes from the global footer. - The CrawlProof unit moves from above the footer to the top of
      . Co-authored-by: Claude Opus 5.5 --- package.json | 2 +- src/config.ts | 2 +- src/views/layout.tsx | 42 ++++++++++++++---------------- src/views/pfs-footer.ts | 23 ----------------- src/views/pit-footer.ts | 57 +++++++++++++++++++++++++++++++++++++++++ web/public/app.css | 18 +++++-------- web/public/sw.js | 2 +- 7 files changed, 86 insertions(+), 60 deletions(-) delete mode 100644 src/views/pfs-footer.ts create mode 100644 src/views/pit-footer.ts diff --git a/package.json b/package.json index b5c52e2..0b9b69c 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "@profullstack/agenticjobs", - "version": "0.22.5", + "version": "0.22.6", "description": "An agent-friendly job board you self-host. It posts its own jobs, never scrapes anyone else's, and answers on every surface: web, API, MCP, CLI, TUI, desktop and PWA. Instances find each other through an open directory.", "license": "MIT", "type": "module", diff --git a/src/config.ts b/src/config.ts index bcb5e69..288464a 100644 --- a/src/config.ts +++ b/src/config.ts @@ -187,7 +187,7 @@ export function loadConfig(env: NodeJS.ProcessEnv = process.env): Config { } /** Kept in step with package.json by the release script. */ -export const VERSION = '0.22.5'; +export const VERSION = '0.22.6'; export const SOFTWARE_NAME = 'agenticjobs'; /** diff --git a/src/views/layout.tsx b/src/views/layout.tsx index 305c33f..d3f17dc 100644 --- a/src/views/layout.tsx +++ b/src/views/layout.tsx @@ -15,7 +15,7 @@ import { renderMarkdown } from '../markup/markdown.ts'; import type { SkillCount } from '../core/skills.ts'; import { pathForQuery } from '../core/landing.ts'; import { EMPTY_QUERY } from '../schema/query.ts'; -import { pfsFooter } from './pfs-footer.ts'; +import { pitFooter } from './pit-footer.ts'; import { AdUnit, showsAd } from './ad-unit.tsx'; export interface PageProps { @@ -267,11 +267,12 @@ export const Layout: FC> = (props) => {

+ {/* The one ad, at the top of the content: never pressed against the footer. */} + {showsAd(path, noindex) && }
{children}
- {showsAd(path, noindex) && } - {skills.length > 0 && ( -
+
+ {skills.length > 0 && (
Popular skills: {skills.map((skill) => ( @@ -281,25 +282,18 @@ export const Layout: FC> = (props) => { ))} all skills
-
- )} - {raw( - pfsFooter({ - site: `${publicUrl.replace(/\/+$/, '')}/`, - links: [ - { label: 'Popular', href: '/popular' }, - { label: 'Most profitable', href: '/most-profitable' }, - { label: 'Agents', href: '/agents' }, - { label: 'API', href: '/docs' }, - { label: 'OpenAPI', href: '/api/v1/openapi.json' }, - { label: 'Instance', href: '/.well-known/agenticjobs' }, - { label: 'Feed', href: '/jobs.json' }, - { label: 'llms.txt', href: '/llms.txt' }, - { label: 'Source', href: 'https://github.com/profullstack/agenticjobs' }, - ], - tagline: `${boardName} runs on agenticjobs, MIT licensed.`, - }), - )} + )} +
+ + © {new Date().getFullYear()} {boardName} + + Popular + Agents + API + Feed + Source +
+
{/* * CrawlProof, as a plain tag. `defer` is what `strategy` meant on the @@ -312,6 +306,8 @@ export const Layout: FC> = (props) => { defer > )} + {/* The pit.world global footer, last in . */} + {raw(pitFooter(publicUrl))} ); diff --git a/src/views/pfs-footer.ts b/src/views/pfs-footer.ts deleted file mode 100644 index 61ad9d4..0000000 --- a/src/views/pfs-footer.ts +++ /dev/null @@ -1,23 +0,0 @@ -/** - * The shared Profullstack footer (@profullstack/footer): the board's link row, - * the copyright line and the webring, from the package's @latest template, so a - * release of the package reaches every board without a redeploy. - * - * Layout renders synchronously (pages and tests stringify it directly), so this - * returns the last footer rendered for these options and refreshes it in the - * background on each use; the package caches the template for an hour. Until - * the first refresh lands it is the template from the installed package. - */ -import { footerHtml, footerHtmlSync } from '@profullstack/footer'; - -type FooterOptions = Parameters[0]; - -const rendered = new Map(); - -export function pfsFooter(options: FooterOptions): string { - const key = JSON.stringify(options); - void footerHtml(options) - .then((html) => rendered.set(key, html)) - .catch(() => undefined); - return rendered.get(key) ?? footerHtmlSync(options); -} diff --git a/src/views/pit-footer.ts b/src/views/pit-footer.ts new file mode 100644 index 0000000..a6724e6 --- /dev/null +++ b/src/views/pit-footer.ts @@ -0,0 +1,57 @@ +/** + * The pit.world global footer (site name, search, ring, publish), fetched on + * the server from https://pit.world/snippets/footer.html?site= and + * rendered as the last thing in . + * + * Layout renders synchronously (pages and tests stringify it directly), so this + * returns the last good copy for the host and refreshes it in the background + * once it is an hour old (3s timeout). A failed refresh keeps the old copy; with + * no copy yet it returns '' and the page simply has no global footer. + */ +const MAX_AGE_MS = 60 * 60 * 1000; + +interface Entry { + html: string; + fetchedAt: number; + inflight: Promise | null; +} + +const cache = new Map(); + +function refresh(site: string, entry: Entry): Promise { + entry.inflight ??= fetch( + `https://pit.world/snippets/footer.html?site=${encodeURIComponent(site)}`, + { signal: AbortSignal.timeout(3000) }, + ) + .then(async (res) => { + const text = res.ok ? await res.text() : ''; + if (!text.includes('data-pit-footer')) throw new Error(`pit footer: HTTP ${res.status}`); + entry.html = text; + entry.fetchedAt = Date.now(); + }) + .catch(() => { + entry.fetchedAt = Date.now() - MAX_AGE_MS + 60_000; // try again in a minute + }) + .finally(() => { + entry.inflight = null; + }); + return entry.inflight; +} + +/** The footer fragment for a board's public URL ('' until the first fetch lands). */ +export function pitFooter(publicUrl: string): string { + let site: string; + try { + site = new URL(publicUrl).hostname; + } catch { + return ''; + } + if (!site || site === 'localhost' || site.endsWith('.test')) return ''; + let entry = cache.get(site); + if (!entry) { + entry = { html: '', fetchedAt: 0, inflight: null }; + cache.set(site, entry); + } + if (Date.now() - entry.fetchedAt > MAX_AGE_MS) void refresh(site, entry); + return entry.html; +} diff --git a/web/public/app.css b/web/public/app.css index c1b7b4f..fb54cd0 100644 --- a/web/public/app.css +++ b/web/public/app.css @@ -143,7 +143,7 @@ main { .site-footer { border-top: 1px solid var(--border); - padding: 2rem 0; + padding: 1.25rem 0; color: var(--muted-foreground); font-size: 0.85rem; } @@ -159,17 +159,13 @@ main { color: var(--muted-foreground); } -/* The shared Profullstack footer (src/views/pfs-footer.ts) under the skills row. */ -footer.pfs-footer { - --pfs-footer-muted: var(--muted-foreground); - border-top-color: var(--border); -} - -/* The skill links above the footer proper: one row that wraps. */ -/* The shared footer's own top rule follows, so the row needs none of its own. */ +/* Two rows: the popular skills, then the copyright and the links people use. */ .footer-skills { gap: 0.5rem 0.9rem; } +.footer-skills + .footer-links { + margin-top: 0.75rem; +} .thread.unread { font-weight: 600; @@ -1100,9 +1096,9 @@ a.badge-plain:hover .badge { .tracker-missing { color: var(--warning); font-size: 0.9rem; margin: 0.25rem 0; } .tracker-improve ul { margin: 0; padding-left: 1.25rem; display: grid; gap: 0.5rem; } -/* CrawlProof ad unit (src/views/ad-unit.tsx): one fluid text_link frame above the footer. */ +/* CrawlProof ad unit (src/views/ad-unit.tsx): one fluid text_link frame at the top of the content. */ .ad-unit { - margin: 1.5rem 0 0; + margin: 0 0 1.5rem; } .ad-unit iframe { display: block; diff --git a/web/public/sw.js b/web/public/sw.js index 40d32d8..5bf8202 100644 --- a/web/public/sw.js +++ b/web/public/sw.js @@ -13,7 +13,7 @@ * drifted, which is the only version of this rule that survives contact. */ -const VERSION = '4a4fd178'; +const VERSION = '4442cc3d'; const SHELL = `shell-${VERSION}`; const ASSETS = ['/assets/app.css', '/assets/tokens.css', '/assets/icon.svg']; From 30191e9f3a2bc2f1c094d8f1c2827c661843c00a Mon Sep 17 00:00:00 2001 From: Anthony Ettinger Date: Mon, 19 Oct 2026 06:24:29 -0700 Subject: [PATCH 103/116] 0.22.7: restore the @profullstack/footer bar under the site footer (#319) The webring bar is being rolled out fleet-wide on purpose. It comes back with no extra links (the site footer row carries them), between the site footer and the pit.world global footer. Co-authored-by: Claude Opus 5.5 --- package.json | 2 +- src/config.ts | 2 +- src/views/layout.tsx | 12 +++++++++--- src/views/pfs-footer.ts | 23 +++++++++++++++++++++++ web/public/app.css | 8 +++++++- web/public/sw.js | 2 +- 6 files changed, 42 insertions(+), 7 deletions(-) create mode 100644 src/views/pfs-footer.ts diff --git a/package.json b/package.json index 0b9b69c..fb73520 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "@profullstack/agenticjobs", - "version": "0.22.6", + "version": "0.22.7", "description": "An agent-friendly job board you self-host. It posts its own jobs, never scrapes anyone else's, and answers on every surface: web, API, MCP, CLI, TUI, desktop and PWA. Instances find each other through an open directory.", "license": "MIT", "type": "module", diff --git a/src/config.ts b/src/config.ts index 288464a..68db124 100644 --- a/src/config.ts +++ b/src/config.ts @@ -187,7 +187,7 @@ export function loadConfig(env: NodeJS.ProcessEnv = process.env): Config { } /** Kept in step with package.json by the release script. */ -export const VERSION = '0.22.6'; +export const VERSION = '0.22.7'; export const SOFTWARE_NAME = 'agenticjobs'; /** diff --git a/src/views/layout.tsx b/src/views/layout.tsx index d3f17dc..1764b0f 100644 --- a/src/views/layout.tsx +++ b/src/views/layout.tsx @@ -15,6 +15,7 @@ import { renderMarkdown } from '../markup/markdown.ts'; import type { SkillCount } from '../core/skills.ts'; import { pathForQuery } from '../core/landing.ts'; import { EMPTY_QUERY } from '../schema/query.ts'; +import { pfsFooter } from './pfs-footer.ts'; import { pitFooter } from './pit-footer.ts'; import { AdUnit, showsAd } from './ad-unit.tsx'; @@ -284,9 +285,6 @@ export const Layout: FC> = (props) => { )}
- - © {new Date().getFullYear()} {boardName} - Popular Agents API @@ -294,6 +292,14 @@ export const Layout: FC> = (props) => { Source
+ {/* Copyright and the Profullstack webring: @profullstack/footer. */} + {raw( + pfsFooter({ + site: `${publicUrl.replace(/\/+$/, '')}/`, + links: [], + tagline: `${boardName} runs on agenticjobs, MIT licensed.`, + }), + )} {/* * CrawlProof, as a plain tag. `defer` is what `strategy` meant on the diff --git a/src/views/pfs-footer.ts b/src/views/pfs-footer.ts new file mode 100644 index 0000000..61ad9d4 --- /dev/null +++ b/src/views/pfs-footer.ts @@ -0,0 +1,23 @@ +/** + * The shared Profullstack footer (@profullstack/footer): the board's link row, + * the copyright line and the webring, from the package's @latest template, so a + * release of the package reaches every board without a redeploy. + * + * Layout renders synchronously (pages and tests stringify it directly), so this + * returns the last footer rendered for these options and refreshes it in the + * background on each use; the package caches the template for an hour. Until + * the first refresh lands it is the template from the installed package. + */ +import { footerHtml, footerHtmlSync } from '@profullstack/footer'; + +type FooterOptions = Parameters[0]; + +const rendered = new Map(); + +export function pfsFooter(options: FooterOptions): string { + const key = JSON.stringify(options); + void footerHtml(options) + .then((html) => rendered.set(key, html)) + .catch(() => undefined); + return rendered.get(key) ?? footerHtmlSync(options); +} diff --git a/web/public/app.css b/web/public/app.css index fb54cd0..7323029 100644 --- a/web/public/app.css +++ b/web/public/app.css @@ -159,7 +159,13 @@ main { color: var(--muted-foreground); } -/* Two rows: the popular skills, then the copyright and the links people use. */ +/* The shared Profullstack footer (src/views/pfs-footer.ts) under the site footer. */ +footer.pfs-footer { + --pfs-footer-muted: var(--muted-foreground); + border-top-color: var(--border); +} + +/* Two rows: the popular skills, then the links people use. */ .footer-skills { gap: 0.5rem 0.9rem; } diff --git a/web/public/sw.js b/web/public/sw.js index 5bf8202..65f77aa 100644 --- a/web/public/sw.js +++ b/web/public/sw.js @@ -13,7 +13,7 @@ * drifted, which is the only version of this rule that survives contact. */ -const VERSION = '4442cc3d'; +const VERSION = 'b264b667'; const SHELL = `shell-${VERSION}`; const ASSETS = ['/assets/app.css', '/assets/tokens.css', '/assets/icon.svg']; From f029bc12047467beab61e77a77259d016df04bc7 Mon Sep 17 00:00:00 2001 From: Anthony Ettinger Date: Mon, 19 Oct 2026 16:15:18 -0700 Subject: [PATCH 104/116] chore: exempt all @profullstack/* from minimumReleaseAge (#320) Our own packages; version-pinned excludes made every fleet bump wait 24h. Co-authored-by: Claude Opus 5.5 --- pnpm-workspace.yaml | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml index 230638e..d27501c 100644 --- a/pnpm-workspace.yaml +++ b/pnpm-workspace.yaml @@ -11,6 +11,4 @@ packages: # hqtui is published by us, often on the same day we depend on the new version. # pnpm 11 refuses packages younger than a day unless they are listed here. minimumReleaseAgeExclude: - - '@profullstack/hqtui' - - '@profullstack/synconfig@0.1.2' - - '@profullstack/footer' + - '@profullstack/*' From d71d7469e711200a92bd92719a562d6554966a80 Mon Sep 17 00:00:00 2001 From: Anthony Ettinger Date: Tue, 20 Oct 2026 22:50:40 -0700 Subject: [PATCH 105/116] No ads on the homepage; low-profile text-link ads elsewhere (#321) * No ads on the homepage; low-profile text-link ads elsewhere Homepage renders no ad unit. Remaining units are a single text_link line per page with quiet spacing, never against the footer. Co-Authored-By: Claude Opus 5.5 * Bump the service worker cache VERSION for the app.css change Co-Authored-By: Claude Opus 5.5 --------- Co-authored-by: Claude Opus 5.5 --- src/views/ad-unit.tsx | 6 +++++- test/views.test.ts | 11 ++++++----- web/public/app.css | 2 +- web/public/sw.js | 2 +- 4 files changed, 13 insertions(+), 8 deletions(-) diff --git a/src/views/ad-unit.tsx b/src/views/ad-unit.tsx index a61b4d7..cc9c666 100644 --- a/src/views/ad-unit.tsx +++ b/src/views/ad-unit.tsx @@ -38,10 +38,14 @@ const NO_AD_SEGMENTS = new Set([ 'revisions', ]); -/** Public, indexable pages only. A noindex page is a dashboard or a one-off flow. */ +/** + * Public, indexable pages only. A noindex page is a dashboard or a one-off flow, + * and the homepage carries no ad. + */ export function showsAd(path: string, noindex?: boolean): boolean { if (noindex) return false; const first = path.split(/[/?#]/)[1] ?? ''; + if (first === '') return false; return !NO_AD_SEGMENTS.has(first); } diff --git a/test/views.test.ts b/test/views.test.ts index 508ecef..08a47a2 100644 --- a/test/views.test.ts +++ b/test/views.test.ts @@ -561,7 +561,7 @@ test('the ad unit is a crawlproof frame on public pages only, and the policy fra const { showsAd, AD_SLOT } = await import('../dist/views/ad-unit.js'); const { Layout } = await import('../dist/views/layout.js'); const { securityHeaders } = await import('../dist/server/middleware.js'); - assert.equal(showsAd('/', false), true); + assert.equal(showsAd('/', false), false, 'the homepage carries no ad'); assert.equal(showsAd('/jobs/abc', false), true); assert.equal(showsAd('/me/settings', false), false); assert.equal(showsAd('/post-a-job', false), false); @@ -579,10 +579,11 @@ test('the ad unit is a crawlproof frame on public pages only, and the policy fra children: 'x', }), ); - const home = page('/'); - assert.equal(home.match(/crawlproof\.com\/api\/ads\/frame/g)?.length, 1, 'exactly one unit'); - assert.ok(home.includes(`slot=${AD_SLOT}&format=text_link`), home); - assert.ok(!home.includes('theme='), 'the frame answers prefers-color-scheme itself'); + assert.ok(!page('/').includes('/api/ads/frame'), 'no ad on the homepage'); + const job = page('/jobs/abc'); + assert.equal(job.match(/crawlproof\.com\/api\/ads\/frame/g)?.length, 1, 'exactly one unit'); + assert.ok(job.includes(`slot=${AD_SLOT}&format=text_link`), job); + assert.ok(!job.includes('theme='), 'the frame answers prefers-color-scheme itself'); assert.ok(!page('/inbox').includes('/api/ads/frame'), 'no ad inside the inbox'); const headers = new Headers(); diff --git a/web/public/app.css b/web/public/app.css index 7323029..4ca7150 100644 --- a/web/public/app.css +++ b/web/public/app.css @@ -1104,7 +1104,7 @@ a.badge-plain:hover .badge { /* CrawlProof ad unit (src/views/ad-unit.tsx): one fluid text_link frame at the top of the content. */ .ad-unit { - margin: 0 0 1.5rem; + margin: 0 0 0.75rem; } .ad-unit iframe { display: block; diff --git a/web/public/sw.js b/web/public/sw.js index 65f77aa..302caaf 100644 --- a/web/public/sw.js +++ b/web/public/sw.js @@ -13,7 +13,7 @@ * drifted, which is the only version of this rule that survives contact. */ -const VERSION = 'b264b667'; +const VERSION = '3a3325d0'; const SHELL = `shell-${VERSION}`; const ASSETS = ['/assets/app.css', '/assets/tokens.css', '/assets/icon.svg']; From 6e9897d9eb9ea449b9e7afd0abe854f137b33872 Mon Sep 17 00:00:00 2001 From: Anthony Ettinger Date: Wed, 21 Oct 2026 06:06:24 -0700 Subject: [PATCH 106/116] feat(invoices): send payer, payee and property to CoinPay; read the nested webhook (#322) requestPayment now passes customer_email (payer email), account_id (payer id) and property agenticjobs.work top-level on /api/payments/create, and the same plus payee_id in metadata. The peer-invoice model is unchanged: the payer still pays the payee's own wallet via merchant_wallet_address. applyWebhook read event/payment_id flat, so a real nested CoinPay webhook ({id: evt_..., type, data: {payment_id, status}}) was always ignored and invoices only settled on the next page load. It now reads data first with the flat shape as a fallback. Co-authored-by: Claude Opus 5.5 --- src/core/coinpay.ts | 21 +++++++++++- src/core/invoices.ts | 44 +++++++++++++++++++++--- test/billing.test.ts | 79 +++++++++++++++++++++++++++++++++++++++++++- 3 files changed, 138 insertions(+), 6 deletions(-) diff --git a/src/core/coinpay.ts b/src/core/coinpay.ts index 55e1dd7..c60b046 100644 --- a/src/core/coinpay.ts +++ b/src/core/coinpay.ts @@ -65,6 +65,9 @@ export interface Payment { export class CoinPayProblem extends Error {} +/** The site every payment here is for, as CoinPay records it (`property`). */ +export const PROPERTY = 'agenticjobs.work'; + export interface CoinPayClient { readonly config: CoinPayConfig; authorizeUrl(input: { state: string; codeChallenge: string; redirectUri: string }): string; @@ -83,6 +86,11 @@ export interface CoinPayClient { redirectUrl: string; idempotencyKey: string; metadata: Record; + /** Who is paying: their email and agenticjobs user id. Sent top-level and in metadata. */ + customerEmail?: string | null; + accountId?: string | null; + /** Who is being paid: the payee's agenticjobs user id. */ + payeeId?: string | null; }): Promise; getPayment(id: string): Promise; /** Where a payer goes to pay. */ @@ -276,7 +284,18 @@ export function createCoinPay(config: CoinPayConfig, fetchImpl: Fetch = fetch): merchant_wallet_address: input.payeeAddress, description: input.description, redirect_url: input.redirectUrl, - metadata: { ...input.metadata, idempotency_key: input.idempotencyKey }, + // Optional on /payments/create: a malformed one is dropped by CoinPay, never a 400. + ...(input.customerEmail ? { customer_email: input.customerEmail } : {}), + ...(input.accountId ? { account_id: input.accountId } : {}), + property: PROPERTY, + metadata: { + ...input.metadata, + property: PROPERTY, + ...(input.accountId ? { account_id: input.accountId } : {}), + ...(input.customerEmail ? { customer_email: input.customerEmail } : {}), + ...(input.payeeId ? { payee_id: input.payeeId } : {}), + idempotency_key: input.idempotencyKey, + }, }), }); if (result.status !== 200 && result.status !== 201) { diff --git a/src/core/invoices.ts b/src/core/invoices.ts index c8ed7df..0e26945 100644 --- a/src/core/invoices.ts +++ b/src/core/invoices.ts @@ -307,6 +307,11 @@ export async function requestPayment( return synced; } + const payer = await pool.query<{ email: string }>('select email from users where id = $1', [ + input.payerId, + ]); + const payerEmail = payer.rows[0]?.email ?? null; + let minted; try { minted = await coinpay.createPayment({ @@ -324,6 +329,9 @@ export async function requestPayment( thread_id: current.threadId, payer_id: input.payerId, }, + customerEmail: payerEmail, + accountId: input.payerId, + payeeId: current.payee.id, }); } catch (error) { if (error instanceof CoinPayProblem) return error.message; @@ -419,15 +427,43 @@ export async function markPaid( * to the next page load, which clears it the same way and does not depend on * a delivery that may never come. */ +export function readWebhook(payload: Record): { + event: string; + paymentId: string; + status: string; + txHash: string | null; + metadata: Record; +} { + // CoinPay nests the payment under `data`; the top-level `id` is the EVENT id, + // never the payment's. Read `data` first, the old flat shape as a fallback. + const nested = payload['data']; + const data = + typeof nested === 'object' && nested !== null ? (nested as Record) : payload; + const s = (v: unknown) => (typeof v === 'string' ? v : ''); + const event = s(payload['type']) || s(payload['event']); + const paymentId = s(data['payment_id']) || (data === payload ? '' : s(data['id'])); + const meta = data['metadata'] ?? payload['metadata']; + return { + event, + paymentId, + status: s(data['status']).toLowerCase(), + txHash: s(data['tx_hash']) || null, + metadata: typeof meta === 'object' && meta !== null ? (meta as Record) : {}, + }; +} + export async function applyWebhook( pool: pg.Pool, payload: Record, ): Promise<'paid' | 'ignored' | 'unknown'> { - const event = typeof payload['event'] === 'string' ? payload['event'] : ''; - const paymentId = typeof payload['payment_id'] === 'string' ? payload['payment_id'] : ''; + const { event, paymentId, status, txHash } = readWebhook(payload); if (paymentId === '') return 'ignored'; - if (event !== 'payment.confirmed' && event !== 'payment.forwarded') return 'ignored'; - const txHash = typeof payload['tx_hash'] === 'string' ? payload['tx_hash'] : null; + const settled = + event === 'payment.confirmed' || + event === 'payment.forwarded' || + status === 'confirmed' || + status === 'forwarded'; + if (!settled) return 'ignored'; const paid = await markPaid(pool, { paymentId, txHash }); return paid ? 'paid' : 'unknown'; } diff --git a/test/billing.test.ts b/test/billing.test.ts index f31ffcf..6748c06 100644 --- a/test/billing.test.ts +++ b/test/billing.test.ts @@ -16,7 +16,7 @@ import { pkcePair, SCOPES, } from '../dist/core/coinpay.js'; -import { parseAmount } from '../dist/core/invoices.js'; +import { applyWebhook, parseAmount, readWebhook } from '../dist/core/invoices.js'; import { inboxMessage } from '../dist/core/mail.js'; const FULL = { @@ -138,6 +138,9 @@ test('the payment request names the payee wallet and the board business, with th redirectUrl: 'https://b/inbox/t', idempotencyKey: 'k', metadata: { invoice_id: 'i' }, + customerEmail: 'payer@example.com', + accountId: 'user-payer', + payeeId: 'user-payee', }); assert.equal(payment.id, 'pay_1'); assert.equal(payment.currency, 'USDC_POL'); @@ -154,6 +157,80 @@ test('the payment request names the payee wallet and the board business, with th assert.equal(sent['blockchain'], 'USDC_POL'); assert.equal(sent['amount_usd'], 1200); assert.equal((sent['metadata'] as Record)['idempotency_key'], 'k'); + // Who pays, who is paid and which site, top-level and in metadata. + assert.equal(sent['customer_email'], 'payer@example.com'); + assert.equal(sent['account_id'], 'user-payer'); + assert.equal(sent['property'], 'agenticjobs.work'); + assert.deepEqual(sent['metadata'], { + invoice_id: 'i', + property: 'agenticjobs.work', + account_id: 'user-payer', + customer_email: 'payer@example.com', + payee_id: 'user-payee', + idempotency_key: 'k', + }); +}); + +test('the webhook is read from the nested data, never the event id, with the old flat shape as a fallback', async () => { + const nested = { + id: 'evt_pay_9_1700000000', + type: 'payment.forwarded', + data: { + payment_id: 'pay_9', + status: 'forwarded', + tx_hash: '0xabc', + customer_email: 'payer@example.com', + account_id: 'user-payer', + property: 'agenticjobs.work', + metadata: { invoice_id: 'i', payee_id: 'user-payee' }, + }, + }; + assert.deepEqual(readWebhook(nested), { + event: 'payment.forwarded', + paymentId: 'pay_9', + status: 'forwarded', + txHash: '0xabc', + metadata: { invoice_id: 'i', payee_id: 'user-payee' }, + }); + assert.equal( + readWebhook({ event: 'payment.confirmed', payment_id: 'pay_flat' }).paymentId, + 'pay_flat', + ); + + const marked: unknown[][] = []; + const pool = { + query: async (_sql: string, params: unknown[]) => { + marked.push(params); + return { rowCount: params[0] === 'pay_9' || params[0] === 'pay_flat' ? 1 : 0, rows: [] }; + }, + } as never; + assert.equal(await applyWebhook(pool, nested), 'paid'); + assert.deepEqual( + marked[0]!.slice(0, 2), + ['pay_9', '0xabc'], + 'settled by the payment id, not evt_', + ); + assert.equal( + await applyWebhook(pool, { event: 'payment.confirmed', payment_id: 'pay_flat' }), + 'paid', + ); + assert.equal( + await applyWebhook(pool, { + id: 'evt', + type: 'payment.detected', + data: { payment_id: 'pay_9', status: 'detected' }, + }), + 'ignored', + ); + assert.equal( + await applyWebhook(pool, { + id: 'evt', + type: 'payment.confirmed', + data: { payment_id: 'pay_nobody', status: 'confirmed' }, + }), + 'unknown', + ); + assert.equal(marked.length, 3, 'detected never reaches the database'); }); test('an HTML answer from CoinPay is reported as such, not parsed', async () => { From 38e42ab289c3a0bb9e911fc9e20d3b8d2a3de242 Mon Sep 17 00:00:00 2001 From: Anthony Ettinger Date: Wed, 21 Oct 2026 07:01:37 -0700 Subject: [PATCH 107/116] feat(crawl): sell training crawlers a day pass on /crawl (x402-gateway 0.11) (#323) The crawl gateway runs first when COINPAY_X402_KEY and CRAWL_PAY_TO are set: GPTBot, ClaudeBot, headless and SEO scrapers get a 402 with PAYMENT-REQUIRED and the /crawl sales page (x402 USDC or the CoinPay Buy a day pass checkout) before the board spends a query on them. People, verified search crawlers, AI chat/search fetchers and aj_session holders pass through; /api/health stays open. A board without the two settings never sells. Co-authored-by: Claude Opus 5.5 --- package.json | 3 +- pnpm-lock.yaml | 25 +++++++++++++--- src/config.ts | 10 +++++++ src/server/app.tsx | 23 ++++++++++++++ test/crawl-gateway.test.ts | 61 ++++++++++++++++++++++++++++++++++++++ 5 files changed, 117 insertions(+), 5 deletions(-) create mode 100644 test/crawl-gateway.test.ts diff --git a/package.json b/package.json index fb73520..347e53b 100644 --- a/package.json +++ b/package.json @@ -58,12 +58,13 @@ "test:only": "node --test \"test/*.test.ts\"" }, "dependencies": { - "@profullstack/footer": "latest", "@hono/node-server": "^1.14.0", "@profullstack/emailer": "^1.0.3", + "@profullstack/footer": "latest", "@profullstack/hqtui": "^0.5.0", "@profullstack/leaderboard": "^0.3.1", "@profullstack/synconfig": "^0.1.2", + "@profullstack/x402-gateway": "^0.11.0", "@simplewebauthn/server": "^14.0.1", "hono": "^4.6.14", "pg": "^8.13.1" diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 5e880ff..78ced65 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -16,7 +16,7 @@ importers: version: 1.0.3 '@profullstack/footer': specifier: latest - version: 0.2.1 + version: 0.2.5 '@profullstack/hqtui': specifier: ^0.5.0 version: 0.5.0 @@ -26,6 +26,9 @@ importers: '@profullstack/synconfig': specifier: ^0.1.2 version: 0.1.2 + '@profullstack/x402-gateway': + specifier: ^0.11.0 + version: 0.11.0 '@simplewebauthn/server': specifier: ^14.0.1 version: 14.0.1 @@ -131,8 +134,8 @@ packages: '@profullstack/emailer@1.0.3': resolution: {integrity: sha512-VyAtCcfnSI6LOwJvWogCr3ZNmEsaZw+iuWrqnosLsdcKsbRyCrCmXigMNZJZEjlgYlR+lK//PwNPG+xtCFvWAw==} - '@profullstack/footer@0.2.1': - resolution: {integrity: sha512-KHmKVwrlzCBrSAAJ4zobNFCxTg8VF0gvNMeAut00dX3+gbWCtk6eOwIR2AaqEC7smj6Aio6cIexzt/dUnv1McA==} + '@profullstack/footer@0.2.5': + resolution: {integrity: sha512-/CKwFP3m+qM0ZFTC9Rj11fgClutJzeYliX44Qp4qwrv2JgA/1k4tVOB3mhkPhaeckUhnfg5UyESDI1uoWr9c2w==} engines: {node: '>=18'} hasBin: true peerDependencies: @@ -146,6 +149,10 @@ packages: engines: {bun: '>=1.1', node: '>=22.6'} hasBin: true + '@profullstack/keys@0.1.0': + resolution: {integrity: sha512-Vys47LvS5ivhdZu4SYOxh9Le3DEmWhjP0+CtrU45RhXAbY0ZFG/2Dk9V1bIIUGDp8UWMJqctvUD21JrNjfh04w==} + engines: {node: '>=20.11'} + '@profullstack/leaderboard@0.3.1': resolution: {integrity: sha512-LbxLwy+RvT/Qez0mfWCk4o9hvcq0kzwBZ0vF+CYp+oGvyqJWUaSTLhCHWGtKKAI3c0ZUXj6ll0iuRjbuZUE2Sg==} engines: {node: '>=20.11'} @@ -154,6 +161,10 @@ packages: resolution: {integrity: sha512-t1Pdms+k/+A7tgFCAcNx8Dry0kwboPEue9Pw2pbn/chXSMfp1dxrcFz672zWkDgvcB7YBmYpIjnvW4NkNkE4Rg==} engines: {node: '>=22'} + '@profullstack/x402-gateway@0.11.0': + resolution: {integrity: sha512-Lfrz+SRTwQZfcoCaVtaaMNPJx74Lp/5oyS7vJJAEuJmH1TjBzhE7dWquISkj1p42oc+VW5I9xH9p7YhEKqmr4Q==} + engines: {node: '>=20.11'} + '@simplewebauthn/server@14.0.1': resolution: {integrity: sha512-kjWgcm9NdSv+Tobo4Swxd1WnEawsBogpYFMjg9pKsVLPN3FdCmR6BipkL+DcPDgmQ7UKbbBZqRqn3E3YaA7NBw==} engines: {node: '>=20.0.0'} @@ -391,14 +402,20 @@ snapshots: '@profullstack/emailer@1.0.3': {} - '@profullstack/footer@0.2.1': {} + '@profullstack/footer@0.2.5': {} '@profullstack/hqtui@0.5.0': {} + '@profullstack/keys@0.1.0': {} + '@profullstack/leaderboard@0.3.1': {} '@profullstack/synconfig@0.1.2': {} + '@profullstack/x402-gateway@0.11.0': + dependencies: + '@profullstack/keys': 0.1.0 + '@simplewebauthn/server@14.0.1': dependencies: '@hexagon/base64': 1.1.28 diff --git a/src/config.ts b/src/config.ts index 68db124..3665dbb 100644 --- a/src/config.ts +++ b/src/config.ts @@ -44,6 +44,12 @@ export interface Config { * absent from every page rather than present and broken. */ coinpay: CoinPayConfig | null; + /** + * The crawl door (x402-gateway): a scoped CoinPay key and the USDC payee. Both or + * nothing; a board without them never sells crawl passes. Optional so a + * hand-built config in a test can leave it out. + */ + crawl?: { apiKey: string; payTo: string } | null; version: string; } @@ -182,6 +188,10 @@ export function loadConfig(env: NodeJS.ProcessEnv = process.env): Config { openaiApiKey: env['OPENAI_API_KEY']?.trim() || null, writerModel: env['WRITER_MODEL']?.trim() || null, coinpay: coinpayConfig(env), + crawl: + env['COINPAY_X402_KEY']?.trim() && env['CRAWL_PAY_TO']?.trim() + ? { apiKey: env['COINPAY_X402_KEY'].trim(), payTo: env['CRAWL_PAY_TO'].trim() } + : null, version: env['npm_package_version']?.trim() || VERSION, }; } diff --git a/src/server/app.tsx b/src/server/app.tsx index 844e72a..bddcbf5 100644 --- a/src/server/app.tsx +++ b/src/server/app.tsx @@ -8,6 +8,9 @@ */ import { Hono } from 'hono'; +import { SESSION_COOKIE } from '../core/auth.ts'; +import { createGateway } from '@profullstack/x402-gateway'; +import { x402Gateway } from '@profullstack/x402-gateway/hono'; import type pg from 'pg'; import type { Config } from '../config.ts'; import { apiRoutes } from './routes/api.ts'; @@ -43,6 +46,26 @@ export function createApp( const deps: Deps = { pool, config, mailer, coinpay, rankings: createRankings(pool, config) }; const app = new Hono(); + // The crawl door, first: a training crawler, headless browser or SEO scraper is + // sold a day pass ($1 over x402, or any coin / PayPal through CoinPay's hosted + // checkout on /crawl) before the board spends a database query on it. People, + // verified search crawlers and the AI chat/search fetchers pass through, as does + // anyone signed in. Ahead of the security headers, whose form-action would stop + // the /crawl/checkout redirect to CoinPay. + if (config.crawl) { + const crawlGateway = createGateway({ + siteUrl: config.publicUrl, + siteName: config.boardName, + coinpay: { apiKey: config.crawl.apiKey }, + payTo: config.crawl.payTo, + contact: 'mailto:anthony@profullstack.com', + openPaths: ['/api/health', '/llms.txt', '/.well-known/'], + exempt: (request) => + new RegExp(`(?:^|;\\s*)${SESSION_COOKIE}=`).test(request.headers.get('cookie') ?? ''), + }); + app.use('*', x402Gateway(crawlGateway)); + } + app.use('*', withViewer(deps)); // A payer is sent from a form on this board to CoinPay's hosted pay page, // and the policy has to say so or the browser stops the redirect. diff --git a/test/crawl-gateway.test.ts b/test/crawl-gateway.test.ts new file mode 100644 index 0000000..91fcb6d --- /dev/null +++ b/test/crawl-gateway.test.ts @@ -0,0 +1,61 @@ +/** + * The crawl door: training crawlers are sold a day pass before the board does + * any work for them; people are not. No database and no network: the offer is + * built locally and the 402 comes before the first query. + */ +import assert from 'node:assert/strict'; +import { test } from 'node:test'; + +const { createApp } = await import('../dist/server/app.js'); +const { loadConfig } = await import('../dist/config.js'); + +let queries = 0; +const pool = { + query: async () => { + queries += 1; + return { rows: [] }; + }, +}; +const config = loadConfig({ + PUBLIC_URL: 'https://agenticjobs.work', + COINPAY_X402_KEY: 'cp_live_test_crawl_key', + CRAWL_PAY_TO: '0xCC3b072391AE7A8d10cF00DdC5F61DB2cA5541E5', +}); +const app = createApp(pool as never, config, null, null); + +const GPTBOT = + 'Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko; compatible; GPTBot/1.2; +https://openai.com/gptbot)'; + +test('crawl config is read from COINPAY_X402_KEY and CRAWL_PAY_TO, both or nothing', () => { + assert.ok(config.crawl); + assert.equal(loadConfig({ COINPAY_X402_KEY: 'cp_live_x' }).crawl, null); +}); + +test('GPTBot gets 402 with PAYMENT-REQUIRED, before any query', async () => { + queries = 0; + const res = await app.request('/', { headers: { 'user-agent': GPTBOT, accept: 'application/json' } }); + assert.equal(res.status, 402); + assert.ok(res.headers.get('payment-required')); + assert.equal(queries, 0); +}); + +test('/crawl sells the day pass', async () => { + const res = await app.request('/crawl', { headers: { 'user-agent': 'curl/8', accept: 'application/json' } }); + assert.equal(res.status, 402); + const body = (await res.json()) as { accepts: Array<{ amount: string }> }; + assert.equal(body.accepts[0]?.amount, '1000000'); +}); + +test('a browser and the status check are not charged', async () => { + const chrome = { + 'user-agent': + 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36', + 'sec-fetch-mode': 'navigate', + 'sec-fetch-site': 'none', + 'sec-fetch-dest': 'document', + }; + const health = await app.request('/api/health', { headers: chrome }); + assert.equal(health.status, 200); + const monitor = await app.request('/api/health', { headers: { 'user-agent': 'GPTBot/1.2' } }); + assert.equal(monitor.status, 200); +}); From bd9bc9cf6bf298ceb06c9398e4edc6165fd1a1f5 Mon Sep 17 00:00:00 2001 From: Anthony Ettinger Date: Mon, 26 Oct 2026 03:54:56 -0700 Subject: [PATCH 108/116] feat(profile): shared signup profile fields via @profullstack/profile (#324) /signup asks for first_name, last_name, company_domain, job_title and linkedin_url beside the email box (plain /login never does). The fields are validated before any link is made, ride on the magic link (magic_links.profile) because the account is created when the link is spent, and are saved into the package's user_profiles table on /auth/callback. A failed save never blocks sign-in. GET/PUT/PATCH /api/v1/me/profile are the package's handlers; /me gets a private Contact details form. Migration 0024 creates user_profiles and backfills first/last name from users.name. Co-authored-by: Claude Opus 5.5 --- migrations/0024_user_profiles.sql | 38 ++++++++ package.json | 1 + pnpm-lock.yaml | 21 ++++ src/core/auth.ts | 30 ++++-- src/core/profile.ts | 69 +++++++++++++ src/server/routes/api.ts | 6 ++ src/server/routes/openapi.ts | 21 ++++ src/server/routes/pages.tsx | 98 ++++++++++++++++++- src/views/auth.tsx | 57 +++++++++++ src/views/me.tsx | 34 +++++++ test/signup-profile.test.ts | 156 ++++++++++++++++++++++++++++++ web/public/app.css | 44 ++++++++- web/public/sw.js | 2 +- 13 files changed, 566 insertions(+), 11 deletions(-) create mode 100644 migrations/0024_user_profiles.sql create mode 100644 src/core/profile.ts create mode 100644 test/signup-profile.test.ts diff --git a/migrations/0024_user_profiles.sql b/migrations/0024_user_profiles.sql new file mode 100644 index 0000000..e53c1c1 --- /dev/null +++ b/migrations/0024_user_profiles.sql @@ -0,0 +1,38 @@ +-- The shared Profullstack profile (@profullstack/profile): email, first and +-- last name, company domain, job title and LinkedIn URL, one row per member. +-- Its own table rather than columns on users, so nothing that reads users +-- (sessions, candidate pages, the API's /me) starts carrying it by accident. +-- Never public: only the member reads it, through /api/v1/me/profile and /me. + +create table if not exists "user_profiles" ( + "user_id" uuid primary key, + "email" text, + "first_name" text, + "last_name" text, + "company_domain" text, + "job_title" text, + "linkedin_url" text, + "created_at" timestamptz not null default now(), + "updated_at" timestamptz not null default now() +); +create index if not exists "user_profiles_email" on "user_profiles" (lower("email")); +create index if not exists "user_profiles_company_domain" on "user_profiles" ("company_domain"); + +-- The account does not exist until the link is followed, so what the signup +-- form validated rides on the link and is saved when it is spent. +alter table magic_links add column if not exists profile jsonb; + +-- One-time backfill: members who already have a name. First word to +-- first_name, the rest to last_name; nothing a member typed is overwritten. +insert into user_profiles (user_id, email, first_name, last_name) +select u.id, + lower(u.email), + split_part(btrim(u.name), ' ', 1), + nullif(btrim(substr(btrim(u.name), length(split_part(btrim(u.name), ' ', 1)) + 1)), '') + from users u + where nullif(btrim(u.name), '') is not null +on conflict (user_id) do update + set email = coalesce(user_profiles.email, excluded.email), + first_name = coalesce(user_profiles.first_name, excluded.first_name), + last_name = coalesce(user_profiles.last_name, excluded.last_name); + diff --git a/package.json b/package.json index 347e53b..532a02b 100644 --- a/package.json +++ b/package.json @@ -63,6 +63,7 @@ "@profullstack/footer": "latest", "@profullstack/hqtui": "^0.5.0", "@profullstack/leaderboard": "^0.3.1", + "@profullstack/profile": "0.1.3", "@profullstack/synconfig": "^0.1.2", "@profullstack/x402-gateway": "^0.11.0", "@simplewebauthn/server": "^14.0.1", diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 78ced65..11c0920 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -23,6 +23,9 @@ importers: '@profullstack/leaderboard': specifier: ^0.3.1 version: 0.3.1 + '@profullstack/profile': + specifier: 0.1.3 + version: 0.1.3 '@profullstack/synconfig': specifier: ^0.1.2 version: 0.1.2 @@ -157,6 +160,22 @@ packages: resolution: {integrity: sha512-LbxLwy+RvT/Qez0mfWCk4o9hvcq0kzwBZ0vF+CYp+oGvyqJWUaSTLhCHWGtKKAI3c0ZUXj6ll0iuRjbuZUE2Sg==} engines: {node: '>=20.11'} + '@profullstack/profile@0.1.3': + resolution: {integrity: sha512-P+VdOqCnNGWa5W8EGLU/ls3hwovRcY8bOBOhWZp3h23sW2LDMFyeWF/pUfO+iiYH3E2Tie2/9xyUnpO4ctwSHw==} + engines: {node: '>=20'} + hasBin: true + peerDependencies: + '@libsql/client': '>=0.6.0' + postgres: ^3.4.0 + react: '>=18' + peerDependenciesMeta: + '@libsql/client': + optional: true + postgres: + optional: true + react: + optional: true + '@profullstack/synconfig@0.1.2': resolution: {integrity: sha512-t1Pdms+k/+A7tgFCAcNx8Dry0kwboPEue9Pw2pbn/chXSMfp1dxrcFz672zWkDgvcB7YBmYpIjnvW4NkNkE4Rg==} engines: {node: '>=22'} @@ -410,6 +429,8 @@ snapshots: '@profullstack/leaderboard@0.3.1': {} + '@profullstack/profile@0.1.3': {} + '@profullstack/synconfig@0.1.2': {} '@profullstack/x402-gateway@0.11.0': diff --git a/src/core/auth.ts b/src/core/auth.ts index e71af54..326dda5 100644 --- a/src/core/auth.ts +++ b/src/core/auth.ts @@ -156,17 +156,29 @@ export function safeRedirect(value: unknown): string | null { return raw; } +/** + * `profile` is what a signup form validated (@profullstack/profile). The + * account does not exist until the link is spent, so it rides on the link and + * is saved by whoever consumes it. Plain sign-in passes nothing. + */ export async function startMagicLink( pool: pg.Pool, email: string, redirect: string | null, + profile: Record | null = null, ): Promise { const token = mintToken(); const result = await pool.query<{ expires_at: string }>( - `insert into magic_links (token_hash, email, redirect, expires_at) - values ($1, $2, $3, now() + ($4 || ' milliseconds')::interval) + `insert into magic_links (token_hash, email, redirect, expires_at, profile) + values ($1, $2, $3, now() + ($4 || ' milliseconds')::interval, $5::jsonb) returning expires_at`, - [hashToken(token), email, redirect, String(MAGIC_TTL_MS)], + [ + hashToken(token), + email, + redirect, + String(MAGIC_TTL_MS), + profile === null ? null : JSON.stringify(profile), + ], ); return { token, expiresAt: result.rows[0]?.expires_at ?? new Date().toISOString() }; } @@ -174,6 +186,8 @@ export async function startMagicLink( export interface ConsumedLink { user: UserRow; redirect: string | null; + /** The signup form's profile fields, when the link was asked for from /signup. */ + profile: Record | null; } /** @@ -187,17 +201,21 @@ export async function consumeMagicLink( pool: pg.Pool, token: string, ): Promise { - const claimed = await pool.query<{ email: string; redirect: string | null }>( + const claimed = await pool.query<{ + email: string; + redirect: string | null; + profile: Record | null; + }>( `update magic_links set used_at = now() where token_hash = $1 and used_at is null and expires_at > now() - returning email, redirect`, + returning email, redirect, profile`, [hashToken(token)], ); const row = claimed.rows[0]; if (row === undefined) return null; const user = await ensureUser(pool, row.email); - return { user, redirect: row.redirect }; + return { user, redirect: row.redirect, profile: row.profile ?? null }; } // --- the device flow ---------------------------------------------------- diff --git a/src/core/profile.ts b/src/core/profile.ts new file mode 100644 index 0000000..3d87c45 --- /dev/null +++ b/src/core/profile.ts @@ -0,0 +1,69 @@ +/** + * The shared Profullstack profile (@profullstack/profile): email, first and + * last name, company domain, job title and LinkedIn URL, in `user_profiles`. + * + * Asked for on /signup only, carried on the magic link (the account is created + * when the link is spent), and editable afterwards on /me and through + * GET/PUT/PATCH /api/v1/me/profile. Never shown to anyone but its owner. + */ + +import type pg from 'pg'; +import { + createProfileHandlers, + createProfileStore, + saveSignupProfile, + type ProfileStore, +} from '@profullstack/profile'; + +const stores = new WeakMap(); + +export function profileStore(pool: pg.Pool): ProfileStore { + let store = stores.get(pool); + if (store === undefined) { + store = createProfileStore(pool); + stores.set(pool, store); + } + return store; +} + +type Handlers = ReturnType; +const handlers = new WeakMap(); + +/** + * GET/PUT/PATCH /api/v1/me/profile: the package's own handlers. `getUser` + * receives the Hono context as its second argument and reads the viewer the + * session middleware already resolved. + */ +export function profileHandlers(pool: pg.Pool): Handlers { + let found = handlers.get(pool); + if (found === undefined) { + found = createProfileHandlers({ + store: profileStore(pool), + getUser: (_request, c) => { + const viewer = (c as { get(key: 'viewer'): { id: string; email: string } | null }).get( + 'viewer', + ); + return viewer === null ? null : { id: viewer.id, email: viewer.email }; + }, + }); + handlers.set(pool, found); + } + return found; +} + +/** + * Save the fields a signup carried on its link. A failure is logged and + * swallowed: it must never cost anybody their sign-in, and /me asks again. + */ +export async function saveCarriedProfile( + pool: pg.Pool, + user: { id: string; email: string }, + profile: Record | null, +): Promise { + if (profile === null) return; + try { + await saveSignupProfile(profileStore(pool), user.id, profile, { email: user.email }); + } catch (error) { + console.error('[auth] signup profile save failed:', (error as Error).message); + } +} diff --git a/src/server/routes/api.ts b/src/server/routes/api.ts index 08ca002..7ff6e65 100644 --- a/src/server/routes/api.ts +++ b/src/server/routes/api.ts @@ -77,6 +77,7 @@ import { updateResume, } from '../../core/resumes.ts'; import { importDocument, ImportProblem, MAX_UPLOAD_BYTES } from '../../core/import.ts'; +import { profileHandlers } from '../../core/profile.ts'; import { deliverMagicLink } from '../../core/mail.ts'; import { resumeForViewer, tagsFrom, toCandidateSummary, withTags } from '../../core/candidates.ts'; import { @@ -843,6 +844,11 @@ export function apiRoutes(): Hono { }); }); + // The shared profile (@profullstack/profile): names, company, title, LinkedIn. + api.get('/me/profile', (c) => profileHandlers(c.get('deps').pool).GET(c.req.raw, c)); + api.put('/me/profile', (c) => profileHandlers(c.get('deps').pool).PUT(c.req.raw, c)); + api.patch('/me/profile', (c) => profileHandlers(c.get('deps').pool).PATCH(c.req.raw, c)); + api.get('/me/jobs', async (c) => { const viewer = viewerOf(c); if (viewer === null) return fail(c, 401, 'unauthenticated', 'Sign in to read your listings.'); diff --git a/src/server/routes/openapi.ts b/src/server/routes/openapi.ts index 7dcf63e..cc01960 100644 --- a/src/server/routes/openapi.ts +++ b/src/server/routes/openapi.ts @@ -409,6 +409,27 @@ export function openApiDocument(config: Config): Record { responses: { 200: ok('The caller.'), 401: err() }, }, }, + '/api/v1/me/profile': { + get: { + tags: ['auth'], + summary: + 'Your contact details: email, first_name, last_name, company_domain, job_title, linkedin_url. Private to you.', + security: [{ bearer: [] }], + responses: { 200: ok('The profile and which fields are still missing.'), 401: err() }, + }, + put: { + tags: ['auth'], + summary: 'Replace your contact details. email, first_name and last_name are required.', + security: [{ bearer: [] }], + responses: { 200: ok('The saved profile.'), 400: err(), 401: err() }, + }, + patch: { + tags: ['auth'], + summary: 'Change only the contact fields you send; null clears one.', + security: [{ bearer: [] }], + responses: { 200: ok('The saved profile.'), 400: err(), 401: err() }, + }, + }, '/api/v1/me/jobs': { get: { tags: ['jobs'], diff --git a/src/server/routes/pages.tsx b/src/server/routes/pages.tsx index 66baf20..762f3f1 100644 --- a/src/server/routes/pages.tsx +++ b/src/server/routes/pages.tsx @@ -8,6 +8,7 @@ */ import { Hono } from 'hono'; +import { PROFILE_ENHANCE_SCRIPT, validateProfile } from '@profullstack/profile'; import type { Context } from 'hono'; import { deleteCookie, getCookie, setCookie } from 'hono/cookie'; import { @@ -69,8 +70,9 @@ import { parseResume, resumeBodyMarkdown, resumeTemplate } from '../../markup/re import { openProfileFromResume } from '../../markup/openprofile.ts'; import { Layout, type PageProps } from '../../views/layout.tsx'; import { EmployerDetail, EmployerList, JobDetail, JobList } from '../../views/jobs.tsx'; -import { DevicePage, LoginPage } from '../../views/auth.tsx'; -import { MePage, ResumeEditor } from '../../views/me.tsx'; +import { DevicePage, LoginPage, SignupPage } from '../../views/auth.tsx'; +import { profileStore, saveCarriedProfile } from '../../core/profile.ts'; +import { MePage, ProfileCard, ResumeEditor } from '../../views/me.tsx'; import { ManageJobPage, NewEmployerPage, PostJobPage } from '../../views/post.tsx'; import { NetworkPage, NetworkSearchPage } from '../../views/network.tsx'; import { DocsPage, SpecPage } from '../../views/docs.tsx'; @@ -901,6 +903,68 @@ export function pageRoutes(): Hono { ); }); + pages.get('/signup', (c) => { + if (c.get('viewer') !== null) return c.redirect('/me', 302); + const next = safeRedirect(new URL(c.req.url).searchParams.get('next')); + return c.html( + + + , + ); + }); + + /** + * Signup is a magic link with the shared profile fields on it. They are + * checked before any link exists, and a refusal goes back to the form with + * what was typed - the same answer for a known or unknown address, so it says + * nothing about who has an account. The account itself is made when the + * link is spent, which is where the fields are saved. + */ + pages.post('/signup', async (c) => { + const { pool, config, mailer } = c.get('deps'); + const form = await formOf(c); + const next = safeRedirect(form['next']); + const check = validateProfile(form); + const email = normaliseEmail(form['email']); + if (!check.ok || email === null) { + const errors: Record = { ...check.errors }; + if (email === null && errors['email'] === undefined) { + errors['email'] = 'That does not look like an email address.'; + } + return c.html( + + + , + 400, + ); + } + + const link = await startMagicLink(pool, email, next, check.profile); + const url = `${config.publicUrl}/auth/callback?token=${link.token}`; + const delivered = await deliverMagicLink({ + mailer, + boardName: config.boardName, + email, + url, + redirect: next, + }); + void sweepExpired(pool).catch(() => undefined); + return c.html( + + + , + ); + }); + + // The signup form's company-from-work-email helper (@profullstack/profile), + // served as a file because the policy allows no inline script. + pages.get('/vendor-profile.js', (c) => + c.body(PROFILE_ENHANCE_SCRIPT, 200, { + 'content-type': 'text/javascript; charset=utf-8', + 'cache-control': 'public, max-age=3600', + }), + ); + pages.post('/login', async (c) => { const { pool, config, mailer } = c.get('deps'); const form = await formOf(c); @@ -951,6 +1015,10 @@ export function pageRoutes(): Hono { ); } + // A signup's profile fields, saved now that the account exists. A failure + // is logged, never fatal: /me asks again. + await saveCarriedProfile(pool, consumed.user, consumed.profile); + const session = await createSession(pool, consumed.user.id, { label: 'browser' }); setSessionCookie(c, session); return c.redirect(consumed.redirect ?? '/me', 303); @@ -1055,6 +1123,9 @@ export function pageRoutes(): Hono { listAgents(pool, viewer.id), ]); const notice = new URL(c.req.url).searchParams.get('coinpay'); + const contact = await profileStore(pool) + .get(viewer.id) + .catch(() => null); return c.html( @@ -1076,6 +1147,10 @@ export function pageRoutes(): Hono { updateMax={BODY_MAX} recommendations={{ received, given }} > + { ); }); + /** The /me contact form; the API twin is PATCH /api/v1/me/profile. */ + pages.post('/me/profile', async (c) => { + const { pool } = c.get('deps'); + const viewer = requireViewer(c); + if (viewer instanceof Response) return viewer; + const form = await formOf(c); + const check = validateProfile({ ...form, email: form['email'] || viewer.email }); + if (!check.ok) { + return c.html( + + + , + 400, + ); + } + await profileStore(pool).save(viewer.id, check.profile); + return c.redirect('/me?profile=saved#profile', 303); + }); + /** Connect a CoinPay account: off to CoinPay, back to /api/v1/coinpay/callback. */ pages.get('/me/coinpay/connect', async (c) => { const { pool, coinpay, config } = c.get('deps'); diff --git a/src/views/auth.tsx b/src/views/auth.tsx index ac07c68..e59b2ad 100644 --- a/src/views/auth.tsx +++ b/src/views/auth.tsx @@ -6,9 +6,18 @@ * browser has WebAuthn at all. */ +import { COLUMNS as PROFILE_COLUMNS, renderProfileFields } from '@profullstack/profile'; +import { raw } from 'hono/html'; import type { FC } from 'hono/jsx'; import { Alert, Card, Field } from './layout.tsx'; +/** + * The rest of the shared profile (@profullstack/profile), asked for on /signup + * only. Email is the form's own box, so the package renders the other five. A + * plain sign-in never sees or needs them. + */ +export const SIGNUP_FIELDS = PROFILE_COLUMNS.filter((field) => field !== 'email'); + export const LoginPage: FC<{ sent?: string; error?: string; next?: string; unsent?: boolean }> = ({ sent, error, @@ -50,6 +59,9 @@ export const LoginPage: FC<{ sent?: string; error?: string; next?: string; unsen +

+ New here? Create an account. +