bopodev-api 0.1.30 → 0.1.32

package/src/routes/observability.ts

@@ -3,6 +3,7 @@ import { readFile, stat } from "node:fs/promises";
 import { basename, resolve } from "node:path";
 import {
   getHeartbeatRun,
+  listAssistantChatThreadStatsInCreatedAtRange,
   listCompanies,
   listAgents,
   listAuditEvents,
@@ -10,13 +11,29 @@ import {
   listGoals,
   listHeartbeatRunMessages,
   listHeartbeatRuns,
-  listPluginRuns
+  listPluginRuns,
+  listProjects
 } from "bopodev-db";
 import type { AppContext } from "../context";
 import { sendError, sendOk } from "../http";
 import { resolveRunArtifactAbsolutePath } from "../lib/run-artifact-paths";
 import { requireCompanyScope } from "../middleware/company-scope";
-import { listAgentMemoryFiles, loadAgentMemoryContext, readAgentMemoryFile } from "../services/memory-file-service";
+import { enforcePermission } from "../middleware/request-actor";
+import {
+  listAgentOperatingMarkdownFiles,
+  readAgentOperatingFile,
+  writeAgentOperatingFile
+} from "../services/agent-operating-file-service";
+import {
+  listAgentMemoryFiles,
+  listCompanyMemoryFiles,
+  listProjectMemoryFiles,
+  loadAgentMemoryContext,
+  readAgentMemoryFile,
+  readCompanyMemoryFile,
+  readProjectMemoryFile,
+  writeAgentMemoryFile
+} from "../services/memory-file-service";
 
 export function createObservabilityRouter(ctx: AppContext) {
   const router = Router();
@@ -44,6 +61,53 @@ export function createObservabilityRouter(ctx: AppContext) {
     );
   });
 
+  /**
+   * Owner-assistant threads with message counts in `[from, toExclusive)` on message `created_at`.
+   * Prefer `from` + `toExclusive` (ISO 8601) so the window matches the browser local month used for cost charts;
+   * otherwise `monthKey=YYYY-MM` selects that month in UTC.
+   */
+  router.get("/assistant-chat-threads", async (req, res) => {
+    const companyId = req.companyId!;
+    const fromRaw = typeof req.query.from === "string" ? req.query.from.trim() : "";
+    const toRaw = typeof req.query.toExclusive === "string" ? req.query.toExclusive.trim() : "";
+    let startInclusive: Date;
+    let endExclusive: Date;
+    if (fromRaw.length > 0 && toRaw.length > 0) {
+      startInclusive = new Date(fromRaw);
+      endExclusive = new Date(toRaw);
+      if (Number.isNaN(startInclusive.getTime()) || Number.isNaN(endExclusive.getTime())) {
+        return sendError(res, "from and toExclusive must be valid ISO 8601 datetimes", 422);
+      }
+      if (endExclusive.getTime() <= startInclusive.getTime()) {
+        return sendError(res, "toExclusive must be after from", 422);
+      }
+      const maxSpanMs = 120 * 86400000;
+      if (endExclusive.getTime() - startInclusive.getTime() > maxSpanMs) {
+        return sendError(res, "Date range too large (max 120 days)", 422);
+      }
+    } else {
+      const monthKey = typeof req.query.monthKey === "string" ? req.query.monthKey.trim() : "";
+      const match = monthKey.match(/^(\d{4})-(\d{2})$/);
+      if (!match) {
+        return sendError(res, "Provide from+toExclusive (ISO) or monthKey (YYYY-MM)", 422);
+      }
+      const year = Number(match[1]);
+      const month = Number(match[2]);
+      if (month < 1 || month > 12) {
+        return sendError(res, "Invalid month in monthKey", 422);
+      }
+      startInclusive = new Date(Date.UTC(year, month - 1, 1, 0, 0, 0, 0));
+      endExclusive = new Date(Date.UTC(year, month, 1, 0, 0, 0, 0));
+    }
+    const threads = await listAssistantChatThreadStatsInCreatedAtRange(
+      ctx.db,
+      companyId,
+      startInclusive,
+      endExclusive
+    );
+    return sendOk(res, { threads });
+  });
+
   router.get("/heartbeats", async (req, res) => {
     const companyId = req.companyId!;
     const rawLimit = Number(req.query.limit ?? 100);
@@ -240,6 +304,84 @@ export function createObservabilityRouter(ctx: AppContext) {
     });
   });
 
