@umudik/task-bridge 0.0.1

package/apps/backend/dist/routes/admin-users.js

@@ -0,0 +1,79 @@
+import { z } from "zod";
+import { AppError } from "../errors/app-error.js";
+import { assertAuth } from "../middleware/auth.js";
+import { listPublicUsers, createUser, updateUser, deleteUser, listUserRows, readUserToken, } from "../db/users-db.js";
+const createUserSchema = z.object({
+    name: z.string().trim().min(1),
+    email: z.string().trim().toLowerCase().email(),
+    password: z.string().min(6),
+    role: z.enum(["admin", "read-write", "read"]).default("read-write"),
+});
+const updateUserSchema = z.object({
+    name: z.string().trim().min(1),
+    role: z.enum(["admin", "read-write", "read"]),
+});
+function requireAdmin(request) {
+    const user = assertAuth(request);
+    if (user.role !== "admin") {
+        throw new AppError("Admin access required", 403);
+    }
+    return user;
+}
+export function adminUserRoutes(app) {
+    app.get("/admin/users", (request) => {
+        requireAdmin(request);
+        return { users: listPublicUsers() };
+    });
+    app.post("/admin/users", async (request, reply) => {
+        requireAdmin(request);
+        const body = createUserSchema.parse(request.body);
+        const user = createUser({
+            name: body.name,
+            email: body.email,
+            password: body.password,
+            role: body.role,
+            isSystemAdmin: false,
+            mustChangePassword: true,
+        });
+        return reply.status(201).send({ user });
+    });
+    app.patch("/admin/users/:userId", (request) => {
+        requireAdmin(request);
+        const { userId } = request.params;
+        const existingRows = listUserRows({ id: userId, email: "", token: "" });
+        if (existingRows.length === 0)
+            throw new AppError("User not found", 404);
+        const existing = existingRows[0];
+        if (!existing)
+            throw new AppError("User not found", 404);
+        const body = updateUserSchema.parse(request.body);
+        if (existing.is_system_admin && body.role !== "admin") {
+            throw new AppError("Cannot change system admin role", 400);
+        }
+        const updated = updateUser(userId, body);
+        if (updated === null)
+            throw new AppError("User not found", 404);
+        return { user: updated };
+    });
+    app.delete("/admin/users/:userId", async (request, reply) => {
+        requireAdmin(request);
+        const { userId } = request.params;
+        const result = deleteUser(userId);
+        if (!result.deleted) {
+            let reason = "Cannot delete user";
+            if (result.reason !== "") {
+                reason = result.reason;
+            }
+            throw new AppError(reason, 400);
+        }
+        return reply.status(204).send();
+    });
+    app.get("/admin/users/:userId/token", (request) => {
+        requireAdmin(request);
+        const { userId } = request.params;
+        const token = readUserToken(userId);
+        if (token === "")
+            throw new AppError("User not found", 404);
+        return { token };
+    });
+}

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

