@web-to-figma/desktop 1.0.0

package/dist/storage/collectionRepo.js

@@ -0,0 +1,104 @@
+import { LOCAL_USER_ID, nowIso } from '../utils.js';
+export class CollectionRepo {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    saveCollection(collection) {
+        const now = nowIso();
+        this.db
+            .prepare(`
+            INSERT INTO collection (
+                created_at, updated_at, name, external_id, parent_external_id,
+                active, is_default, user_id, icon_url
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT(user_id, external_id) DO UPDATE SET
+                name = excluded.name,
+                parent_external_id = excluded.parent_external_id,
+                active = excluded.active,
+                updated_at = excluded.updated_at
+        `)
+            .run(now, now, collection.name, collection.externalId, collection.parentExternalId ?? null, collection.active ? 1 : 0, collection.isDefault ? 1 : 0, collection.userId ?? LOCAL_USER_ID, collection.iconUrl ?? null);
+    }
+    saveCollections(collections) {
+        for (const collection of collections) {
+            this.saveCollection(collection);
+        }
+    }
+    listCollections() {
+        const rows = this.db
+            .prepare(`
+            SELECT id, external_id, user_id, name, parent_external_id, active, is_default, icon_url
+            FROM collection
+            WHERE user_id = ? AND active = 1 AND deleted_at IS NULL
+            ORDER BY updated_at DESC
+        `)
+            .all(LOCAL_USER_ID);
+        return rows.map(rowToCollection);
+    }
+    listCollectionsWithMetadata() {
+        const rows = this.db
+            .prepare(`
+            SELECT c.id, c.external_id, c.user_id, c.name, c.parent_external_id,
+                   c.active, c.is_default, c.icon_url,
+                   COALESCE(m.capture_count, 0) as capture_count
+            FROM collection c
+            LEFT JOIN (
+                SELECT collection_external_id, COUNT(*) as capture_count
+                FROM capture
+                WHERE user_id = ? AND deleted_at IS NULL
+                GROUP BY collection_external_id
+            ) m ON c.external_id = m.collection_external_id
+            WHERE c.user_id = ? AND c.active = 1 AND c.deleted_at IS NULL
+            ORDER BY c.updated_at DESC
+        `)
+            .all(LOCAL_USER_ID, LOCAL_USER_ID);
+        return rows.map((row) => ({
+            ...rowToCollection(row),
+            captureCount: Number(row.capture_count),
+        }));
+    }
+    getCollectionOwner(externalId) {
+        const row = this.db
+            .prepare('SELECT user_id FROM collection WHERE external_id = ? AND deleted_at IS NULL')
+            .get(externalId);
+        return row?.user_id ?? null;
+    }
+    getDefaultCollectionExternalId() {
+        const row = this.db
+            .prepare('SELECT external_id FROM collection WHERE user_id = ? AND is_default = 1 AND active = 1 AND deleted_at IS NULL')
+            .get(LOCAL_USER_ID);
+        if (!row) {
+            throw new Error('Default collection not found');
+        }
+        return row.external_id;
+    }
+    deleteCollection(collectionExternalId, replacementCollectionId) {
+        const tx = this.db.transaction(() => {
+            this.db
+                .prepare('UPDATE capture SET collection_external_id = ?, updated_at = ? WHERE collection_external_id = ?')
+                .run(replacementCollectionId, nowIso(), collectionExternalId);
+            this.db
+                .prepare('UPDATE collection SET active = 0, updated_at = ? WHERE external_id = ?')
+                .run(nowIso(), collectionExternalId);
+        });
+        tx();
+    }
+    updateIcon(externalId, iconUrl) {
+        this.db
+            .prepare('UPDATE collection SET icon_url = ?, updated_at = ? WHERE external_id = ?')
+            .run(iconUrl, nowIso(), externalId);
+    }
+}
+function rowToCollection(row) {
+    return {
+        id: row.id,
+        externalId: row.external_id,
+        userId: row.user_id,
+        name: row.name,
+        parentExternalId: row.parent_external_id ?? null,
+        active: Boolean(row.active),
+        isDefault: Boolean(row.is_default),
+        iconUrl: row.icon_url ?? null,
+    };
+}