+  router.get("/memory/company/files", async (req, res) => {
+    const companyId = req.companyId!;
+    const rawLimit = Number(req.query.limit ?? 100);
+    const limit = Number.isFinite(rawLimit) ? Math.min(Math.max(Math.floor(rawLimit), 1), 500) : 100;
+    try {
+      const files = await listCompanyMemoryFiles({ companyId, maxFiles: limit });
+      return sendOk(res, {
+        items: files.map((file) => ({
+          relativePath: file.relativePath,
+          path: file.path
+        }))
+      });
+    } catch (error) {
+      return sendError(res, String(error), 422);
+    }
+  });
+
+  router.get("/memory/company/file", async (req, res) => {
+    const companyId = req.companyId!;
+    const relativePath = typeof req.query.path === "string" ? req.query.path.trim() : "";
+    if (!relativePath) {
+      return sendError(res, "Query parameter 'path' is required.", 422);
+    }
+    try {
+      const file = await readCompanyMemoryFile({ companyId, relativePath });
+      return sendOk(res, file);
+    } catch (error) {
+      return sendError(res, String(error), 422);
+    }
+  });
+
+  router.get("/memory/project/:projectId/files", async (req, res) => {
+    const companyId = req.companyId!;
+    const projectId = req.params.projectId?.trim() ?? "";
+    if (!projectId) {
+      return sendError(res, "Missing project id.", 422);
+    }
+    const projects = await listProjects(ctx.db, companyId);
+    if (!projects.some((p) => p.id === projectId)) {
+      return sendError(res, "Project not found.", 404);
+    }
+    const rawLimit = Number(req.query.limit ?? 100);
+    const limit = Number.isFinite(rawLimit) ? Math.min(Math.max(Math.floor(rawLimit), 1), 500) : 100;
+    try {
+      const files = await listProjectMemoryFiles({ companyId, projectId, maxFiles: limit });
+      return sendOk(res, {
+        items: files.map((file) => ({
+          relativePath: file.relativePath,
+          path: file.path
+        }))
+      });
+    } catch (error) {
+      return sendError(res, String(error), 422);
+    }
+  });
+
+  router.get("/memory/project/:projectId/file", async (req, res) => {
+    const companyId = req.companyId!;
+    const projectId = req.params.projectId?.trim() ?? "";
+    if (!projectId) {
+      return sendError(res, "Missing project id.", 422);
+    }
+    const projects = await listProjects(ctx.db, companyId);
+    if (!projects.some((p) => p.id === projectId)) {
+      return sendError(res, "Project not found.", 404);
+    }
+    const relativePath = typeof req.query.path === "string" ? req.query.path.trim() : "";
+    if (!relativePath) {
+      return sendError(res, "Query parameter 'path' is required.", 422);
+    }
+    try {
+      const file = await readProjectMemoryFile({ companyId, projectId, relativePath });
+      return sendOk(res, file);
+    } catch (error) {
+      return sendError(res, String(error), 422);
+    }
+  });
+
   router.get("/memory/:agentId/file", async (req, res) => {
     const companyId = req.companyId!;
     const agentId = req.params.agentId;
@@ -259,6 +401,117 @@ export function createObservabilityRouter(ctx: AppContext) {
     }
   });
 
