@vibescope/mcp-server 0.2.0 → 0.2.2

package/dist/handlers/ideas.js

@@ -10,54 +10,78 @@
  *
  * MIGRATED: Uses Vibescope API client instead of direct Supabase
  */
-import { validateRequired, validateUUID, validatePriority, validateEstimatedMinutes } from '../validators.js';
+import { parseArgs, uuidValidator, priorityValidator, minutesValidator, createEnumValidator, } from '../validators.js';
 import { getApiClient } from '../api-client.js';
+const VALID_IDEA_STATUSES = ['raw', 'exploring', 'planned', 'in_development', 'shipped'];
+// Argument schemas for type-safe parsing
+const addIdeaSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    title: { type: 'string', required: true },
+    description: { type: 'string' },
+    status: { type: 'string', validate: createEnumValidator(VALID_IDEA_STATUSES) },
+};
+const updateIdeaSchema = {
+    idea_id: { type: 'string', required: true, validate: uuidValidator },
+    title: { type: 'string' },
+    description: { type: 'string' },
+    status: { type: 'string', validate: createEnumValidator(VALID_IDEA_STATUSES) },
+    doc_url: { type: 'string' },
+};
+const getIdeasSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    status: { type: 'string', validate: createEnumValidator(VALID_IDEA_STATUSES) },
+    limit: { type: 'number', default: 50 },
+    offset: { type: 'number', default: 0 },
+    search_query: { type: 'string' },
+};
+const deleteIdeaSchema = {
+    idea_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const convertIdeaToTaskSchema = {
+    idea_id: { type: 'string', required: true, validate: uuidValidator },
+    priority: { type: 'number', default: 3, validate: priorityValidator },
+    estimated_minutes: { type: 'number', validate: minutesValidator },
+    update_status: { type: 'boolean', default: true },
+};
 export const addIdea = async (args, ctx) => {
-    const { project_id, title, description, status } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
-    validateRequired(title, 'title');
+    const { project_id, title, description, status } = parseArgs(args, addIdeaSchema);
     const { session } = ctx;
     const apiClient = getApiClient();
     const response = await apiClient.addIdea(project_id, {
         title,
         description,
-        status
+        status: status
     }, session.currentSessionId || undefined);
     if (!response.ok) {
-        throw new Error(`Failed to add idea: ${response.error}`);
+        return { result: { error: response.error || 'Failed to add idea' }, isError: true };
     }
     return { result: { success: true, idea_id: response.data?.idea_id, title } };
 };
-export const updateIdea = async (args, ctx) => {
-    const { idea_id, title, description, status, doc_url } = args;
-    validateRequired(idea_id, 'idea_id');
-    validateUUID(idea_id, 'idea_id');
+export const updateIdea = async (args, _ctx) => {
+    const { idea_id, title, description, status, doc_url } = parseArgs(args, updateIdeaSchema);
     const apiClient = getApiClient();
     const response = await apiClient.updateIdea(idea_id, {
         title,
         description,
-        status,
+        status: status,
         doc_url
     });
     if (!response.ok) {
-        throw new Error(`Failed to update idea: ${response.error}`);
+        return { result: { error: response.error || 'Failed to update idea' }, isError: true };
     }
     return { result: { success: true, idea_id } };
 };
-export const getIdeas = async (args, ctx) => {
-    const { project_id, status, limit = 50, offset = 0, search_query } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
+export const getIdeas = async (args, _ctx) => {
+    const { project_id, status, limit, offset, search_query } = parseArgs(args, getIdeasSchema);
     const apiClient = getApiClient();
     const response = await apiClient.getIdeas(project_id, {
-        status,
+        status: status,
         limit,
         offset,
         search_query
     });
     if (!response.ok) {
-        throw new Error(`Failed to fetch ideas: ${response.error}`);
+        return { result: { error: response.error || 'Failed to fetch ideas' }, isError: true };
     }
     return {
         result: {
@@ -65,23 +89,17 @@ export const getIdeas = async (args, ctx) => {
         },
     };
 };
-export const deleteIdea = async (args, ctx) => {
-    const { idea_id } = args;
-    validateRequired(idea_id, 'idea_id');
-    validateUUID(idea_id, 'idea_id');
+export const deleteIdea = async (args, _ctx) => {
+    const { idea_id } = parseArgs(args, deleteIdeaSchema);
     const apiClient = getApiClient();
     const response = await apiClient.deleteIdea(idea_id);
     if (!response.ok) {
-        throw new Error(`Failed to delete idea: ${response.error}`);
+        return { result: { error: response.error || 'Failed to delete idea' }, isError: true };
     }
     return { result: { success: true } };
 };
-export const convertIdeaToTask = async (args, ctx) => {
-    const { idea_id, priority = 3, estimated_minutes, update_status = true } = args;
-    validateRequired(idea_id, 'idea_id');
-    validateUUID(idea_id, 'idea_id');
-    validatePriority(priority);
-    validateEstimatedMinutes(estimated_minutes);
+export const convertIdeaToTask = async (args, _ctx) => {
+    const { idea_id, priority, estimated_minutes, update_status } = parseArgs(args, convertIdeaToTaskSchema);
     const apiClient = getApiClient();
     // Use proxy for convert_idea_to_task operation
     const response = await apiClient.proxy('convert_idea_to_task', {
@@ -91,7 +109,7 @@ export const convertIdeaToTask = async (args, ctx) => {
         update_status
     });
     if (!response.ok) {
-        throw new Error(`Failed to convert idea: ${response.error}`);
+        return { result: { error: response.error || 'Failed to convert idea' }, isError: true };
     }
     return { result: response.data };
 };

package/dist/handlers/index.d.ts

@@ -24,6 +24,9 @@ export * from './organizations.js';
 export * from './cost.js';
 export * from './git-issues.js';
 export * from './sprints.js';
+export * from './file-checkouts.js';
+export * from './roles.js';
+export * from './connectors.js';
 import type { HandlerRegistry } from './types.js';
 /**
  * Build the complete handler registry from all modules

package/dist/handlers/index.js

@@ -24,6 +24,9 @@ export * from './organizations.js';
 export * from './cost.js';
 export * from './git-issues.js';
 export * from './sprints.js';
+export * from './file-checkouts.js';
+export * from './roles.js';
+export * from './connectors.js';
 import { milestoneHandlers } from './milestones.js';
 import { sessionHandlers } from './session.js';
 import { ideaHandlers } from './ideas.js';
@@ -43,6 +46,9 @@ import { organizationHandlers } from './organizations.js';
 import { costHandlers } from './cost.js';
 import { gitIssueHandlers } from './git-issues.js';
 import { sprintHandlers } from './sprints.js';
+import { fileCheckoutHandlers } from './file-checkouts.js';
+import { roleHandlers } from './roles.js';
+import { connectorHandlers } from './connectors.js';
 /**
  * Build the complete handler registry from all modules
  */
@@ -67,5 +73,8 @@ export function buildHandlerRegistry() {
         ...costHandlers,
         ...gitIssueHandlers,
         ...sprintHandlers,
+        ...fileCheckoutHandlers,
+        ...roleHandlers,
+        ...connectorHandlers,
     };
 }

package/dist/handlers/milestones.js

@@ -10,13 +10,34 @@
  *
  * MIGRATED: Uses Vibescope API client instead of direct Supabase
  */
-import { ValidationError, validateRequired, validateUUID } from '../validators.js';
+import { parseArgs, uuidValidator, createEnumValidator, ValidationError, } from '../validators.js';
 import { getApiClient } from '../api-client.js';
+const VALID_MILESTONE_STATUSES = ['pending', 'in_progress', 'completed'];
+// Argument schemas for type-safe parsing
+const addMilestoneSchema = {
+    task_id: { type: 'string', required: true, validate: uuidValidator },
+    title: { type: 'string', required: true },
+    description: { type: 'string' },
+    order_index: { type: 'number' },
+};
+const updateMilestoneSchema = {
+    milestone_id: { type: 'string', required: true, validate: uuidValidator },
+    title: { type: 'string' },
+    description: { type: 'string' },
+    status: { type: 'string', validate: createEnumValidator(VALID_MILESTONE_STATUSES) },
+    order_index: { type: 'number' },
+};
+const completeMilestoneSchema = {
+    milestone_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const deleteMilestoneSchema = {
+    milestone_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const getMilestonesSchema = {
+    task_id: { type: 'string', required: true, validate: uuidValidator },
+};
 export const addMilestone = async (args, ctx) => {
-    const { task_id, title, description, order_index } = args;
-    validateRequired(task_id, 'task_id');
-    validateUUID(task_id, 'task_id');
-    validateRequired(title, 'title');
+    const { task_id, title, description, order_index } = parseArgs(args, addMilestoneSchema);
     const { session } = ctx;
     const apiClient = getApiClient();
     const response = await apiClient.addMilestone(task_id, {
@@ -25,7 +46,7 @@ export const addMilestone = async (args, ctx) => {
         order_index
     }, session.currentSessionId || undefined);
     if (!response.ok) {
-        throw new Error(`Failed to add milestone: ${response.error}`);
+        return { result: { error: response.error || 'Failed to add milestone' }, isError: true };
     }
     return {
         result: {
@@ -34,16 +55,8 @@ export const addMilestone = async (args, ctx) => {
         },
     };
 };
-export const updateMilestone = async (args, ctx) => {
-    const { milestone_id, title, description, status, order_index } = args;
-    validateRequired(milestone_id, 'milestone_id');
-    validateUUID(milestone_id, 'milestone_id');
-    // Validate status if provided
-    if (status !== undefined) {
-        if (!['pending', 'in_progress', 'completed'].includes(status)) {
-            throw new ValidationError('status must be pending, in_progress, or completed');
-        }
-    }
+export const updateMilestone = async (args, _ctx) => {
+    const { milestone_id, title, description, status, order_index } = parseArgs(args, updateMilestoneSchema);
     // Check that at least one field is provided
     if (title === undefined && description === undefined && status === undefined && order_index === undefined) {
         throw new ValidationError('At least one field to update is required');
@@ -56,7 +69,7 @@ export const updateMilestone = async (args, ctx) => {
         order_index
     });
     if (!response.ok) {
-        throw new Error(`Failed to update milestone: ${response.error}`);
+        return { result: { error: response.error || 'Failed to update milestone' }, isError: true };
     }
     return {
         result: {
@@ -65,14 +78,12 @@ export const updateMilestone = async (args, ctx) => {
         },
     };
 };
-export const completeMilestone = async (args, ctx) => {
-    const { milestone_id } = args;
-    validateRequired(milestone_id, 'milestone_id');
-    validateUUID(milestone_id, 'milestone_id');
+export const completeMilestone = async (args, _ctx) => {
+    const { milestone_id } = parseArgs(args, completeMilestoneSchema);
     const apiClient = getApiClient();
     const response = await apiClient.completeMilestone(milestone_id);
     if (!response.ok) {
-        throw new Error(`Failed to complete milestone: ${response.error}`);
+        return { result: { error: response.error || 'Failed to complete milestone' }, isError: true };
     }
     return {
         result: {
@@ -81,14 +92,12 @@ export const completeMilestone = async (args, ctx) => {
         },
     };
 };
-export const deleteMilestone = async (args, ctx) => {
-    const { milestone_id } = args;
-    validateRequired(milestone_id, 'milestone_id');
-    validateUUID(milestone_id, 'milestone_id');
+export const deleteMilestone = async (args, _ctx) => {
+    const { milestone_id } = parseArgs(args, deleteMilestoneSchema);
     const apiClient = getApiClient();
     const response = await apiClient.deleteMilestone(milestone_id);
     if (!response.ok) {
-        throw new Error(`Failed to delete milestone: ${response.error}`);
+        return { result: { error: response.error || 'Failed to delete milestone' }, isError: true };
     }
     return {
         result: {
@@ -97,14 +106,12 @@ export const deleteMilestone = async (args, ctx) => {
         },
     };
 };
-export const getMilestones = async (args, ctx) => {
-    const { task_id } = args;
-    validateRequired(task_id, 'task_id');
-    validateUUID(task_id, 'task_id');
+export const getMilestones = async (args, _ctx) => {
+    const { task_id } = parseArgs(args, getMilestonesSchema);
     const apiClient = getApiClient();
     const response = await apiClient.getMilestones(task_id);
     if (!response.ok) {
-        throw new Error(`Failed to get milestones: ${response.error}`);
+        return { result: { error: response.error || 'Failed to get milestones' }, isError: true };
     }
     // Stats are calculated server-side now
     return {

package/dist/handlers/organizations.js

@@ -16,26 +16,80 @@
  * - unshare_project
  * - list_project_shares
  */
-import { validateRequired, validateUUID } from '../validators.js';
+import { parseArgs, uuidValidator, createEnumValidator, ValidationError } from '../validators.js';
 import { getApiClient } from '../api-client.js';
 // Valid roles in order of permission level
 const ROLE_ORDER = ['viewer', 'member', 'admin', 'owner'];
+const ASSIGNABLE_ROLES = ['viewer', 'member', 'admin'];
 // Valid share permissions
 const PERMISSION_ORDER = ['read', 'write', 'admin'];
 // ============================================================================
+// Argument Schemas
+// ============================================================================
+const createOrganizationSchema = {
+    name: { type: 'string', required: true },
+    description: { type: 'string' },
+    slug: { type: 'string' },
+};
+const updateOrganizationSchema = {
+    organization_id: { type: 'string', required: true, validate: uuidValidator },
+    name: { type: 'string' },
+    description: { type: 'string' },
+    logo_url: { type: 'string' },
+};
+const deleteOrganizationSchema = {
+    organization_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const listOrgMembersSchema = {
+    organization_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const inviteMemberSchema = {
+    organization_id: { type: 'string', required: true, validate: uuidValidator },
+    email: { type: 'string', required: true },
+    role: { type: 'string', default: 'member', validate: createEnumValidator(ASSIGNABLE_ROLES) },
+};
+const updateMemberRoleSchema = {
+    organization_id: { type: 'string', required: true, validate: uuidValidator },
+    user_id: { type: 'string', required: true, validate: uuidValidator },
+    role: { type: 'string', required: true, validate: createEnumValidator(ROLE_ORDER) },
+};
+const removeMemberSchema = {
+    organization_id: { type: 'string', required: true, validate: uuidValidator },
+    user_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const leaveOrganizationSchema = {
+    organization_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const shareProjectWithOrgSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    organization_id: { type: 'string', required: true, validate: uuidValidator },
+    permission: { type: 'string', default: 'read', validate: createEnumValidator(PERMISSION_ORDER) },
+};
+const updateProjectShareSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    organization_id: { type: 'string', required: true, validate: uuidValidator },
+    permission: { type: 'string', required: true, validate: createEnumValidator(PERMISSION_ORDER) },
+};
+const unshareProjectSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    organization_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const listProjectSharesSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+};
+// ============================================================================
 // Organization Management
 // ============================================================================
-export const listOrganizations = async (_args, ctx) => {
+export const listOrganizations = async (_args, _ctx) => {
     const apiClient = getApiClient();
     const response = await apiClient.listOrganizations();
     if (!response.ok) {
-        throw new Error(response.error || 'Failed to list organizations');
+        return { result: { error: response.error || 'Failed to list organizations' }, isError: true };
     }
     return { result: response.data };
 };
-export const createOrganization = async (args, ctx) => {
-    const { name, description, slug } = args;
-    validateRequired(name, 'name');
+export const createOrganization = async (args, _ctx) => {
+    const { name, description, slug } = parseArgs(args, createOrganizationSchema);
     const apiClient = getApiClient();
     const response = await apiClient.createOrganization({
         name,
@@ -43,14 +97,16 @@ export const createOrganization = async (args, ctx) => {
         slug
     });
     if (!response.ok) {
-        throw new Error(response.error || 'Failed to create organization');
+        return { result: { error: response.error || 'Failed to create organization' }, isError: true };
     }
     return { result: response.data };
 };
-export const updateOrganization = async (args, ctx) => {
-    const { organization_id, name, description, logo_url } = args;
-    validateRequired(organization_id, 'organization_id');
-    validateUUID(organization_id, 'organization_id');
+export const updateOrganization = async (args, _ctx) => {
+    const { organization_id, name, description, logo_url } = parseArgs(args, updateOrganizationSchema);
+    // Check that at least one update is provided
+    if (name === undefined && description === undefined && logo_url === undefined) {
+        throw new ValidationError('No updates provided');
+    }
     const updates = {};
     if (name !== undefined)
         updates.name = name;
@@ -58,157 +114,109 @@ export const updateOrganization = async (args, ctx) => {
         updates.description = description;
     if (logo_url !== undefined)
         updates.logo_url = logo_url;
-    if (Object.keys(updates).length === 0) {
-        throw new Error('No updates provided');
-    }
     const apiClient = getApiClient();
     const response = await apiClient.updateOrganization(organization_id, updates);
     if (!response.ok) {
-        throw new Error(response.error || 'Failed to update organization');
+        return { result: { error: response.error || 'Failed to update organization' }, isError: true };
     }
     return { result: response.data };
 };
-export const deleteOrganization = async (args, ctx) => {
-    const { organization_id } = args;
-    validateRequired(organization_id, 'organization_id');
-    validateUUID(organization_id, 'organization_id');
+export const deleteOrganization = async (args, _ctx) => {
+    const { organization_id } = parseArgs(args, deleteOrganizationSchema);
     const apiClient = getApiClient();
     const response = await apiClient.deleteOrganization(organization_id);
     if (!response.ok) {
-        throw new Error(response.error || 'Failed to delete organization');
+        return { result: { error: response.error || 'Failed to delete organization' }, isError: true };
     }
     return { result: response.data };
 };
 // ============================================================================
 // Member Management
 // ============================================================================
-export const listOrgMembers = async (args, ctx) => {
-    const { organization_id } = args;
-    validateRequired(organization_id, 'organization_id');
-    validateUUID(organization_id, 'organization_id');
+export const listOrgMembers = async (args, _ctx) => {
+    const { organization_id } = parseArgs(args, listOrgMembersSchema);
     const apiClient = getApiClient();
     const response = await apiClient.listOrgMembers(organization_id);
     if (!response.ok) {
-        throw new Error(response.error || 'Failed to list members');
+        return { result: { error: response.error || 'Failed to list members' }, isError: true };
     }
     return { result: response.data };
 };
-export const inviteMember = async (args, ctx) => {
-    const { organization_id, email, role = 'member' } = args;
-    validateRequired(organization_id, 'organization_id');
-    validateRequired(email, 'email');
-    validateUUID(organization_id, 'organization_id');
-    if (!['admin', 'member', 'viewer'].includes(role)) {
-        throw new Error('Invalid role. Must be admin, member, or viewer.');
-    }
+export const inviteMember = async (args, _ctx) => {
+    const { organization_id, email, role } = parseArgs(args, inviteMemberSchema);
     const apiClient = getApiClient();
     const response = await apiClient.inviteMember(organization_id, email, role);
     if (!response.ok) {
-        throw new Error(response.error || 'Failed to create invite');
+        return { result: { error: response.error || 'Failed to create invite' }, isError: true };
     }
     return { result: response.data };
 };
-export const updateMemberRole = async (args, ctx) => {
-    const { organization_id, user_id, role } = args;
-    validateRequired(organization_id, 'organization_id');
-    validateRequired(user_id, 'user_id');
-    validateRequired(role, 'role');
-    validateUUID(organization_id, 'organization_id');
-    validateUUID(user_id, 'user_id');
-    if (!ROLE_ORDER.includes(role)) {
-        throw new Error(`Invalid role. Must be one of: ${ROLE_ORDER.join(', ')}`);
-    }
+export const updateMemberRole = async (args, _ctx) => {
+    const { organization_id, user_id, role } = parseArgs(args, updateMemberRoleSchema);
     if (role === 'owner') {
-        throw new Error('Cannot assign owner role. Use transfer ownership instead.');
+        throw new ValidationError('Cannot assign owner role. Use transfer ownership instead.');
     }
     const apiClient = getApiClient();
     const response = await apiClient.updateMemberRole(organization_id, user_id, role);
     if (!response.ok) {
-        throw new Error(response.error || 'Failed to update member role');
+        return { result: { error: response.error || 'Failed to update member role' }, isError: true };
     }
     return { result: response.data };
 };
-export const removeMember = async (args, ctx) => {
-    const { organization_id, user_id } = args;
-    validateRequired(organization_id, 'organization_id');
-    validateRequired(user_id, 'user_id');
-    validateUUID(organization_id, 'organization_id');
-    validateUUID(user_id, 'user_id');
+export const removeMember = async (args, _ctx) => {
+    const { organization_id, user_id } = parseArgs(args, removeMemberSchema);
     const apiClient = getApiClient();
     const response = await apiClient.removeMember(organization_id, user_id);
     if (!response.ok) {
-        throw new Error(response.error || 'Failed to remove member');
+        return { result: { error: response.error || 'Failed to remove member' }, isError: true };
     }
     return { result: response.data };
 };
-export const leaveOrganization = async (args, ctx) => {
-    const { organization_id } = args;
-    validateRequired(organization_id, 'organization_id');
-    validateUUID(organization_id, 'organization_id');
+export const leaveOrganization = async (args, _ctx) => {
+    const { organization_id } = parseArgs(args, leaveOrganizationSchema);
     const apiClient = getApiClient();
     const response = await apiClient.leaveOrganization(organization_id);
     if (!response.ok) {
-        throw new Error(response.error || 'Failed to leave organization');
+        return { result: { error: response.error || 'Failed to leave organization' }, isError: true };
     }
     return { result: response.data };
 };
 // ============================================================================
 // Project Sharing
 // ============================================================================
-export const shareProjectWithOrg = async (args, ctx) => {
-    const { project_id, organization_id, permission = 'read' } = args;
-    validateRequired(project_id, 'project_id');
-    validateRequired(organization_id, 'organization_id');
-    validateUUID(project_id, 'project_id');
-    validateUUID(organization_id, 'organization_id');
-    if (!PERMISSION_ORDER.includes(permission)) {
-        throw new Error(`Invalid permission. Must be one of: ${PERMISSION_ORDER.join(', ')}`);
-    }
+export const shareProjectWithOrg = async (args, _ctx) => {
+    const { project_id, organization_id, permission } = parseArgs(args, shareProjectWithOrgSchema);
     const apiClient = getApiClient();
     const response = await apiClient.shareProjectWithOrg(project_id, organization_id, permission);
     if (!response.ok) {
-        throw new Error(response.error || 'Failed to share project');
+        return { result: { error: response.error || 'Failed to share project' }, isError: true };
     }
     return { result: response.data };
 };
-export const updateProjectShare = async (args, ctx) => {
-    const { project_id, organization_id, permission } = args;
-    validateRequired(project_id, 'project_id');
-    validateRequired(organization_id, 'organization_id');
-    validateRequired(permission, 'permission');
-    validateUUID(project_id, 'project_id');
-    validateUUID(organization_id, 'organization_id');
-    if (!PERMISSION_ORDER.includes(permission)) {
-        throw new Error(`Invalid permission. Must be one of: ${PERMISSION_ORDER.join(', ')}`);
-    }
+export const updateProjectShare = async (args, _ctx) => {
+    const { project_id, organization_id, permission } = parseArgs(args, updateProjectShareSchema);
     const apiClient = getApiClient();
     const response = await apiClient.updateProjectShare(project_id, organization_id, permission);
     if (!response.ok) {
-        throw new Error(response.error || 'Failed to update share');
+        return { result: { error: response.error || 'Failed to update share' }, isError: true };
     }
     return { result: response.data };
 };
-export const unshareProject = async (args, ctx) => {
-    const { project_id, organization_id } = args;
-    validateRequired(project_id, 'project_id');
-    validateRequired(organization_id, 'organization_id');
-    validateUUID(project_id, 'project_id');
-    validateUUID(organization_id, 'organization_id');
+export const unshareProject = async (args, _ctx) => {
+    const { project_id, organization_id } = parseArgs(args, unshareProjectSchema);
     const apiClient = getApiClient();
     const response = await apiClient.unshareProject(project_id, organization_id);
     if (!response.ok) {
-        throw new Error(response.error || 'Failed to unshare project');
+        return { result: { error: response.error || 'Failed to unshare project' }, isError: true };
     }
     return { result: response.data };
 };
-export const listProjectShares = async (args, ctx) => {
-    const { project_id } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
+export const listProjectShares = async (args, _ctx) => {
+    const { project_id } = parseArgs(args, listProjectSharesSchema);
     const apiClient = getApiClient();
     const response = await apiClient.listProjectShares(project_id);
     if (!response.ok) {
-        throw new Error(response.error || 'Failed to list shares');
+        return { result: { error: response.error || 'Failed to list shares' }, isError: true };
     }
     return { result: response.data };
 };