package/dist/storage/db.d.ts

@@ -0,0 +1,10 @@
+import type Database from 'better-sqlite3';
+import { runMigrations } from './migrate.js';
+export declare function initDb(dbPath: string, logger?: Parameters<typeof runMigrations>[1]): Database.Database;
+export declare function getDb(): Database.Database;
+export declare function closeDb(): void;
+export declare function getDbDiagnostics(db: Database.Database): {
+    schemaVersion: number;
+    journalMode: string;
+    foreignKeys: number;
+};

package/dist/storage/db.js

@@ -0,0 +1,30 @@
+import { runMigrations } from './migrate.js';
+import { seedDefaultsIfNeeded } from './seeds.js';
+let dbInstance = null;
+export function initDb(dbPath, logger) {
+    if (dbInstance) {
+        return dbInstance;
+    }
+    dbInstance = runMigrations(dbPath, logger);
+    seedDefaultsIfNeeded(dbInstance);
+    return dbInstance;
+}
+export function getDb() {
+    if (!dbInstance) {
+        throw new Error('Database not initialized');
+    }
+    return dbInstance;
+}
+export function closeDb() {
+    if (dbInstance) {
+        dbInstance.close();
+        dbInstance = null;
+    }
+}
+export function getDbDiagnostics(db) {
+    const schemaVersion = db.prepare('SELECT MAX(version) as version FROM schema_migration').get()
+        ?.version ?? 0;
+    const journalMode = db.pragma('journal_mode', { simple: true }) ?? 'unknown';
+    const foreignKeys = db.pragma('foreign_keys', { simple: true });
+    return { schemaVersion, journalMode, foreignKeys };
+}

package/dist/storage/fileStore.d.ts

@@ -0,0 +1,26 @@
+import type { ResolvedPaths } from '../config.js';
+export declare const MULTIPART_UPLOAD_TTL_MS: number;
+export declare class FileStore {
+    private readonly paths;
+    constructor(paths: ResolvedPaths);
+    resolveKeyPath(key: string): string;
+    writeFile(key: string, data: Buffer, _contentType?: string, _contentEncoding?: string | null): void;
+    readFile(relativePath: string): {
+        data: Buffer;
+        filePath: string;
+    };
+    partPath(uploadId: string, partNumber: number): string;
+    writePart(uploadId: string, partNumber: number, data: Buffer): void;
+    completeMultipart(key: string, uploadId: string, numParts: number): void;
+    accessUrl(baseUrl: string, key: string): string;
+}
+export type MultipartUploadState = {
+    uploadId: string;
+    key: string;
+    numParts: number;
+    createdAt: number;
+};
+export declare function registerMultipartUpload(state: MultipartUploadState): void;
+export declare function getMultipartUpload(uploadId: string): MultipartUploadState | undefined;
+export declare function removeMultipartUpload(uploadId: string): void;
+export declare function cleanupStaleMultipartUploads(tmpDir: string, now?: number): number;

package/dist/storage/fileStore.js

