openclaw-bridge-hub 0.1.0

package/.env.example

@@ -0,0 +1,6 @@
+PORT=3080
+API_KEY=your-secret-api-key-here
+DATA_DIR=./data
+CLEANUP_INTERVAL_MS=3600000
+FILE_TTL_MS=86400000
+COMMAND_TTL_MS=3600000

package/ecosystem.config.js

@@ -0,0 +1,15 @@
+export default {
+  apps: [
+    {
+      name: "openclaw-bridge-hub",
+      script: "src/index.ts",
+      interpreter: "node",
+      interpreter_args: "--import tsx",
+      env: {
+        NODE_ENV: "production",
+      },
+      max_memory_restart: "256M",
+      log_date_format: "YYYY-MM-DD HH:mm:ss",
+    },
+  ],
+};

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "openclaw-bridge-hub",
+  "version": "0.1.0",
+  "description": "OpenClaw Bridge Hub — gateway registry, file relay, and command queue for distributed OpenClaw instances",
+  "type": "module",
+  "main": "src/index.ts",
+  "bin": {
+    "openclaw-bridge-hub": "src/cli.ts"
+  },
+  "scripts": {
+    "start": "tsx src/index.ts",
+    "build": "tsc",
+    "dev": "tsx watch src/index.ts"
+  },
+  "dependencies": {
+    "fastify": "^5.0.0",
+    "better-sqlite3": "^11.0.0",
+    "uuid": "^11.0.0",
+    "dotenv": "^16.4.0",
+    "tsx": "^4.19.0"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.0",
+    "@types/uuid": "^10.0.0",
+    "typescript": "^5.7.0"
+  },
+  "keywords": ["openclaw", "bridge", "filerelay", "gateway", "registry"],
+  "license": "MIT"
+}

package/src/cleanup.ts

@@ -0,0 +1,31 @@
+import { unlinkSync } from "node:fs";
+import { db } from "./db.js";
+import { config } from "./config.js";
+
+export function startCleanup(): ReturnType<typeof setInterval> {
+  return setInterval(() => {
+    const now = Date.now();
+
+    const oldFiles = db
+      .prepare(
+        `SELECT id, diskPath FROM files
+         WHERE status = 'acknowledged'
+            OR (createdAt < ? AND status = 'pending')`,
+      )
+      .all(new Date(now - config.fileTtlMs).toISOString()) as Array<{
+      id: string;
+      diskPath: string;
+    }>;
+
+    for (const f of oldFiles) {
+      try { unlinkSync(f.diskPath); } catch {}
+      db.prepare(`DELETE FROM files WHERE id = ?`).run(f.id);
+    }
+
+    db.prepare(
+      `DELETE FROM commands
+       WHERE (status IN ('responded', 'error'))
+          OR (createdAt < ? AND status = 'queued')`,
+    ).run(new Date(now - config.commandTtlMs).toISOString());
+  }, config.cleanupIntervalMs);
+}

package/src/cli.ts

