agentclick 0.1.0

package/AGENTS.md

@@ -0,0 +1,146 @@
+# AgentClick — Claude Code Context
+
+## What This Project Is
+
+AgentClick is a human-in-the-loop UI layer for AI agents. Agents POST structured data here; users review/approve/edit in the browser; results callback to the agent. AgentClick never connects directly to email or external services — all data flows through the agent.
+
+GitHub: https://github.com/agentlayer-io/AgentClick
+
+---
+
+## Start the Dev Server
+
+```bash
+npm run dev
+# Server: http://localhost:3001
+# UI:     http://localhost:5173
+```
+
+The server auto-loads root `.env` via `dotenv` for `PORT` and `OPENCLAW_WEBHOOK` overrides.
+
+Production-style local run (single port):
+
+```bash
+npm run build
+npm start
+# API + UI: http://localhost:3001
+```
+
+Global CLI install target (packaging in progress):
+
+```bash
+npm install -g agentclick
+agentclick
+```
+
+Deployment / production notes:
+- `docs/deployment.md` (single-port serving, `.env`, Nginx reverse proxy example, Docker/OpenClaw host mapping)
+
+To test without a live agent, POST a mock session:
+
+```bash
+curl -s -X POST http://localhost:3001/api/review \
+  -H "Content-Type: application/json" \
+  -d '{
+    "type": "email_review",
+    "sessionKey": "test-key",
+    "payload": {
+      "inbox": [
+        { "id": "e1", "from": "john@example.com", "subject": "Q1 Follow-up",
+          "preview": "Hi, just wanted to follow up...", "category": "Work",
+          "isRead": false, "timestamp": 1771747653333 }
+      ],
+      "draft": {
+        "replyTo": "e1", "to": "john@example.com",
+        "subject": "Re: Q1 Follow-up",
+        "paragraphs": [
+          { "id": "p1", "content": "Hi John, thanks for following up." },
+          { "id": "p2", "content": "We are aligned on the timeline." },
+          { "id": "p3", "content": "Let me know if anything else is needed." }
+        ]
+      }
+    }
+  }'
+# Browser opens automatically to the review session
+```
+
+---
+
+## Key Files
+
+| File | Purpose |
+|------|---------|
+| `packages/server/src/index.ts` | Express API: all routes, long-poll `/wait` endpoint, browser auto-open |
+| `packages/server/src/store.ts` | SQLite session store via `better-sqlite3` → `~/.openclaw/clawui-sessions.db` |
+| `packages/server/src/preference.ts` | Writes AVOID rules to `~/.openclaw/workspace/MEMORY.md` |
+| `packages/web/src/pages/ReviewPage.tsx` | Main UI — two-column inbox + draft review (Format B) and legacy single-column (Format A) |
+| `packages/web/src/pages/ApprovalPage.tsx` | Action approval UI |
+| `packages/web/src/pages/CodeReviewPage.tsx` | Shell command review UI |
+| `packages/web/src/pages/HomePage.tsx` | Session history list |
+| `skills/` | OpenClaw SKILL.md files (use `host.docker.internal:3001` if OpenClaw runs in Docker) |
+| `scripts/demo.sh` | One-command test: `./scripts/demo.sh [email\|approval\|code]` |
+| `scripts/install-skills.sh` | Copies skills to `~/.openclaw/skills/` and `~/.openclaw/workspace/skills/` |
+
+---
+
+## API Shape
+
+**POST /api/review** — agent creates a session, browser opens automatically
+**GET /api/sessions** — list sessions (max 20, sorted by createdAt desc)
+**GET /api/sessions/:id** — get single session
+**GET /api/sessions/:id/wait** — long-poll, blocks up to 5 min until user submits (agent calls this to wait for review result)
+**POST /api/sessions/:id/complete** — UI submits user decision
+
+OpenClaw webhook (optional): `POST http://localhost:18789/hooks/agent`
+Body: `{ message: string, sessionKey: string, deliver: true }`
+
+> For agents running in Docker: use `host.docker.internal:3001` instead of `localhost:3001`.
+
+---
+
+## Two Payload Formats
+
+**Format A (legacy):** `{ to, subject, paragraphs[] }`
+**Format B (v2):** `{ inbox[], draft: { replyTo, to, subject, paragraphs[], ccSuggestions? } }`
+
+`ReviewPage.tsx` auto-detects via `'inbox' in payload`.
+
+---
+
+## Rules
+
+Read `docs/dev-rules.md` before writing any code. Key rules:
+- TypeScript only, no `any`
+- Tailwind only, no inline styles
+- Linear/Vercel aesthetic: zinc/gray palette, `shadow-sm` max, no gradients
+- Commit format: `type: short description` (no emoji, no Claude attribution)
+- No over-abstraction — if one file handles it, keep it in one file
+
+---
+
+## What's Done / What's Pending
+
+**Done:**
+- ReviewPage v2 (two-column inbox + draft), ApprovalPage, CodeReviewPage, HomePage
+- Preference learning (writes AVOID rules to MEMORY.md on paragraph delete)
+- Risk-based color grading on session history
+- SQLite session persistence (`~/.openclaw/clawui-sessions.db`)
+- Long-poll `/wait` endpoint for agent integration
+- Keyboard shortcuts: `Escape` closes dropdown, `Cmd+Enter` submits
+- End-to-end tested with OpenClaw (Docker) via Feishu — full loop verified
+- Production single-port serving (`npm run build && npm start`)
+- Minimal CI build workflow (GitHub Actions: `npm ci && npm run build`)
+- Deployment guide (`docs/deployment.md`) for single-port runtime, env vars, reverse proxy, and Docker/OpenClaw notes
+- Global CLI packaging entrypoint (`bin/agentclick.mjs`) for `agentclick` command startup
+
+**Pending:**
+- npm publish execution (`npm publish`) after final package review
+- CC suggestions as checkboxes (currently free-text input; agent can pass `ccSuggestions[]`)
+
+---
+
+## Recent Verification
+
+- 2026-02-23 (local): Verified API session creation for `email_review`, `action_approval`, and `code_review` via `scripts/demo.sh`.
+- 2026-02-23 (local): Verified `create -> GET session (pending) -> complete -> /wait (completed)` flow on `action_approval`.
+- 2026-02-23 (local): Verified single-port production mode (`npm run build && PORT=3101 npm start`) serves `/`, SPA fallback routes, `/api/*`, and returns single-port review URLs.