@@ -0,0 +1,93 @@
+import fs from 'fs';
+import path from 'path';
+import { isValidArtifactKey } from '../utils.js';
+const MAX_FILE_SIZE = 500 * 1024 * 1024;
+export const MULTIPART_UPLOAD_TTL_MS = 2 * 60 * 60 * 1000;
+export class FileStore {
+    paths;
+    constructor(paths) {
+        this.paths = paths;
+    }
+    resolveKeyPath(key) {
+        if (!isValidArtifactKey(key)) {
+            throw new Error('Invalid artifact key');
+        }
+        const resolved = path.resolve(this.paths.artifactsDir, key);
+        if (!resolved.startsWith(path.resolve(this.paths.artifactsDir))) {
+            throw new Error('Path traversal blocked');
+        }
+        return resolved;
+    }
+    writeFile(key, data, _contentType, _contentEncoding) {
+        if (data.byteLength > MAX_FILE_SIZE) {
+            throw new Error('File exceeds maximum size');
+        }
+        const filePath = this.resolveKeyPath(key);
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.writeFileSync(filePath, data);
+    }
+    readFile(relativePath) {
+        const normalized = relativePath.replace(/^\/+/, '').replace(/\\/g, '/');
+        const filePath = path.resolve(this.paths.artifactsDir, normalized);
+        if (!filePath.startsWith(path.resolve(this.paths.artifactsDir))) {
+            throw new Error('Path traversal blocked');
+        }
+        if (!fs.existsSync(filePath)) {
+            throw new Error('File not found');
+        }
+        return { data: fs.readFileSync(filePath), filePath };
+    }
+    partPath(uploadId, partNumber) {
+        return path.join(this.paths.tmpDir, uploadId, `part-${partNumber}`);
+    }
+    writePart(uploadId, partNumber, data) {
+        if (data.byteLength > MAX_FILE_SIZE) {
+            throw new Error('Part exceeds maximum size');
+        }
+        const partFile = this.partPath(uploadId, partNumber);
+        fs.mkdirSync(path.dirname(partFile), { recursive: true });
+        fs.writeFileSync(partFile, data);
+    }
+    completeMultipart(key, uploadId, numParts) {
+        const chunks = [];
+        let totalBytes = 0;
+        for (let i = 1; i <= numParts; i++) {
+            const partFile = this.partPath(uploadId, i);
+            if (!fs.existsSync(partFile)) {
+                throw new Error(`Missing part ${i}`);
+            }
+            const partData = fs.readFileSync(partFile);
+            totalBytes += partData.byteLength;
+            if (totalBytes > MAX_FILE_SIZE) {
+                throw new Error('Multipart upload exceeds maximum size');
+            }
+            chunks.push(partData);
+        }
+        this.writeFile(key, Buffer.concat(chunks));
+        fs.rmSync(path.join(this.paths.tmpDir, uploadId), { recursive: true, force: true });
+    }
+    accessUrl(baseUrl, key) {
+        return `${baseUrl}/files/${key}`;
+    }
+}
+const multipartUploads = new Map();
+export function registerMultipartUpload(state) {
+    multipartUploads.set(state.uploadId, state);
+}
+export function getMultipartUpload(uploadId) {
+    return multipartUploads.get(uploadId);
+}
+export function removeMultipartUpload(uploadId) {
+    multipartUploads.delete(uploadId);
+}
+export function cleanupStaleMultipartUploads(tmpDir, now = Date.now()) {
+    let removed = 0;
+    for (const [uploadId, upload] of multipartUploads.entries()) {
+        if (now - upload.createdAt > MULTIPART_UPLOAD_TTL_MS) {
+            multipartUploads.delete(uploadId);
+            fs.rmSync(path.join(tmpDir, uploadId), { recursive: true, force: true });
+            removed += 1;
+        }
+    }
+    return removed;
+}

package/dist/storage/migrate.d.ts

@@ -0,0 +1,8 @@
+import Database from 'better-sqlite3';
+export type MigrationLogger = {
+    info: (obj: Record<string, unknown>, msg: string) => void;
+    error: (obj: Record<string, unknown>, msg: string) => void;
+};
+export declare function getLatestMigrationVersion(migrationsDir?: string): number;
+export declare function getAppliedSchemaVersion(db: Database.Database): number;
+export declare function runMigrations(dbPath: string, logger?: MigrationLogger): Database.Database;

package/dist/storage/migrate.js