@@ -0,0 +1,209 @@
+#!/usr/bin/env -S npx tsx
+import { mkdirSync, writeFileSync, readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { randomBytes } from "node:crypto";
+import { execSync } from "node:child_process";
+
+const DATA_DIR = process.env.BRIDGE_FILERELAY_DATA || join(process.env.HOME || "/root", ".openclaw-bridge-hub");
+const ENV_FILE = join(DATA_DIR, ".env");
+const IS_LINUX = process.platform === "linux";
+
+const command = process.argv[2];
+
+function printHelp() {
+  console.log(`
+openclaw-bridge-hub — OpenClaw Bridge FileRelay Server
+
+Commands:
+  init              Initialize config (generates API key, creates data dir)
+  start             Start the server
+  status            Check if server is running
+  install-service   Install as systemd service (Linux, auto-start on boot)
+  uninstall-service Remove systemd service
+  help              Show this help
+
+Environment:
+  BRIDGE_FILERELAY_DATA   Data directory (default: ~/.openclaw-bridge-hub)
+  PORT                    Server port (default: 3080)
+  API_KEY                 API key for authentication
+
+Example:
+  npm install -g openclaw-bridge-hub
+  openclaw-bridge-hub init
+  openclaw-bridge-hub start
+  openclaw-bridge-hub install-service   # auto-start on reboot
+`);
+}
+
+function init() {
+  mkdirSync(DATA_DIR, { recursive: true });
+
+  if (existsSync(ENV_FILE)) {
+    console.log(`Config already exists at ${ENV_FILE}`);
+    console.log("Edit it to change settings, then run: openclaw-bridge-hub start");
+    return;
+  }
+
+  const apiKey = randomBytes(32).toString("hex");
+  const envContent = `# Bridge FileRelay Configuration
+PORT=3080
+API_KEY=${apiKey}
+DATA_DIR=${DATA_DIR}/data
+CLEANUP_INTERVAL_MS=3600000
+FILE_TTL_MS=86400000
+COMMAND_TTL_MS=3600000
+`;
+
+  writeFileSync(ENV_FILE, envContent);
+  mkdirSync(join(DATA_DIR, "data", "files"), { recursive: true });
+
+  console.log(`
+Initialized openclaw-bridge-hub at ${DATA_DIR}
+
+Your API key (save this — clients need it to connect):
+
+  ${apiKey}
+
+Config file: ${ENV_FILE}
+Data dir:    ${DATA_DIR}/data
+
+Next steps:
+  openclaw-bridge-hub start              # start the server
+  openclaw-bridge-hub install-service    # auto-start on boot (Linux)
+`);
+}
+
+function start() {
+  if (existsSync(ENV_FILE)) {
+    // Load env from config file
+    const content = readFileSync(ENV_FILE, "utf-8");
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+      const eqIdx = trimmed.indexOf("=");
+      if (eqIdx > 0) {
+        const key = trimmed.slice(0, eqIdx).trim();
+        const val = trimmed.slice(eqIdx + 1).trim();
+        if (!process.env[key]) process.env[key] = val;
+      }
+    }
+  } else {
+    console.log("No config found. Run 'openclaw-bridge-hub init' first.");
+    process.exit(1);
+  }
+
+  // Import and start the server
+  import("./index.js");
+}
+
+function status() {
+  if (!existsSync(ENV_FILE)) {
+    console.log("Not initialized. Run: openclaw-bridge-hub init");
+    return;
+  }
+
+  const content = readFileSync(ENV_FILE, "utf-8");
+  const portMatch = content.match(/^PORT=(\d+)/m);
+  const port = portMatch ? portMatch[1] : "3080";
+
+  try {
+    execSync(`curl -sf http://localhost:${port}/api/v1/health`, { timeout: 5000 });
+    console.log(`FileRelay is running on port ${port}`);
+  } catch {
+    console.log(`FileRelay is NOT running (port ${port})`);
+  }
+}
+
+function installService() {
+  if (!IS_LINUX) {
+    console.log("systemd service is only supported on Linux.");
+    console.log("On other platforms, use pm2 or your system's service manager.");
+    return;
+  }
+
+  // Find the actual path of openclaw-bridge-hub bin
+  let binPath: string;
+  try {
+    binPath = execSync("which openclaw-bridge-hub", { encoding: "utf-8" }).trim();
+  } catch {
+    binPath = "/usr/local/bin/openclaw-bridge-hub";
+  }
+
+  const user = process.env.USER || "root";
+
+  const serviceContent = `[Unit]
+Description=OpenClaw Bridge FileRelay
+After=network.target
+
+[Service]
+Type=simple
+User=${user}
+Environment=BRIDGE_FILERELAY_DATA=${DATA_DIR}
+ExecStart=${binPath} start
+Restart=always
+RestartSec=5
+
+[Install]
+WantedBy=multi-user.target
+`;
+
+  const servicePath = "/etc/systemd/system/openclaw-bridge-hub.service";
+  try {
+    writeFileSync(servicePath, serviceContent);
+    execSync("systemctl daemon-reload");
+    execSync("systemctl enable openclaw-bridge-hub");
+    execSync("systemctl start openclaw-bridge-hub");
+    console.log(`
+Service installed and started!
+
+  systemctl status openclaw-bridge-hub   # check status
+  systemctl restart openclaw-bridge-hub  # restart
+  journalctl -u openclaw-bridge-hub -f   # view logs
+`);
+  } catch (err) {
+    console.log(`Failed to install service. You may need sudo:\n  sudo openclaw-bridge-hub install-service`);
+    // Write service file to data dir as fallback
+    const fallbackPath = join(DATA_DIR, "openclaw-bridge-hub.service");
+    writeFileSync(fallbackPath, serviceContent);
+    console.log(`\nService file saved to: ${fallbackPath}`);
+    console.log("Install manually:");
+    console.log(`  sudo cp ${fallbackPath} /etc/systemd/system/`);
+    console.log("  sudo systemctl daemon-reload && sudo systemctl enable --now openclaw-bridge-hub");
+  }
+}
+
+function uninstallService() {
+  if (!IS_LINUX) {
+    console.log("systemd service is only supported on Linux.");
+    return;
+  }
+  try {
+    execSync("systemctl stop openclaw-bridge-hub");
+    execSync("systemctl disable openclaw-bridge-hub");
+    execSync("rm /etc/systemd/system/openclaw-bridge-hub.service");
+    execSync("systemctl daemon-reload");
+    console.log("Service removed.");
+  } catch {
+    console.log("Failed to remove service. Try with sudo.");
+  }
+}
+
+switch (command) {
+  case "init":
+    init();
+    break;
+  case "start":
+    start();
+    break;
+  case "status":
+    status();
+    break;
+  case "install-service":
+    installService();
+    break;
+  case "uninstall-service":
+    uninstallService();
+    break;
+  default:
+    printHelp();
+}

