taskmarket-feed 1.0.0

package/README.md

@@ -0,0 +1,92 @@
+# @taskmarket/feed
+
+RSS feeds and webhook subscriptions for [TaskMarket](https://market.daydreams.systems) activity.
+
+## Features
+
+- **RSS feeds** — subscribe in any RSS reader
+  - `GET /rss/tasks/open` — live open bounties
+  - `GET /rss/tasks/completed` — recently completed tasks
+  - `GET /rss/agents/:id` — tasks for a specific agent
+- **Webhooks** — receive events via HTTP POST with HMAC-SHA256 signatures
+  - `POST /subscribe` — register a webhook URL
+  - `DELETE /subscribe/:id` — unsubscribe
+  - `GET /subscriptions` — list active subscriptions
+- **Polling** — checks TaskMarket API every 60s for new/completed tasks
+- **SQLite** — subscriptions persisted with `bun:sqlite`
+- **Retry logic** — 3 attempts with backoff on delivery failure
+
+## Quick Start
+
+```bash
+npm install -g @taskmarket/feed
+taskmarket-feed
+# Listening on port 3000
+```
+
+Or as a library:
+
+```ts
+import { createServer, startPoller } from '@taskmarket/feed';
+
+startPoller();
+const server = createServer();
+console.log(`Listening on port ${server.port}`);
+```
+
+## Webhook Payload
+
+```json
+{
+  "event": "task.new",
+  "task": { "id": "0x...", "description": "...", "reward": "5000000", ... },
+  "timestamp": "2026-03-03T12:00:00.000Z"
+}
+```
+
+Verify the signature:
+
+```ts
+import { createHmac } from 'crypto';
+
+function verify(secret: string, body: string, header: string): boolean {
+  const expected = 'sha256=' + createHmac('sha256', secret).update(body).digest('hex');
+  return header === expected;
+}
+```
+
+## Subscription Filters
+
+```json
+{
+  "url": "https://your-server.com/webhook",
+  "secret": "your-hmac-secret",
+  "filters": {
+    "events": ["task.new"],
+    "tags": ["python"],
+    "minReward": 5
+  }
+}
+```
+
+## Environment Variables
+
+| Variable          | Default             | Description                    |
+|-------------------|---------------------|--------------------------------|
+| `PORT`            | `3000`              | Server port                    |
+| `DB_PATH`         | `subscriptions.db`  | SQLite database path           |
+| `POLL_INTERVAL_MS`| `60000`             | TaskMarket poll interval (ms)  |
+
+## Deploy on Railway
+
+[![Deploy on Railway](https://railway.app/button.svg)](https://railway.app/template/taskmarket-feed)
+
+```bash
+railway login
+railway init
+railway up
+```
+
+## License
+
+MIT

package/bun.lock

@@ -0,0 +1,26 @@
+{
+  "lockfileVersion": 1,
+  "configVersion": 1,
+  "workspaces": {
+    "": {
+      "name": "feed",
+      "devDependencies": {
+        "@types/bun": "latest",
+      },
+      "peerDependencies": {
+        "typescript": "^5",
+      },
+    },
+  },
+  "packages": {
+    "@types/bun": ["@types/bun@1.3.10", "", { "dependencies": { "bun-types": "1.3.10" } }, "sha512-0+rlrUrOrTSskibryHbvQkDOWRJwJZqZlxrUs1u4oOoTln8+WIXBPmAuCF35SWB2z4Zl3E84Nl/D0P7803nigQ=="],
+
+    "@types/node": ["@types/node@25.3.3", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-DpzbrH7wIcBaJibpKo9nnSQL0MTRdnWttGyE5haGwK86xgMOkFLp7vEyfQPGLOJh5wNYiJ3V9PmUMDhV9u8kkQ=="],
+
+    "bun-types": ["bun-types@1.3.10", "", { "dependencies": { "@types/node": "*" } }, "sha512-tcpfCCl6XWo6nCVnpcVrxQ+9AYN1iqMIzgrSKYMB/fjLtV2eyAVEg7AxQJuCq/26R6HpKWykQXuSOq/21RYcbg=="],
+
+    "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
+
+    "undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="],
+  }
+}

package/index.ts

@@ -0,0 +1 @@
+console.log("Hello via Bun!");

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "taskmarket-feed",
+  "version": "1.0.0",
+  "description": "RSS feeds and webhook subscriptions for TaskMarket activity",
+  "module": "src/index.ts",
+  "main": "src/index.ts",
+  "type": "module",
+  "bin": {
+    "taskmarket-feed": "./src/server.ts"
+  },
+  "scripts": {
+    "start": "bun run src/server.ts",
+    "test": "bun test"
+  },
+  "keywords": [
+    "taskmarket",
+    "rss",
+    "webhooks",
+    "feed"
+  ],
+  "license": "MIT",
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  }
+}

package/railway.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "https://railway.app/railway.schema.json",
+  "build": {
+    "builder": "NIXPACKS"
+  },
+  "deploy": {
+    "startCommand": "bun run src/server.ts",
+    "healthcheckPath": "/health",
+    "healthcheckTimeout": 300,
+    "restartPolicyType": "ON_FAILURE",
+    "restartPolicyMaxRetries": 10
+  }
+}

