@sealab/mcp-server 1.0.3 → 1.0.4

package/src/tools/projects.ts

@@ -0,0 +1,370 @@
+import { z } from 'zod';
+import { client, handleAxiosError } from '../client/api-client';
+
+const ProjectStatusSchema = z.enum(['Active', 'On Hold', 'Complete']);
+const PermissionTypeSchema = z.enum(['VIEW', 'EDIT', 'ADMIN']);
+const MaterialFieldSchema = z.enum(['caseMaterial', 'frontMaterial', 'backPanelMaterial', 'innerCaseMaterial']);
+const FinishingTypeSchema = z.enum(['Matte', 'Satin', 'Primed']);
+
+const ListProjectsSchema = z.object({});
+
+const GetProjectSchema = z.object({
+  projectId: z.number().int().positive().describe('Project ID. Use list_projects first if unknown.'),
+});
+
+const ProjectInputSchema = z.object({
+  name: z.string().min(1).describe('Project name.'),
+  address1: z.string().optional().describe('Project address line 1.'),
+  address2: z.string().optional().describe('Project address line 2.'),
+  city: z.string().optional().describe('Project city.'),
+  state: z.string().optional().describe('Project state.'),
+  zipcode: z.string().optional().describe('Project ZIP/postal code.'),
+  status: ProjectStatusSchema.default('Active').describe('Project status.'),
+  phase: z.string().optional().describe('Project phase, e.g. Design, Shop Drawings, Install.'),
+  clientName: z.string().optional().describe('Client or end-customer name.'),
+  budget: z.number().optional().describe('Optional project budget.'),
+  dueDate: z.string().optional().describe('Optional due date in YYYY-MM-DD format.'),
+  taxExempt: z.boolean().optional().describe('Whether project summary pricing should display without sales tax.'),
+  notes: z.string().optional().describe('Project notes.'),
+});
+
+const CreateProjectSchema = ProjectInputSchema;
+
+const UpdateProjectSchema = ProjectInputSchema.partial().extend({
+  projectId: z.number().int().positive().describe('Project ID to update.'),
+});
+
+const DeleteProjectSchema = z.object({
+  projectId: z.number().int().positive().describe('Project ID to delete.'),
+});
+
+const ProjectOrderSchema = z.object({
+  projectId: z.number().int().positive().describe('Project ID.'),
+  orderId: z.string().describe('Order ID to attach or detach.'),
+});
+
+const UpdateProjectOrderQuantitySchema = ProjectOrderSchema.extend({
+  quantity: z.number().int().min(1).describe('Project quantity multiplier for this order. Does not change the order itself.'),
+});
+
+const UpdateProjectOrderOptionsSchema = ProjectOrderSchema.extend({
+  includeDrawerboxes: z.boolean().optional().describe('Include drawer boxes for this order. Omit to leave unchanged.'),
+  includeAssembly: z.boolean().optional().describe('Include assembly for this order. Omit to leave unchanged.'),
+  includeHardware: z.boolean().optional().describe('Include hardware for this order. Omit to leave unchanged.'),
+  includeFinishing: z.boolean().optional().describe('Include finishing for this order. Omit to leave unchanged.'),
+  finishingType: FinishingTypeSchema.optional().describe('Finishing type. Required when setting includeFinishing to true.'),
+  finishingColor: z.string().optional().describe('Finishing color. Required when setting includeFinishing to true.'),
+});
+
+const UpdateProjectArticleMaterialSchema = ProjectOrderSchema.extend({
+  positionName: z.string().describe('Article position name within the order, e.g. "Base_01".'),
+  field: MaterialFieldSchema.describe('Material field to update.'),
+  materialDescription: z.string().min(1).describe('Exact material description from the Sealab material list.'),
+});
+
+const UpdateProjectArticleMaterialsSchema = ProjectOrderSchema.extend({
+  positionNames: z.array(z.string()).min(1).describe('Article position names to update.'),
+  field: MaterialFieldSchema.describe('Material field to update.'),
+  materialDescription: z.string().min(1).describe('Exact material description from the Sealab material list.'),
+});
+
+const ProjectAccessSchema = z.object({
+  projectId: z.number().int().positive().describe('Project ID.'),
+  grantedToEmail: z.string().email().describe('Email address to grant or update access for.'),
+  permissionType: PermissionTypeSchema.default('VIEW').describe('VIEW = read-only, EDIT = can update project/order options, ADMIN = admin-level project permission.'),
+  hidePrice: z.boolean().default(false).describe('Whether to hide project pricing from this user.'),
+});
+
+const RevokeProjectAccessSchema = z.object({
+  projectId: z.number().int().positive().describe('Project ID.'),
+  email: z.string().email().describe('Email address whose project access should be revoked.'),
+});
+
+const ListProjectAccessSchema = z.object({
+  projectId: z.number().int().positive().describe('Project ID.'),
+});
+
+function compactProject(project: any): any {
+  return {
+    projectId: project.projectId,
+    name: project.name,
+    status: project.status,
+    phase: project.phase,
+    clientName: project.clientName,
+    address: [project.address1, project.address2, project.city, project.state, project.zipcode].filter(Boolean).join(', '),
+    shared: project.shared,
+    permissionType: project.permissionType,
+    hidePrice: project.hidePrice,
+    updatedAt: project.updatedAt,
+    orderCount: project.orders?.length ?? project.summary?.orderSummaries?.length,
+    projectTotalValue: project.hidePrice ? undefined : project.summary?.projectTotalValue,
+  };
+}
+
+function formatProjectList(projects: any[]): string {
+  if (!projects || projects.length === 0) return 'No projects found.';
+  return JSON.stringify(projects.map(compactProject), null, 2);
+}
+
+function formatProject(project: any): string {
+  return JSON.stringify(project, null, 2);
+}
+
+async function apiError(error: unknown, fallback: string): Promise<string> {
+  try { handleAxiosError(error); } catch (e: any) { return e.message; }
+  return fallback;
+}
+
+export async function listProjects(_: z.infer<typeof ListProjectsSchema>): Promise<string> {
+  try {
+    const { data } = await client.get('/projects');
+    return formatProjectList(data);
+  } catch (error) {
+    return apiError(error, 'Unexpected error listing projects.');
+  }
+}
+
+export async function getProject(input: z.infer<typeof GetProjectSchema>): Promise<string> {
+  try {
+    const { data } = await client.get(`/projects/${input.projectId}`);
+    return formatProject(data);
+  } catch (error) {
+    return apiError(error, 'Unexpected error fetching project.');
+  }
+}
+
+export async function createProject(input: z.infer<typeof CreateProjectSchema>): Promise<string> {
+  try {
+    const { data } = await client.post('/projects', input);
+    return `Project created successfully. Project ID: ${data.projectId}. Name: ${data.name}.`;
+  } catch (error) {
+    return apiError(error, 'Unexpected error creating project.');
+  }
+}
+
+export async function updateProject(input: z.infer<typeof UpdateProjectSchema>): Promise<string> {
+  const { projectId, ...payload } = input;
+  try {
+    const { data: current } = await client.get(`/projects/${projectId}`);
+    const { data } = await client.put(`/projects/${projectId}`, { ...current, ...payload });
+    return `Project updated successfully.\n${formatProject(data)}`;
+  } catch (error) {
+    return apiError(error, 'Unexpected error updating project.');
+  }
+}
+
+export async function deleteProject(input: z.infer<typeof DeleteProjectSchema>): Promise<string> {
+  try {
+    await client.delete(`/projects/${input.projectId}`);
+    return `Project ${input.projectId} deleted successfully. Pending attached orders were detached, not deleted.`;
+  } catch (error) {
+    return apiError(error, 'Unexpected error deleting project.');
+  }
+}
+
+export async function attachOrderToProject(input: z.infer<typeof ProjectOrderSchema>): Promise<string> {
+  try {
+    await client.post(`/projects/${input.projectId}/orders/${input.orderId}`);
+    return `Order ${input.orderId} attached to project ${input.projectId}.`;
+  } catch (error) {
+    return apiError(error, 'Unexpected error attaching order to project.');
+  }
+}
+
+export async function detachOrderFromProject(input: z.infer<typeof ProjectOrderSchema>): Promise<string> {
+  try {
+    await client.delete(`/projects/${input.projectId}/orders/${input.orderId}`);
+    return `Order ${input.orderId} detached from project ${input.projectId}.`;
+  } catch (error) {
+    return apiError(error, 'Unexpected error detaching order from project.');
+  }
+}
+
+export async function updateProjectOrderQuantity(input: z.infer<typeof UpdateProjectOrderQuantitySchema>): Promise<string> {
+  try {
+    const { data } = await client.put(`/projects/${input.projectId}/orders/${input.orderId}/quantity`, {
+      quantity: input.quantity,
+    });
+    return `Project order quantity updated.\n${formatProject(data)}`;
+  } catch (error) {
+    return apiError(error, 'Unexpected error updating project order quantity.');
+  }
+}
+
+export async function updateProjectOrderOptions(input: z.infer<typeof UpdateProjectOrderOptionsSchema>): Promise<string> {
+  const { projectId, orderId, ...payload } = input;
+  try {
+    const { data } = await client.patch(`/projects/${projectId}/orders/${orderId}/options`, payload);
+    return `Project order options updated.\n${JSON.stringify(data, null, 2)}`;
+  } catch (error) {
+    return apiError(error, 'Unexpected error updating project order options.');
+  }
+}
+
+export async function updateProjectArticleMaterial(input: z.infer<typeof UpdateProjectArticleMaterialSchema>): Promise<string> {
+  try {
+    const { data } = await client.patch(
+      `/projects/${input.projectId}/orders/${input.orderId}/articles/${encodeURIComponent(input.positionName)}/materials`,
+      { field: input.field, materialDescription: input.materialDescription }
+    );
+    return `Project article material updated.\n${JSON.stringify(data, null, 2)}`;
+  } catch (error) {
+    return apiError(error, 'Unexpected error updating project article material.');
+  }
+}
+
+export async function updateProjectArticleMaterials(input: z.infer<typeof UpdateProjectArticleMaterialsSchema>): Promise<string> {
+  try {
+    const { data } = await client.patch(
+      `/projects/${input.projectId}/orders/${input.orderId}/articles/materials`,
+      { positionNames: input.positionNames, field: input.field, materialDescription: input.materialDescription }
+    );
+    return `Project article materials updated.\n${JSON.stringify(data, null, 2)}`;
+  } catch (error) {
+    return apiError(error, 'Unexpected error updating project article materials.');
+  }
+}
+
+export async function shareProjectAccess(input: z.infer<typeof ProjectAccessSchema>): Promise<string> {
+  try {
+    await client.post(`/projects/${input.projectId}/permissions/grant`, {
+      grantedToEmail: input.grantedToEmail,
+      permissionType: input.permissionType,
+      hidePrice: input.hidePrice,
+    });
+    const priceNote = input.hidePrice ? ' Pricing will be hidden from them.' : '';
+    return `Access granted. ${input.grantedToEmail} now has ${input.permissionType} access to project ${input.projectId}.${priceNote}`;
+  } catch (error) {
+    return apiError(error, 'Unexpected error granting project access.');
+  }
+}
+
+export async function updateProjectAccess(input: z.infer<typeof ProjectAccessSchema>): Promise<string> {
+  try {
+    await client.put(`/projects/${input.projectId}/permissions/update`, {
+      grantedToEmail: input.grantedToEmail,
+      permissionType: input.permissionType,
+      hidePrice: input.hidePrice,
+    });
+    const priceNote = input.hidePrice ? ' Pricing is hidden from them.' : ' Pricing is visible to them.';
+    return `Permission updated. ${input.grantedToEmail} now has ${input.permissionType} access to project ${input.projectId}.${priceNote}`;
+  } catch (error) {
+    return apiError(error, 'Unexpected error updating project access.');
+  }
+}
+
+export async function revokeProjectAccess(input: z.infer<typeof RevokeProjectAccessSchema>): Promise<string> {
+  try {
+    await client.delete(`/projects/${input.projectId}/permissions/revoke`, {
+      params: { email: input.email },
+    });
+    return `Access revoked. ${input.email} can no longer access project ${input.projectId}.`;
+  } catch (error) {
+    return apiError(error, 'Unexpected error revoking project access.');
+  }
+}
+
+export async function listProjectAccess(input: z.infer<typeof ListProjectAccessSchema>): Promise<string> {
+  try {
+    const { data } = await client.get(`/projects/${input.projectId}/permissions`);
+    if (!data || data.length === 0) {
+      return `No shared access on project ${input.projectId}. Only the project owner can view it.`;
+    }
+    return JSON.stringify(data, null, 2);
+  } catch (error) {
+    return apiError(error, 'Unexpected error listing project access.');
+  }
+}
+
+export const projectTools = [
+  {
+    name: 'list_projects',
+    description: 'List projects available to the authenticated customer, including owned and shared projects. Use this before choosing a projectId.',
+    inputSchema: ListProjectsSchema,
+    handler: listProjects,
+  },
+  {
+    name: 'get_project',
+    description: 'Get full project details including attached orders, material/service/component summaries, custom line items, and permission metadata.',
+    inputSchema: GetProjectSchema,
+    handler: getProject,
+  },
+  {
+    name: 'create_project',
+    description: 'Create a new customer project. Use this when the customer wants a new job/project container before attaching or placing orders.',
+    inputSchema: CreateProjectSchema,
+    handler: createProject,
+  },
+  {
+    name: 'update_project',
+    description: 'Update project metadata such as name, address, status, phase, client, budget, due date, tax exemption, or notes. Omitted fields are left unchanged.',
+    inputSchema: UpdateProjectSchema,
+    handler: updateProject,
+  },
+  {
+    name: 'delete_project',
+    description: 'Delete a project owned by the customer. Production or paid attached orders block deletion; pending orders are detached and remain in order history.',
+    inputSchema: DeleteProjectSchema,
+    handler: deleteProject,
+  },
+  {
+    name: 'attach_order_to_project',
+    description: 'Attach one of the customer-owned orders to a project the customer can edit. This copies the project snapshot to the order.',
+    inputSchema: ProjectOrderSchema,
+    handler: attachOrderToProject,
+  },
+  {
+    name: 'detach_order_from_project',
+    description: 'Remove an order from a project without deleting the order.',
+    inputSchema: ProjectOrderSchema,
+    handler: detachOrderFromProject,
+  },
+  {
+    name: 'update_project_order_quantity',
+    description: 'Set the project quantity multiplier for an attached order. This affects project summaries only; it does not alter the actual order.',
+    inputSchema: UpdateProjectOrderQuantitySchema,
+    handler: updateProjectOrderQuantity,
+  },
+  {
+    name: 'update_project_order_options',
+    description: 'Update service options for an order within a project: drawerboxes, assembly, hardware, finishing type/color. Omit unchanged fields.',
+    inputSchema: UpdateProjectOrderOptionsSchema,
+    handler: updateProjectOrderOptions,
+  },
+  {
+    name: 'update_project_article_material',
+    description: 'Update a material field for one cabinet/article in an attached project order. Use exact material descriptions.',
+    inputSchema: UpdateProjectArticleMaterialSchema,
+    handler: updateProjectArticleMaterial,
+  },
+  {
+    name: 'update_project_article_materials',
+    description: 'Bulk update a material field for multiple cabinet/article positions in an attached project order. Use exact material descriptions.',
+    inputSchema: UpdateProjectArticleMaterialsSchema,
+    handler: updateProjectArticleMaterials,
+  },
+  {
+    name: 'share_project_access',
+    description: 'Grant another user access to a project. Project owners only. Permission levels are VIEW, EDIT, and ADMIN; hidePrice hides project pricing.',
+    inputSchema: ProjectAccessSchema,
+    handler: shareProjectAccess,
+  },
+  {
+    name: 'update_project_access',
+    description: 'Update an existing project permission level or price visibility. Project owners only.',
+    inputSchema: ProjectAccessSchema,
+    handler: updateProjectAccess,
+  },
+  {
+    name: 'revoke_project_access',
+    description: 'Revoke a user from a project. Project owners only.',
+    inputSchema: RevokeProjectAccessSchema,
+    handler: revokeProjectAccess,
+  },
+  {
+    name: 'list_project_access',
+    description: 'List users who currently have shared access to a project. Project owners only.',
+    inputSchema: ListProjectAccessSchema,
+    handler: listProjectAccess,
+  },
+];