package/README.md

@@ -0,0 +1,148 @@
+# AgentClick
+
+**Rich web UI for AI agent interactions — click to edit, human-in-the-loop, preference learning.**
+
+[![GitHub stars](https://img.shields.io/github/stars/agentlayer-io/AgentClick?style=flat-square)](https://github.com/agentlayer-io/AgentClick/stargazers)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=flat-square)](LICENSE)
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](https://github.com/agentlayer-io/AgentClick/pulls)
+
+---
+
+## The Problem
+
+Every OpenClaw user interacts with their agent through text chat (WhatsApp / Telegram). Text is a degraded interface:
+
+- You can't click a paragraph and say "rewrite this"
+- You can't drag steps to reorder them
+- Every correction requires typing out instructions again
+- The agent never remembers your preferences
+
+## The Solution
+
+When your agent finishes a task that needs your input, it opens a browser page — a purpose-built interaction UI. You click, choose, drag. No typing.
+
+```
+Agent finishes email draft
+  → Browser opens automatically
+  → You click paragraph → choose: Delete / Rewrite / Keep
+  → You confirm
+  → Agent continues, remembers your choices for next time
+```
+
+Every interaction teaches the agent your preferences. The more you use it, the less you need to explain.
+
+---
+
+## Current Status
+
+This project is already in a working prototype stage and supports multiple review flows end-to-end.
+
+Implemented:
+
+- Email review UI (legacy single-column + v2 inbox + draft layout)
+- Action approval UI (approve/reject + note)
+- Code/shell command review UI
+- Session history homepage with recent sessions
+- SQLite session persistence (`~/.openclaw/clawui-sessions.db`)
+- Long-poll wait endpoint for agent integration (`/api/sessions/:id/wait`)
+- Preference learning from paragraph deletions (writes rules to `MEMORY.md`)
+- Keyboard shortcuts (`Cmd/Ctrl+Enter` submit, `Escape` handling)
+- Browser auto-open on session creation
+
+---
+
+## Quick Start
+
+```bash
+git clone https://github.com/agentlayer-io/AgentClick.git
+cd AgentClick
+npm install
+npm run dev        # dev mode: API on 3001, Vite UI on 5173
+```
+
+## Install (Global CLI)
+
+```bash
+npm install -g agentclick
+agentclick
+```
+
+This starts the AgentClick server on `http://localhost:3001` and serves the built web UI on the same port.
+
+Optional server config (defaults shown in `.env.example`):
+
+```bash
+PORT=3001
+OPENCLAW_WEBHOOK=http://localhost:18789/hooks/agent
+```
+
+Create a local `.env` in the project root to override these values during development (server auto-loads it via `dotenv`).
+
+Production-style local run (single port after build):
+
+```bash
+npm run build
+npm start          # serves API + built web UI on localhost:3001
+```
+
+Deployment notes (reverse proxy, Docker/OpenClaw host mapping, env vars):
+
+- See `docs/deployment.md`
+
+Copy the skill to your OpenClaw workspace:
+
+```bash
+cp -r skills/clawui-email ~/.openclaw/skills/
+```
+
+Restart OpenClaw. Ask it to write an email — the review page will open automatically.
+
+---
+
+## Project Structure
+
+```
+AgentClick/
+├── packages/
+│   ├── server/          # Node.js + Express — receives agent data, handles callbacks
+│   └── web/             # React + Vite + Tailwind — the interaction UI
+├── skills/
+│   └── clawui-email/
+│       └── SKILL.md     # OpenClaw skill definition
+└── docs/
+    └── research.md      # Market & technical research notes
+```
+
+---
+
+## Roadmap
+
+- [x] **M0** — Email draft review (click to delete/rewrite paragraphs)
+- [x] **M1** — Preference learning (auto-save rules to MEMORY.md)
+- [x] **M2 (partial)** — Agent integration loop (`/review` create session + `/wait` long-poll + callback)
+- [x] **Next** — Unified serving (single port; no separate Vite port in production)
+- [x] **Next** — Production serve polish (deployment docs / environment examples)
+- [ ] **Next** — npm global package (`agentclick`)
+- [ ] **Next** — Remote mode UX + link delivery polish
+- [ ] **Later** — Agent task visualization (Mission Control view)
+- [ ] **Later** — Multi-framework support (beyond OpenClaw)
+
+---
+
+## Why Not ClawX?
+
+[ClawX](https://github.com/ValueCell-ai/ClawX) is a desktop app for *managing* OpenClaw (installing skills, configuring channels, running the gateway). AgentClick is for *working with* your agent — reviewing its output, making decisions, teaching it your preferences. They're complementary.
+
+---
+
+## Contributing
+
+This is an early-stage open source project. All contributions welcome — UI components, new interaction patterns, OpenClaw integration improvements, documentation.
+
+Open an issue to discuss before submitting large PRs.
+
+---
+
+## License
+
+MIT

package/bin/agentclick.mjs

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+
+import { existsSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { spawnSync } from 'node:child_process'
+
+const __filename = fileURLToPath(import.meta.url)
+const rootDir = dirname(dirname(__filename))
+const webDistIndex = join(rootDir, 'packages', 'web', 'dist', 'index.html')
+const serverDistEntry = join(rootDir, 'packages', 'server', 'dist', 'index.js')
+
+function run(command, args) {
+  const result = spawnSync(command, args, {
+    cwd: rootDir,
+    stdio: 'inherit',
+    env: process.env,
+  })
+  if (result.error) {
+    console.error(`[agentclick] Failed to run ${command}:`, result.error.message)
+    process.exit(1)
+  }
+  if (typeof result.status === 'number' && result.status !== 0) {
+    process.exit(result.status)
+  }
+}
+
+if (!existsSync(webDistIndex) || !existsSync(serverDistEntry)) {
+  console.log('[agentclick] Build artifacts not found, running npm run build...')
+  const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm'
+  run(npmCmd, ['run', 'build'])
+}
+
+if (!existsSync(serverDistEntry)) {
+  console.error('[agentclick] Server build output missing after build. Expected packages/server/dist/index.js')
+  process.exit(1)
+}
+
+run(process.execPath, [serverDistEntry])

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "agentclick",
+  "version": "0.1.0",
+  "bin": {
+    "agentclick": "./bin/agentclick.mjs"
+  },
+  "files": [
+    "bin/",
+    "packages/server/dist/",
+    "packages/server/src/",
+    "packages/server/package.json",
+    "packages/web/dist/",
+    "packages/web/package.json",
+    "README.md",
+    "AGENTS.md"
+  ],
+  "workspaces": [
+    "packages/*"
+  ],
+  "scripts": {
+    "dev": "concurrently \"npm run dev -w packages/server\" \"npm run dev -w packages/web\"",
+    "build": "npm run build -w packages/server && npm run build -w packages/web",
+    "start": "npm run start -w packages/server"
+  },
+  "dependencies": {
+    "better-sqlite3": "^12.6.2",
+    "cors": "^2.8.5",
+    "dotenv": "^17.3.1",
+    "express": "^4.19.2",
+    "open": "^10.1.0"
+  },
+  "devDependencies": {
+    "concurrently": "^9.0.0"
+  }
+}

package/packages/server/dist/index.js

@@ -0,0 +1,170 @@
+import 'dotenv/config';
+import express from 'express';
+import cors from 'cors';
+import open from 'open';
+import { existsSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { learnFromDeletions } from './preference.js';
+import { createSession, getSession, listSessions, completeSession } from './store.js';
+const app = express();
+const PORT = Number(process.env.PORT || 3001);
+const OPENCLAW_WEBHOOK = process.env.OPENCLAW_WEBHOOK || 'http://localhost:18789/hooks/agent';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const WEB_DIST_DIR = join(__dirname, '../../web/dist');
+const SHOULD_SERVE_BUILT_WEB = existsSync(WEB_DIST_DIR) && (__filename.endsWith('/dist/index.js') || process.env.NODE_ENV === 'production');
+const WEB_ORIGIN = SHOULD_SERVE_BUILT_WEB ? `http://localhost:${PORT}` : 'http://localhost:5173';
+app.use(cors());
+app.use(express.json());
+// OpenClaw calls this when a review is needed
+app.post('/api/review', async (req, res) => {
+    const { type, sessionKey, payload } = req.body;
+    if (!sessionKey) {
+        console.warn('[agentclick] Warning: sessionKey missing — callback will be skipped');
+    }
+    const id = `session_${Date.now()}`;
+    createSession({
+        id,
+        type: type || 'email_review',
+        payload,
+        sessionKey,
+        status: 'pending',
+        createdAt: Date.now(),
+    });
+    const routeMap = {
+        action_approval: 'approval',
+        code_review: 'code-review',
+    };
+    const path = routeMap[type] ?? 'review';
+    const url = `${WEB_ORIGIN}/${path}/${id}`;
+    console.log(`[agentclick] Review session created: ${id}`);
+    console.log(`[agentclick] Opening browser: ${url}`);
+    try {
+        await open(url);
+    }
+    catch (err) {
+        console.warn('[agentclick] Failed to open browser:', err);
+    }
+    res.json({ sessionId: id, url });
+});
+// List recent sessions for homepage
+app.get('/api/sessions', (_req, res) => {
+    const list = listSessions(20).map(s => {
+        const p = s.payload;
+        // Format B (inbox+draft) stores subject/to inside draft
+        const draft = p?.draft;
+        return {
+            id: s.id,
+            type: s.type,
+            status: s.status,
+            createdAt: s.createdAt,
+            subject: (draft?.subject ?? p?.subject),
+            to: (draft?.to ?? p?.to),
+            risk: p?.risk,
+            command: p?.command,
+        };
+    });
+    res.json(list);
+});
+// Web UI fetches session data
+app.get('/api/sessions/:id', (req, res) => {
+    const session = getSession(req.params.id);
+    if (!session)
+        return res.status(404).json({ error: 'Session not found' });
+    res.json(session);
+});
+// Long-poll: agent calls this and blocks until user completes review (up to 5 min)
+app.get('/api/sessions/:id/wait', async (req, res) => {
+    const TIMEOUT_MS = 5 * 60 * 1000;
+    const POLL_MS = 1500;
+    const start = Date.now();
+    while (Date.now() - start < TIMEOUT_MS) {
+        const session = getSession(req.params.id);
+        if (!session)
+            return res.status(404).json({ error: 'Session not found' });
+        if (session.status === 'completed')
+            return res.json(session);
+        await new Promise(r => setTimeout(r, POLL_MS));
+    }
+    res.status(408).json({ error: 'timeout', message: 'User did not complete review within 5 minutes' });
+});
+// Web UI submits user actions
+app.post('/api/sessions/:id/complete', async (req, res) => {
+    const session = getSession(req.params.id);
+    if (!session)
+        return res.status(404).json({ error: 'Session not found' });
+    completeSession(req.params.id, req.body);
+    console.log(`[agentclick] Session ${session.id} completed:`, JSON.stringify(req.body, null, 2));
+    // Learn from delete actions and persist rules to MEMORY.md
+    const actions = (req.body.actions ?? []);
+    learnFromDeletions(actions, session.payload);
+    // Send result back to OpenClaw
+    let callbackFailed = false;
+    let callbackError = '';
+    if (session.sessionKey) {
+        try {
+            const summary = buildActionSummary(req.body);
+            await fetch(OPENCLAW_WEBHOOK, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${process.env.OPENCLAW_TOKEN || ''}`
+                },
+                body: JSON.stringify({
+                    message: summary,
+                    sessionKey: session.sessionKey,
+                    deliver: true
+                })
+            });
+            console.log(`[agentclick] Callback sent to OpenClaw`);
+        }
+        catch (err) {
+            callbackFailed = true;
+            callbackError = String(err);
+            console.error(`[agentclick] Failed to callback OpenClaw:`, err);
+        }
+    }
+    res.json({ ok: true, callbackFailed, callbackError });
+});
+function buildActionSummary(result) {
+    // If result has approved field, it's an action_approval or code_review
+    if ('approved' in result) {
+        const approved = result.approved;
+        const note = result.note;
+        const lines = ['[agentclick] User reviewed the request:'];
+        lines.push(approved ? '- Approved: proceed.' : '- Rejected: do not proceed.');
+        if (note)
+            lines.push(`- Note: ${note}`);
+        return lines.join('\n');
+    }
+    const actions = result.actions || [];
+    const lines = ['[agentclick] User reviewed the draft:'];
+    const deleted = actions.filter(a => a.type === 'delete');
+    const rewritten = actions.filter(a => a.type === 'rewrite');
+    if (deleted.length > 0) {
+        lines.push(`- Deleted ${deleted.length} paragraph(s): ${deleted.map(a => `${a.paragraphId} (reason: ${a.reason})`).join(', ')}`);
+    }
+    if (rewritten.length > 0) {
+        lines.push(`- Requested rewrite for: ${rewritten.map(a => `${a.paragraphId} — "${a.instruction}"`).join(', ')}`);
+    }
+    if (result.confirmed) {
+        lines.push('- User confirmed: proceed with sending.');
+    }
+    if (result.regenerate) {
+        lines.push('- User requested full regeneration.');
+    }
+    return lines.join('\n');
+}
+if (SHOULD_SERVE_BUILT_WEB) {
+    app.use(express.static(WEB_DIST_DIR));
+    app.get('*', (req, res, next) => {
+        if (req.path.startsWith('/api/'))
+            return next();
+        res.sendFile(join(WEB_DIST_DIR, 'index.html'));
+    });
+    console.log(`[agentclick] Serving web UI from ${WEB_DIST_DIR}`);
+}
+app.listen(PORT, () => {
+    console.log(`[agentclick] Server running at http://localhost:${PORT}`);
+});

package/packages/server/dist/preference.js

@@ -0,0 +1,68 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+const MEMORY_PATH = path.join(os.homedir(), '.openclaw', 'workspace', 'MEMORY.md');
+const SECTION_HEADER = '## Email Preferences (ClawUI Auto-Learned)';
+// Map raw reason keys to human-readable descriptions
+const REASON_LABELS = {
+    too_formal: 'too formal',
+    too_casual: 'too casual',
+    too_long: 'too long',
+    off_topic: 'off topic',
+    inaccurate: 'inaccurate',
+    repetitive: 'repetitive',
+    unnecessary: 'unnecessary',
+    wrong_tone: 'wrong tone',
+    too_polite: 'too polite',
+    redundant: 'redundant',
+};
+function ensureMemoryFile() {
+    const dir = path.dirname(MEMORY_PATH);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    if (!fs.existsSync(MEMORY_PATH)) {
+        fs.writeFileSync(MEMORY_PATH, '# ClawUI Learned Preferences\n', 'utf-8');
+    }
+}
+// Truncate paragraph content into a short description for the rule
+function summarize(content) {
+    const cleaned = content.trim().replace(/\s+/g, ' ');
+    if (cleaned.length <= 80)
+        return cleaned;
+    return cleaned.slice(0, 77) + '...';
+}
+function resolveReason(reason) {
+    if (!reason)
+        return 'user deleted';
+    return REASON_LABELS[reason] ?? reason;
+}
+export function learnFromDeletions(actions, payload) {
+    const deletions = actions.filter(a => a.type === 'delete');
+    if (deletions.length === 0)
+        return;
+    const paragraphMap = new Map((payload.paragraphs ?? []).map(p => [p.id, p.content]));
+    // Infer scope from session type
+    const scope = payload.type === 'email_review' ? 'email' : 'general';
+    const rules = [];
+    for (const action of deletions) {
+        const content = paragraphMap.get(action.paragraphId);
+        // Skip if we cannot find the original paragraph text
+        if (!content)
+            continue;
+        const description = summarize(content);
+        const reason = resolveReason(action.reason);
+        rules.push(`- AVOID: ${description} (reason: ${reason}) - SCOPE: ${scope}`);
+    }
+    if (rules.length === 0)
+        return;
+    ensureMemoryFile();
+    const existing = fs.readFileSync(MEMORY_PATH, 'utf-8');
+    // Append section header once if not present, then append rules
+    const needsHeader = !existing.includes(SECTION_HEADER);
+    const block = needsHeader
+        ? `\n${SECTION_HEADER}\n${rules.join('\n')}\n`
+        : `${rules.join('\n')}\n`;
+    fs.appendFileSync(MEMORY_PATH, block, 'utf-8');
+    console.log(`[agentclick] Learned ${rules.length} preference rule(s) -> ${MEMORY_PATH}`);
+}

package/packages/server/dist/store.js

@@ -0,0 +1,55 @@
+import Database from 'better-sqlite3';
+import { mkdirSync, existsSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+const DB_DIR = join(homedir(), '.openclaw');
+const DB_PATH = join(DB_DIR, 'clawui-sessions.db');
+if (!existsSync(DB_DIR))
+    mkdirSync(DB_DIR, { recursive: true });
+const db = new Database(DB_PATH);
+db.exec(`
+  CREATE TABLE IF NOT EXISTS sessions (
+    id TEXT PRIMARY KEY,
+    type TEXT NOT NULL,
+    payload TEXT NOT NULL,
+    status TEXT NOT NULL DEFAULT 'pending',
+    result TEXT,
+    sessionKey TEXT,
+    createdAt INTEGER NOT NULL
+  )
+`);
+export function createSession(session) {
+    db.prepare(`
+    INSERT INTO sessions (id, type, payload, status, sessionKey, createdAt)
+    VALUES (@id, @type, @payload, @status, @sessionKey, @createdAt)
+  `).run({
+        ...session,
+        payload: JSON.stringify(session.payload),
+    });
+}
+export function getSession(id) {
+    const row = db.prepare('SELECT * FROM sessions WHERE id = ?').get(id);
+    if (!row)
+        return null;
+    return deserialize(row);
+}
+export function listSessions(limit = 20) {
+    const rows = db.prepare('SELECT * FROM sessions ORDER BY createdAt DESC LIMIT ?').all(limit);
+    return rows.map(deserialize);
+}
+export function completeSession(id, result) {
+    db.prepare(`
+    UPDATE sessions SET status = 'completed', result = ? WHERE id = ?
+  `).run(JSON.stringify(result), id);
+}
+function deserialize(row) {
+    return {
+        id: row.id,
+        type: row.type,
+        payload: JSON.parse(row.payload),
+        status: row.status,
+        result: row.result ? JSON.parse(row.result) : undefined,
+        sessionKey: row.sessionKey,
+        createdAt: row.createdAt,
+    };
+}

package/packages/server/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@agentclick/server",
+  "version": "0.1.0",
+  "type": "module",
+  "scripts": {
+    "dev": "tsx watch src/index.ts",
+    "build": "tsc",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "better-sqlite3": "^12.6.2",
+    "cors": "^2.8.5",
+    "dotenv": "^17.3.1",
+    "express": "^4.19.2",
+    "open": "^10.1.0"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/cors": "^2.8.17",
+    "@types/express": "^4.17.21",
+    "@types/node": "^22.0.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.6.0"
+  }
+}