package/src/db.ts

@@ -0,0 +1,93 @@
+import { Database } from 'bun:sqlite';
+import type { Subscription, SubscriptionFilters } from './types';
+import { randomUUID } from 'crypto';
+
+let _db: Database | null = null;
+
+export function getDb(path = process.env.DB_PATH || 'subscriptions.db'): Database {
+  if (!_db) {
+    _db = new Database(path);
+    _db.run(`
+      CREATE TABLE IF NOT EXISTS subscriptions (
+        id          TEXT PRIMARY KEY,
+        url         TEXT NOT NULL,
+        secret      TEXT NOT NULL,
+        filters     TEXT NOT NULL DEFAULT '{}',
+        created_at  TEXT NOT NULL,
+        fail_count  INTEGER NOT NULL DEFAULT 0,
+        last_delivery TEXT
+      )
+    `);
+  }
+  return _db;
+}
+
+export function resetDb() { _db = null; }
+
+export function createSubscription(
+  url: string,
+  secret: string,
+  filters: SubscriptionFilters = {}
+): Subscription {
+  const db  = getDb();
+  const sub: Subscription = {
+    id:          randomUUID(),
+    url,
+    secret,
+    filters,
+    createdAt:   new Date().toISOString(),
+    failCount:   0,
+    lastDelivery: null,
+  };
+  db.run(
+    `INSERT INTO subscriptions (id, url, secret, filters, created_at, fail_count, last_delivery)
+     VALUES (?, ?, ?, ?, ?, 0, NULL)`,
+    [sub.id, sub.url, sub.secret, JSON.stringify(sub.filters), sub.createdAt]
+  );
+  return sub;
+}
+
+export function getSubscription(id: string): Subscription | null {
+  const db  = getDb();
+  const row = db.query('SELECT * FROM subscriptions WHERE id = ?').get(id) as any;
+  return row ? rowToSub(row) : null;
+}
+
+export function getAllSubscriptions(): Subscription[] {
+  const db   = getDb();
+  const rows = db.query('SELECT * FROM subscriptions').all() as any[];
+  return rows.map(rowToSub);
+}
+
+export function deleteSubscription(id: string): boolean {
+  const db = getDb();
+  const r  = db.run('DELETE FROM subscriptions WHERE id = ?', [id]);
+  return r.changes > 0;
+}
+
+export function recordDelivery(id: string, success: boolean): void {
+  const db = getDb();
+  if (success) {
+    db.run(
+      'UPDATE subscriptions SET fail_count = 0, last_delivery = ? WHERE id = ?',
+      [new Date().toISOString(), id]
+    );
+  } else {
+    db.run(
+      'UPDATE subscriptions SET fail_count = fail_count + 1 WHERE id = ?',
+      [id]
+    );
+  }
+}
+
+function rowToSub(row: any): Subscription {
+  return {
+    id:          row.id,
+    url:         row.url,
+    secret:      row.secret,
+    filters:     JSON.parse(row.filters || '{}'),
+    createdAt:   row.created_at,
+    failCount:   row.fail_count,
+    lastDelivery: row.last_delivery,
+  };
+}

package/src/feed.test.ts

