claudity 1.0.0

package/setup.sh

@@ -0,0 +1,134 @@
+#!/bin/bash
+set -e
+
+DIR="$(cd "$(dirname "$0")" && pwd)"
+
+green="\033[0;32m"
+yellow="\033[0;33m"
+red="\033[0;31m"
+dim="\033[2m"
+bold="\033[1m"
+reset="\033[0m"
+
+step() { echo -e "\n${green}→${reset} $1"; }
+info() { echo -e "  ${dim}$1${reset}"; }
+warn() { echo -e "  ${yellow}!${reset} $1"; }
+fail() { echo -e "  ${red}✗${reset} $1"; exit 1; }
+ok() { echo -e "  ${dim}done${reset}"; }
+
+ask() {
+  echo -en "  $1 ${dim}[y/n]${reset} "
+  read -r answer
+  [[ "$answer" =~ ^[yY] ]]
+}
+
+echo -e "\n${bold}${green}claudity${reset} setup"
+echo -e "${dim}personal ai agent platform${reset}"
+
+# node check
+step "checking node.js"
+if ! command -v node &>/dev/null; then
+  fail "node.js is required. install from https://nodejs.org"
+fi
+NODE_VER=$(node -v | cut -d. -f1 | tr -d 'v')
+if [ "$NODE_VER" -lt 18 ]; then
+  fail "node 18+ required (found $(node -v))"
+fi
+info "$(node -v)"
+
+# dependencies
+step "installing dependencies"
+cd "$DIR"
+npm install --silent 2>&1 | tail -1
+ok
+
+# env file
+step "configuring environment"
+if [ ! -f "$DIR/.env" ]; then
+  echo "PORT=6767" > "$DIR/.env"
+  echo "RELAY_SECRET=$(openssl rand -hex 24)" >> "$DIR/.env"
+  info "created .env"
+else
+  if ! grep -q '^RELAY_SECRET=' "$DIR/.env" || grep -q 'change-me' "$DIR/.env"; then
+    SECRET=$(openssl rand -hex 24)
+    if grep -q '^RELAY_SECRET=' "$DIR/.env"; then
+      sed -i '' "s|^RELAY_SECRET=.*|RELAY_SECRET=$SECRET|" "$DIR/.env"
+    else
+      echo "RELAY_SECRET=$SECRET" >> "$DIR/.env"
+    fi
+    info "generated relay secret"
+  fi
+  info ".env already exists"
+fi
+ok
+
+# auth
+step "checking authentication"
+KEYCHAIN_CREDS=$(security find-generic-password -s "Claude Code-credentials" -w 2>/dev/null || true)
+if [ -n "$KEYCHAIN_CREDS" ]; then
+  info "found oauth credentials in keychain"
+else
+  HAS_API_KEY=$(grep '^API_KEY=' "$DIR/.env" 2>/dev/null | cut -d= -f2-)
+  if [ -n "$HAS_API_KEY" ] && [ "$HAS_API_KEY" != "" ]; then
+    info "using api key from .env"
+  else
+    warn "no authentication found"
+    echo ""
+    echo -e "  option 1: run ${green}claude setup-token${reset} to connect your claude subscription"
+    echo -e "  option 2: add ${green}API_KEY=sk-ant-api03-...${reset} to .env"
+    echo ""
+    echo -e "  ${dim}you can finish this later — claudity will show a setup screen${reset}"
+  fi
+fi
+
+# imessage relay
+step "imessage relay"
+echo -e "  chat with your agents over imessage by texting yourself"
+echo -e "  ${dim}send \"agent_name: your message\" in your self-chat${reset}"
+echo ""
+
+if ask "enable imessage relay?"; then
+  CHAT_DB="$HOME/Library/Messages/chat.db"
+
+  if ! sqlite3 "$CHAT_DB" "select 1 limit 1" &>/dev/null; then
+    echo ""
+    warn "terminal needs full disk access to read imessages"
+    warn "system settings → privacy & security → full disk access → enable your terminal app"
+    echo ""
+    info "after granting access, run ${green}npm run setup${reset} again"
+  else
+    info "full disk access: ok"
+  fi
+
+  echo -en "  your phone number ${dim}(e.g. +15551234567)${reset}: "
+  read -r PHONE
+  if [ -z "$PHONE" ]; then
+    warn "no phone number provided, skipping imessage relay"
+  else
+    if grep -q '^IMESSAGE_PHONE=' "$DIR/.env"; then
+      sed -i '' "s|^IMESSAGE_PHONE=.*|IMESSAGE_PHONE=$PHONE|" "$DIR/.env"
+    else
+      echo "IMESSAGE_PHONE=$PHONE" >> "$DIR/.env"
+    fi
+
+    if grep -q '^IMESSAGE_RELAY=' "$DIR/.env"; then
+      sed -i '' "s|^IMESSAGE_RELAY=.*|IMESSAGE_RELAY=true|" "$DIR/.env"
+    else
+      echo "IMESSAGE_RELAY=true" >> "$DIR/.env"
+    fi
+    info "enabled in .env"
+    ok
+  fi
+else
+  if grep -q '^IMESSAGE_RELAY=' "$DIR/.env"; then
+    sed -i '' "s|^IMESSAGE_RELAY=.*|IMESSAGE_RELAY=false|" "$DIR/.env"
+  fi
+  info "skipped"
+fi
+
+# done
+echo -e "\n${bold}${green}ready${reset}\n"
+echo -e "  start claudity:  ${green}npm start${reset}"
+echo -e "  dev mode:        ${green}npm run dev${reset}"
+echo -e "  then visit:      ${green}http://localhost:6767${reset}"
+echo ""