+  router.put("/memory/:agentId/file", async (req, res) => {
+    if (!enforcePermission(req, res, "agents:write")) {
+      return;
+    }
+    const companyId = req.companyId!;
+    const agentId = req.params.agentId;
+    const relativePath = typeof req.query.path === "string" ? req.query.path.trim() : "";
+    if (!relativePath) {
+      return sendError(res, "Query parameter 'path' is required.", 422);
+    }
+    const body = req.body as { content?: unknown };
+    if (typeof body?.content !== "string") {
+      return sendError(res, "Expected JSON body with string 'content'.", 422);
+    }
+    const agents = await listAgents(ctx.db, companyId);
+    if (!agents.some((entry) => entry.id === agentId)) {
+      return sendError(res, "Agent not found", 404);
+    }
+    try {
+      const result = await writeAgentMemoryFile({
+        companyId,
+        agentId,
+        relativePath,
+        content: body.content
+      });
+      return sendOk(res, result);
+    } catch (error) {
+      return sendError(res, String(error), 422);
+    }
+  });
+
+  router.get("/agent-operating/:agentId/files", async (req, res) => {
+    const companyId = req.companyId!;
+    const agentId = req.params.agentId;
+    const agents = await listAgents(ctx.db, companyId);
+    if (!agents.some((entry) => entry.id === agentId)) {
+      return sendError(res, "Agent not found", 404);
+    }
+    const rawLimit = Number(req.query.limit ?? 100);
+    const limit = Number.isFinite(rawLimit) ? Math.min(Math.max(Math.floor(rawLimit), 1), 500) : 100;
+    try {
+      const files = await listAgentOperatingMarkdownFiles({
+        companyId,
+        agentId,
+        maxFiles: limit
+      });
+      return sendOk(res, {
+        items: files.map((file) => ({
+          relativePath: file.relativePath,
+          path: file.path
+        }))
+      });
+    } catch (error) {
+      return sendError(res, String(error), 422);
+    }
+  });
+
+  router.get("/agent-operating/:agentId/file", async (req, res) => {
+    const companyId = req.companyId!;
+    const agentId = req.params.agentId;
+    const relativePath = typeof req.query.path === "string" ? req.query.path.trim() : "";
+    if (!relativePath) {
+      return sendError(res, "Query parameter 'path' is required.", 422);
+    }
+    const agents = await listAgents(ctx.db, companyId);
+    if (!agents.some((entry) => entry.id === agentId)) {
+      return sendError(res, "Agent not found", 404);
+    }
+    try {
+      const file = await readAgentOperatingFile({
+        companyId,
+        agentId,
+        relativePath
+      });
+      return sendOk(res, file);
+    } catch (error) {
+      return sendError(res, String(error), 422);
+    }
+  });
+
+  router.put("/agent-operating/:agentId/file", async (req, res) => {
+    if (!enforcePermission(req, res, "agents:write")) {
+      return;
+    }
+    const companyId = req.companyId!;
+    const agentId = req.params.agentId;
+    const relativePath = typeof req.query.path === "string" ? req.query.path.trim() : "";
+    if (!relativePath) {
+      return sendError(res, "Query parameter 'path' is required.", 422);
+    }
+    const body = req.body as { content?: unknown };
+    if (typeof body?.content !== "string") {
+      return sendError(res, "Expected JSON body with string 'content'.", 422);
+    }
+    const agents = await listAgents(ctx.db, companyId);
+    if (!agents.some((entry) => entry.id === agentId)) {
+      return sendError(res, "Agent not found", 404);
+    }
+    try {
+      const result = await writeAgentOperatingFile({
+        companyId,
+        agentId,
+        relativePath,
+        content: body.content
+      });
+      return sendOk(res, result);
+    } catch (error) {
+      return sendError(res, String(error), 422);
+    }
+  });
+
   router.get("/memory/:agentId/context-preview", async (req, res) => {
     const companyId = req.companyId!;
     const agentId = req.params.agentId;

package/src/services/agent-operating-file-service.ts

@@ -0,0 +1,116 @@
+import { mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
+import { dirname, join, relative, resolve } from "node:path";
+import { isInsidePath, resolveAgentOperatingPath } from "../lib/instance-paths";
+
+const MAX_OBSERVABILITY_FILES = 200;
+const MAX_OBSERVABILITY_FILE_BYTES = 512 * 1024;
+
+function isMarkdownFileName(name: string) {
+  return name.toLowerCase().endsWith(".md");
+}
+
+async function walkMarkdownFiles(root: string, maxFiles: number) {
+  const collected: string[] = [];
+  const queue = [root];
+  while (queue.length > 0 && collected.length < maxFiles) {
+    const current = queue.shift();
+    if (!current) {
+      continue;
+    }
+    const entries = await readdir(current, { withFileTypes: true });
+    for (const entry of entries) {
+      const absolutePath = join(current, entry.name);
+      if (entry.isDirectory()) {
+        queue.push(absolutePath);
+        continue;
+      }
+      if (entry.isFile() && isMarkdownFileName(entry.name)) {
+        collected.push(absolutePath);
+        if (collected.length >= maxFiles) {
+          break;
+        }
+      }
+    }
+  }
+  return collected.sort();
+}
+
+export async function listAgentOperatingMarkdownFiles(input: {
+  companyId: string;
+  agentId: string;
+  maxFiles?: number;
+}) {
+  const root = resolveAgentOperatingPath(input.companyId, input.agentId);
+  await mkdir(root, { recursive: true });
+  const maxFiles = Math.max(1, Math.min(MAX_OBSERVABILITY_FILES, input.maxFiles ?? 100));
+  const files = await walkMarkdownFiles(root, maxFiles);
+  return files.map((filePath) => ({
+    path: filePath,
+    relativePath: relative(root, filePath),
+    operatingRoot: root
+  }));
+}
+
+export async function readAgentOperatingFile(input: {
+  companyId: string;
+  agentId: string;
+  relativePath: string;
+}) {
+  const root = resolveAgentOperatingPath(input.companyId, input.agentId);
+  await mkdir(root, { recursive: true });
+  const candidate = resolve(root, input.relativePath);
+  if (!isInsidePath(root, candidate)) {
+    throw new Error("Requested operating path is outside of operating root.");
+  }
+  const info = await stat(candidate);
+  if (!info.isFile()) {
+    throw new Error("Requested operating path is not a file.");
+  }
+  if (info.size > MAX_OBSERVABILITY_FILE_BYTES) {
+    throw new Error("Requested operating file exceeds size limit.");
+  }
+  const content = await readFile(candidate, "utf8");
+  return {
+    path: candidate,
+    relativePath: relative(root, candidate),
+    content,
+    sizeBytes: info.size
+  };
+}
+
+export async function writeAgentOperatingFile(input: {
+  companyId: string;
+  agentId: string;
+  relativePath: string;
+  content: string;
+}) {
+  const root = resolveAgentOperatingPath(input.companyId, input.agentId);
+  await mkdir(root, { recursive: true });
+  const normalizedRel = input.relativePath.trim();
+  if (!normalizedRel || normalizedRel.includes("..")) {
+    throw new Error("Invalid relative path.");
+  }
+  if (!isMarkdownFileName(normalizedRel)) {
+    throw new Error("Only .md files can be written under the operating directory.");
+  }
+  const candidate = resolve(root, normalizedRel);
+  if (!isInsidePath(root, candidate)) {
+    throw new Error("Requested operating path is outside of operating root.");
+  }
+  const bytes = Buffer.byteLength(input.content, "utf8");
+  if (bytes > MAX_OBSERVABILITY_FILE_BYTES) {
+    throw new Error("Content exceeds size limit.");
+  }
+  const parent = dirname(candidate);
+  if (!isInsidePath(root, parent)) {
+    throw new Error("Invalid parent directory.");
+  }
+  await mkdir(parent, { recursive: true });
+  await writeFile(candidate, input.content, { encoding: "utf8" });
+  const info = await stat(candidate);
+  return {
+    path: candidate,
+    relativePath: relative(root, candidate),
+    sizeBytes: info.size
+  };
+}

package/src/services/company-assistant-brain.ts

@@ -0,0 +1,50 @@
+import { getAdapterMetadata } from "bopodev-agent-sdk";
+
+/** CLI/local runtimes only (no direct API keys in Chat). */
+export const ASK_ASSISTANT_BRAIN_IDS = [
+  "claude_code",
+  "codex",
+  "cursor",
+  "opencode",
+  "gemini_cli"
+] as const;
+
+export type AskAssistantBrainId = (typeof ASK_ASSISTANT_BRAIN_IDS)[number];
+
+export type AskCliBrainId = AskAssistantBrainId;
+
+const ASK_BRAIN_SET = new Set<string>(ASK_ASSISTANT_BRAIN_IDS);
+
+/** Default when the client omits `brain` (env `BOPO_CHAT_DEFAULT_BRAIN` if set and valid, else codex). */
+export const DEFAULT_ASK_ASSISTANT_BRAIN: AskAssistantBrainId = "codex";
+
+const CLI_BRAINS = ASK_BRAIN_SET;
+
+export function listAskAssistantBrains() {
+  return getAdapterMetadata()
+    .filter((m) => ASK_BRAIN_SET.has(m.providerType))
+    .map((m) => ({
+      providerType: m.providerType,
+      label: m.label,
+      requiresRuntimeCwd: m.requiresRuntimeCwd
+    }));
+}
+
+export function parseAskBrain(raw?: string | null): string {
+  const trimmed = typeof raw === "string" ? raw.trim() : "";
+  if (!trimmed) {
+    const env = process.env.BOPO_CHAT_DEFAULT_BRAIN?.trim();
+    if (env && ASK_BRAIN_SET.has(env)) {
+      return env;
+    }
+    return DEFAULT_ASK_ASSISTANT_BRAIN;
+  }
+  if (!ASK_BRAIN_SET.has(trimmed)) {
+    throw new Error(`Unsupported assistant brain "${trimmed}".`);
+  }
+  return trimmed;
+}
+
+export function isAskCliBrain(brain: string): boolean {
+  return CLI_BRAINS.has(brain);
+}