botschat 0.1.0

package/packages/api/src/routes/jobs.ts

@@ -0,0 +1,65 @@
+import { Hono } from "hono";
+import type { Env } from "../env.js";
+
+/**
+ * Jobs API — background task execution history.
+ * Mounted at /api/channels/:channelId/tasks/:taskId/jobs
+ */
+const jobs = new Hono<{ Bindings: Env; Variables: { userId: string } }>();
+
+/** GET / — list jobs for a background task */
+jobs.get("/", async (c) => {
+  const userId = c.get("userId");
+  const channelId = c.req.param("channelId");
+  const taskId = c.req.param("taskId");
+  const limit = Math.min(Number(c.req.query("limit") ?? 50), 200);
+
+  // Verify ownership chain
+  const channel = await c.env.DB.prepare(
+    "SELECT id FROM channels WHERE id = ? AND user_id = ?",
+  )
+    .bind(channelId, userId)
+    .first();
+  if (!channel) return c.json({ error: "Channel not found" }, 404);
+
+  const task = await c.env.DB.prepare(
+    "SELECT id, kind FROM tasks WHERE id = ? AND channel_id = ?",
+  )
+    .bind(taskId, channelId)
+    .first<{ id: string; kind: string }>();
+  if (!task) return c.json({ error: "Task not found" }, 404);
+  if (task.kind !== "background") return c.json({ error: "Only background tasks have jobs" }, 400);
+
+  const { results } = await c.env.DB.prepare(
+    `SELECT id, session_key, status, started_at, finished_at, duration_ms, summary, created_at
+     FROM jobs WHERE task_id = ? AND user_id = ?
+     ORDER BY started_at DESC LIMIT ?`,
+  )
+    .bind(taskId, userId, limit)
+    .all<{
+      id: string;
+      session_key: string;
+      status: string;
+      started_at: number;
+      finished_at: number | null;
+      duration_ms: number | null;
+      summary: string;
+      created_at: number;
+    }>();
+
+  return c.json({
+    jobs: (results ?? []).map((r, idx, arr) => ({
+      id: r.id,
+      number: arr.length - idx,
+      sessionKey: r.session_key,
+      status: r.status,
+      startedAt: r.started_at,
+      finishedAt: r.finished_at,
+      durationMs: r.duration_ms,
+      summary: r.summary,
+      time: new Date(r.started_at * 1000).toLocaleString(),
+    })),
+  });
+});
+
+export { jobs };

package/packages/api/src/routes/models.ts

@@ -0,0 +1,22 @@
+import { Hono } from "hono";
+import type { Env } from "../env.js";
+
+export type ModelInfo = {
+  id: string;
+  name: string;
+  provider: string;
+};
+
+const models = new Hono<{ Bindings: Env; Variables: { userId: string } }>();
+
+/** GET /api/models — list available models (fetched from OpenClaw plugin via DO) */
+models.get("/", async (c) => {
+  const userId = c.get("userId");
+  const doId = c.env.CONNECTION_DO.idFromName(userId);
+  const stub = c.env.CONNECTION_DO.get(doId);
+  const res = await stub.fetch(new Request("https://internal/models"));
+  const data = await res.json<{ models: ModelInfo[] }>();
+  return c.json(data);
+});
+
+export { models };

package/packages/api/src/routes/pairing.ts

