@umudik/task-bridge 0.0.1

package/apps/backend/dist/routes/tasks.js

@@ -0,0 +1,522 @@
+import { z } from "zod";
+import { assertAuth } from "../middleware/auth.js";
+import { buildInboxItems, mapComments, mapTaskDetail, } from "../mappers/task-response.js";
+import { getProjectById, refreshProjectRegistry } from "../services/project-registry.js";
+import { addBridgeTaskUserComment, allocateTaskId, claimBridgeTask, getBridgeTask, listBridgeTasks, releaseBridgeTask, updateBridgeTaskSpec, upsertBridgeTask, } from "../services/task-service.js";
+import { applyTodoCascadeFromTask, listEpicSubtasks, spawnEpicWorkflow, syncEpicStage, updateTaskWorkStatus, } from "../services/epic-service.js";
+import { resolveEpicId } from "../domain/task.js";
+import { resolveWorkStatus, workStatusLabel } from "../domain/work-status.js";
+import { getStageTitleLookup, resolveNewTaskPlacement } from "../services/workflow-service.js";
+import { isWorkStatus } from "../domain/work-status.js";
+import { claimNextTask, listPendingTasks, validateTaskClaim, } from "../services/task-queue.js";
+import { resolveClaimActor } from "../services/task-claim-policy.js";
+import { createEpicRecords } from "../services/workflow-state-service.js";
+import { AppError } from "../errors/app-error.js";
+const createEpicBodySchema = z
+    .object({
+    text: z.string().trim().optional(),
+    projectId: z.string().trim().min(1),
+    title: z.string().trim().optional(),
+    description: z.string().trim().optional(),
+})
+    .superRefine((data, ctx) => {
+    let titleTrimmed = "";
+    if (data.title) {
+        titleTrimmed = data.title;
+    }
+    let textTrimmed = "";
+    if (data.text) {
+        textTrimmed = data.text;
+    }
+    if (!titleTrimmed && !textTrimmed) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "title or text is required",
+            path: ["title"],
+        });
+    }
+});
+const createTaskBodySchema = z
+    .object({
+    parentId: z.coerce.number().int().positive(),
+    title: z.string().trim().min(1),
+    description: z.string().trim().optional(),
+    stageId: z.string().trim().min(1).optional(),
+});
+function resolveEpicFields(body) {
+    let titleInput = "";
+    if (body.title) {
+        titleInput = body.title;
+    }
+    let descriptionInput = "";
+    if (body.description) {
+        descriptionInput = body.description;
+    }
+    let text = "";
+    if (body.text) {
+        text = body.text;
+    }
+    if (titleInput) {
+        return {
+            title: titleInput.slice(0, 200),
+            description: descriptionInput || text,
+        };
+    }
+    const newline = text.indexOf("\n");
+    if (newline === -1) {
+        return {
+            title: text.slice(0, 200),
+            description: "",
+        };
+    }
+    const firstLine = text.slice(0, newline);
+    const rest = text.slice(newline + 1);
+    return {
+        title: (firstLine || text).slice(0, 200),
+        description: rest,
+    };
+}
+function createdItemResponse(task) {
+    return {
+        id: task.id,
+        title: task.title,
+        createdAt: task.createdAt,
+        projectId: task.projectId,
+        projectName: task.projectName,
+        parentId: task.parentId,
+        stageId: task.stageId,
+        assignee: task.assignee,
+    };
+}
+const taskIdParamsSchema = z.object({
+    id: z.coerce.number().int().positive(),
+});
+const claimTaskBodySchema = z.object({
+    claimedBy: z.string().trim().min(1),
+});
+const claimNextBodySchema = z.object({
+    claimedBy: z.string().trim().min(1),
+    projectId: z.string().trim().min(1).optional(),
+});
+const patchTaskBodySchema = z
+    .object({
+    comment: z
+        .object({
+        text: z.string().trim().min(1),
+        by: z.string().trim().min(1).default("web"),
+    })
+        .optional(),
+    description: z.string().trim().optional(),
+})
+    .superRefine((data, ctx) => {
+    if (!data.comment && !data.description) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "comment or description is required",
+        });
+    }
+});
+const workStatusBodySchema = z.object({
+    workStatus: z.enum(["todo", "in_progress", "done"]),
+    claimedBy: z.string().trim().min(1),
+});
+const inboxQuerySchema = z.object({
+    projectId: z.string().trim().min(1).nullable().default(null),
+    commentsOnly: z
+        .enum(["true", "false"])
+        .nullable()
+        .default(null)
+        .transform((value) => {
+        if (value === null) {
+            return null;
+        }
+        return value === "true";
+    }),
+    epicsOnly: z
+        .enum(["true", "false"])
+        .nullable()
+        .default(null)
+        .transform((value) => {
+        if (value === null) {
+            return null;
+        }
+        return value === "true";
+    }),
+    cursor: z.string().trim().min(1).nullable().default(null),
+    limit: z.coerce.number().int().positive().max(100).optional().default(20),
+});
+export function taskRoutes(app) {
+    app.post("/epics", async (request, reply) => {
+        const user = assertAuth(request);
+        const body = createEpicBodySchema.parse(request.body);
+        refreshProjectRegistry();
+        const project = getProjectById(body.projectId);
+        if (!project) {
+            return reply.status(400).send({ error: "Unknown project" });
+        }
+        const id = allocateTaskId();
+        const { title, description } = resolveEpicFields(body);
+        const placement = resolveNewTaskPlacement(project.id);
+        let hasText = false;
+        if (body.text) {
+            hasText = body.text.length > 0;
+        }
+        let hasTitle = false;
+        if (body.title) {
+            hasTitle = body.title.length > 0;
+        }
+        let createdBy = user.id;
+        if (hasText && !hasTitle) {
+            createdBy = user.id;
+        }
+        createEpicRecords({
+            id,
+            projectId: project.id,
+            title,
+            description,
+            stageId: placement.stageId,
+            createdBy,
+        });
+        const epic = upsertBridgeTask({
+            id,
+            projectId: project.id,
+            projectName: project.name,
+            title,
+            description,
+            createdBy,
+            createdAt: null,
+            stageId: placement.stageId,
+            assignee: placement.assignee,
+            assigneeRole: null,
+            assigneeKind: null,
+            parentId: null,
+            epicId: null,
+            templateId: null,
+            workStatus: null,
+        });
+        spawnEpicWorkflow(epic);
+        syncEpicStage(epic.id);
+        return reply.status(201).send(createdItemResponse(epic));
+    });
+    app.post("/tasks", async (request, reply) => {
+        assertAuth(request);
+        const body = createTaskBodySchema.parse(request.body);
+        refreshProjectRegistry();
+        const parent = getBridgeTask(body.parentId);
+        if (!parent) {
+            return reply.status(400).send({ error: "Unknown parent task" });
+        }
+        const allTasks = listBridgeTasks();
+        const epicId = resolveEpicId(allTasks, parent);
+        if (!epicId) {
+            return reply.status(400).send({ error: "Task must belong to an epic" });
+        }
+        const epic = getBridgeTask(epicId);
+        if (!epic || epic.parentId !== null) {
+            return reply.status(400).send({ error: "Unknown epic" });
+        }
+        const project = getProjectById(epic.projectId);
+        if (!project) {
+            return reply.status(400).send({ error: "Unknown project" });
+        }
+        const placement = resolveNewTaskPlacement(project.id);
+        let bodyStageId = null;
+        if (body.stageId) {
+            bodyStageId = body.stageId;
+        }
+        let stageId = bodyStageId;
+        if (stageId === null) {
+            stageId = parent.stageId;
+        }
+        if (stageId === null) {
+            stageId = epic.stageId;
+        }
+        if (stageId === null) {
+            stageId = placement.stageId;
+        }
+        let descriptionValue = "";
+        if (body.description) {
+            descriptionValue = body.description;
+        }
+        const task = upsertBridgeTask({
+            id: allocateTaskId(),
+            projectId: project.id,
+            projectName: project.name,
+            title: body.title.slice(0, 200),
+            description: descriptionValue,
+            createdBy: "web",
+            createdAt: null,
+            stageId,
+            assignee: null,
+            assigneeRole: null,
+            assigneeKind: null,
+            parentId: parent.id,
+            epicId: epic.id,
+            templateId: null,
+            workStatus: "todo",
+        });
+        applyTodoCascadeFromTask(task, "web", { laterStages: null, descendants: false });
+        syncEpicStage(epic.id);
+        return reply.status(201).send(createdItemResponse(task));
+    });
+    app.get("/tasks", (request) => {
+        assertAuth(request);
+        const bridgeTasks = listBridgeTasks();
+        return {
+            items: bridgeTasks.map((task) => ({
+                id: task.id,
+                title: task.title,
+                projectId: task.projectId,
+                projectName: task.projectName,
+                parentId: task.parentId,
+                stageId: task.stageId,
+                assignee: task.assignee,
+                createdBy: task.createdBy,
+                createdAt: task.createdAt,
+                claimedBy: task.claimedBy,
+                claimedAt: task.claimedAt,
+                events: task.events,
+            })),
+        };
+    });
+    app.post("/tasks/:id/claim", async (request, reply) => {
+        assertAuth(request);
+        const { id } = taskIdParamsSchema.parse(request.params);
+        const claimBody = request.body || {};
+        const body = claimTaskBodySchema.parse(claimBody);
+        const existing = getBridgeTask(id);
+        if (!existing) {
+            return reply.status(404).send({ error: "Task not found" });
+        }
+        const claimedBy = body.claimedBy;
+        const actor = resolveClaimActor(existing.projectId, claimedBy);
+        if (!actor) {
+            return reply.status(404).send({ error: "Project member not found" });
+        }
+        const blockReason = validateTaskClaim(id, actor);
+        if (blockReason) {
+            const existingAgain = getBridgeTask(id);
+            if (!existingAgain) {
+                return reply.status(404).send({ error: "Task not found" });
+            }
+            return reply.status(409).send({ error: blockReason });
+        }
+        const task = claimBridgeTask(id, body.claimedBy);
+        if (!task) {
+            return reply.status(409).send({ error: "Task is not available to claim" });
+        }
+        return task;
+    });
+    app.post("/tasks/:id/unclaim", async (request, reply) => {
+        assertAuth(request);
+        const { id } = taskIdParamsSchema.parse(request.params);
+        const task = releaseBridgeTask(id);
+        if (!task) {
+            return reply.status(404).send({ error: "Task not found" });
+        }
+        return { taskId: task.id, stageId: task.stageId };
+    });
+    app.post("/worker/claim-next", async (request, reply) => {
+        assertAuth(request);
+        const claimNextBody = request.body || {};
+        const body = claimNextBodySchema.parse(claimNextBody);
+        if (!body.projectId) {
+            return reply.status(400).send({ error: "projectId is required" });
+        }
+        const actor = resolveClaimActor(body.projectId, body.claimedBy);
+        if (!actor) {
+            return reply.status(404).send({ error: "Project member not found" });
+        }
+        const claimed = claimNextTask(actor, { projectId: body.projectId });
+        if (!claimed) {
+            return reply.status(404).send({ error: "No tasks available" });
+        }
+        const { task, item } = claimed;
+        return Object.assign({}, item, {
+            stageId: task.stageId,
+            claimedBy: task.claimedBy,
+            claimedAt: task.claimedAt,
+            comments: mapComments(task),
+        });
+    });
+    app.patch("/tasks/:id/work-status", async (request, reply) => {
+        assertAuth(request);
+        const { id } = taskIdParamsSchema.parse(request.params);
+        const workStatusBody = request.body || {};
+        const body = workStatusBodySchema.parse(workStatusBody);
+        if (!isWorkStatus(body.workStatus)) {
+            return reply.status(400).send({ error: "Invalid work status" });
+        }
+        const existing = getBridgeTask(id);
+        if (!existing) {
+            return reply.status(404).send({ error: "Task not found" });
+        }
+        const actor = resolveClaimActor(existing.projectId, body.claimedBy);
+        if (!actor) {
+            return reply.status(404).send({ error: "Project member not found" });
+        }
+        try {
+            const updated = updateTaskWorkStatus(id, body.workStatus, actor.claimedBy, actor);
+            if (!updated) {
+                if (existing.parentId === null) {
+                    return reply.status(400).send({ error: "Only subtasks support work status" });
+                }
+                return reply.status(404).send({ error: "Task not found" });
+            }
+            return mapTaskDetail(updated);
+        }
+        catch (error) {
+            if (error instanceof AppError) {
+                return reply.status(error.statusCode).send({ error: error.message });
+            }
+            throw error;
+        }
+    });
+    app.get("/projects/:projectId/epics/:epicId/tasks", async (request, reply) => {
+        assertAuth(request);
+        const params = z
+            .object({
+            projectId: z.string().trim().min(1),
+            epicId: z.coerce.number().int().positive(),
+        })
+            .parse(request.params);
+        const epic = getBridgeTask(params.epicId);
+        if (!epic || epic.projectId !== params.projectId || epic.parentId !== null) {
+            return reply.status(404).send({ error: "Epic not found" });
+        }
+        syncEpicStage(epic.id);
+        const refreshedRaw = getBridgeTask(params.epicId);
+        let refreshed = epic;
+        if (refreshedRaw) {
+            refreshed = refreshedRaw;
+        }
+        const subtasks = listEpicSubtasks(epic.id);
+        const stageTitles = getStageTitleLookup(params.projectId);
+        let epicStageTitle = null;
+        if (refreshed.stageId) {
+            const t = stageTitles.get(refreshed.stageId);
+            if (t) {
+                epicStageTitle = t;
+            }
+            else {
+                epicStageTitle = refreshed.stageId;
+            }
+        }
+        return {
+            epicId: refreshed.id,
+            epicTitle: refreshed.title,
+            stageId: refreshed.stageId,
+            stageTitle: epicStageTitle,
+            tasks: subtasks.map((task) => {
+                let taskStageTitle = null;
+                if (task.stageId) {
+                    const t = stageTitles.get(task.stageId);
+                    if (t) {
+                        taskStageTitle = t;
+                    }
+                    else {
+                        taskStageTitle = task.stageId;
+                    }
+                }
+                return {
+                    id: task.id,
+                    title: task.title,
+                    stageId: task.stageId,
+                    stageTitle: taskStageTitle,
+                    templateId: task.templateId,
+                    workStatus: resolveWorkStatus(task),
+                    workStatusLabel: workStatusLabel(resolveWorkStatus(task)),
+                    assignee: task.assignee,
+                };
+            }),
+        };
+    });
+    app.get("/tasks/:id", async (request, reply) => {
+        assertAuth(request);
+        const { id } = taskIdParamsSchema.parse(request.params);
+        const task = getBridgeTask(id);
+        if (!task) {
+            return reply.status(404).send({ error: "Task not found" });
+        }
+        return mapTaskDetail(task);
+    });
+    app.patch("/tasks/:id", async (request, reply) => {
+        assertAuth(request);
+        const { id } = taskIdParamsSchema.parse(request.params);
+        const patchBody = request.body || {};
+        const body = patchTaskBodySchema.parse(patchBody);
+        const existing = getBridgeTask(id);
+        if (!existing) {
+            return reply.status(404).send({ error: "Task not found" });
+        }
+        if (existing.parentId === null) {
+            if (!body.comment && !body.description) {
+                return reply.status(400).send({ error: "Epics support description or comment updates" });
+            }
+            let task = existing;
+            if (body.description) {
+                let commentBy = "web";
+                if (body.comment) {
+                    commentBy = body.comment.by;
+                }
+                const updated = updateBridgeTaskSpec(id, {
+                    description: body.description,
+                    title: null,
+                    by: commentBy,
+                });
+                if (!updated) {
+                    return reply.status(404).send({ error: "Task not found" });
+                }
+                task = updated;
+            }
+            if (body.comment) {
+                const updated = addBridgeTaskUserComment(id, body.comment.by, body.comment.text);
+                if (!updated) {
+                    return reply.status(404).send({ error: "Task not found" });
+                }
+                task = updated;
+            }
+            return mapTaskDetail(task);
+        }
+        if (!body.comment) {
+            return reply.status(400).send({ error: "comment is required" });
+        }
+        const task = addBridgeTaskUserComment(id, body.comment.by, body.comment.text);
+        if (!task) {
+            return reply.status(404).send({ error: "Task not found" });
+        }
+        return mapTaskDetail(task);
+    });
+    app.get("/worker/pending", async (request, reply) => {
+        assertAuth(request);
+        const query = z
+            .object({
+            projectId: z.string().trim().min(1).optional(),
+            claimedBy: z.string().trim().min(1).optional(),
+        })
+            .parse(request.query);
+        let actor = null;
+        if (query.claimedBy) {
+            if (!query.projectId) {
+                return reply.status(400).send({ error: "projectId is required when filtering by claimedBy" });
+            }
+            actor = resolveClaimActor(query.projectId, query.claimedBy);
+            if (!actor) {
+                return reply.status(404).send({ error: "Project member not found" });
+            }
+        }
+        const items = listPendingTasks(query.projectId, actor);
+        return { items };
+    });
+    app.get("/inbox", (request) => {
+        assertAuth(request);
+        const query = inboxQuerySchema.parse(request.query);
+        return buildInboxItems({
+            projectId: query.projectId,
+            commentsOnly: query.commentsOnly,
+            epicsOnly: query.epicsOnly,
+            cursor: query.cursor,
+            limit: query.limit,
+        });
+    });
+}