package/src/db.js

@@ -0,0 +1,162 @@
+const Database = require('better-sqlite3');
+const path = require('path');
+
+const db = new Database(path.join(__dirname, '..', 'claudity.db'));
+
+db.pragma('journal_mode = WAL');
+db.pragma('foreign_keys = ON');
+
+db.exec(`
+  create table if not exists config (
+    key text primary key,
+    value text not null,
+    updated_at datetime default current_timestamp
+  );
+
+  create table if not exists agents (
+    id text primary key,
+    name text not null unique,
+    role text not null,
+    tools_config text not null default '{}',
+    created_at datetime default current_timestamp,
+    updated_at datetime default current_timestamp
+  );
+
+  create table if not exists memories (
+    id text primary key,
+    agent_id text not null,
+    summary text not null,
+    created_at datetime default current_timestamp,
+    foreign key (agent_id) references agents(id) on delete cascade
+  );
+
+  create table if not exists messages (
+    id text primary key,
+    agent_id text not null,
+    role text not null,
+    content text not null,
+    tool_calls text,
+    created_at datetime default current_timestamp,
+    foreign key (agent_id) references agents(id) on delete cascade
+  );
+
+  create table if not exists schedules (
+    id text primary key,
+    agent_id text not null,
+    description text not null,
+    interval_ms integer not null,
+    next_run_at integer not null,
+    last_run_at integer,
+    active integer not null default 1,
+    created_at datetime default current_timestamp,
+    foreign key (agent_id) references agents(id) on delete cascade
+  );
+
+  create table if not exists connections (
+    id text primary key,
+    platform text not null,
+    config text not null default '{}',
+    enabled integer not null default 0,
+    status text not null default 'disconnected',
+    status_detail text,
+    created_at datetime default current_timestamp,
+    updated_at datetime default current_timestamp
+  );
+
+  create unique index if not exists idx_connections_platform on connections(platform);
+  create index if not exists idx_memories_agent on memories(agent_id);
+  create index if not exists idx_messages_agent on messages(agent_id, created_at);
+  create index if not exists idx_schedules_due on schedules(active, next_run_at);
+`);
+
+try {
+  db.exec('alter table agents add column is_default integer not null default 0');
+} catch {}
+
+try {
+  db.exec('alter table agents add column heartbeat_interval integer default null');
+} catch {}
+
+try {
+  db.exec('alter table agents add column bootstrapped integer not null default 1');
+} catch {}
+
+try {
+  db.exec("alter table agents add column model text not null default 'opus'");
+} catch {}
+
+try {
+  db.exec("alter table agents add column thinking text not null default 'high'");
+} catch {}
+
+try {
+  db.exec("alter table messages add column type text not null default 'chat'");
+} catch {}
+
+try {
+  db.exec('alter table agents add column show_heartbeat integer not null default 0');
+} catch {}
+
+db.exec(`
+  create table if not exists sessions (
+    agent_id text primary key,
+    session_id text not null,
+    prompt_hash text not null,
+    updated_at datetime default current_timestamp,
+    foreign key (agent_id) references agents(id) on delete cascade
+  )
+`);
+
+const stmts = {
+  getConfig: db.prepare('select value from config where key = ?'),
+  setConfig: db.prepare('insert into config (key, value, updated_at) values (?, ?, current_timestamp) on conflict(key) do update set value = excluded.value, updated_at = current_timestamp'),
+  deleteConfig: db.prepare('delete from config where key = ?'),
+
+  listAgents: db.prepare("select a.*, max(m.created_at) as last_message_at from agents a left join messages m on m.agent_id = a.id and m.type = 'chat' group by a.id order by coalesce(last_message_at, a.created_at) desc"),
+  getAgent: db.prepare('select * from agents where id = ?'),
+  getAgentByName: db.prepare('select * from agents where lower(name) = lower(?)'),
+  createAgent: db.prepare("insert into agents (id, name, role) values (?, ?, '')"),
+  updateAgent: db.prepare('update agents set name = ?, updated_at = current_timestamp where id = ?'),
+  updateAgentToolsConfig: db.prepare('update agents set tools_config = ?, updated_at = current_timestamp where id = ?'),
+  deleteAgent: db.prepare('delete from agents where id = ?'),
+  getDefaultAgent: db.prepare('select * from agents where is_default = 1'),
+  clearDefaultAgent: db.prepare('update agents set is_default = 0 where is_default = 1'),
+  setDefaultAgent: db.prepare('update agents set is_default = 1, updated_at = current_timestamp where id = ?'),
+  unsetDefaultAgent: db.prepare('update agents set is_default = 0, updated_at = current_timestamp where id = ?'),
+
+  listMemories: db.prepare('select * from memories where agent_id = ? order by created_at desc'),
+  createMemory: db.prepare('insert into memories (id, agent_id, summary) values (?, ?, ?)'),
+  deleteMemories: db.prepare('delete from memories where agent_id = ?'),
+
+  listMessages: db.prepare('select * from messages where agent_id = ? order by created_at asc'),
+  recentMessages: db.prepare("select * from messages where agent_id = ? and type = 'chat' order by created_at desc limit ?"),
+  createMessage: db.prepare("insert into messages (id, agent_id, role, content, tool_calls, type) values (?, ?, ?, ?, ?, 'chat')"),
+  createHeartbeatMessage: db.prepare("insert into messages (id, agent_id, role, content, tool_calls, type) values (?, ?, ?, ?, ?, 'heartbeat')"),
+  deleteMessages: db.prepare('delete from messages where agent_id = ?'),
+  createSchedule: db.prepare('insert into schedules (id, agent_id, description, interval_ms, next_run_at) values (?, ?, ?, ?, ?)'),
+  dueSchedules: db.prepare('select * from schedules where active = 1 and next_run_at <= ?'),
+  updateScheduleRun: db.prepare('update schedules set last_run_at = ?, next_run_at = ? where id = ?'),
+  deactivateSchedule: db.prepare('update schedules set active = 0 where id = ? and agent_id = ?'),
+  agentSchedules: db.prepare('select * from schedules where agent_id = ? and active = 1'),
+  listConnections: db.prepare('select * from connections order by created_at asc'),
+  getConnectionByPlatform: db.prepare('select * from connections where platform = ?'),
+  upsertConnection: db.prepare('insert into connections (id, platform, config, enabled, status, status_detail, updated_at) values (?, ?, ?, ?, ?, ?, current_timestamp) on conflict(platform) do update set config = excluded.config, enabled = excluded.enabled, status = excluded.status, status_detail = excluded.status_detail, updated_at = current_timestamp'),
+  updateConnectionStatus: db.prepare('update connections set status = ?, status_detail = ?, updated_at = current_timestamp where platform = ?'),
+  updateConnectionEnabled: db.prepare('update connections set enabled = ?, updated_at = current_timestamp where platform = ?'),
+  updateConnectionConfig: db.prepare('update connections set config = ?, updated_at = current_timestamp where platform = ?'),
+  deleteConnection: db.prepare('delete from connections where platform = ?'),
+  enabledConnections: db.prepare('select * from connections where enabled = 1'),
+
+  agentsWithHeartbeat: db.prepare('select * from agents where heartbeat_interval is not null'),
+  setBootstrapped: db.prepare('update agents set bootstrapped = ?, updated_at = current_timestamp where id = ?'),
+  setHeartbeatInterval: db.prepare('update agents set heartbeat_interval = ?, updated_at = current_timestamp where id = ?'),
+  setModel: db.prepare('update agents set model = ?, updated_at = current_timestamp where id = ?'),
+  setThinking: db.prepare('update agents set thinking = ?, updated_at = current_timestamp where id = ?'),
+  setShowHeartbeat: db.prepare('update agents set show_heartbeat = ?, updated_at = current_timestamp where id = ?'),
+
+  getSession: db.prepare('select * from sessions where agent_id = ?'),
+  upsertSession: db.prepare('insert into sessions (agent_id, session_id, prompt_hash, updated_at) values (?, ?, ?, current_timestamp) on conflict(agent_id) do update set session_id = excluded.session_id, prompt_hash = excluded.prompt_hash, updated_at = current_timestamp'),
+  deleteSession: db.prepare('delete from sessions where agent_id = ?'),
+};
+
+module.exports = { db, stmts };