package/src/config.ts

@@ -0,0 +1,10 @@
+import "dotenv/config";
+
+export const config = {
+  port: parseInt(process.env.PORT ?? "3080", 10),
+  apiKey: process.env.API_KEY ?? "",
+  dataDir: process.env.DATA_DIR ?? "./data",
+  cleanupIntervalMs: parseInt(process.env.CLEANUP_INTERVAL_MS ?? "3600000", 10),
+  fileTtlMs: parseInt(process.env.FILE_TTL_MS ?? "86400000", 10),
+  commandTtlMs: parseInt(process.env.COMMAND_TTL_MS ?? "3600000", 10),
+};

package/src/db.ts

@@ -0,0 +1,48 @@
+import Database from "better-sqlite3";
+import { mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { config } from "./config.js";
+
+mkdirSync(config.dataDir, { recursive: true });
+mkdirSync(join(config.dataDir, "files"), { recursive: true });
+
+const dbPath = join(config.dataDir, "relay.db");
+export const db = new Database(dbPath);
+
+db.pragma("journal_mode = WAL");
+
+db.exec(`
+  CREATE TABLE IF NOT EXISTS files (
+    id TEXT PRIMARY KEY,
+    fromAgent TEXT NOT NULL,
+    toAgent TEXT NOT NULL,
+    filename TEXT NOT NULL,
+    diskPath TEXT NOT NULL,
+    size INTEGER NOT NULL DEFAULT 0,
+    metadata TEXT NOT NULL DEFAULT '{}',
+    status TEXT NOT NULL DEFAULT 'pending',
+    createdAt TEXT NOT NULL
+  );
+
+  CREATE TABLE IF NOT EXISTS commands (
+    id TEXT PRIMARY KEY,
+    fromAgent TEXT NOT NULL,
+    toAgent TEXT NOT NULL,
+    type TEXT NOT NULL,
+    payload TEXT NOT NULL DEFAULT '{}',
+    status TEXT NOT NULL DEFAULT 'queued',
+    response TEXT,
+    createdAt TEXT NOT NULL,
+    respondedAt TEXT
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_files_toAgent_status ON files(toAgent, status);
+  CREATE INDEX IF NOT EXISTS idx_commands_toAgent_status ON commands(toAgent, status);
+
+  CREATE TABLE IF NOT EXISTS registry (
+    agentId TEXT PRIMARY KEY,
+    data TEXT NOT NULL DEFAULT '{}',
+    lastHeartbeat TEXT NOT NULL,
+    createdAt TEXT NOT NULL
+  );
+`);

package/src/index.ts

@@ -0,0 +1,36 @@
+import Fastify from "fastify";
+import { config } from "./config.js";
+import "./db.js";
+import { registerFileRoutes } from "./routes/files.js";
+import { registerCommandRoutes } from "./routes/commands.js";
+import { registerHealthRoutes } from "./routes/health.js";
+import { registerRegistryRoutes } from "./routes/registry.js";
+import { authMiddleware } from "./middleware/auth.js";
+import { startCleanup } from "./cleanup.js";
+
+const app = Fastify({ logger: true });
+
+app.addHook("onRequest", authMiddleware);
+
+registerFileRoutes(app);
+registerCommandRoutes(app);
+registerHealthRoutes(app);
+registerRegistryRoutes(app);
+
+const cleanupTimer = startCleanup();
+
+const shutdown = async () => {
+  clearInterval(cleanupTimer);
+  await app.close();
+  process.exit(0);
+};
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);
+
+app.listen({ port: config.port, host: "0.0.0.0" }, (err, address) => {
+  if (err) {
+    console.error("Failed to start FileRelay:", err);
+    process.exit(1);
+  }
+  console.log(`Bridge FileRelay listening on ${address}`);
+});

