figmanage 1.0.1 → 1.2.0

package/dist/cli/versions.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function versionsCommand(): Command;
+//# sourceMappingURL=versions.d.ts.map

package/dist/cli/versions.js

@@ -0,0 +1,46 @@
+import { Command } from 'commander';
+import { listVersions, createVersion } from '../operations/versions.js';
+import { output, error } from './format.js';
+import { requirePat, requireCookie } from './helpers.js';
+export function versionsCommand() {
+    const versions = new Command('versions')
+        .description('Manage file version history');
+    versions
+        .command('list <file-key>')
+        .description('List version history for a file')
+        .option('--json', 'Force JSON output')
+        .action(async (fileKey, options) => {
+        try {
+            const config = requirePat();
+            const result = await listVersions(config, { file_key: fileKey });
+            output(result, options);
+        }
+        catch (e) {
+            error(e.response?.status ? `API error: ${e.response.status}` : e.message);
+            process.exit(1);
+        }
+    });
+    versions
+        .command('create <file-key>')
+        .description('Create a named version (checkpoint)')
+        .requiredOption('--title <title>', 'Version title/label')
+        .option('--description <text>', 'Version description')
+        .option('--json', 'Force JSON output')
+        .action(async (fileKey, options) => {
+        try {
+            const config = requireCookie();
+            const result = await createVersion(config, {
+                file_key: fileKey,
+                title: options.title,
+                description: options.description,
+            });
+            output(result, options);
+        }
+        catch (e) {
+            error(e.response?.status ? `API error: ${e.response.status}` : e.message);
+            process.exit(1);
+        }
+    });
+    return versions;
+}
+//# sourceMappingURL=versions.js.map

package/dist/cli/webhooks.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function webhooksCommand(): Command;
+//# sourceMappingURL=webhooks.d.ts.map

package/dist/cli/webhooks.js

@@ -0,0 +1,100 @@
+import { Command } from 'commander';
+import { listWebhooks, createWebhook, updateWebhook, deleteWebhook, } from '../operations/webhooks.js';
+import { output, error } from './format.js';
+import { requirePat } from './helpers.js';
+const VALID_EVENT_TYPES = [
+    'FILE_UPDATE',
+    'FILE_DELETE',
+    'FILE_VERSION_UPDATE',
+    'LIBRARY_PUBLISH',
+    'FILE_COMMENT',
+    'PING',
+];
+export function webhooksCommand() {
+    const webhooks = new Command('webhooks')
+        .description('Manage team webhooks');
+    webhooks
+        .command('list <team-id>')
+        .description('List webhooks for a team')
+        .option('--json', 'Force JSON output')
+        .action(async (teamId, options) => {
+        try {
+            const config = requirePat();
+            const result = await listWebhooks(config, { team_id: teamId });
+            output(result, options);
+        }
+        catch (e) {
+            error(e.response?.status ? `API error: ${e.response.status}` : e.message);
+            process.exit(1);
+        }
+    });
+    webhooks
+        .command('create <team-id>')
+        .description('Create a webhook subscription for a team')
+        .requiredOption('--event-type <type>', `Event type (${VALID_EVENT_TYPES.join(', ')})`)
+        .requiredOption('--endpoint <url>', 'URL to receive webhook payloads')
+        .requiredOption('--passcode <secret>', 'Secret for signature verification')
+        .option('--description <text>', 'Webhook description')
+        .option('--json', 'Force JSON output')
+        .action(async (teamId, options) => {
+        try {
+            const config = requirePat();
+            const result = await createWebhook(config, {
+                team_id: teamId,
+                event_type: options.eventType,
+                endpoint: options.endpoint,
+                passcode: options.passcode,
+                description: options.description,
+            });
+            output(result, options);
+        }
+        catch (e) {
+            error(e.response?.status ? `API error: ${e.response.status}` : e.message);
+            process.exit(1);
+        }
+    });
+    webhooks
+        .command('update <webhook-id>')
+        .description('Update a webhook')
+        .option('--event-type <type>', `Event type (${VALID_EVENT_TYPES.join(', ')})`)
+        .option('--endpoint <url>', 'URL to receive webhook payloads')
+        .option('--passcode <secret>', 'Secret for signature verification')
+        .option('--description <text>', 'Webhook description')
+        .option('--status <status>', 'Webhook status (ACTIVE, PAUSED)')
+        .option('--json', 'Force JSON output')
+        .action(async (webhookId, options) => {
+        try {
+            const config = requirePat();
+            const result = await updateWebhook(config, {
+                webhook_id: webhookId,
+                event_type: options.eventType,
+                endpoint: options.endpoint,
+                passcode: options.passcode,
+                description: options.description,
+                status: options.status,
+            });
+            output(result, options);
+        }
+        catch (e) {
+            error(e.response?.status ? `API error: ${e.response.status}` : e.message);
+            process.exit(1);
+        }
+    });
+    webhooks
+        .command('delete <webhook-id>')
+        .description('Delete a webhook')
+        .option('--json', 'Force JSON output')
+        .action(async (webhookId, options) => {
+        try {
+            const config = requirePat();
+            await deleteWebhook(config, { webhook_id: webhookId });
+            output({ deleted: webhookId }, options);
+        }
+        catch (e) {
+            error(e.response?.status ? `API error: ${e.response.status}` : e.message);
+            process.exit(1);
+        }
+    });
+    return webhooks;
+}
+//# sourceMappingURL=webhooks.js.map