@@ -0,0 +1,81 @@
+import { z } from "zod";
+import { AppError } from "../errors/app-error.js";
+import { hasAnyUser, createUser, listUserRows, verifyPassword, readUserToken, updateUserPassword, } from "../db/users-db.js";
+import { resolveAuthUser } from "../middleware/auth.js";
+const setupSchema = z.object({
+    name: z.string().trim().min(1),
+    email: z.string().trim().toLowerCase().email(),
+    password: z.string().min(6),
+});
+const loginSchema = z.object({
+    email: z.string().trim().toLowerCase().email(),
+    password: z.string().min(1),
+});
+const changePasswordSchema = z.object({
+    currentPassword: z.string().min(1),
+    newPassword: z.string().min(6),
+});
+function mapAuthUser(userRow) {
+    return {
+        id: userRow.id,
+        name: userRow.name,
+        email: userRow.email,
+        role: userRow.role,
+        isSystemAdmin: userRow.is_system_admin === 1,
+        mustChangePassword: userRow.must_change_password === 1,
+    };
+}
+export function authRoutes(app) {
+    app.get("/auth/status", () => {
+        return { hasUsers: hasAnyUser() };
+    });
+    app.post("/auth/setup", async (request, reply) => {
+        if (hasAnyUser()) {
+            throw new AppError("Setup already completed", 409);
+        }
+        const body = setupSchema.parse(request.body);
+        const user = createUser({
+            name: body.name,
+            email: body.email,
+            password: body.password,
+            role: "admin",
+            isSystemAdmin: true,
+            mustChangePassword: false,
+        });
+        return reply.status(201).send({ user, message: "Admin account created" });
+    });
+    app.post("/auth/login", async (request, reply) => {
+        const body = loginSchema.parse(request.body);
+        const userRows = listUserRows({ id: "", email: body.email, token: "" });
+        const firstRow = userRows[0];
+        if (userRows.length === 0 || !firstRow || !verifyPassword(firstRow, body.password)) {
+            throw new AppError("Invalid email or password", 401);
+        }
+        const userRow = firstRow;
+        const token = readUserToken(userRow.id);
+        if (token === "")
+            throw new AppError("Token not found", 500);
+        return reply.send({
+            token,
+            user: mapAuthUser(userRow),
+        });
+    });
+    app.get("/auth/me", (request) => {
+        const userRow = resolveAuthUser(request);
+        return mapAuthUser(userRow);
+    });
+    app.post("/auth/change-password", (request) => {
+        const userRow = resolveAuthUser(request);
+        const body = changePasswordSchema.parse(request.body);
+        if (!verifyPassword(userRow, body.currentPassword)) {
+            throw new AppError("Invalid current password", 401);
+        }
+        if (body.currentPassword === body.newPassword) {
+            throw new AppError("New password must be different", 400);
+        }
+        updateUserPassword(userRow.id, body.newPassword);
+        return {
+            user: Object.assign({}, mapAuthUser(userRow), { mustChangePassword: false }),
+        };
+    });
+}

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

@@ -0,0 +1 @@
+export async function connectRoutes(_app) { }

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

@@ -0,0 +1,13 @@
+import { openapiSpec } from "../openapi.js";
+/**
+ * GET /api/docs — returns the OpenAPI 3.1 spec as raw JSON.
+ * No auth required. No Swagger UI — just the machine-readable spec.
+ */
+export function docsRoutes(app) {
+    app.get("/docs", async (_request, reply) => {
+        return reply
+            .header("Content-Type", "application/json; charset=utf-8")
+            .header("Cache-Control", "no-cache")
+            .send(JSON.stringify(openapiSpec, null, 2));
+    });
+}

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

@@ -0,0 +1,6 @@
+export function healthRoutes(app) {
+    app.get("/health", () => ({
+        status: "ok",
+        timestamp: new Date().toISOString(),
+    }));
+}

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