@@ -0,0 +1,76 @@
+import { Hono } from "hono";
+import type { Env } from "../env.js";
+import { generateId, generatePairingToken } from "../utils/id.js";
+
+const pairing = new Hono<{ Bindings: Env; Variables: { userId: string } }>();
+
+/** GET /api/pairing-tokens — list pairing tokens for the current user */
+pairing.get("/", async (c) => {
+  const userId = c.get("userId");
+
+  const { results } = await c.env.DB.prepare(
+    "SELECT id, token, label, last_connected_at, created_at FROM pairing_tokens WHERE user_id = ? ORDER BY created_at DESC",
+  )
+    .bind(userId)
+    .all<{
+      id: string;
+      token: string;
+      label: string | null;
+      last_connected_at: number | null;
+      created_at: number;
+    }>();
+
+  return c.json({
+    tokens: (results ?? []).map((r) => ({
+      id: r.id,
+      // Show only last 8 chars for security
+      token: r.token,
+      tokenPreview: `bc_pat_...${r.token.slice(-8)}`,
+      label: r.label,
+      lastConnectedAt: r.last_connected_at,
+      createdAt: r.created_at,
+    })),
+  });
+});
+
+/** POST /api/pairing-tokens — generate a new pairing token */
+pairing.post("/", async (c) => {
+  const userId = c.get("userId");
+  const { label } = await c.req.json<{ label?: string }>().catch(() => ({
+    label: undefined,
+  }));
+
+  const id = generateId("pt_");
+  const token = generatePairingToken();
+
+  await c.env.DB.prepare(
+    "INSERT INTO pairing_tokens (id, user_id, token, label) VALUES (?, ?, ?, ?)",
+  )
+    .bind(id, userId, token, label?.trim() ?? null)
+    .run();
+
+  return c.json(
+    {
+      id,
+      token, // Show full token only on creation
+      label: label?.trim() ?? null,
+    },
+    201,
+  );
+});
+
+/** DELETE /api/pairing-tokens/:id — revoke a pairing token */
+pairing.delete("/:id", async (c) => {
+  const userId = c.get("userId");
+  const tokenId = c.req.param("id");
+
+  await c.env.DB.prepare(
+    "DELETE FROM pairing_tokens WHERE id = ? AND user_id = ?",
+  )
+    .bind(tokenId, userId)
+    .run();
+
+  return c.json({ ok: true });
+});
+
+export { pairing };

package/packages/api/src/routes/projects.ts

@@ -0,0 +1,177 @@
+import { Hono } from "hono";
+import type { Env } from "../env.js";
+import { generateId } from "../utils/id.js";
+
+const projects = new Hono<{ Bindings: Env; Variables: { userId: string } }>();
+
+/** GET /api/projects — list all projects for the current user */
+projects.get("/", async (c) => {
+  const userId = c.get("userId");
+
+  const { results } = await c.env.DB.prepare(
+    "SELECT id, name, description, openclaw_agent_id, system_prompt, created_at, updated_at FROM projects WHERE user_id = ? ORDER BY created_at DESC",
+  )
+    .bind(userId)
+    .all<{
+      id: string;
+      name: string;
+      description: string;
+      openclaw_agent_id: string;
+      system_prompt: string;
+      created_at: number;
+      updated_at: number;
+    }>();
+
+  return c.json({
+    projects: (results ?? []).map((r) => ({
+      id: r.id,
+      name: r.name,
+      description: r.description,
+      openclawAgentId: r.openclaw_agent_id,
+      systemPrompt: r.system_prompt,
+      createdAt: r.created_at,
+      updatedAt: r.updated_at,
+    })),
+  });
+});
+
+/** POST /api/projects — create a new project */
+projects.post("/", async (c) => {
+  const userId = c.get("userId");
+  const { name, description, openclawAgentId, systemPrompt } = await c.req.json<{
+    name: string;
+    description?: string;
+    openclawAgentId?: string;
+    systemPrompt?: string;
+  }>();
+
+  if (!name?.trim()) {
+    return c.json({ error: "Project name is required" }, 400);
+  }
+
+  const id = generateId("prj_");
+  // Default agent ID derived from project name (slug)
+  const agentId =
+    openclawAgentId?.trim() ||
+    name
+      .trim()
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, "-")
+      .replace(/^-|-$/g, "");
+
+  await c.env.DB.prepare(
+    "INSERT INTO projects (id, user_id, name, description, openclaw_agent_id, system_prompt) VALUES (?, ?, ?, ?, ?, ?)",
+  )
+    .bind(id, userId, name.trim(), description?.trim() ?? "", agentId, systemPrompt?.trim() ?? "")
+    .run();
+
+  // Auto-create a default "Ad Hoc Chat" task
+  const taskId = generateId("tsk_");
+  const sessionKey = `agent:${agentId}:botschat:${userId}:adhoc`;
+  await c.env.DB.prepare(
+    "INSERT INTO tasks (id, project_id, name, kind, session_key) VALUES (?, ?, ?, ?, ?)",
+  )
+    .bind(taskId, id, "Ad Hoc Chat", "adhoc", sessionKey)
+    .run();
+
+  return c.json(
+    {
+      id,
+      name: name.trim(),
+      description: description?.trim() ?? "",
+      openclawAgentId: agentId,
+      systemPrompt: systemPrompt?.trim() ?? "",
+    },
+    201,
+  );
+});
+
+/** GET /api/projects/:id — get a single project */
+projects.get("/:id", async (c) => {
+  const userId = c.get("userId");
+  const projectId = c.req.param("id");
+
+  const row = await c.env.DB.prepare(
+    "SELECT id, name, description, openclaw_agent_id, system_prompt, created_at, updated_at FROM projects WHERE id = ? AND user_id = ?",
+  )
+    .bind(projectId, userId)
+    .first<{
+      id: string;
+      name: string;
+      description: string;
+      openclaw_agent_id: string;
+      system_prompt: string;
+      created_at: number;
+      updated_at: number;
+    }>();
+
+  if (!row) return c.json({ error: "Project not found" }, 404);
+
+  return c.json({
+    id: row.id,
+    name: row.name,
+    description: row.description,
+    openclawAgentId: row.openclaw_agent_id,
+    systemPrompt: row.system_prompt,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+  });
+});
+
+/** PATCH /api/projects/:id — update a project */
+projects.patch("/:id", async (c) => {
+  const userId = c.get("userId");
+  const projectId = c.req.param("id");
+  const body = await c.req.json<{
+    name?: string;
+    description?: string;
+    systemPrompt?: string;
+  }>();
+
+  const sets: string[] = [];
+  const values: unknown[] = [];
+
+  if (body.name !== undefined) {
+    sets.push("name = ?");
+    values.push(body.name.trim());
+  }
+  if (body.description !== undefined) {
+    sets.push("description = ?");
+    values.push(body.description.trim());
+  }
+  if (body.systemPrompt !== undefined) {
+    sets.push("system_prompt = ?");
+    values.push(body.systemPrompt.trim());
+  }
+
+  if (sets.length === 0) {
+    return c.json({ error: "No fields to update" }, 400);
+  }
+
+  sets.push("updated_at = unixepoch()");
+  values.push(projectId, userId);
+
+  await c.env.DB.prepare(
+    `UPDATE projects SET ${sets.join(", ")} WHERE id = ? AND user_id = ?`,
+  )
+    .bind(...values)
+    .run();
+
+  return c.json({ ok: true });
+});
+
+/** DELETE /api/projects/:id — delete a project */
+projects.delete("/:id", async (c) => {
+  const userId = c.get("userId");
+  const projectId = c.req.param("id");
+
+  await c.env.DB.prepare(
+    "DELETE FROM projects WHERE id = ? AND user_id = ?",
+  )
+    .bind(projectId, userId)
+    .run();
+
+  return c.json({ ok: true });
+});
+
+export { projects };

