bopodev-api 0.1.8 → 0.1.9

package/src/routes/issues.ts

@@ -1,14 +1,19 @@
 import { Router } from "express";
+import { and, eq } from "drizzle-orm";
 import { z } from "zod";
 import {
   addIssueComment,
+  agents,
   appendActivity,
   appendAuditEvent,
   createIssue,
   deleteIssueComment,
   deleteIssue,
+  issues,
+  listIssueActivity,
   listIssueComments,
   listIssues,
+  projects,
   updateIssueComment,
   updateIssue
 } from "bopodev-db";
@@ -31,14 +36,14 @@ const createIssueSchema = z.object({
 
 const createIssueCommentSchema = z.object({
   body: z.string().min(1),
-  authorType: z.enum(["human", "agent", "system"]).default("human"),
+  authorType: z.enum(["human", "agent", "system"]).optional(),
   authorId: z.string().optional()
 });
 
 const createIssueCommentLegacySchema = z.object({
   issueId: z.string().min(1),
   body: z.string().min(1),
-  authorType: z.enum(["human", "agent", "system"]).default("human"),
+  authorType: z.enum(["human", "agent", "system"]).optional(),
   authorId: z.string().optional()
 });
 
@@ -107,6 +112,17 @@ export function createIssuesRouter(ctx: AppContext) {
     if (!parsed.success) {
       return sendError(res, parsed.error.message, 422);
     }
+    if (parsed.data.assigneeAgentId) {
+      const assignmentValidation = await validateIssueAssignmentScope(
+        ctx,
+        req.companyId!,
+        parsed.data.projectId,
+        parsed.data.assigneeAgentId
+      );
+      if (assignmentValidation) {
+        return sendError(res, assignmentValidation, 422);
+      }
+    }
     const issue = await createIssue(ctx.db, { companyId: req.companyId!, ...parsed.data });
     await appendActivity(ctx.db, {
       companyId: req.companyId!,
@@ -131,6 +147,17 @@ export function createIssuesRouter(ctx: AppContext) {
     return sendOk(res, comments);
   });
 
+  router.get("/:issueId/activity", async (req, res) => {
+    const activity = await listIssueActivity(ctx.db, req.companyId!, req.params.issueId);
+    return sendOk(
+      res,
+      activity.map((row) => ({
+        ...row,
+        payload: parsePayload(row.payloadJson)
+      }))
+    );
+  });
+
   router.post("/:issueId/comments", async (req, res) => {
     requirePermission("issues:write")(req, res, () => {});
     if (res.headersSent) {
@@ -140,10 +167,13 @@ export function createIssuesRouter(ctx: AppContext) {
     if (!parsed.success) {
       return sendError(res, parsed.error.message, 422);
     }
+    const author = resolveIssueCommentAuthor(req.actor?.type, req.actor?.id, parsed.data);
     const comment = await addIssueComment(ctx.db, {
       companyId: req.companyId!,
       issueId: req.params.issueId,
-      ...parsed.data
+      body: parsed.data.body,
+      authorType: author.authorType,
+      authorId: author.authorId
     });
     await appendActivity(ctx.db, {
       companyId: req.companyId!,
@@ -175,7 +205,14 @@ export function createIssuesRouter(ctx: AppContext) {
     if (!parsed.success) {
       return sendError(res, parsed.error.message, 422);
     }
-    const comment = await addIssueComment(ctx.db, { companyId: req.companyId!, ...parsed.data });
+    const author = resolveIssueCommentAuthor(req.actor?.type, req.actor?.id, parsed.data);
+    const comment = await addIssueComment(ctx.db, {
+      companyId: req.companyId!,
+      issueId: parsed.data.issueId,
+      body: parsed.data.body,
+      authorType: author.authorType,
+      authorId: author.authorId
+    });
     await appendActivity(ctx.db, {
       companyId: req.companyId!,
       issueId: comment.issueId,
@@ -271,6 +308,34 @@ export function createIssuesRouter(ctx: AppContext) {
     if (!parsed.success) {
       return sendError(res, parsed.error.message, 422);
     }
+    if (parsed.data.assigneeAgentId !== undefined || parsed.data.projectId !== undefined) {
+      const [existingIssue] = await ctx.db
+        .select({
+          id: issues.id,
+          projectId: issues.projectId,
+          assigneeAgentId: issues.assigneeAgentId
+        })
+        .from(issues)
+        .where(and(eq(issues.companyId, req.companyId!), eq(issues.id, req.params.issueId)))
+        .limit(1);
+      if (!existingIssue) {
+        return sendError(res, "Issue not found.", 404);
+      }
+      const effectiveProjectId = parsed.data.projectId ?? existingIssue.projectId;
+      const effectiveAssigneeAgentId =
+        parsed.data.assigneeAgentId === undefined ? existingIssue.assigneeAgentId : parsed.data.assigneeAgentId;
+      if (effectiveAssigneeAgentId) {
+        const assignmentValidation = await validateIssueAssignmentScope(
+          ctx,
+          req.companyId!,
+          effectiveProjectId,
+          effectiveAssigneeAgentId
+        );
+        if (assignmentValidation) {
+          return sendError(res, assignmentValidation, 422);
+        }
+      }
+    }
 
     const issue = await updateIssue(ctx.db, { companyId: req.companyId!, id: req.params.issueId, ...parsed.data });
     if (!issue) {
@@ -317,3 +382,56 @@ export function createIssuesRouter(ctx: AppContext) {
 
   return router;
 }
+
+function parsePayload(payloadJson: string) {
+  try {
+    const parsed = JSON.parse(payloadJson) as unknown;
+    return parsed && typeof parsed === "object" ? (parsed as Record<string, unknown>) : {};
+  } catch {
+    return {};
+  }
+}
+
+function resolveIssueCommentAuthor(
+  actorType: "board" | "member" | "agent" | undefined,
+  actorId: string | undefined,
+  input: { authorType?: "human" | "agent" | "system"; authorId?: string }
+) {
+  const inferredAuthorType = actorType === "agent" ? "agent" : "human";
+  const authorType = input.authorType ?? inferredAuthorType;
+  if (input.authorId) {
+    return { authorType, authorId: input.authorId };
+  }
+  if (authorType === "agent" && actorId) {
+    return { authorType, authorId: actorId };
+  }
+  return { authorType, authorId: undefined };
+}
+
+async function validateIssueAssignmentScope(
+  ctx: AppContext,
+  companyId: string,
+  projectId: string,
+  assigneeAgentId: string
+) {
+  const [project] = await ctx.db
+    .select({ id: projects.id })
+    .from(projects)
+    .where(and(eq(projects.companyId, companyId), eq(projects.id, projectId)))
+    .limit(1);
+  if (!project) {
+    return "Project not found.";
+  }
+
+  const [agent] = await ctx.db
+    .select({ id: agents.id })
+    .from(agents)
+    .where(and(eq(agents.companyId, companyId), eq(agents.id, assigneeAgentId)))
+    .limit(1);
+  if (!agent) {
+    return "Assigned agent not found.";
+  }
+
+  return null;
+}
+

package/src/routes/projects.ts

@@ -1,8 +1,10 @@
 import { Router } from "express";
+import { mkdir } from "node:fs/promises";
 import { z } from "zod";
 import { appendAuditEvent, createProject, deleteProject, listProjects, syncProjectGoals, updateProject } from "bopodev-db";
 import type { AppContext } from "../context";
 import { sendError, sendOk } from "../http";
+import { normalizeAbsolutePath, resolveProjectWorkspacePath } from "../lib/instance-paths";
 import { requireCompanyScope } from "../middleware/company-scope";
 import { requirePermission } from "../middleware/request-actor";
 
@@ -59,15 +61,23 @@ export function createProjectsRouter(ctx: AppContext) {
     if (!parsed.success) {
       return sendError(res, parsed.error.message, 422);
     }
-    const project = await createProject(ctx.db, {
+    const explicitWorkspaceLocalPath = normalizeOptionalPath(parsed.data.workspaceLocalPath);
+    const created = await createProject(ctx.db, {
       companyId: req.companyId!,
       name: parsed.data.name,
       description: parsed.data.description,
       status: parsed.data.status,
       plannedStartAt: parsePlannedStartAt(parsed.data.plannedStartAt),
-      workspaceLocalPath: parsed.data.workspaceLocalPath,
+      workspaceLocalPath: explicitWorkspaceLocalPath ?? undefined,
       workspaceGithubRepo: parsed.data.workspaceGithubRepo
     });
+    const project =
+      explicitWorkspaceLocalPath
+        ? created
+        : await ensureAutoWorkspaceLocalPath(ctx, req.companyId!, created.id);
+    if (explicitWorkspaceLocalPath) {
+      await mkdir(explicitWorkspaceLocalPath, { recursive: true });
+    }
     await syncProjectGoals(ctx.db, {
       companyId: req.companyId!,
       projectId: project.id,
@@ -102,12 +112,38 @@ export function createProjectsRouter(ctx: AppContext) {
       status: parsed.data.status,
       plannedStartAt:
         parsed.data.plannedStartAt === undefined ? undefined : parsePlannedStartAt(parsed.data.plannedStartAt),
-      workspaceLocalPath: parsed.data.workspaceLocalPath,
+      workspaceLocalPath:
+        parsed.data.workspaceLocalPath === undefined
+          ? undefined
+          : parsed.data.workspaceLocalPath === null
+            ? null
+            : normalizeAbsolutePath(parsed.data.workspaceLocalPath),
       workspaceGithubRepo: parsed.data.workspaceGithubRepo
     });
+    if (
+      parsed.data.workspaceLocalPath !== undefined &&
+      parsed.data.workspaceLocalPath !== null &&
+      parsed.data.workspaceLocalPath.trim().length > 0
+    ) {
+      await mkdir(normalizeAbsolutePath(parsed.data.workspaceLocalPath), { recursive: true });
+    }
     if (!project) {
       return sendError(res, "Project not found.", 404);
     }
+    if (parsed.data.workspaceLocalPath === null) {
+      const autoWorkspacePath = resolveProjectWorkspacePath(req.companyId!, project.id);
+      await mkdir(autoWorkspacePath, { recursive: true });
+      const updated = await updateProject(ctx.db, {
+        companyId: req.companyId!,
+        id: req.params.projectId,
+        workspaceLocalPath: autoWorkspacePath
+      });
+      if (!updated) {
+        return sendError(res, "Project not found.", 404);
+      }
+      Object.assign(project, updated);
+    }
+
     if (parsed.data.goalIds) {
       await syncProjectGoals(ctx.db, {
         companyId: req.companyId!,
@@ -150,3 +186,24 @@ export function createProjectsRouter(ctx: AppContext) {
 
   return router;
 }
+
+async function ensureAutoWorkspaceLocalPath(ctx: AppContext, companyId: string, projectId: string) {
+  const workspaceLocalPath = resolveProjectWorkspacePath(companyId, projectId);
+  await mkdir(workspaceLocalPath, { recursive: true });
+  const updated = await updateProject(ctx.db, {
+    companyId,
+    id: projectId,
+    workspaceLocalPath
+  });
+  if (!updated) {
+    throw new Error("Project not found after creation.");
+  }
+  return updated;
+}
+
+function normalizeOptionalPath(value: string | undefined) {
+  if (!value || value.trim().length === 0) {
+    return null;
+  }
+  return normalizeAbsolutePath(value);
+}

package/src/scripts/backfill-project-workspaces.ts

@@ -0,0 +1,118 @@
+import { access, constants, mkdir } from "node:fs/promises";
+import { isAbsolute } from "node:path";
+import { pathToFileURL } from "node:url";
+import { bootstrapDatabase, listCompanies, listProjects, updateProject } from "bopodev-db";
+import { normalizeAbsolutePath, resolveBopoInstanceRoot, resolveProjectWorkspacePath, resolveStorageRoot } from "../lib/instance-paths";
+
+export interface ProjectWorkspaceBackfillSummary {
+  scannedProjects: number;
+  missingWorkspaceLocalPath: number;
+  relativeWorkspaceLocalPath: number;
+  updatedProjects: number;
+  createdDirectories: number;
+  writableInstanceRoot: boolean;
+  writableStorageRoot: boolean;
+  dryRun: boolean;
+}
+
+export async function backfillProjectWorkspaces(input: { dbPath?: string; dryRun: boolean }) {
+  const { db, client } = await bootstrapDatabase(input.dbPath);
+  const instanceRoot = resolveBopoInstanceRoot();
+  const storageRoot = resolveStorageRoot();
+  let scannedProjects = 0;
+  let missingWorkspaceLocalPath = 0;
+  let relativeWorkspaceLocalPath = 0;
+  let updatedProjects = 0;
+  let createdDirectories = 0;
+
+  try {
+    const companies = await listCompanies(db);
+    for (const company of companies) {
+      const projects = await listProjects(db, company.id);
+      for (const project of projects) {
+        scannedProjects += 1;
+        const workspaceLocalPath = project.workspaceLocalPath?.trim() ?? "";
+        if (!workspaceLocalPath) {
+          missingWorkspaceLocalPath += 1;
+          const nextPath = resolveProjectWorkspacePath(company.id, project.id);
+          if (!input.dryRun) {
+            await mkdir(nextPath, { recursive: true });
+            createdDirectories += 1;
+            const updated = await updateProject(db, {
+              companyId: company.id,
+              id: project.id,
+              workspaceLocalPath: nextPath
+            });
+            if (updated) {
+              updatedProjects += 1;
+            }
+          }
+          continue;
+        }
+
+        if (!isAbsolute(workspaceLocalPath)) {
+          relativeWorkspaceLocalPath += 1;
+          const nextPath = normalizeAbsolutePath(workspaceLocalPath);
+          if (!input.dryRun) {
+            await mkdir(nextPath, { recursive: true });
+            createdDirectories += 1;
+            const updated = await updateProject(db, {
+              companyId: company.id,
+              id: project.id,
+              workspaceLocalPath: nextPath
+            });
+            if (updated) {
+              updatedProjects += 1;
+            }
+          }
+        }
+      }
+    }
+
+    if (!input.dryRun) {
+      await mkdir(instanceRoot, { recursive: true });
+      await mkdir(storageRoot, { recursive: true });
+    }
+    const writableInstanceRoot = await isDirectoryWritable(instanceRoot);
+    const writableStorageRoot = await isDirectoryWritable(storageRoot);
+
+    return {
+      scannedProjects,
+      missingWorkspaceLocalPath,
+      relativeWorkspaceLocalPath,
+      updatedProjects,
+      createdDirectories,
+      writableInstanceRoot,
+      writableStorageRoot,
+      dryRun: input.dryRun
+    } satisfies ProjectWorkspaceBackfillSummary;
+  } finally {
+    const maybeClose = (client as { close?: () => Promise<void> }).close;
+    if (maybeClose) {
+      await maybeClose.call(client);
+    }
+  }
+}
+
+async function isDirectoryWritable(path: string) {
+  try {
+    await mkdir(path, { recursive: true });
+    await access(path, constants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function main() {
+  const summary = await backfillProjectWorkspaces({
+    dbPath: process.env.BOPO_DB_PATH,
+    dryRun: process.env.BOPO_BACKFILL_DRY_RUN !== "0"
+  });
+  // eslint-disable-next-line no-console
+  console.log(JSON.stringify(summary));
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  void main();
+}