package/src/index.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+require('dotenv').config();
+const express = require('express');
+const path = require('path');
+const { v4: uuid } = require('uuid');
+const { execSync } = require('child_process');
+const { stmts } = require('./db');
+const apiRoutes = require('./routes/api');
+const relayRoutes = require('./routes/relay');
+const connectionRoutes = require('./routes/connections');
+const scheduler = require('./services/scheduler');
+const connections = require('./services/connections');
+const memory = require('./services/memory');
+const heartbeat = require('./services/heartbeat');
+
+const app = express();
+const PORT = process.env.PORT || 6767;
+
+app.use(express.json());
+app.use(express.static(path.join(__dirname, '..', 'public')));
+
+app.use('/api', apiRoutes);
+app.use('/relay', relayRoutes);
+app.use('/api/connections', connectionRoutes);
+
+function autoUpdate() {
+  const root = path.join(__dirname, '..');
+  try {
+    execSync('git rev-parse --git-dir', { cwd: root, stdio: 'ignore' });
+  } catch { return; }
+  try {
+    const result = execSync('git pull --ff-only 2>&1', { cwd: root, encoding: 'utf8', timeout: 15000 });
+    if (result && !result.includes('Already up to date')) {
+      console.log('[update] ' + result.trim());
+    }
+  } catch (err) {
+    console.log('[update] skipped: ' + (err.stderr || err.message || 'unknown error').toString().trim());
+  }
+}
+
+function migrateImessageFromEnv() {
+  if (process.env.IMESSAGE_RELAY !== 'true') return;
+  const existing = stmts.getConnectionByPlatform.get('imessage');
+  if (existing) return;
+  const phone = process.env.IMESSAGE_PHONE;
+  if (!phone) return;
+  const id = uuid();
+  stmts.upsertConnection.run(id, 'imessage', JSON.stringify({ phone }), 1, 'disconnected', null);
+  console.log('[connections] migrated imessage config from .env to database');
+}
+
+autoUpdate();
+
+app.listen(PORT, () => {
+  console.log(`claudity running on http://localhost:${PORT}`);
+  scheduler.start();
+  memory.startConsolidation();
+  migrateImessageFromEnv();
+  connections.start();
+  heartbeat.start();
+});