package/packages/api/src/routes/sessions.ts

@@ -0,0 +1,171 @@
+import { Hono } from "hono";
+import type { Env } from "../env.js";
+import { generateId } from "../utils/id.js";
+
+const sessions = new Hono<{ Bindings: Env; Variables: { userId: string } }>();
+
+/** GET /api/channels/:channelId/sessions — list all sessions for a channel */
+sessions.get("/", async (c) => {
+  const userId = c.get("userId");
+  const channelId = c.req.param("channelId");
+
+  // Verify channel ownership
+  const channel = await c.env.DB.prepare(
+    "SELECT id, openclaw_agent_id FROM channels WHERE id = ? AND user_id = ?",
+  )
+    .bind(channelId, userId)
+    .first<{ id: string; openclaw_agent_id: string }>();
+
+  if (!channel) return c.json({ error: "Channel not found" }, 404);
+
+  const { results } = await c.env.DB.prepare(
+    "SELECT id, name, session_key, created_at, updated_at FROM sessions WHERE channel_id = ? AND user_id = ? ORDER BY created_at ASC",
+  )
+    .bind(channelId, userId)
+    .all<{
+      id: string;
+      name: string;
+      session_key: string;
+      created_at: number;
+      updated_at: number;
+    }>();
+
+  return c.json({
+    sessions: (results ?? []).map((r) => ({
+      id: r.id,
+      name: r.name,
+      sessionKey: r.session_key,
+      createdAt: r.created_at,
+      updatedAt: r.updated_at,
+    })),
+  });
+});
+
+/** POST /api/channels/:channelId/sessions — create a new session */
+sessions.post("/", async (c) => {
+  const userId = c.get("userId");
+  const channelId = c.req.param("channelId");
+
+  // Verify channel ownership
+  const channel = await c.env.DB.prepare(
+    "SELECT id, openclaw_agent_id FROM channels WHERE id = ? AND user_id = ?",
+  )
+    .bind(channelId, userId)
+    .first<{ id: string; openclaw_agent_id: string }>();
+
+  if (!channel) return c.json({ error: "Channel not found" }, 404);
+
+  const { name } = await c.req.json<{ name?: string }>();
+
+  // Count existing sessions for auto-naming
+  const countRow = await c.env.DB.prepare(
+    "SELECT COUNT(*) as cnt FROM sessions WHERE channel_id = ? AND user_id = ?",
+  )
+    .bind(channelId, userId)
+    .first<{ cnt: number }>();
+  const count = countRow?.cnt ?? 0;
+
+  const sessionName = name?.trim() || `Session ${count + 1}`;
+  const id = generateId("ses_");
+  const sessionKey = `agent:${channel.openclaw_agent_id}:botschat:${userId}:ses:${id}`;
+
+  await c.env.DB.prepare(
+    "INSERT INTO sessions (id, channel_id, user_id, name, session_key) VALUES (?, ?, ?, ?, ?)",
+  )
+    .bind(id, channelId, userId, sessionName, sessionKey)
+    .run();
+
+  return c.json(
+    {
+      id,
+      name: sessionName,
+      sessionKey,
+      createdAt: Math.floor(Date.now() / 1000),
+      updatedAt: Math.floor(Date.now() / 1000),
+    },
+    201,
+  );
+});
+
+/** PATCH /api/channels/:channelId/sessions/:sessionId — rename a session */
+sessions.patch("/:sessionId", async (c) => {
+  const userId = c.get("userId");
+  const channelId = c.req.param("channelId");
+  const sessionId = c.req.param("sessionId");
+
+  // Verify channel ownership
+  const channel = await c.env.DB.prepare(
+    "SELECT id FROM channels WHERE id = ? AND user_id = ?",
+  )
+    .bind(channelId, userId)
+    .first();
+
+  if (!channel) return c.json({ error: "Channel not found" }, 404);
+
+  const { name } = await c.req.json<{ name: string }>();
+
+  if (!name?.trim()) {
+    return c.json({ error: "Session name is required" }, 400);
+  }
+
+  await c.env.DB.prepare(
+    "UPDATE sessions SET name = ?, updated_at = unixepoch() WHERE id = ? AND channel_id = ? AND user_id = ?",
+  )
+    .bind(name.trim(), sessionId, channelId, userId)
+    .run();
+
+  return c.json({ ok: true });
+});
+
+/** DELETE /api/channels/:channelId/sessions/:sessionId — delete a session */
+sessions.delete("/:sessionId", async (c) => {
+  const userId = c.get("userId");
+  const channelId = c.req.param("channelId");
+  const sessionId = c.req.param("sessionId");
+
+  // Verify channel ownership
+  const channel = await c.env.DB.prepare(
+    "SELECT id FROM channels WHERE id = ? AND user_id = ?",
+  )
+    .bind(channelId, userId)
+    .first();
+
+  if (!channel) return c.json({ error: "Channel not found" }, 404);
+
+  // Don't allow deleting the last session
+  const countRow = await c.env.DB.prepare(
+    "SELECT COUNT(*) as cnt FROM sessions WHERE channel_id = ? AND user_id = ?",
+  )
+    .bind(channelId, userId)
+    .first<{ cnt: number }>();
+
+  if ((countRow?.cnt ?? 0) <= 1) {
+    return c.json({ error: "Cannot delete the last session" }, 400);
+  }
+
+  // Get session_key before deleting (to clean up messages)
+  const session = await c.env.DB.prepare(
+    "SELECT session_key FROM sessions WHERE id = ? AND channel_id = ? AND user_id = ?",
+  )
+    .bind(sessionId, channelId, userId)
+    .first<{ session_key: string }>();
+
+  await c.env.DB.prepare(
+    "DELETE FROM sessions WHERE id = ? AND channel_id = ? AND user_id = ?",
+  )
+    .bind(sessionId, channelId, userId)
+    .run();
+
+  // Clean up messages for this session
+  if (session?.session_key) {
+    await c.env.DB.prepare(
+      "DELETE FROM messages WHERE session_key = ?",
+    )
+      .bind(session.session_key)
+      .run();
+  }
+
+  return c.json({ ok: true });
+});
+
+export { sessions };