package/dist/operations/analytics.d.ts

@@ -0,0 +1,10 @@
+import type { AuthConfig } from '../auth/client.js';
+export declare function libraryUsage(config: AuthConfig, params: {
+    library_file_key: string;
+    days?: number;
+}): Promise<any>;
+export declare function componentUsage(config: AuthConfig, params: {
+    component_key: string;
+    org_id?: string;
+}): Promise<any>;
+//# sourceMappingURL=analytics.d.ts.map

package/dist/operations/analytics.js

@@ -0,0 +1,15 @@
+import { internalClient } from '../clients/internal-api.js';
+import { requireOrgId } from '../tools/register.js';
+export async function libraryUsage(config, params) {
+    const lookback = params.days ?? 30;
+    const end_ts = Math.floor(Date.now() / 1000);
+    const start_ts = end_ts - lookback * 86400;
+    const res = await internalClient(config).get(`/api/dsa/library/${params.library_file_key}/team_usage`, { params: { start_ts, end_ts } });
+    return res.data;
+}
+export async function componentUsage(config, params) {
+    const orgId = requireOrgId(config, params.org_id);
+    const res = await internalClient(config).get(`/api/design_systems/component/${params.component_key}/file_usage`, { params: { org_id: orgId, fv: 4 } });
+    return res.data;
+}
+//# sourceMappingURL=analytics.js.map

package/dist/operations/branching.d.ts

@@ -0,0 +1,24 @@
+import type { AuthConfig } from '../auth/client.js';
+export interface Branch {
+    key: string;
+    name: string;
+    thumbnail_url: string | null;
+    last_modified: string | null;
+    link_access: string | null;
+}
+export interface CreatedBranch {
+    key: string | null;
+    name: string;
+    main_file_key: string;
+}
+export declare function listBranches(config: AuthConfig, params: {
+    file_key: string;
+}): Promise<Branch[]>;
+export declare function createBranch(config: AuthConfig, params: {
+    file_key: string;
+    name: string;
+}): Promise<CreatedBranch>;
+export declare function deleteBranch(config: AuthConfig, params: {
+    branch_key: string;
+}): Promise<void>;
+//# sourceMappingURL=branching.d.ts.map

package/dist/operations/branching.js

@@ -0,0 +1,41 @@
+import { hasCookie } from '../auth/client.js';
+import { publicClient } from '../clients/public-api.js';
+import { internalClient } from '../clients/internal-api.js';
+export async function listBranches(config, params) {
+    let branches;
+    if (hasCookie(config)) {
+        const res = await internalClient(config).get(`/api/files/${params.file_key}`);
+        const f = res.data?.meta || res.data;
+        branches = f.branches || [];
+    }
+    else {
+        const res = await publicClient(config).get(`/v1/files/${params.file_key}`, {
+            params: { branch_data: 'true', depth: '0' },
+        });
+        branches = res.data?.branches || [];
+    }
+    return branches.map((b) => ({
+        key: b.key,
+        name: b.name,
+        thumbnail_url: b.thumbnail_url || null,
+        last_modified: b.last_modified || null,
+        link_access: b.link_access || null,
+    }));
+}
+export async function createBranch(config, params) {
+    const res = await internalClient(config).post(`/api/multiplayer/${params.file_key}/branch_create?name=${encodeURIComponent(params.name)}`);
+    const meta = res.data?.meta || res.data || {};
+    const file = meta.file || meta;
+    const branchKey = file.key || file.file_key || null;
+    return {
+        key: branchKey,
+        name: params.name,
+        main_file_key: params.file_key,
+    };
+}
+export async function deleteBranch(config, params) {
+    await internalClient(config).delete('/api/files_batch', {
+        data: { files: [{ key: params.branch_key }], trashed: true },
+    });
+}
+//# sourceMappingURL=branching.js.map

