figmanage 0.1.0

package/dist/tools/org.js

@@ -0,0 +1,311 @@
+import { z } from 'zod';
+import { internalClient } from '../clients/internal-api.js';
+import { defineTool, toolResult, toolError, figmaId, requireOrgId } from './register.js';
+// -- list_admins --
+defineTool({
+    toolset: 'org',
+    auth: 'cookie',
+    register(server, config) {
+        server.registerTool('list_admins', {
+            description: 'List org admins with their permission levels, seat status, and email validation state.',
+            inputSchema: {
+                org_id: figmaId.optional().describe('Org ID override (defaults to current workspace)'),
+                include_license_admins: z.boolean().optional().describe('Include license admins (default false)'),
+            },
+        }, async ({ org_id, include_license_admins }) => {
+            try {
+                let orgId;
+                try {
+                    orgId = requireOrgId(config, org_id);
+                }
+                catch (e) {
+                    return toolError(e.message);
+                }
+                const res = await internalClient(config).get(`/api/orgs/${orgId}/admins`, { params: { include_license_admins: include_license_admins ?? false } });
+                const admins = (res.data?.meta || []).map((a) => ({
+                    user_id: a.user_id,
+                    email: a.user?.email,
+                    name: a.user?.handle,
+                    permission: a.permission,
+                    seat_type: a.active_seat_type?.key || null,
+                    is_email_validated: a.is_email_validated,
+                    license_admin: a.license_admin,
+                }));
+                return toolResult(JSON.stringify(admins, null, 2));
+            }
+            catch (e) {
+                return toolError(`Failed to list admins: ${e.response?.status || e.message}`);
+            }
+        });
+    },
+});
+// -- list_org_teams --
+defineTool({
+    toolset: 'org',
+    auth: 'cookie',
+    register(server, config) {
+        server.registerTool('list_org_teams', {
+            description: 'List all teams in the org with member counts, project counts, and access levels.',
+            inputSchema: {
+                org_id: figmaId.optional().describe('Org ID override (defaults to current workspace)'),
+                include_secret_teams: z.boolean().optional().describe('Include secret teams (default false)'),
+            },
+        }, async ({ org_id, include_secret_teams }) => {
+            try {
+                let orgId;
+                try {
+                    orgId = requireOrgId(config, org_id);
+                }
+                catch (e) {
+                    return toolError(e.message);
+                }
+                const res = await internalClient(config).get(`/api/orgs/${orgId}/teams`, {
+                    params: {
+                        include_member_count: true,
+                        include_project_count: true,
+                        include_top_members: true,
+                        include_secret_teams: include_secret_teams ?? false,
+                    },
+                });
+                const teams = res.data?.meta || res.data;
+                const mapped = (Array.isArray(teams) ? teams : []).map((t) => ({
+                    id: String(t.id),
+                    name: t.name,
+                    member_count: t.member_count ?? null,
+                    project_count: t.project_count ?? null,
+                    access_level: t.access_level ?? null,
+                }));
+                return toolResult(JSON.stringify(mapped, null, 2));
+            }
+            catch (e) {
+                return toolError(`Failed to list org teams: ${e.response?.status || e.message}`);
+            }
+        });
+    },
+});
+// -- seat_usage --
+defineTool({
+    toolset: 'org',
+    auth: 'cookie',
+    register(server, config) {
+        server.registerTool('seat_usage', {
+            description: 'Seat usage breakdown: permission counts, seat types, activity recency, and account type distribution.',
+            inputSchema: {
+                org_id: figmaId.optional().describe('Org ID override (defaults to current workspace)'),
+                search_query: z.string().optional().describe('Filter counts by user search query'),
+            },
+        }, async ({ org_id, search_query }) => {
+            try {
+                let orgId;
+                try {
+                    orgId = requireOrgId(config, org_id);
+                }
+                catch (e) {
+                    return toolError(e.message);
+                }
+                const params = {};
+                if (search_query)
+                    params.search_query = search_query;
+                const res = await internalClient(config).get(`/api/orgs/${orgId}/org_users/filter_counts`, { params });
+                return toolResult(JSON.stringify(res.data?.meta || res.data, null, 2));
+            }
+            catch (e) {
+                return toolError(`Failed to fetch seat usage: ${e.response?.status || e.message}`);
+            }
+        });
+    },
+});
+// -- list_team_members --
+defineTool({
+    toolset: 'org',
+    auth: 'cookie',
+    register(server, config) {
+        server.registerTool('list_team_members', {
+            description: 'List members of a team with name, email, avatar, last active date, and role.',
+            inputSchema: {
+                team_id: figmaId.describe('Team ID'),
+            },
+        }, async ({ team_id }) => {
+            try {
+                const res = await internalClient(config).get(`/api/teams/${team_id}/members`);
+                const members = (res.data?.meta || res.data || []).map((m) => ({
+                    id: m.id,
+                    name: m.name,
+                    email: m.email,
+                    img_url: m.img_url,
+                    last_active: m.last_active,
+                    team_role: m.team_role?.level || null,
+                    permission: m.team_user?.permission || null,
+                    seat_type: m.seat_type || null,
+                }));
+                return toolResult(JSON.stringify(members, null, 2));
+            }
+            catch (e) {
+                return toolError(`Failed to list team members: ${e.response?.status || e.message}`);
+            }
+        });
+    },
+});
+// -- billing_overview --
+defineTool({
+    toolset: 'org',
+    auth: 'cookie',
+    register(server, config) {
+        server.registerTool('billing_overview', {
+            description: 'Org billing data including invoice history, status, amounts, and billing periods.',
+            inputSchema: {
+                org_id: figmaId.optional().describe('Org ID override (defaults to current workspace)'),
+            },
+        }, async ({ org_id }) => {
+            try {
+                let orgId;
+                try {
+                    orgId = requireOrgId(config, org_id);
+                }
+                catch (e) {
+                    return toolError(e.message);
+                }
+                const res = await internalClient(config).get(`/api/orgs/${orgId}/billing_data`);
+                const data = res.data?.meta || res.data;
+                const { shipping_address, ...billing } = data;
+                return toolResult(JSON.stringify(billing, null, 2));
+            }
+            catch (e) {
+                return toolError(`Failed to fetch billing overview: ${e.response?.status || e.message}`);
+            }
+        });
+    },
+});
+// -- list_invoices --
+defineTool({
+    toolset: 'org',
+    auth: 'cookie',
+    register(server, config) {
+        server.registerTool('list_invoices', {
+            description: 'List open and upcoming invoices for the org.',
+            inputSchema: {
+                org_id: figmaId.optional().describe('Org ID override (defaults to current workspace)'),
+            },
+        }, async ({ org_id }) => {
+            try {
+                let orgId;
+                try {
+                    orgId = requireOrgId(config, org_id);
+                }
+                catch (e) {
+                    return toolError(e.message);
+                }
+                const client = internalClient(config);
+                const [openResult, upcomingResult] = await Promise.allSettled([
+                    client.get(`/api/plans/organization/${orgId}/invoices/open`),
+                    client.get(`/api/plans/organization/${orgId}/invoices/upcoming`),
+                ]);
+                const response = {};
+                if (openResult.status === 'fulfilled')
+                    response.open = openResult.value.data;
+                else
+                    response.open_error = 'Failed to fetch open invoices';
+                if (upcomingResult.status === 'fulfilled')
+                    response.upcoming = upcomingResult.value.data;
+                else
+                    response.upcoming_error = 'Failed to fetch upcoming invoices';
+                return toolResult(JSON.stringify(response, null, 2));
+            }
+            catch (e) {
+                return toolError(`Failed to list invoices: ${e.response?.status || e.message}`);
+            }
+        });
+    },
+});
+// -- org_domains --
+defineTool({
+    toolset: 'org',
+    auth: 'cookie',
+    register(server, config) {
+        server.registerTool('org_domains', {
+            description: 'Org domain configuration and SSO/SAML settings.',
+            inputSchema: {
+                org_id: figmaId.optional().describe('Org ID override (defaults to current workspace)'),
+            },
+        }, async ({ org_id }) => {
+            try {
+                let orgId;
+                try {
+                    orgId = requireOrgId(config, org_id);
+                }
+                catch (e) {
+                    return toolError(e.message);
+                }
+                const client = internalClient(config);
+                const [domainsResult, ssoResult] = await Promise.allSettled([
+                    client.get(`/api/orgs/${orgId}/domains`),
+                    client.get(`/api/org/${orgId}/org_saml_config`),
+                ]);
+                const response = {};
+                if (domainsResult.status === 'fulfilled')
+                    response.domains = domainsResult.value.data;
+                else
+                    response.domains_error = 'Failed to fetch domains';
+                if (ssoResult.status === 'fulfilled')
+                    response.sso = ssoResult.value.data;
+                else
+                    response.sso_error = 'SSO config not available';
+                return toolResult(JSON.stringify(response, null, 2));
+            }
+            catch (e) {
+                return toolError(`Failed to fetch org domains: ${e.response?.status || e.message}`);
+            }
+        });
+    },
+});
+// -- ai_credit_usage --
+defineTool({
+    toolset: 'org',
+    auth: 'cookie',
+    register(server, config) {
+        server.registerTool('ai_credit_usage', {
+            description: 'AI credit usage summary for a billing plan. Get the plan_id from billing_overview.',
+            inputSchema: {
+                plan_id: figmaId.describe('Plan ID (from billing_overview response)'),
+            },
+        }, async ({ plan_id }) => {
+            try {
+                const res = await internalClient(config).get(`/api/plans/${plan_id}/ai_credits/plan_usage_summary`);
+                return toolResult(JSON.stringify(res.data, null, 2));
+            }
+            catch (e) {
+                return toolError(`Failed to fetch AI credit usage: ${e.response?.status || e.message}`);
+            }
+        });
+    },
+});
+// -- export_members --
+defineTool({
+    toolset: 'org',
+    auth: 'cookie',
+    mutates: true,
+    register(server, config) {
+        server.registerTool('export_members', {
+            description: 'Trigger async CSV export of all org members. The CSV is sent to the admin email on file.',
+            inputSchema: {
+                org_id: figmaId.optional().describe('Org ID override (defaults to current workspace)'),
+            },
+        }, async ({ org_id }) => {
+            try {
+                let orgId;
+                try {
+                    orgId = requireOrgId(config, org_id);
+                }
+                catch (e) {
+                    return toolError(e.message);
+                }
+                await internalClient(config).post(`/api/orgs/${orgId}/export_members`);
+                return toolResult('CSV export queued. It will be emailed to the org admin.');
+            }
+            catch (e) {
+                return toolError(`Failed to export members: ${e.response?.status || e.message}`);
+            }
+        });
+    },
+});
+//# sourceMappingURL=org.js.map