package/src/routes/api.js

@@ -0,0 +1,194 @@
+const express = require('express');
+const { v4: uuid } = require('uuid');
+const { stmts } = require('../db');
+const auth = require('../services/auth');
+const chat = require('../services/chat');
+const workspace = require('../services/workspace');
+const heartbeat = require('../services/heartbeat');
+
+const router = express.Router();
+
+router.get('/auth/status', (req, res) => {
+  res.json(auth.getAuthStatus());
+});
+
+router.post('/auth/api-key', (req, res) => {
+  const { key } = req.body;
+  if (!key) return res.status(400).json({ error: 'key required' });
+  if (!key.startsWith('sk-ant-api')) return res.status(400).json({ error: 'invalid api key — must start with sk-ant-api. setup tokens and oauth tokens are not supported here. run claude setup-token instead.' });
+  auth.setApiKey(key);
+  res.json({ saved: true });
+});
+
+router.post('/auth/setup-token', (req, res) => {
+  const { token } = req.body;
+  if (!token) return res.status(400).json({ error: 'token required' });
+  if (!token.startsWith('sk-ant-oat')) return res.status(400).json({ error: 'invalid setup token — must start with sk-ant-oat. if you have an api key, use the api key option instead.' });
+  try {
+    auth.writeSetupToken(token);
+    const status = auth.getAuthStatus();
+    if (status.authenticated) return res.json({ saved: true });
+    return res.status(400).json({ error: 'token saved to keychain but authentication failed — token may be invalid or expired' });
+  } catch (err) {
+    return res.status(500).json({ error: 'failed to write to keychain: ' + err.message });
+  }
+});
+
+router.delete('/auth/api-key', (req, res) => {
+  auth.removeApiKey();
+  res.json({ removed: true });
+});
+
+router.get('/agents', (req, res) => {
+  res.json(stmts.listAgents.all());
+});
+
+router.post('/agents', (req, res) => {
+  const { name, is_default, model, thinking } = req.body;
+  if (!name) return res.status(400).json({ error: 'name required' });
+  const id = uuid();
+  try {
+    stmts.createAgent.run(id, name);
+    stmts.setBootstrapped.run(0, id);
+    if (model) stmts.setModel.run(model, id);
+    if (thinking) stmts.setThinking.run(thinking, id);
+    if (is_default) {
+      stmts.clearDefaultAgent.run();
+      stmts.setDefaultAgent.run(id);
+    }
+    workspace.initWorkspace(name);
+    const agent = stmts.getAgent.get(id);
+    res.status(201).json(agent);
+  } catch (err) {
+    if (err.message.includes('UNIQUE')) return res.status(409).json({ error: 'agent name already exists' });
+    throw err;
+  }
+});
+
+router.get('/agents/:id', (req, res) => {
+  const agent = stmts.getAgent.get(req.params.id);
+  if (!agent) return res.status(404).json({ error: 'agent not found' });
+  res.json(agent);
+});
+
+router.patch('/agents/:id', (req, res) => {
+  const agent = stmts.getAgent.get(req.params.id);
+  if (!agent) return res.status(404).json({ error: 'agent not found' });
+  const name = req.body.name || agent.name;
+  if (name !== agent.name) {
+    workspace.renameWorkspace(agent.name, name);
+  }
+  stmts.updateAgent.run(name, req.params.id);
+  if (req.body.is_default) {
+    stmts.clearDefaultAgent.run();
+    stmts.setDefaultAgent.run(req.params.id);
+  } else if (req.body.is_default === false) {
+    stmts.unsetDefaultAgent.run(req.params.id);
+  }
+  if ('heartbeat_interval' in req.body) {
+    heartbeat.updateInterval(req.params.id, req.body.heartbeat_interval);
+  }
+  if (req.body.model) stmts.setModel.run(req.body.model, req.params.id);
+  if (req.body.thinking) stmts.setThinking.run(req.body.thinking, req.params.id);
+  if ('show_heartbeat' in req.body) stmts.setShowHeartbeat.run(req.body.show_heartbeat ? 1 : 0, req.params.id);
+  res.json(stmts.getAgent.get(req.params.id));
+});
+
+router.delete('/agents/:id', (req, res) => {
+  const agent = stmts.getAgent.get(req.params.id);
+  if (!agent) return res.status(404).json({ error: 'agent not found' });
+  heartbeat.removeAgent(req.params.id);
+  workspace.deleteWorkspace(agent.name);
+  stmts.deleteAgent.run(req.params.id);
+  res.json({ deleted: true });
+});
+
+router.get('/agents/:id/memories', (req, res) => {
+  res.json(stmts.listMemories.all(req.params.id));
+});
+
+router.delete('/agents/:id/memories', (req, res) => {
+  stmts.deleteMemories.run(req.params.id);
+  res.json({ cleared: true });
+});
+
+router.get('/agents/:id/messages', (req, res) => {
+  res.json(stmts.listMessages.all(req.params.id));
+});
+
+router.delete('/agents/:id/messages', (req, res) => {
+  stmts.deleteMessages.run(req.params.id);
+  res.json({ cleared: true });
+});
+
+router.post('/agents/:id/chat', (req, res) => {
+  const agent = stmts.getAgent.get(req.params.id);
+  if (!agent) return res.status(404).json({ error: 'agent not found' });
+  const { content } = req.body;
+  if (!content) return res.status(400).json({ error: 'content required' });
+
+  res.json({ status: 'queued' });
+
+  chat.enqueueMessage(req.params.id, content).catch(err => {
+    chat.emit(req.params.id, 'error', { error: err.message });
+  });
+});
+
+router.get('/agents/:id/stream', (req, res) => {
+  const agent = stmts.getAgent.get(req.params.id);
+  if (!agent) return res.status(404).json({ error: 'agent not found' });
+
+  res.writeHead(200, {
+    'content-type': 'text/event-stream',
+    'cache-control': 'no-cache',
+    'connection': 'keep-alive'
+  });
+
+  res.write(`event: connected\ndata: ${JSON.stringify({ agent_id: req.params.id })}\n\n`);
+
+  if (chat.isProcessing(req.params.id)) {
+    res.write(`event: typing\ndata: ${JSON.stringify({ active: true })}\n\n`);
+  }
+
+  chat.addStream(req.params.id, res);
+
+  req.on('close', () => {
+    chat.removeStream(req.params.id, res);
+  });
+});
+
+router.get('/agents/:id/workspace', (req, res) => {
+  const agent = stmts.getAgent.get(req.params.id);
+  if (!agent) return res.status(404).json({ error: 'agent not found' });
+  const files = workspace.listFiles(agent.name);
+  res.json(agent.bootstrapped === 0 ? files.filter(f => f !== 'BOOTSTRAP.md') : files);
+});
+
+router.get('/agents/:id/logs', (req, res) => {
+  const agent = stmts.getAgent.get(req.params.id);
+  if (!agent) return res.status(404).json({ error: 'agent not found' });
+  res.json(workspace.listMemoryLogs(agent.name));
+});
+
+router.get('/agents/:id/workspace/*', (req, res) => {
+  const agent = stmts.getAgent.get(req.params.id);
+  if (!agent) return res.status(404).json({ error: 'agent not found' });
+  const filePath = req.params[0];
+  if (filePath.includes('..')) return res.status(400).json({ error: 'invalid path' });
+  const content = workspace.readFile(agent.name, filePath);
+  if (content === null) return res.status(404).json({ error: 'file not found' });
+  res.json({ path: filePath, content });
+});
+
+router.put('/agents/:id/workspace/*', (req, res) => {
+  const agent = stmts.getAgent.get(req.params.id);
+  if (!agent) return res.status(404).json({ error: 'agent not found' });
+  const filePath = req.params[0];
+  if (filePath.includes('..')) return res.status(400).json({ error: 'invalid path' });
+  const { content } = req.body;
+  if (typeof content !== 'string') return res.status(400).json({ error: 'content required' });
+  workspace.writeFile(agent.name, filePath, content);
+  res.json({ written: true, path: filePath });
+});
+
+module.exports = router;