@@ -0,0 +1,139 @@
+import { z } from "zod";
+import { assertAuth } from "../middleware/auth.js";
+import { createLibrary, createLibraryDocument, getLibrary, getLibraryDocument, linkDocumentToTask, listLibraries, listTaskLibraryLinks, removeLibrary, removeLibraryDocument, unlinkDocumentFromTask, updateLibrary, updateLibraryDocument, } from "../services/library-service.js";
+const libraryIdParamsSchema = z.object({
+    libraryId: z.string().trim().min(1),
+});
+const documentIdParamsSchema = z.object({
+    documentId: z.string().trim().min(1),
+});
+const libraryDocumentParamsSchema = z.object({
+    libraryId: z.string().trim().min(1),
+    documentId: z.string().trim().min(1),
+});
+const taskIdParamsSchema = z.object({
+    taskId: z.coerce.number().int().positive(),
+});
+const createLibrarySchema = z.object({
+    id: z.string().trim().default(""),
+    title: z.string().trim().min(1),
+    description: z.string().trim().default(""),
+});
+const updateLibrarySchema = z.object({
+    title: z.string().trim().min(1),
+    description: z.string().trim().default(""),
+});
+const createDocumentSchema = z.object({
+    id: z.string().trim().default(""),
+    title: z.string().trim().min(1),
+    description: z.string().trim().default(""),
+});
+const linkDocumentSchema = z.object({
+    taskId: z.coerce.number().int().positive(),
+});
+export function libraryRoutes(app) {
+    app.get("/libraries", (request) => {
+        assertAuth(request);
+        return { items: listLibraries() };
+    });
+    app.post("/libraries", async (request, reply) => {
+        assertAuth(request);
+        let rawBody = request.body;
+        if (rawBody === null) {
+            rawBody = {};
+        }
+        const body = createLibrarySchema.parse(rawBody);
+        const library = createLibrary(body);
+        return reply.status(201).send(library);
+    });
+    app.get("/libraries/:libraryId", async (request, reply) => {
+        assertAuth(request);
+        const { libraryId } = libraryIdParamsSchema.parse(request.params);
+        const library = getLibrary(libraryId);
+        if (!library)
+            return reply.status(404).send({ error: "Library not found" });
+        return library;
+    });
+    app.put("/libraries/:libraryId", (request) => {
+        assertAuth(request);
+        const { libraryId } = libraryIdParamsSchema.parse(request.params);
+        let rawBody = request.body;
+        if (rawBody === null) {
+            rawBody = {};
+        }
+        const body = updateLibrarySchema.parse(rawBody);
+        return updateLibrary(libraryId, body);
+    });
+    app.delete("/libraries/:libraryId", async (request, reply) => {
+        assertAuth(request);
+        const { libraryId } = libraryIdParamsSchema.parse(request.params);
+        removeLibrary(libraryId);
+        return reply.status(204).send();
+    });
+    app.post("/libraries/:libraryId/documents", async (request, reply) => {
+        assertAuth(request);
+        const { libraryId } = libraryIdParamsSchema.parse(request.params);
+        let rawBody = request.body;
+        if (rawBody === null) {
+            rawBody = {};
+        }
+        const body = createDocumentSchema.parse(rawBody);
+        const document = createLibraryDocument(libraryId, body);
+        return reply.status(201).send(document);
+    });
+    app.get("/library-documents/:documentId", async (request, reply) => {
+        assertAuth(request);
+        const { documentId } = documentIdParamsSchema.parse(request.params);
+        const document = getLibraryDocument(documentId);
+        if (!document)
+            return reply.status(404).send({ error: "Document not found" });
+        return document;
+    });
+    app.put("/libraries/:libraryId/documents/:documentId", async (request, reply) => {
+        assertAuth(request);
+        const { libraryId, documentId } = libraryDocumentParamsSchema.parse(request.params);
+        let rawBody = request.body;
+        if (rawBody === null) {
+            rawBody = {};
+        }
+        const body = updateLibrarySchema.parse(rawBody);
+        const existing = getLibraryDocument(documentId);
+        if (!existing || existing.libraryId !== libraryId) {
+            return reply.status(404).send({ error: "Document not found" });
+        }
+        return updateLibraryDocument(documentId, body);
+    });
+    app.delete("/libraries/:libraryId/documents/:documentId", async (request, reply) => {
+        assertAuth(request);
+        const { libraryId, documentId } = libraryDocumentParamsSchema.parse(request.params);
+        const existing = getLibraryDocument(documentId);
+        if (!existing || existing.libraryId !== libraryId) {
+            return reply.status(404).send({ error: "Document not found" });
+        }
+        removeLibraryDocument(documentId);
+        return reply.status(204).send();
+    });
+    app.post("/library-documents/:documentId/links", async (request, reply) => {
+        assertAuth(request);
+        const { documentId } = documentIdParamsSchema.parse(request.params);
+        let rawBody = request.body;
+        if (rawBody === null) {
+            rawBody = {};
+        }
+        const body = linkDocumentSchema.parse(rawBody);
+        const links = linkDocumentToTask(documentId, body.taskId);
+        return reply.status(201).send({ items: links });
+    });
+    app.delete("/library-documents/:documentId/links/:taskId", async (request, reply) => {
+        assertAuth(request);
+        const { documentId } = documentIdParamsSchema.parse(request.params);
+        const { taskId } = taskIdParamsSchema.parse(request.params);
+        unlinkDocumentFromTask(documentId, taskId);
+        return reply.status(204).send();
+    });
+    app.get("/tasks/:taskId/library-links", (request) => {
+        assertAuth(request);
+        const { taskId } = taskIdParamsSchema.parse(request.params);
+        return { items: listTaskLibraryLinks(taskId) };
+    });
+}

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