@@ -0,0 +1,61 @@
+import fs from 'fs';
+import path from 'path';
+import Database from 'better-sqlite3';
+import { bundledMigrationsDir } from '../config.js';
+import { nowIso } from '../utils.js';
+const defaultLogger = {
+    info: (obj, msg) => console.log(msg, obj),
+    error: (obj, msg) => console.error(msg, obj),
+};
+export function getLatestMigrationVersion(migrationsDir = bundledMigrationsDir()) {
+    if (!fs.existsSync(migrationsDir)) {
+        return 0;
+    }
+    const files = fs.readdirSync(migrationsDir).filter((f) => f.endsWith('.up.sql'));
+    if (files.length === 0) {
+        return 0;
+    }
+    return Math.max(...files.map((f) => parseInt(f.split('_')[0], 10)));
+}
+export function getAppliedSchemaVersion(db) {
+    const row = db.prepare('SELECT MAX(version) as version FROM schema_migration').get();
+    return row?.version ?? 0;
+}
+export function runMigrations(dbPath, logger = defaultLogger) {
+    const db = new Database(dbPath);
+    db.pragma('journal_mode = WAL');
+    db.pragma('foreign_keys = ON');
+    db.exec(`
+        CREATE TABLE IF NOT EXISTS schema_migration (
+            version INTEGER PRIMARY KEY NOT NULL,
+            applied_at TEXT NOT NULL
+        )
+    `);
+    const applied = new Set(db.prepare('SELECT version FROM schema_migration').all().map((r) => r.version));
+    const migrationsDir = bundledMigrationsDir();
+    const files = fs
+        .readdirSync(migrationsDir)
+        .filter((f) => f.endsWith('.up.sql'))
+        .sort();
+    for (const file of files) {
+        const version = parseInt(file.split('_')[0], 10);
+        if (applied.has(version)) {
+            continue;
+        }
+        const sql = fs.readFileSync(path.join(migrationsDir, file), 'utf8');
+        const migrate = db.transaction(() => {
+            db.exec(sql);
+            db.prepare('INSERT INTO schema_migration (version, applied_at) VALUES (?, ?)').run(version, nowIso());
+        });
+        try {
+            migrate();
+            logger.info({ version, file }, 'migration_applied');
+        }
+        catch (err) {
+            logger.error({ version, file, err }, 'migration_failed');
+            db.close();
+            throw new Error(`Database migration ${file} failed. See desktop.log.`);
+        }
+    }
+    return db;
+}

package/dist/storage/seeds.d.ts

@@ -0,0 +1,7 @@
+import type Database from 'better-sqlite3';
+declare const DEFAULT_COLLECTIONS: Array<{
+    name: string;
+    isDefault: boolean;
+}>;
+export declare function seedDefaultsIfNeeded(db: Database.Database): void;
+export { DEFAULT_COLLECTIONS };

package/dist/storage/seeds.js

@@ -0,0 +1,30 @@
+import { v4 as uuidv4 } from 'uuid';
+import { LOCAL_USER_ID, nowIso } from '../utils.js';
+const DEFAULT_COLLECTIONS = [
+    { name: 'Miscellaneous', isDefault: true },
+    { name: 'Landing Page', isDefault: false },
+    { name: 'Dashboard', isDefault: false },
+    { name: 'Illustrations', isDefault: false },
+    { name: 'Headers', isDefault: false },
+    { name: 'Cards', isDefault: false },
+    { name: 'Buttons', isDefault: false },
+];
+export function seedDefaultsIfNeeded(db) {
+    const row = db.prepare('SELECT COUNT(*) as n FROM collection').get();
+    if (row.n > 0) {
+        return;
+    }
+    const insert = db.prepare(`
+        INSERT INTO collection (
+            created_at, updated_at, name, external_id, active, is_default, user_id
+        ) VALUES (?, ?, ?, ?, 1, ?, ?)
+    `);
+    const now = nowIso();
+    const seed = db.transaction(() => {
+        for (const collection of DEFAULT_COLLECTIONS) {
+            insert.run(now, now, collection.name, uuidv4(), collection.isDefault ? 1 : 0, LOCAL_USER_ID);
+        }
+    });
+    seed();
+}
+export { DEFAULT_COLLECTIONS };

package/dist/storage/tagRepo.d.ts

@@ -0,0 +1,7 @@
+import type Database from 'better-sqlite3';
+import type { TagValue } from '../types.js';
+export declare class TagRepo {
+    private readonly db;
+    constructor(db: Database.Database);
+    getAllTags(): Record<string, TagValue[]>;
+}