package/dist/tools/permissions.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=permissions.d.ts.map

package/dist/tools/permissions.js

@@ -0,0 +1,246 @@
+import { z } from 'zod';
+import { internalClient } from '../clients/internal-api.js';
+import { defineTool, toolResult, toolError, figmaId } from './register.js';
+const LEVEL_MAP = { owner: 999, editor: 300, viewer: 100 };
+const LEVEL_NAMES = { 999: 'owner', 300: 'editor', 100: 'viewer' };
+function levelName(level) {
+    return LEVEL_NAMES[level] || `level:${level}`;
+}
+async function getRoles(config, resourceType, resourceId) {
+    const res = await internalClient(config).get(`/api/roles/${resourceType}/${resourceId}`);
+    const meta = res.data?.meta;
+    return Array.isArray(meta) ? meta : [];
+}
+// -- get_permissions --
+defineTool({
+    toolset: 'permissions',
+    auth: 'cookie',
+    register(server, config) {
+        server.registerTool('get_permissions', {
+            description: 'See who has access to a file, project, or team. Returns users with roles and role IDs.',
+            inputSchema: {
+                resource_type: z.enum(['file', 'folder', 'team']).describe('Type of resource'),
+                resource_id: figmaId.describe('Resource ID (file key, folder ID, or team ID)'),
+            },
+        }, async ({ resource_type, resource_id }) => {
+            try {
+                const roles = await getRoles(config, resource_type, resource_id);
+                const users = roles.map((r) => ({
+                    role_id: String(r.id),
+                    user_id: r.user_id ? String(r.user_id) : undefined,
+                    handle: r.user?.handle,
+                    email: r.user?.email || r.pending_email,
+                    role: levelName(r.level),
+                    level: r.level,
+                    pending: !!r.pending_email,
+                }));
+                return toolResult(JSON.stringify(users, null, 2));
+            }
+            catch (e) {
+                return toolError(`Failed to get permissions: ${e.response?.status || e.message}`);
+            }
+        });
+    },
+});
+// -- set_permissions --
+defineTool({
+    toolset: 'permissions',
+    auth: 'cookie',
+    mutates: true,
+    register(server, config) {
+        server.registerTool('set_permissions', {
+            description: 'Change access level for a user on a file, project, or team. Looks up the role by user_id.',
+            inputSchema: {
+                resource_type: z.enum(['file', 'folder', 'team']).describe('Type of resource'),
+                resource_id: figmaId.describe('Resource ID'),
+                user_id: figmaId.describe('User ID to change access for'),
+                role: z.enum(['owner', 'editor', 'viewer']).describe('Role to assign'),
+            },
+        }, async ({ resource_type, resource_id, user_id, role }) => {
+            try {
+                const roles = await getRoles(config, resource_type, resource_id);
+                const target = roles.find((r) => String(r.user_id) === user_id);
+                if (!target) {
+                    return toolError(`User ${user_id} has no role on this ${resource_type}. Use share to invite them first.`);
+                }
+                const level = LEVEL_MAP[role];
+                await internalClient(config).put(`/api/roles/${target.id}`, { level });
+                return toolResult(`Set ${role} (level ${level}) for user ${user_id} on ${resource_type} ${resource_id}`);
+            }
+            catch (e) {
+                return toolError(`Failed to set permissions: ${e.response?.status || e.message}`);
+            }
+        });
+    },
+});
+// -- share --
+defineTool({
+    toolset: 'permissions',
+    auth: 'cookie',
+    mutates: true,
+    register(server, config) {
+        server.registerTool('share', {
+            description: 'Share a file or project with someone by email. Sends an invite.',
+            inputSchema: {
+                resource_type: z.enum(['file', 'folder', 'team']).describe('Type of resource'),
+                resource_id: figmaId.describe('Resource ID (file key, folder ID, or team ID)'),
+                email: z.string().describe('Email address to invite'),
+                role: z.enum(['editor', 'viewer']).optional().describe('Role to grant (default: viewer)'),
+            },
+        }, async ({ resource_type, resource_id, email, role }) => {
+            try {
+                const level = LEVEL_MAP[role || 'viewer'];
+                const res = await internalClient(config).post('/api/invites', {
+                    resource_type,
+                    resource_id_or_key: resource_id,
+                    emails: [email],
+                    level,
+                });
+                const invites = res.data?.meta?.invites || [];
+                const roleId = invites[0]?.id;
+                let msg = `Invited ${email} as ${role || 'viewer'} on ${resource_type} ${resource_id}`;
+                if (roleId)
+                    msg += ` (role_id: ${roleId})`;
+                return toolResult(msg);
+            }
+            catch (e) {
+                return toolError(`Failed to share: ${e.response?.status || e.message}`);
+            }
+        });
+    },
+});
+// -- revoke_access --
+defineTool({
+    toolset: 'permissions',
+    auth: 'cookie',
+    mutates: true,
+    destructive: true,
+    register(server, config) {
+        server.registerTool('revoke_access', {
+            description: "Remove someone's access to a file, project, or team. Looks up the role by user_id.",
+            inputSchema: {
+                resource_type: z.enum(['file', 'folder', 'team']).describe('Type of resource'),
+                resource_id: figmaId.describe('Resource ID'),
+                user_id: figmaId.describe('User ID to revoke access from'),
+            },
+        }, async ({ resource_type, resource_id, user_id }) => {
+            try {
+                const roles = await getRoles(config, resource_type, resource_id);
+                const target = roles.find((r) => String(r.user_id) === user_id);
+                if (!target) {
+                    return toolError(`User ${user_id} has no role on this ${resource_type}.`);
+                }
+                await internalClient(config).delete(`/api/roles/${target.id}`);
+                return toolResult(`Revoked access for user ${user_id} on ${resource_type} ${resource_id}`);
+            }
+            catch (e) {
+                return toolError(`Failed to revoke access: ${e.response?.status || e.message}`);
+            }
+        });
+    },
+});
+// -- list_role_requests --
+defineTool({
+    toolset: 'permissions',
+    auth: 'cookie',
+    register(server, config) {
+        server.registerTool('list_role_requests', {
+            description: 'List pending file access requests. These come through the notification system.',
+            inputSchema: {},
+        }, async () => {
+            try {
+                const res = await internalClient(config).get('/api/user_notifications/server_driven/plan', {
+                    params: { current_plan_id: '-1', app_version: '1', client_type: 'web' },
+                });
+                const notifications = res.data?.meta || [];
+                const requests = (Array.isArray(notifications) ? notifications : [])
+                    .filter((n) => n.notification_type === 'FileRoleRequestCreatedNotif')
+                    .map((n) => {
+                    const locals = n.notification?.locals || n.preferred_attachments?.[0]?.body || {};
+                    // Extract from notification locals if available, otherwise parse from display text
+                    const title = n.preferred_attachments?.[0]?.body?.title || [];
+                    const subtitle = n.preferred_attachments?.[0]?.body?.subtitle || [];
+                    const email = title[0]?.html_text?.replace(/<[^>]+>/g, '') || undefined;
+                    const action = subtitle[0]?.html_text || undefined;
+                    const fileName = subtitle[2]?.html_text || undefined;
+                    const hasActions = !!n.preferred_attachments?.[0]?.actions;
+                    return {
+                        notification_id: n.notification_id,
+                        email,
+                        action,
+                        file_name: fileName,
+                        pending: hasActions,
+                        is_unread: n.is_unread,
+                        created_at: n.preferred_attachments?.[0]?.body?.created_at,
+                    };
+                });
+                return toolResult(JSON.stringify(requests, null, 2));
+            }
+            catch (e) {
+                return toolError(`Failed to list role requests: ${e.response?.status || e.message}`);
+            }
+        });
+    },
+});
+// -- approve_role_request --
+defineTool({
+    toolset: 'permissions',
+    auth: 'cookie',
+    mutates: true,
+    register(server, config) {
+        server.registerTool('approve_role_request', {
+            description: 'Approve a pending file access request by notification ID.',
+            inputSchema: {
+                notification_id: figmaId.describe('Notification ID from list_role_requests'),
+            },
+        }, async ({ notification_id }) => {
+            try {
+                const res = await internalClient(config).put('/api/user_notifications/accept', {
+                    id: notification_id,
+                    medium: 'web',
+                    appVersion: '1',
+                    clientType: 'web',
+                });
+                const notif = res.data?.meta?.notification;
+                const locals = notif?.locals || {};
+                let msg = `Approved access request ${notification_id}`;
+                if (locals.file_name)
+                    msg += ` for ${locals.file_name}`;
+                if (locals.user_id)
+                    msg += ` (user ${locals.user_id})`;
+                return toolResult(msg);
+            }
+            catch (e) {
+                return toolError(`Failed to approve request: ${e.response?.status || e.message}`);
+            }
+        });
+    },
+});
+// -- deny_role_request --
+defineTool({
+    toolset: 'permissions',
+    auth: 'cookie',
+    mutates: true,
+    register(server, config) {
+        server.registerTool('deny_role_request', {
+            description: 'Decline a pending file access request by notification ID.',
+            inputSchema: {
+                notification_id: figmaId.describe('Notification ID from list_role_requests'),
+            },
+        }, async ({ notification_id }) => {
+            try {
+                await internalClient(config).put('/api/user_notifications/reject', {
+                    id: notification_id,
+                    medium: 'web',
+                    appVersion: '1',
+                    clientType: 'web',
+                });
+                return toolResult(`Declined access request ${notification_id}`);
+            }
+            catch (e) {
+                return toolError(`Failed to deny request: ${e.response?.status || e.message}`);
+            }
+        });
+    },
+});
+//# sourceMappingURL=permissions.js.map

package/dist/tools/projects.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=projects.d.ts.map