package/src/routes/connections.js

@@ -0,0 +1,41 @@
+const express = require('express');
+const connections = require('../services/connections');
+
+const router = express.Router();
+
+router.get('/', (req, res) => {
+  res.json(connections.list());
+});
+
+router.post('/:platform/enable', async (req, res) => {
+  const { platform } = req.params;
+  const config = req.body || {};
+  try {
+    await connections.enable(platform, config);
+    res.json({ enabled: true });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+router.post('/:platform/disable', async (req, res) => {
+  const { platform } = req.params;
+  try {
+    await connections.disable(platform);
+    res.json({ disabled: true });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+router.delete('/:platform', async (req, res) => {
+  const { platform } = req.params;
+  try {
+    await connections.remove(platform);
+    res.json({ removed: true });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+module.exports = router;

package/src/routes/relay.js

@@ -0,0 +1,37 @@
+const express = require('express');
+const { stmts } = require('../db');
+const chat = require('../services/chat');
+
+const router = express.Router();
+
+router.use((req, res, next) => {
+  const secret = process.env.RELAY_SECRET;
+  if (!secret) return res.status(500).json({ error: 'relay not configured' });
+  const auth = req.headers.authorization;
+  if (!auth || auth !== `Bearer ${secret}`) {
+    return res.status(401).json({ error: 'unauthorized' });
+  }
+  next();
+});
+
+router.post('/chat', (req, res) => {
+  const { agent_name, content } = req.body;
+  if (!agent_name || !content) return res.status(400).json({ error: 'agent_name and content required' });
+
+  const agent = stmts.getAgentByName.get(agent_name);
+  if (!agent) return res.status(404).json({ error: `agent not found: ${agent_name}` });
+
+  chat.enqueueMessage(agent.id, content).catch(err => {
+    chat.emit(agent.id, 'error', { error: err.message });
+  });
+
+  res.json({ status: 'queued' });
+});
+
+router.get('/messages/:agent_name', (req, res) => {
+  const agent = stmts.getAgentByName.get(req.params.agent_name);
+  if (!agent) return res.status(404).json({ error: 'agent not found' });
+  res.json(stmts.listMessages.all(agent.id));
+});
+
+module.exports = router;