package/dist/operations/comments.d.ts

@@ -0,0 +1,43 @@
+import type { AuthConfig } from '../auth/client.js';
+export interface Comment {
+    id: string;
+    parent_id: string | null;
+    message: string;
+    author: string;
+    author_id: string;
+    created_at: string;
+    resolved_at: string | null;
+    node_id: string | null;
+    order_id: number;
+}
+export interface PostedComment {
+    id: string;
+    message: string;
+    author: string;
+    created_at: string;
+    parent_id: string | null;
+}
+export interface Reaction {
+    emoji: string;
+    user: string;
+    created_at: string;
+}
+export declare function listComments(config: AuthConfig, params: {
+    file_key: string;
+}): Promise<Comment[]>;
+export declare function formatCommentsAsMarkdown(comments: Comment[]): string;
+export declare function postComment(config: AuthConfig, params: {
+    file_key: string;
+    message: string;
+    comment_id?: string;
+    node_id?: string;
+}): Promise<PostedComment>;
+export declare function deleteComment(config: AuthConfig, params: {
+    file_key: string;
+    comment_id: string;
+}): Promise<void>;
+export declare function listCommentReactions(config: AuthConfig, params: {
+    file_key: string;
+    comment_id: string;
+}): Promise<Reaction[]>;
+//# sourceMappingURL=comments.d.ts.map

package/dist/operations/comments.js