package/dist/storage/tagRepo.js

@@ -0,0 +1,31 @@
+export class TagRepo {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    getAllTags() {
+        const tagTypes = this.db
+            .prepare('SELECT id, name FROM tag_type WHERE active = 1 AND deleted_at IS NULL')
+            .all();
+        const tagValues = this.db
+            .prepare('SELECT id, tag_type_id, name, active FROM tag_value WHERE active = 1 AND deleted_at IS NULL')
+            .all();
+        const result = {};
+        for (const tagType of tagTypes) {
+            result[tagType.name] = [];
+        }
+        for (const value of tagValues) {
+            const tagType = tagTypes.find((t) => t.id === value.tag_type_id);
+            if (!tagType) {
+                continue;
+            }
+            result[tagType.name].push({
+                id: value.id,
+                tagTypeId: value.tag_type_id,
+                name: value.name,
+                active: Boolean(value.active),
+            });
+        }
+        return result;
+    }
+}

package/dist/terminal/banner.d.ts

@@ -0,0 +1,10 @@
+export type ServerBannerOptions = {
+    currentVersion: string;
+    port: number;
+    updateAvailable: {
+        latest: string;
+    } | null;
+    updateKey: string;
+    showNpxUpdateHint: boolean;
+};
+export declare function formatServerBanner(options: ServerBannerOptions): string;

package/dist/terminal/banner.js