package/src/middleware/auth.ts

@@ -0,0 +1,13 @@
+import type { FastifyRequest, FastifyReply } from "fastify";
+import { config } from "../config.js";
+
+export async function authMiddleware(
+  request: FastifyRequest,
+  reply: FastifyReply,
+): Promise<void> {
+  if (!config.apiKey) return;
+  const key = request.headers["x-api-key"];
+  if (key !== config.apiKey) {
+    reply.code(401).send({ error: "Invalid API key" });
+  }
+}

package/src/routes/commands.ts

@@ -0,0 +1,93 @@
+import type { FastifyInstance } from "fastify";
+import { v4 as uuid } from "uuid";
+import { db } from "../db.js";
+
+export function registerCommandRoutes(app: FastifyInstance): void {
+  app.post("/api/v1/commands/enqueue", async (request) => {
+    const body = request.body as {
+      fromAgent: string;
+      toAgent: string;
+      type: string;
+      payload: Record<string, unknown>;
+    };
+
+    const id = uuid();
+    const createdAt = new Date().toISOString();
+    db.prepare(
+      `INSERT INTO commands (id, fromAgent, toAgent, type, payload, status, createdAt)
+       VALUES (?, ?, ?, ?, ?, 'queued', ?)`,
+    ).run(id, body.fromAgent, body.toAgent, body.type, JSON.stringify(body.payload), createdAt);
+
+    return { id, status: "queued" };
+  });
+
+  app.get("/api/v1/commands/pending", async (request) => {
+    const { agent } = request.query as { agent: string };
+    const rows = db
+      .prepare(
+        `SELECT id, fromAgent, type, payload, createdAt
+         FROM commands WHERE toAgent = ? AND status = 'queued'
+         ORDER BY createdAt ASC`,
+      )
+      .all(agent) as Array<{
+      id: string;
+      fromAgent: string;
+      type: string;
+      payload: string;
+      createdAt: string;
+    }>;
+
+    return {
+      commands: rows.map((r) => ({
+        ...r,
+        payload: JSON.parse(r.payload),
+      })),
+    };
+  });
+
+  app.post("/api/v1/commands/respond/:id", async (request, reply) => {
+    const { id } = request.params as { id: string };
+    const body = request.body as {
+      status: "ok" | "error";
+      payload: Record<string, unknown>;
+    };
+
+    const existing = db.prepare(`SELECT id FROM commands WHERE id = ?`).get(id);
+    if (!existing) {
+      reply.code(404).send({ error: "Command not found" });
+      return;
+    }
+
+    db.prepare(
+      `UPDATE commands SET status = ?, response = ?, respondedAt = ? WHERE id = ?`,
+    ).run(
+      body.status === "ok" ? "responded" : "error",
+      JSON.stringify(body.payload),
+      new Date().toISOString(),
+      id,
+    );
+
+    return { status: "updated" };
+  });
+
+  app.get("/api/v1/commands/result/:id", async (request, reply) => {
+    const { id } = request.params as { id: string };
+    const row = db.prepare(`SELECT status, response FROM commands WHERE id = ?`).get(id) as
+      | { status: string; response: string | null }
+      | undefined;
+
+    if (!row) {
+      reply.code(404).send({ error: "Command not found" });
+      return;
+    }
+
+    if (row.status === "queued") {
+      return { status: "queued" };
+    }
+
+    return {
+      status: row.status === "responded" ? "ok" : "error",
+      payload: row.response ? JSON.parse(row.response) : null,
+    };
+  });
+}

package/src/routes/files.ts