@@ -0,0 +1,65 @@
+import { publicClient } from '../clients/public-api.js';
+export async function listComments(config, params) {
+    const res = await publicClient(config).get(`/v1/files/${params.file_key}/comments`);
+    const comments = res.data?.comments || [];
+    return comments.map((c) => ({
+        id: c.id,
+        parent_id: c.parent_id || null,
+        message: c.message,
+        author: c.user?.handle,
+        author_id: c.user?.id,
+        created_at: c.created_at,
+        resolved_at: c.resolved_at || null,
+        node_id: c.client_meta?.node_id || c.client_meta?.node_offset?.node_id || null,
+        order_id: c.order_id,
+    }));
+}
+export function formatCommentsAsMarkdown(comments) {
+    const threads = new Map();
+    for (const c of comments) {
+        const parentId = c.parent_id || c.id;
+        if (!threads.has(parentId))
+            threads.set(parentId, []);
+        threads.get(parentId).push(c);
+    }
+    const lines = [];
+    for (const [, thread] of threads) {
+        thread.sort((a, b) => new Date(a.created_at).getTime() - new Date(b.created_at).getTime());
+        for (const c of thread) {
+            const indent = c.parent_id ? '  ' : '';
+            const resolved = c.resolved_at ? ' [resolved]' : '';
+            lines.push(`${indent}- **${c.author}** (${c.created_at})${resolved}: ${c.message}`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+export async function postComment(config, params) {
+    const body = { message: params.message };
+    if (params.comment_id)
+        body.comment_id = params.comment_id;
+    if (params.node_id)
+        body.client_meta = { node_id: params.node_id, node_offset: { x: 0, y: 0 } };
+    const res = await publicClient(config).post(`/v1/files/${params.file_key}/comments`, body);
+    const c = res.data;
+    return {
+        id: c.id,
+        message: c.message,
+        author: c.user?.handle,
+        created_at: c.created_at,
+        parent_id: c.parent_id || null,
+    };
+}
+export async function deleteComment(config, params) {
+    await publicClient(config).delete(`/v1/files/${params.file_key}/comments/${params.comment_id}`);
+}
+export async function listCommentReactions(config, params) {
+    const res = await publicClient(config).get(`/v1/files/${params.file_key}/comments/${params.comment_id}/reactions`);
+    const reactions = res.data?.reactions || [];
+    return reactions.map((r) => ({
+        emoji: r.emoji,
+        user: r.user?.handle,
+        created_at: r.created_at,
+    }));
+}
+//# sourceMappingURL=comments.js.map

package/dist/operations/components.d.ts

@@ -0,0 +1,24 @@
+import type { AuthConfig } from '../auth/client.js';
+export declare function listFileComponents(config: AuthConfig, params: {
+    file_key: string;
+}): Promise<any[]>;
+export declare function listFileStyles(config: AuthConfig, params: {
+    file_key: string;
+}): Promise<any[]>;
+export declare function listTeamComponents(config: AuthConfig, params: {
+    team_id: string;
+    page_size?: number;
+    cursor?: string;
+}): Promise<{
+    components: any[];
+    pagination: any;
+}>;
+export declare function listTeamStyles(config: AuthConfig, params: {
+    team_id: string;
+    page_size?: number;
+    cursor?: string;
+}): Promise<{
+    styles: any[];
+    pagination: any;
+}>;
+//# sourceMappingURL=components.d.ts.map

package/dist/operations/components.js

@@ -0,0 +1,30 @@
+import { publicClient } from '../clients/public-api.js';
+export async function listFileComponents(config, params) {
+    const res = await publicClient(config).get(`/v1/files/${params.file_key}/components`);
+    return res.data?.meta?.components || [];
+}
+export async function listFileStyles(config, params) {
+    const res = await publicClient(config).get(`/v1/files/${params.file_key}/styles`);
+    return res.data?.meta?.styles || [];
+}
+export async function listTeamComponents(config, params) {
+    const queryParams = { page_size: params.page_size ?? 30 };
+    if (params.cursor)
+        queryParams.after = params.cursor;
+    const res = await publicClient(config).get(`/v1/teams/${params.team_id}/components`, { params: queryParams });
+    return {
+        components: res.data?.meta?.components || [],
+        pagination: res.data?.pagination || null,
+    };
+}
+export async function listTeamStyles(config, params) {
+    const queryParams = { page_size: params.page_size ?? 30 };
+    if (params.cursor)
+        queryParams.after = params.cursor;
+    const res = await publicClient(config).get(`/v1/teams/${params.team_id}/styles`, { params: queryParams });
+    return {
+        styles: res.data?.meta?.styles || [],
+        pagination: res.data?.pagination || null,
+    };
+}
+//# sourceMappingURL=components.js.map

package/dist/operations/compound-manager.d.ts

@@ -0,0 +1,101 @@
+import type { AuthConfig } from '../auth/client.js';
+export declare function offboardUser(config: AuthConfig, params: {
+    user_identifier: string;
+    execute: boolean;
+    transfer_to?: string;
+    org_id?: string;
+}): Promise<{
+    user: {
+        org_user_id: string;
+        user_id: string;
+        name: any;
+        email: any;
+        seat_type: any;
+        permission: any;
+    };
+    team_memberships: {
+        team_id: string;
+        team_name: string;
+        role: string;
+    }[];
+    project_permissions: {
+        project_id: string;
+        project_name: string;
+        team_name: string;
+        role: string;
+    }[];
+    file_ownership: {
+        file_key: string;
+        file_name: string;
+        project_name: string;
+        team_name: string;
+    }[];
+    summary: {
+        teams: number;
+        projects_with_access: number;
+        files_owned: number;
+    };
+    transfer_plan: string[];
+    note: string;
+    executed?: undefined;
+    actions?: undefined;
+} | {
+    user: {
+        org_user_id: string;
+        user_id: string;
+        name: any;
+        email: any;
+        seat_type: any;
+        permission: any;
+    };
+    executed: boolean;
+    actions: {
+        action: string;
+        status: string;
+        detail?: string;
+    }[];
+    summary: {
+        succeeded: number;
+        failed: number;
+        total: number;
+    };
+    note: string;
+    team_memberships?: undefined;
+    project_permissions?: undefined;
+    file_ownership?: undefined;
+    transfer_plan?: undefined;
+}>;
+export declare function onboardUser(config: AuthConfig, params: {
+    email: string;
+    team_ids: string[];
+    role: string;
+    share_files?: string[];
+    seat_type?: string;
+    confirm?: boolean;
+    org_id?: string;
+}): Promise<{
+    user_email: string;
+    setup_results: {
+        teams_joined: {
+            team_id: string;
+            team_name: string;
+            role: string;
+            status: string;
+        }[];
+        files_shared: {
+            file_key: string;
+            role: string;
+            status: string;
+        }[];
+        seat_change: {
+            status: string;
+            note?: string;
+        };
+    };
+    next_steps: string[];
+}>;
+export declare function quarterlyDesignOpsReport(config: AuthConfig, params: {
+    org_id?: string;
+    days: number;
+}): Promise<Record<string, any>>;
+//# sourceMappingURL=compound-manager.d.ts.map