package/apps/backend/dist/routes/web.js

@@ -0,0 +1,79 @@
+import { existsSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import fastifyStatic from "@fastify/static";
+const moduleDir = dirname(fileURLToPath(import.meta.url));
+function resolveWebRoot() {
+    const candidates = [
+        join(moduleDir, "..", "..", "public"),
+        join(moduleDir, "..", "..", "web", "dist"),
+        join(process.cwd(), "public"),
+        join(process.cwd(), "apps", "web", "dist"),
+    ];
+    for (const candidate of candidates) {
+        if (existsSync(join(candidate, "index.html"))) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function resolveMobileApkPath(root) {
+    return join(root, "downloads", "task-bridge.apk");
+}
+export async function webRoutes(app) {
+    const root = resolveWebRoot();
+    if (!root) {
+        return;
+    }
+    const mobileApkPath = resolveMobileApkPath(root);
+    app.get("/mobile/release", async (_request, reply) => {
+        if (!existsSync(mobileApkPath)) {
+            return reply.send({ available: false });
+        }
+        const stats = statSync(mobileApkPath);
+        return reply.send({
+            available: true,
+            downloadUrl: "/downloads/task-bridge.apk",
+            sizeBytes: stats.size,
+            fileName: "task-bridge.apk",
+        });
+    });
+    app.get("/downloads/task-bridge.apk", async (_request, reply) => {
+        if (!existsSync(mobileApkPath)) {
+            return reply.status(404).send({ error: "Android APK not bundled in this image" });
+        }
+        return reply
+            .type("application/vnd.android.package-archive")
+            .header("Content-Disposition", 'attachment; filename="task-bridge.apk"')
+            .sendFile("downloads/task-bridge.apk", root);
+    });
+    await app.register(fastifyStatic, {
+        root,
+        prefix: "/app/",
+        wildcard: false,
+    });
+    const spa = (_request, reply) => reply.sendFile("index.html", root);
+    app.get("/", async (_request, reply) => reply.redirect("/app/login"));
+    app.get("/app", async (_request, reply) => reply.redirect("/app/login"));
+    app.get("/app/login", spa);
+    app.get("/app/projects", spa);
+    app.get("/app/projects/:projectId/tasks", spa);
+    app.get("/app/projects/:projectId/inbox", spa);
+    app.get("/app/projects/:projectId/tasks/:taskId", spa);
+    app.get("/app/projects/:projectId/mobile", spa);
+    app.get("/app/projects/:projectId/workflow", spa);
+    app.get("/app/workflow-templates", spa);
+    app.get("/app/setup", spa);
+    app.get("/app/admin/users", spa);
+    app.get("/app/*", async (request, reply) => {
+        const questionIndex = request.url.indexOf("?");
+        let path = request.url;
+        if (questionIndex >= 0) {
+            path = request.url.slice(0, questionIndex);
+        }
+        if (path.startsWith("/app/assets/")) {
+            return reply.status(404).send({ error: "Not found" });
+        }
+        return reply.sendFile("index.html", root);
+    });
+}