@@ -0,0 +1,308 @@
+import { describe, it, expect, beforeEach, afterEach, mock } from 'bun:test';
+import { buildFeed } from './rss';
+import { signPayload, matchesFilter, matchesEvent } from './webhooks';
+import {
+  getDb, resetDb,
+  createSubscription, getSubscription,
+  getAllSubscriptions, deleteSubscription, recordDelivery,
+} from './db';
+import { createServer } from './server';
+import { resetPoller } from './poller';
+import type { Task, SubscriptionFilters } from './types';
+
+// ── Fixtures ──────────────────────────────────────────────────────────────────
+
+function makeTask(overrides: Partial<Task> = {}): Task {
+  return {
+    id:               '0xabc123',
+    requester:        '0xDeAdBeEf',
+    description:      'Write a Python script to scrape data and output CSV',
+    reward:           '5000000',   // $5 USDC
+    status:           'open',
+    mode:             'bounty',
+    tags:             ['python', 'data'],
+    createdAt:        '2026-03-01T10:00:00.000Z',
+    expiryTime:       '2026-03-07T10:00:00.000Z',
+    submissionCount:  0,
+    worker:           null,
+    workerAgentId:    null,
+    requesterAgentId: '12345',
+    ...overrides,
+  };
+}
+
+// ── 1. RSS: valid XML structure ───────────────────────────────────────────────
+
+describe('RSS Feed', () => {
+  it('produces valid XML declaration', () => {
+    const xml = buildFeed('Test', 'Desc', 'http://example.com', []);
+    expect(xml).toStartWith('<?xml version="1.0" encoding="UTF-8"?>');
+  });
+
+  it('includes rss version 2.0', () => {
+    const xml = buildFeed('Test', 'Desc', 'http://example.com', []);
+    expect(xml).toContain('version="2.0"');
+  });
+
+  it('renders channel title and description', () => {
+    const xml = buildFeed('My Title', 'My Desc', 'http://example.com', []);
+    expect(xml).toContain('<title>My Title</title>');
+    expect(xml).toContain('<description>My Desc</description>');
+  });
+
+  it('renders one item per task', () => {
+    const xml = buildFeed('T', 'D', 'http://example.com', [makeTask(), makeTask({ id: '0xdef456' })]);
+    expect(xml.match(/<item>/g)?.length).toBe(2);
+  });
+
+  it('escapes HTML special chars in description', () => {
+    const task = makeTask({ description: '<script>alert("xss")</script>' });
+    const xml  = buildFeed('T', 'D', 'http://example.com', [task]);
+    expect(xml).not.toContain('<script>');
+    expect(xml).toContain('&lt;script&gt;');
+  });
+
+  it('includes task id as guid', () => {
+    const task = makeTask({ id: '0xdeadbeef' });
+    const xml  = buildFeed('T', 'D', 'http://example.com', [task]);
+    expect(xml).toContain('<guid isPermaLink="false">0xdeadbeef</guid>');
+  });
+
+  it('includes reward in item title', () => {
+    const task = makeTask({ reward: '10000000' }); // $10
+    const xml  = buildFeed('T', 'D', 'http://example.com', [task]);
+    expect(xml).toContain('$10.00 USDC');
+  });
+
+  it('returns empty channel with no tasks', () => {
+    const xml = buildFeed('T', 'D', 'http://example.com', []);
+    expect(xml).toContain('<channel>');
+    expect(xml).not.toContain('<item>');
+  });
+});
+
+// ── 2. HMAC generation ────────────────────────────────────────────────────────
+
+describe('HMAC Signing', () => {
+  it('produces sha256= prefix', () => {
+    const sig = signPayload('mysecret', '{"event":"task.new"}');
+    expect(sig).toStartWith('sha256=');
+  });
+
+  it('produces consistent signature for same input', () => {
+    const body = '{"event":"task.new","task":{}}';
+    expect(signPayload('secret', body)).toBe(signPayload('secret', body));
+  });
+
+  it('produces different signature for different secrets', () => {
+    const body = '{"event":"task.new"}';
+    expect(signPayload('secret1', body)).not.toBe(signPayload('secret2', body));
+  });
+
+  it('produces different signature for different bodies', () => {
+    const sig1 = signPayload('secret', '{"event":"task.new"}');
+    const sig2 = signPayload('secret', '{"event":"task.completed"}');
+    expect(sig1).not.toBe(sig2);
+  });
+
+  it('produces 71-char string (sha256= + 64 hex)', () => {
+    const sig = signPayload('secret', 'body');
+    expect(sig.length).toBe(71);
+  });
+});
+
+// ── 3. Filter evaluation ──────────────────────────────────────────────────────
+
+describe('Subscription Filters', () => {
+  it('passes task with no filters set', () => {
+    expect(matchesFilter(makeTask(), {})).toBe(true);
+  });
+
+  it('passes task matching required tag', () => {
+    expect(matchesFilter(makeTask({ tags: ['python'] }), { tags: ['python'] })).toBe(true);
+  });
+
+  it('fails task missing required tag', () => {
+    expect(matchesFilter(makeTask({ tags: ['js'] }), { tags: ['python'] })).toBe(false);
+  });
+
+  it('passes task above minReward', () => {
+    expect(matchesFilter(makeTask({ reward: '5000000' }), { minReward: 4 })).toBe(true);
+  });
+
+  it('fails task below minReward', () => {
+    expect(matchesFilter(makeTask({ reward: '1000000' }), { minReward: 5 })).toBe(false);
+  });
+
+  it('passes exact minReward boundary', () => {
+    expect(matchesFilter(makeTask({ reward: '5000000' }), { minReward: 5 })).toBe(true);
+  });
+
+  it('matchesEvent passes when no event filter', () => {
+    expect(matchesEvent('task.new', {})).toBe(true);
+  });
+
+  it('matchesEvent passes matching event', () => {
+    expect(matchesEvent('task.new', { events: ['task.new', 'task.completed'] })).toBe(true);
+  });
+
+  it('matchesEvent fails non-matching event', () => {
+    expect(matchesEvent('task.accepted', { events: ['task.new'] })).toBe(false);
+  });
+});
+
+// ── 4. Database operations ────────────────────────────────────────────────────
+
+describe('Database', () => {
+  beforeEach(() => {
+    resetDb();
+    process.env.DB_PATH = ':memory:';
+  });
+  afterEach(() => resetDb());
+
+  it('creates a subscription', () => {
+    const sub = createSubscription('https://example.com/hook', 'secret', {});
+    expect(sub.id).toBeTruthy();
+    expect(sub.url).toBe('https://example.com/hook');
+    expect(sub.failCount).toBe(0);
+  });
+
+  it('retrieves created subscription by id', () => {
+    const sub  = createSubscription('https://example.com/hook', 'sec', {});
+    const fetched = getSubscription(sub.id);
+    expect(fetched?.id).toBe(sub.id);
+  });
+
+  it('returns null for unknown subscription', () => {
+    expect(getSubscription('nonexistent')).toBeNull();
+  });
+
+  it('lists all subscriptions', () => {
+    createSubscription('https://a.com', 'sec1', {});
+    createSubscription('https://b.com', 'sec2', {});
+    expect(getAllSubscriptions().length).toBe(2);
+  });
+
+  it('deletes a subscription', () => {
+    const sub = createSubscription('https://example.com', 'sec', {});
+    expect(deleteSubscription(sub.id)).toBe(true);
+    expect(getSubscription(sub.id)).toBeNull();
+  });
+
+  it('returns false deleting unknown subscription', () => {
+    expect(deleteSubscription('nonexistent')).toBe(false);
+  });
+
+  it('increments fail_count on failed delivery', () => {
+    const sub = createSubscription('https://example.com', 'sec', {});
+    recordDelivery(sub.id, false);
+    expect(getSubscription(sub.id)?.failCount).toBe(1);
+  });
+
+  it('resets fail_count on successful delivery', () => {
+    const sub = createSubscription('https://example.com', 'sec', {});
+    recordDelivery(sub.id, false);
+    recordDelivery(sub.id, false);
+    recordDelivery(sub.id, true);
+    expect(getSubscription(sub.id)?.failCount).toBe(0);
+  });
+
+  it('stores and retrieves filters correctly', () => {
+    const filters: SubscriptionFilters = { events: ['task.new'], minReward: 10 };
+    const sub = createSubscription('https://example.com', 'sec', filters);
+    const fetched = getSubscription(sub.id);
+    expect(fetched?.filters).toEqual(filters);
+  });
+});
+
+// ── 5. HTTP Server endpoints ──────────────────────────────────────────────────
+
+describe('HTTP Server', () => {
+  let server: ReturnType<typeof createServer>;
+
+  beforeEach(() => {
+    resetDb();
+    resetPoller();
+    process.env.DB_PATH = ':memory:';
+    process.env.PORT    = '0'; // random port
+    server = createServer();
+  });
+  afterEach(() => { server.stop(true); resetDb(); });
+
+  async function req(path: string, opts?: RequestInit) {
+    return fetch(`http://localhost:${server.port}${path}`, opts);
+  }
+
+  it('GET /health returns ok', async () => {
+    const res  = await req('/health');
+    const data = await res.json() as any;
+    expect(res.status).toBe(200);
+    expect(data.ok).toBe(true);
+  });
+
+  it('POST /subscribe creates subscription', async () => {
+    const res  = await req('/subscribe', {
+      method:  'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body:    JSON.stringify({ url: 'https://example.com/hook', secret: 'sec' }),
+    });
+    expect(res.status).toBe(201);
+    const data = await res.json() as any;
+    expect(data.ok).toBe(true);
+    expect(data.id).toBeTruthy();
+  });
+
+  it('POST /subscribe rejects missing url', async () => {
+    const res = await req('/subscribe', {
+      method:  'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body:    JSON.stringify({ secret: 'sec' }),
+    });
+    expect(res.status).toBe(400);
+  });
+
+  it('POST /subscribe rejects invalid url', async () => {
+    const res = await req('/subscribe', {
+      method:  'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body:    JSON.stringify({ url: 'not-a-url', secret: 'sec' }),
+    });
+    expect(res.status).toBe(400);
+  });
+
+  it('GET /subscriptions returns list', async () => {
+    await req('/subscribe', {
+      method:  'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body:    JSON.stringify({ url: 'https://example.com/hook', secret: 'sec' }),
+    });
+    const res  = await req('/subscriptions');
+    const data = await res.json() as any;
+    expect(data.subscriptions.length).toBe(1);
+    expect(data.subscriptions[0].url).toBe('https://example.com/hook');
+    expect(data.subscriptions[0].secret).toBeUndefined(); // never expose secret
+  });
+
+  it('DELETE /subscribe/:id removes subscription', async () => {
+    const create = await req('/subscribe', {
+      method:  'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body:    JSON.stringify({ url: 'https://example.com/hook', secret: 'sec' }),
+    });
+    const { id } = await create.json() as any;
+    const del = await req(`/subscribe/${id}`, { method: 'DELETE' });
+    expect(del.status).toBe(200);
+    const list = await (await req('/subscriptions')).json() as any;
+    expect(list.subscriptions.length).toBe(0);
+  });
+
+  it('DELETE /subscribe/:id returns 404 for unknown id', async () => {
+    const res = await req('/subscribe/nonexistent', { method: 'DELETE' });
+    expect(res.status).toBe(404);
+  });
+
+  it('unknown routes return 404', async () => {
+    const res = await req('/notaroute');
+    expect(res.status).toBe(404);
+  });
+});