@@ -0,0 +1,115 @@
+const BOX_WIDTH = 59;
+const BRAND_PURPLE = '38;2;130;67;234';
+const BRAND_PURPLE_BRIGHT = '38;2;112;25;255';
+const ANSI = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    purple: '\x1b[35m',
+    brightPurple: '\x1b[95m',
+    cyan: '\x1b[36m',
+    brightCyan: '\x1b[96m',
+    green: '\x1b[32m',
+    brightGreen: '\x1b[92m',
+    yellow: '\x1b[33m',
+    brightYellow: '\x1b[93m',
+    red: '\x1b[31m',
+    brightRed: '\x1b[91m',
+    white: '\x1b[37m',
+    brightWhite: '\x1b[97m',
+    gray: '\x1b[90m',
+};
+function useColor() {
+    return process.stdout.isTTY === true && process.env.NO_COLOR === undefined;
+}
+function visibleLength(text) {
+    return text.replace(/\x1b\[[0-9;]*m/g, '').length;
+}
+function c(code, text, color) {
+    return color ? `${code}${text}${ANSI.reset}` : text;
+}
+function brand(text, color, bright = false) {
+    if (!color) {
+        return text;
+    }
+    const rgb = bright ? BRAND_PURPLE_BRIGHT : BRAND_PURPLE;
+    return `\x1b[1;${rgb}m${text}${ANSI.reset}`;
+}
+function brandBorder(text, color) {
+    if (!color) {
+        return text;
+    }
+    return `\x1b[${BRAND_PURPLE}m${text}${ANSI.reset}`;
+}
+function row(content, color) {
+    const inner = ` ${content}${' '.repeat(Math.max(0, BOX_WIDTH - visibleLength(content)))} `;
+    if (color) {
+        return `${brandBorder('║', color)}${inner}${brandBorder('║', color)}`;
+    }
+    return `║${inner}║`;
+}
+function topBorder(color) {
+    const line = '═'.repeat(BOX_WIDTH + 2);
+    return color ? `${brandBorder(`╔${line}╗`, color)}` : `╔${line}╗`;
+}
+function bottomBorder(color) {
+    const line = '═'.repeat(BOX_WIDTH + 2);
+    return color ? `${brandBorder(`╚${line}╝`, color)}` : `╚${line}╝`;
+}
+function emptyRow(color) {
+    return row('', color);
+}
+export function formatServerBanner(options) {
+    const { currentVersion, updateAvailable, updateKey, showNpxUpdateHint } = options;
+    const color = useColor();
+    const title = [
+        brand('Web to Figma', color),
+        c(ANSI.dim + ANSI.gray, ` v${currentVersion}`, color),
+    ].join('');
+    const statusLine = [
+        c(ANSI.brightGreen, '●', color),
+        '  ',
+        c(ANSI.dim + ANSI.gray, 'Ready — keep this window open', color),
+    ].join('');
+    const stopLine = [
+        c(ANSI.dim + ANSI.gray, 'Press ', color),
+        c(ANSI.bold + ANSI.brightRed, 'Ctrl+C', color),
+        c(ANSI.dim + ANSI.gray, ' to stop', color),
+    ].join('');
+    const lines = [
+        topBorder(color),
+        emptyRow(color),
+        row(title, color),
+        emptyRow(color),
+        row(statusLine, color),
+    ];
+    if (updateAvailable) {
+        const updateTitle = [
+            c(ANSI.bold + ANSI.brightYellow, '⬆', color),
+            '  ',
+            c(ANSI.bold + ANSI.brightYellow, 'Update available:', color),
+            '  ',
+            c(ANSI.bold + ANSI.brightGreen, `v${updateAvailable.latest}`, color),
+        ].join('');
+        const updateAction = [
+            c(ANSI.dim + ANSI.gray, 'Press ', color),
+            c(ANSI.bold + ANSI.brightYellow, updateKey, color),
+            c(ANSI.dim + ANSI.gray, ' to update now', color),
+        ].join('');
+        lines.push(emptyRow(color));
+        lines.push(row(updateTitle, color));
+        lines.push(row(updateAction, color));
+        if (showNpxUpdateHint) {
+            const npxLine = [
+                c(ANSI.dim + ANSI.gray, 'Or run: ', color),
+                brand('npx @web-to-figma/desktop@latest start', color, true),
+            ].join('');
+            lines.push(row(npxLine, color));
+        }
+    }
+    lines.push(emptyRow(color));
+    lines.push(row(stopLine, color));
+    lines.push(emptyRow(color));
+    lines.push(bottomBorder(color));
+    return lines.join('\n');
+}

package/dist/terminal/chromeInstall.d.ts

@@ -0,0 +1,3 @@
+export declare function startChromeInstallSpinner(): void;
+export declare function stopChromeInstallSpinner(outcome: 'success' | 'stopped'): void;
+export declare function printChromeInstallError(error: unknown, logPath: string, verbose?: boolean): void;

package/dist/terminal/chromeInstall.js

@@ -0,0 +1,45 @@
+import ora from 'ora';
+const CHROME_INSTALL_TEXT = 'Web to Figma requires its own Chrome browser to run. Downloading it.';
+let activeSpinner = null;
+function useSpinner() {
+    return process.stdout.isTTY === true && process.env.NO_COLOR === undefined;
+}
+export function startChromeInstallSpinner() {
+    if (activeSpinner) {
+        return;
+    }
+    if (useSpinner()) {
+        activeSpinner = ora({
+            text: CHROME_INSTALL_TEXT,
+            color: 'magenta',
+        }).start();
+        return;
+    }
+    console.log(CHROME_INSTALL_TEXT);
+}
+export function stopChromeInstallSpinner(outcome) {
+    if (!activeSpinner) {
+        return;
+    }
+    if (outcome === 'success') {
+        activeSpinner.succeed('Chrome browser ready');
+    }
+    else {
+        activeSpinner.stop();
+    }
+    activeSpinner = null;
+}
+export function printChromeInstallError(error, logPath, verbose = false) {
+    stopChromeInstallSpinner('stopped');
+    const message = error instanceof Error ? error.message : 'Unknown error';
+    console.error('');
+    console.error('Web to Figma could not download its Chrome browser.');
+    console.error(message);
+    console.error(`See ${logPath} for details.`);
+    console.error('Tips: check your network connection and corporate proxy or firewall settings.');
+    console.error('Retry with: npx @web-to-figma/desktop doctor --update-chrome');
+    if (verbose && error instanceof Error && error.stack) {
+        console.error(error.stack);
+    }
+    console.error('');
+}