@@ -0,0 +1,103 @@
+import type { FastifyInstance } from "fastify";
+import { writeFileSync, readFileSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { v4 as uuid } from "uuid";
+import { db } from "../db.js";
+import { config } from "../config.js";
+
+export function registerFileRoutes(app: FastifyInstance): void {
+  app.post("/api/v1/files/upload", async (request) => {
+    const body = request.body as {
+      fromAgent: string;
+      toAgent: string;
+      filename: string;
+      content: string;
+      metadata?: Record<string, unknown>;
+    };
+
+    const id = uuid();
+    const diskPath = join(config.dataDir, "files", `${id}.bin`);
+    const buffer = Buffer.from(body.content, "base64");
+    writeFileSync(diskPath, buffer);
+
+    const createdAt = new Date().toISOString();
+    db.prepare(
+      `INSERT INTO files (id, fromAgent, toAgent, filename, diskPath, size, metadata, status, createdAt)
+       VALUES (?, ?, ?, ?, ?, ?, ?, 'pending', ?)`,
+    ).run(
+      id,
+      body.fromAgent,
+      body.toAgent,
+      body.filename,
+      diskPath,
+      buffer.length,
+      JSON.stringify(body.metadata ?? {}),
+      createdAt,
+    );
+
+    return { id, status: "pending", createdAt };
+  });
+
+  app.get("/api/v1/files/pending", async (request) => {
+    const { agent } = request.query as { agent: string };
+    const rows = db
+      .prepare(
+        `SELECT id, fromAgent, filename, size, metadata, createdAt
+         FROM files WHERE toAgent = ? AND status = 'pending'
+         ORDER BY createdAt ASC`,
+      )
+      .all(agent) as Array<{
+      id: string;
+      fromAgent: string;
+      filename: string;
+      size: number;
+      metadata: string;
+      createdAt: string;
+    }>;
+
+    return {
+      files: rows.map((r) => ({
+        ...r,
+        metadata: JSON.parse(r.metadata),
+      })),
+    };
+  });
+
+  app.get("/api/v1/files/download/:id", async (request, reply) => {
+    const { id } = request.params as { id: string };
+    const row = db.prepare(`SELECT diskPath FROM files WHERE id = ?`).get(id) as
+      | { diskPath: string }
+      | undefined;
+
+    if (!row) {
+      reply.code(404).send({ error: "File not found" });
+      return;
+    }
+
+    try {
+      const content = readFileSync(row.diskPath);
+      return { content: content.toString("base64") };
+    } catch {
+      reply.code(404).send({ error: "File data not found on disk" });
+    }
+  });
+
+  app.post("/api/v1/files/ack/:id", async (request, reply) => {
+    const { id } = request.params as { id: string };
+    const row = db.prepare(`SELECT diskPath FROM files WHERE id = ?`).get(id) as
+      | { diskPath: string }
+      | undefined;
+
+    if (!row) {
+      reply.code(404).send({ error: "File not found" });
+      return;
+    }
+
+    try {
+      unlinkSync(row.diskPath);
+    } catch {}
+    db.prepare(`UPDATE files SET status = 'acknowledged' WHERE id = ?`).run(id);
+
+    return { status: "acknowledged" };
+  });
+}

package/src/routes/health.ts

@@ -0,0 +1,41 @@
+import type { FastifyInstance } from "fastify";
+import { db } from "../db.js";
+import { statSync } from "node:fs";
+import { join } from "node:path";
+import { config } from "../config.js";
+
+export function registerHealthRoutes(app: FastifyInstance): void {
+  app.get("/api/v1/health", async () => {
+    return { status: "ok", timestamp: new Date().toISOString() };
+  });
+
+  app.get("/api/v1/stats", async () => {
+    const pendingFiles = (
+      db.prepare(`SELECT COUNT(*) as count FROM files WHERE status = 'pending'`).get() as {
+        count: number;
+      }
+    ).count;
+    const queuedCommands = (
+      db.prepare(`SELECT COUNT(*) as count FROM commands WHERE status = 'queued'`).get() as {
+        count: number;
+      }
+    ).count;
+
+    let diskUsageBytes = 0;
+    try {
+      const dbFile = join(config.dataDir, "relay.db");
+      try { diskUsageBytes += statSync(dbFile).size; } catch {}
+      const rows = db.prepare(`SELECT diskPath FROM files WHERE status = 'pending'`).all() as Array<{ diskPath: string }>;
+      for (const r of rows) {
+        try { diskUsageBytes += statSync(r.diskPath).size; } catch {}
+      }
+    } catch {}
+
+    return {
+      pendingFiles,
+      queuedCommands,
+      diskUsageBytes,
+      diskUsageMB: Math.round(diskUsageBytes / 1024 / 1024 * 100) / 100,
+    };
+  });
+}

package/src/routes/registry.ts

@@ -0,0 +1,87 @@
+import type { FastifyInstance } from "fastify";
+import { db } from "../db.js";
+
+export function registerRegistryRoutes(app: FastifyInstance): void {
+  // Register or update a gateway entry
+  app.post("/api/v1/registry/register", async (request) => {
+    const body = request.body as Record<string, unknown>;
+    const agentId = body.agentId as string;
+    if (!agentId) return { error: "agentId is required" };
+
+    const now = new Date().toISOString();
+    const data = JSON.stringify(body);
+
+    db.prepare(
+      `INSERT INTO registry (agentId, data, lastHeartbeat, createdAt)
+       VALUES (?, ?, ?, ?)
+       ON CONFLICT(agentId) DO UPDATE SET data = ?, lastHeartbeat = ?`,
+    ).run(agentId, data, now, now, data, now);
+
+    return { status: "ok", agentId };
+  });
+
+  // Heartbeat — update lastHeartbeat and optionally update data
+  app.post("/api/v1/registry/heartbeat", async (request) => {
+    const body = request.body as Record<string, unknown>;
+    const agentId = body.agentId as string;
+    if (!agentId) return { error: "agentId is required" };
+
+    const now = new Date().toISOString();
+
+    if (Object.keys(body).length > 1) {
+      // Full data update
+      const data = JSON.stringify(body);
+      db.prepare(
+        `UPDATE registry SET data = ?, lastHeartbeat = ? WHERE agentId = ?`,
+      ).run(data, now, agentId);
+    } else {
+      // Heartbeat only
+      db.prepare(
+        `UPDATE registry SET lastHeartbeat = ? WHERE agentId = ?`,
+      ).run(now, agentId);
+    }
+
+    return { status: "ok", agentId, lastHeartbeat: now };
+  });
+
+  // Discover — list all registered gateways
+  app.get("/api/v1/registry/discover", async () => {
+    const rows = db
+      .prepare(`SELECT agentId, data, lastHeartbeat, createdAt FROM registry ORDER BY agentId`)
+      .all() as Array<{
+      agentId: string;
+      data: string;
+      lastHeartbeat: string;
+      createdAt: string;
+    }>;
+
+    return {
+      agents: rows.map((r) => ({
+        ...JSON.parse(r.data),
+        lastHeartbeat: r.lastHeartbeat,
+      })),
+    };
+  });
+
+  // Whois — get a specific gateway
+  app.get("/api/v1/registry/whois/:agentId", async (request, reply) => {
+    const { agentId } = request.params as { agentId: string };
+    const row = db
+      .prepare(`SELECT data, lastHeartbeat FROM registry WHERE agentId = ?`)
+      .get(agentId) as { data: string; lastHeartbeat: string } | undefined;
+
+    if (!row) {
+      reply.code(404).send({ error: `Agent "${agentId}" not found` });
+      return;
+    }
+
+    return { ...JSON.parse(row.data), lastHeartbeat: row.lastHeartbeat };
+  });
+
+  // Deregister — remove a gateway
+  app.delete("/api/v1/registry/:agentId", async (request) => {
+    const { agentId } = request.params as { agentId: string };
+    db.prepare(`DELETE FROM registry WHERE agentId = ?`).run(agentId);
+    return { status: "ok", agentId };
+  });
+}

package/src/types.ts

@@ -0,0 +1,23 @@
+export interface FileRecord {
+  id: string;
+  fromAgent: string;
+  toAgent: string;
+  filename: string;
+  diskPath: string;
+  size: number;
+  metadata: string;
+  status: "pending" | "acknowledged";
+  createdAt: string;
+}
+
+export interface CommandRecord {
+  id: string;
+  fromAgent: string;
+  toAgent: string;
+  type: string;
+  payload: string;
+  status: "queued" | "responded" | "error";
+  response: string | null;
+  createdAt: string;
+  respondedAt: string | null;
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true
+  },
+  "include": ["src"]
+}