package/src/index.ts

@@ -0,0 +1,6 @@
+export { buildFeed, fetchTasks, fetchAgentTasks } from './rss';
+export { signPayload, dispatch, matchesFilter, matchesEvent } from './webhooks';
+export { createSubscription, getAllSubscriptions, deleteSubscription, recordDelivery, getDb } from './db';
+export { startPoller, stopPoller, poll, resetPoller } from './poller';
+export { createServer } from './server';
+export type { Task, Subscription, SubscriptionFilters, WebhookPayload, EventType } from './types';

package/src/poller.ts

@@ -0,0 +1,71 @@
+import { dispatch } from './webhooks';
+import { fetchTasks } from './rss';
+import type { Task } from './types';
+
+const POLL_INTERVAL = parseInt(process.env.POLL_INTERVAL_MS || '60000', 10);
+
+let knownOpen      = new Map<string, Task>();
+let knownCompleted = new Set<string>();
+let pollTimer: Timer | null = null;
+
+export async function poll(): Promise<void> {
+  try {
+    const [open, completed] = await Promise.all([
+      fetchTasks('open'),
+      fetchTasks('completed'),
+    ]);
+
+    // Detect new open tasks
+    for (const task of open) {
+      if (!knownOpen.has(task.id)) {
+        knownOpen.set(task.id, task);
+        await dispatch('task.new', task);
+      }
+    }
+
+    // Detect newly completed tasks
+    for (const task of completed) {
+      if (!knownCompleted.has(task.id)) {
+        knownCompleted.add(task.id);
+        await dispatch('task.completed', task);
+      }
+    }
+
+    // Detect tasks that moved from open → accepted
+    for (const [id, task] of knownOpen) {
+      const stillOpen = open.find(t => t.id === id);
+      if (!stillOpen && task.status !== 'completed') {
+        knownOpen.delete(id);
+        // Re-fetch to get current status
+        try {
+          const res  = await fetch(`https://api-market.daydreams.systems/api/tasks/${id}`);
+          const data = await res.json() as any;
+          const updated: Task = data.data || data;
+          if (updated.status === 'accepted') {
+            await dispatch('task.accepted', updated);
+          }
+        } catch {}
+      }
+    }
+  } catch (e) {
+    console.error('[poller] error:', e);
+  }
+}
+
+export function startPoller(): void {
+  poll(); // immediate first run
+  pollTimer = setInterval(poll, POLL_INTERVAL);
+  console.log(`[poller] polling every ${POLL_INTERVAL / 1000}s`);
+}
+
+export function stopPoller(): void {
+  if (pollTimer) {
+    clearInterval(pollTimer);
+    pollTimer = null;
+  }
+}
+
+export function resetPoller(): void {
+  knownOpen      = new Map();
+  knownCompleted = new Set();
+}