@@ -0,0 +1,95 @@
+import { z } from "zod";
+import { DEFAULT_WORKFLOW_TEMPLATE_ID } from "../domain/workflow-template-id.js";
+import { isAppError } from "../errors/app-error.js";
+import { assertAuth } from "../middleware/auth.js";
+import { createProject, listPublicProjects, refreshProjectRegistry, updateProject, updateProjectRepoPath, } from "../services/project-registry.js";
+const projectIdPattern = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const createProjectSchema = z.object({
+    name: z.string().trim().min(1),
+    id: z
+        .string()
+        .trim()
+        .default("")
+        .refine((value) => value === "" || projectIdPattern.test(value)),
+    repoPath: z.string().trim().min(1),
+    description: z.string().trim().default(""),
+    workflowTemplateId: z.string().trim().default(DEFAULT_WORKFLOW_TEMPLATE_ID),
+});
+const updateProjectSchema = z.object({
+    name: z.string().trim().min(1),
+    repoPath: z.string().trim().min(1),
+    description: z.string().trim(),
+    workflowTemplateId: z.string().trim(),
+});
+const updateRepoPathSchema = z.object({
+    repoPath: z.string().trim().min(1),
+});
+const projectIdParamsSchema = z.object({
+    id: z.string().trim().min(1),
+});
+export function projectRoutes(app) {
+    app.get("/projects", (request) => {
+        assertAuth(request);
+        refreshProjectRegistry();
+        return { projects: listPublicProjects() };
+    });
+    app.post("/projects", async (request, reply) => {
+        assertAuth(request);
+        let postBody = request.body;
+        if (postBody === null) {
+            postBody = {};
+        }
+        const body = createProjectSchema.parse(postBody);
+        const created = createProject(body);
+        if (created === "duplicate") {
+            return reply.status(409).send({ error: "Project id already exists" });
+        }
+        if (!created) {
+            return reply.status(400).send({ error: "Invalid project" });
+        }
+        return reply.status(201).send(created);
+    });
+    app.patch("/projects/:id", async (request, reply) => {
+        assertAuth(request);
+        const { id } = projectIdParamsSchema.parse(request.params);
+        let patchBody = request.body;
+        if (patchBody === null) {
+            patchBody = {};
+        }
+        const body = updateProjectSchema.parse(patchBody);
+        try {
+            const updated = updateProject(id, body);
+            if (!updated) {
+                return reply.status(404).send({ error: "Project not found" });
+            }
+            return {
+                id: updated.id,
+                name: updated.name,
+                repoPath: updated.repoPath,
+                description: updated.description,
+                workflowTemplateId: updated.workflowTemplateId,
+            };
+        }
+        catch (error) {
+            const handled = error;
+            if (isAppError(handled)) {
+                return reply.status(handled.statusCode).send({ error: handled.message });
+            }
+            throw error;
+        }
+    });
+    app.put("/projects/:id/repo-path", async (request, reply) => {
+        assertAuth(request);
+        const { id } = projectIdParamsSchema.parse(request.params);
+        const body = updateRepoPathSchema.parse(request.body);
+        const updated = updateProjectRepoPath(id, body.repoPath);
+        if (!updated) {
+            return reply.status(404).send({ error: "Project not found" });
+        }
+        return {
+            id: updated.id,
+            name: updated.name,
+            repoPath: updated.repoPath,
+        };
+    });
+}