package/src/rss.ts

@@ -0,0 +1,81 @@
+import type { Task } from './types';
+
+const API_BASE = 'https://api-market.daydreams.systems';
+
+function esc(s: string): string {
+  return s
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&apos;');
+}
+
+function rewardUsdc(task: Task): string {
+  return (parseInt(task.reward, 10) / 1_000_000).toFixed(2);
+}
+
+function taskToItem(task: Task): string {
+  const link  = `https://market.daydreams.systems/tasks/${task.id}`;
+  const title = esc(`[${task.mode}] $${rewardUsdc(task)} USDC — ${task.description.slice(0, 80)}`);
+  const desc  = esc(task.description);
+  const pubDate = new Date(task.createdAt).toUTCString();
+  return `    <item>
+      <title>${title}</title>
+      <link>${link}</link>
+      <guid isPermaLink="false">${task.id}</guid>
+      <pubDate>${pubDate}</pubDate>
+      <description>${desc}</description>
+      <category>${esc(task.mode)}</category>
+    </item>`;
+}
+
+export function buildFeed(
+  title: string,
+  description: string,
+  link: string,
+  tasks: Task[]
+): string {
+  const items   = tasks.map(taskToItem).join('\n');
+  const updated = new Date().toUTCString();
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
+  <channel>
+    <title>${esc(title)}</title>
+    <description>${esc(description)}</description>
+    <link>${link}</link>
+    <atom:link href="${link}" rel="self" type="application/rss+xml"/>
+    <lastBuildDate>${updated}</lastBuildDate>
+    <generator>@taskmarket/feed</generator>
+${items}
+  </channel>
+</rss>`;
+}
+
+export async function fetchTasks(status?: string, agentId?: string): Promise<Task[]> {
+  try {
+    const params = new URLSearchParams({ limit: '50' });
+    if (status)  params.set('status', status);
+    if (agentId) params.set('agentId', agentId);
+    const res  = await fetch(`${API_BASE}/api/tasks?${params}`);
+    const data = await res.json() as any;
+    return (data.tasks || data.data?.tasks || []) as Task[];
+  } catch {
+    return [];
+  }
+}
+
+export async function fetchAgentTasks(agentId: string): Promise<Task[]> {
+  // Fetch tasks created by or assigned to this agent
+  const [asRequester, asWorker] = await Promise.all([
+    fetchTasks(undefined, agentId),
+    fetchTasks(undefined, undefined),
+  ]);
+  const byWorker = asWorker.filter(t => t.workerAgentId === agentId || t.requesterAgentId === agentId);
+  const seen = new Set<string>();
+  return [...asRequester, ...byWorker].filter(t => {
+    if (seen.has(t.id)) return false;
+    seen.add(t.id);
+    return true;
+  });
+}

package/src/server.ts

@@ -0,0 +1,114 @@
+import { createSubscription, getAllSubscriptions, deleteSubscription } from './db';
+import { buildFeed, fetchTasks, fetchAgentTasks } from './rss';
+import { startPoller } from './poller';
+
+const PORT = parseInt(process.env.PORT || '3000', 10);
+
+export function createServer() {
+  return Bun.serve({
+    port: PORT,
+    async fetch(req: Request): Promise<Response> {
+      const url      = new URL(req.url);
+      const { pathname } = url;
+      const method   = req.method.toUpperCase();
+
+      // ── RSS feeds ──────────────────────────────────────────────────────────
+
+      if (method === 'GET' && pathname === '/rss/tasks/open') {
+        const tasks = await fetchTasks('open');
+        const xml   = buildFeed(
+          'TaskMarket — Open Tasks',
+          'Live feed of open bounties on TaskMarket',
+          `${req.headers.get('origin') || ''}${pathname}`,
+          tasks
+        );
+        return new Response(xml, {
+          headers: { 'Content-Type': 'application/rss+xml; charset=utf-8' }
+        });
+      }
+
+      if (method === 'GET' && pathname === '/rss/tasks/completed') {
+        const tasks = await fetchTasks('completed');
+        const xml   = buildFeed(
+          'TaskMarket — Completed Tasks',
+          'Recently completed tasks on TaskMarket',
+          `${req.headers.get('origin') || ''}${pathname}`,
+          tasks
+        );
+        return new Response(xml, {
+          headers: { 'Content-Type': 'application/rss+xml; charset=utf-8' }
+        });
+      }
+
+      if (method === 'GET' && pathname.startsWith('/rss/agents/')) {
+        const agentId = pathname.split('/rss/agents/')[1];
+        if (!agentId) return json({ error: 'missing agentId' }, 400);
+        const tasks = await fetchAgentTasks(agentId);
+        const xml   = buildFeed(
+          `TaskMarket — Agent ${agentId}`,
+          `Tasks for agent ${agentId}`,
+          `${req.headers.get('origin') || ''}${pathname}`,
+          tasks
+        );
+        return new Response(xml, {
+          headers: { 'Content-Type': 'application/rss+xml; charset=utf-8' }
+        });
+      }
+
+      // ── Webhook subscriptions ──────────────────────────────────────────────
+
+      if (method === 'POST' && pathname === '/subscribe') {
+        let body: any;
+        try { body = await req.json(); } catch { return json({ error: 'invalid JSON' }, 400); }
+        const { url: hookUrl, secret, filters } = body;
+        if (!hookUrl || !secret) return json({ error: 'url and secret are required' }, 400);
+        try { new URL(hookUrl); } catch { return json({ error: 'invalid url' }, 400); }
+        const sub = createSubscription(hookUrl, secret, filters || {});
+        return json({ ok: true, id: sub.id }, 201);
+      }
+
+      if (method === 'GET' && pathname === '/subscriptions') {
+        const subs = getAllSubscriptions().map(s => ({
+          id:          s.id,
+          url:         s.url,
+          filters:     s.filters,
+          createdAt:   s.createdAt,
+          failCount:   s.failCount,
+          lastDelivery: s.lastDelivery,
+          // never expose secret
+        }));
+        return json({ ok: true, subscriptions: subs });
+      }
+
+      if (method === 'DELETE' && pathname.startsWith('/subscribe/')) {
+        const id = pathname.split('/subscribe/')[1];
+        if (!id) return json({ error: 'missing id' }, 400);
+        const removed = deleteSubscription(id);
+        if (!removed) return json({ error: 'not found' }, 404);
+        return json({ ok: true });
+      }
+
+      // ── Health ─────────────────────────────────────────────────────────────
+
+      if (method === 'GET' && pathname === '/health') {
+        return json({ ok: true, service: '@taskmarket/feed' });
+      }
+
+      return json({ error: 'not found' }, 404);
+    },
+  });
+}
+
+function json(data: unknown, status = 200): Response {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: { 'Content-Type': 'application/json' }
+  });
+}
+
+// ── Entry point ───────────────────────────────────────────────────────────────
+if (import.meta.main) {
+  startPoller();
+  const server = createServer();
+  console.log(`[@taskmarket/feed] listening on port ${server.port}`);
+}

package/src/types.ts

@@ -0,0 +1,39 @@
+export interface Task {
+  id: string;
+  requester: string;
+  description: string;
+  reward: string;
+  status: string;
+  mode: string;
+  tags: string[];
+  createdAt: string;
+  expiryTime: string;
+  submissionCount: number;
+  worker: string | null;
+  workerAgentId: string | null;
+  requesterAgentId: string | null;
+}
+
+export interface Subscription {
+  id: string;
+  url: string;
+  secret: string;
+  filters: SubscriptionFilters;
+  createdAt: string;
+  failCount: number;
+  lastDelivery: string | null;
+}
+
+export interface SubscriptionFilters {
+  events?: string[];   // e.g. ['task.new', 'task.completed']
+  tags?: string[];     // only tasks matching these tags
+  minReward?: number;  // minimum reward in USDC (full units)
+}
+
+export interface WebhookPayload {
+  event: string;
+  task: Task;
+  timestamp: string;
+}
+
+export type EventType = 'task.new' | 'task.completed' | 'task.accepted';

package/src/webhooks.ts

@@ -0,0 +1,81 @@
+import { createHmac } from 'crypto';
+import { getAllSubscriptions, recordDelivery } from './db';
+import type { Subscription, WebhookPayload, EventType, Task, SubscriptionFilters } from './types';
+
+const MAX_RETRIES   = 3;
+const RETRY_DELAYS  = [1000, 5000, 15000]; // ms
+const MAX_FAIL_COUNT = 10; // disable after 10 consecutive failures
+
+export function signPayload(secret: string, body: string): string {
+  return 'sha256=' + createHmac('sha256', secret).update(body).digest('hex');
+}
+
+export function matchesFilter(task: Task, filters: SubscriptionFilters): boolean {
+  if (filters.tags && filters.tags.length > 0) {
+    const hasTag = filters.tags.some(t => task.tags.includes(t));
+    if (!hasTag) return false;
+  }
+  if (filters.minReward !== undefined) {
+    const rewardUsdc = parseInt(task.reward, 10) / 1_000_000;
+    if (rewardUsdc < filters.minReward) return false;
+  }
+  return true;
+}
+
+export function matchesEvent(event: string, filters: SubscriptionFilters): boolean {
+  if (!filters.events || filters.events.length === 0) return true;
+  return filters.events.includes(event);
+}
+
+async function deliverOnce(url: string, body: string, sig: string): Promise<boolean> {
+  try {
+    const res = await fetch(url, {
+      method:  'POST',
+      headers: {
+        'Content-Type':            'application/json',
+        'X-TaskMarket-Signature':  sig,
+      },
+      body,
+      signal: AbortSignal.timeout(10_000),
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+
+async function deliverWithRetry(
+  sub: Subscription,
+  body: string,
+  sig: string
+): Promise<boolean> {
+  for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+    if (attempt > 0) {
+      await new Promise(r => setTimeout(r, RETRY_DELAYS[attempt - 1]));
+    }
+    const ok = await deliverOnce(sub.url, body, sig);
+    if (ok) return true;
+  }
+  return false;
+}
+
+export async function dispatch(event: EventType, task: Task): Promise<void> {
+  const subs = getAllSubscriptions();
+  const payload: WebhookPayload = { event, task, timestamp: new Date().toISOString() };
+  const body  = JSON.stringify(payload);
+
+  await Promise.allSettled(subs.map(async (sub) => {
+    // Skip subscriptions with too many failures
+    if (sub.failCount >= MAX_FAIL_COUNT) return;
+
+    // Filter by event type
+    if (!matchesEvent(event, sub.filters)) return;
+
+    // Filter by task properties
+    if (!matchesFilter(task, sub.filters)) return;
+
+    const sig = signPayload(sub.secret, body);
+    const ok  = await deliverWithRetry(sub, body, sig);
+    recordDelivery(sub.id, ok);
+  }));
+}

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}