@web-to-figma/desktop 1.0.0

package/dist/types.d.ts

@@ -0,0 +1,102 @@
+export type Size = {
+    name: string;
+    width: number;
+    height: number;
+};
+export type Theme = {
+    name: string;
+};
+export type Export = {
+    id?: number;
+    captureId?: number;
+    theme: string;
+    sizeName: string;
+    width: number;
+    height: number;
+    url: string;
+    screenshotUrl: string;
+    thumbnailUrl: string;
+};
+export type Capture = {
+    id?: number;
+    externalId: string;
+    userId?: number;
+    url: string;
+    isFullPage: boolean;
+    collectionExternalId?: string;
+    exports: Export[];
+};
+export type Collection = {
+    id?: number;
+    externalId: string;
+    userId?: number;
+    name: string;
+    parentExternalId?: string | null;
+    active: boolean;
+    isDefault: boolean;
+    iconUrl?: string | null;
+};
+export type CollectionWithMetadata = Collection & {
+    captureCount: number;
+};
+export type CaptureUpdate = {
+    type: 'CaptureProgress' | 'CaptureCompleted' | 'CaptureFailed';
+    data: unknown;
+};
+export type TagValue = {
+    id: number;
+    tagTypeId: number;
+    name: string;
+    active: boolean;
+};
+export type CaptureUser = {
+    externalId: string;
+    name: string;
+    photoUrl: string;
+    token: string;
+};
+export type UploadUrlRequest = {
+    key: string;
+    contentType: string;
+    contentEncoding?: string | null;
+};
+export type MultipartUploadUrlRequest = UploadUrlRequest & {
+    numParts: number;
+};
+export type CompleteMultipartUploadRequest = {
+    key: string;
+    uploadId: string;
+    parts: Array<{
+        eTag: string;
+        partNumber: number;
+    }>;
+};
+export type CaptureRequestBody = {
+    url: string;
+    sizes: Size[];
+    themes: Theme[];
+};
+export type UpdateCaptureMetadataRequest = {
+    captureExternalId: string;
+    collectionExternalId: string;
+    collectionIconUrl: string;
+    tags: number[];
+};
+export type RemoveCaptureFromCollectionRequest = {
+    captureExternalId: string;
+    collectionExternalId?: string;
+};
+export type CancelCaptureRequest = {
+    requestId: string;
+};
+export type ImageResizeRequest = {
+    image: string;
+    type: 'jpeg' | 'jpg' | 'png' | 'webp';
+    width: number;
+    height: number;
+};
+export type ConvertImageRequest = {
+    image: string;
+    from_type: 'jpeg' | 'jpg' | 'png' | 'webp' | 'ico';
+    to_type: 'jpeg' | 'jpg' | 'png' | 'webp';
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/updater/installer.d.ts

@@ -0,0 +1,2 @@
+export declare function isGloballyInstalled(): boolean;
+export declare function installUpdate(latestVersion: string, verbose: boolean): Promise<void>;

package/dist/updater/installer.js

@@ -0,0 +1,61 @@
+import { execFile, execFileSync, spawn } from 'node:child_process';
+import { promisify } from 'node:util';
+import path from 'node:path';
+const execFileAsync = promisify(execFile);
+export function isGloballyInstalled() {
+    try {
+        const scriptPath = process.argv[1];
+        if (!scriptPath) {
+            return false;
+        }
+        const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+        const prefix = path.resolve(execFileSync(npmCmd, ['prefix', '-g'], { encoding: 'utf8' }).trim());
+        const resolvedScript = path.resolve(scriptPath);
+        return resolvedScript.startsWith(prefix + path.sep) || resolvedScript === prefix;
+    }
+    catch {
+        return false;
+    }
+}
+export async function installUpdate(latestVersion, verbose) {
+    const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+    const spec = `@web-to-figma/desktop@${latestVersion}`;
+    await new Promise((resolve, reject) => {
+        const child = spawn(npmCmd, ['install', '-g', spec], {
+            stdio: verbose ? 'inherit' : 'pipe',
+            env: process.env,
+            shell: process.platform === 'win32',
+        });
+        child.on('error', reject);
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(`npm install exited with code ${code ?? 'unknown'}`));
+            }
+        });
+    });
+    respawnFromGlobalBin();
+}
+function respawnFromGlobalBin() {
+    const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+    let binPath = 'web-to-figma';
+    try {
+        const resolved = execFileSync(npmCmd, ['bin', '-g', 'web-to-figma'], { encoding: 'utf8' }).trim();
+        if (resolved) {
+            binPath = resolved;
+        }
+    }
+    catch {
+        // fall back to PATH lookup
+    }
+    const args = process.argv.slice(2);
+    const child = spawn(binPath, args.length > 0 ? args : ['start'], {
+        stdio: 'inherit',
+        detached: true,
+        shell: process.platform === 'win32',
+    });
+    child.unref();
+    process.exit(0);
+}

package/dist/updater/runtime.d.ts

@@ -0,0 +1,25 @@
+import type { ResolvedPaths } from '../config.js';
+import type { UpdateInfo } from './types.js';
+export type UpdaterOptions = {
+    currentVersion: string;
+    port: number;
+    paths: ResolvedPaths;
+    verbose: boolean;
+    isCaptureBusy: () => boolean;
+};
+export declare class UpdaterRuntime {
+    private readonly options;
+    private updateAvailable;
+    private installing;
+    private interval;
+    private keypressHandler;
+    constructor(options: UpdaterOptions);
+    get pendingUpdate(): UpdateInfo | null;
+    checkNow(): Promise<UpdateInfo | null>;
+    printBanner(): void;
+    startBackgroundChecks(): void;
+    attachKeyListener(onInterrupt?: () => void): void;
+    triggerUpdate(): Promise<void>;
+    dispose(): void;
+}
+export declare function printUnsupportedVersionMessage(currentVersion: string, minSupportedVersion: string): void;

package/dist/updater/runtime.js

@@ -0,0 +1,153 @@
+import readline from 'node:readline';
+import os from 'node:os';
+import { formatServerBanner } from '../terminal/banner.js';
+import { CHECK_INTERVAL_MS, checkForUpdate } from './versionCheck.js';
+import { installUpdate, isGloballyInstalled } from './installer.js';
+import { appendUpdateLog } from './updateLog.js';
+export class UpdaterRuntime {
+    options;
+    updateAvailable = null;
+    installing = false;
+    interval = null;
+    keypressHandler = null;
+    constructor(options) {
+        this.options = options;
+    }
+    get pendingUpdate() {
+        return this.updateAvailable;
+    }
+    async checkNow() {
+        try {
+            const info = await checkForUpdate(this.options.currentVersion);
+            if (info) {
+                this.updateAvailable = info;
+                appendUpdateLog(this.options.paths, {
+                    event: 'update_available',
+                    from: this.options.currentVersion,
+                    to: info.latest,
+                });
+            }
+            else {
+                this.updateAvailable = null;
+            }
+            return info;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err.message : 'Unknown error';
+            appendUpdateLog(this.options.paths, { event: 'update_check_failed', error });
+            if (this.options.verbose) {
+                console.warn(`Update check failed: ${error}`);
+            }
+            return null;
+        }
+    }
+    printBanner() {
+        const { currentVersion, port } = this.options;
+        const updateKey = os.platform() === 'darwin' ? 'Cmd+U' : 'Ctrl+U';
+        console.log(formatServerBanner({
+            currentVersion,
+            port,
+            updateAvailable: this.updateAvailable,
+            updateKey,
+            showNpxUpdateHint: !isGloballyInstalled(),
+        }));
+    }
+    startBackgroundChecks() {
+        if (this.interval) {
+            return;
+        }
+        this.interval = setInterval(() => {
+            void this.checkNow().then((info) => {
+                if (info) {
+                    this.printBanner();
+                }
+            });
+        }, CHECK_INTERVAL_MS);
+        this.interval.unref();
+    }
+    attachKeyListener(onInterrupt) {
+        if (!process.stdin.isTTY || this.installing) {
+            return;
+        }
+        readline.emitKeypressEvents(process.stdin);
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(true);
+        }
+        process.stdin.resume();
+        this.keypressHandler = (_str, key) => {
+            if (!key) {
+                return;
+            }
+            // Raw mode stdin swallows Ctrl+C before it becomes SIGINT.
+            if ((key.ctrl && key.name === 'c') || _str === '\u0003') {
+                if (onInterrupt) {
+                    onInterrupt();
+                }
+                else {
+                    process.kill(process.pid, 'SIGINT');
+                }
+                return;
+            }
+            const isUpdateKey = (key.meta && key.name === 'u') || (key.ctrl && key.name === 'u');
+            if (!isUpdateKey || !this.updateAvailable || this.installing) {
+                return;
+            }
+            void this.triggerUpdate();
+        };
+        process.stdin.on('keypress', this.keypressHandler);
+    }
+    async triggerUpdate() {
+        if (!this.updateAvailable || this.installing) {
+            return;
+        }
+        if (this.options.isCaptureBusy()) {
+            console.log('Update deferred until capture completes.');
+            appendUpdateLog(this.options.paths, { event: 'update_deferred', reason: 'capture_in_progress' });
+            return;
+        }
+        const { latest } = this.updateAvailable;
+        const from = this.options.currentVersion;
+        this.installing = true;
+        console.log(`\nUpdating @web-to-figma/desktop to v${latest}...`);
+        appendUpdateLog(this.options.paths, { event: 'update_started', from, to: latest, method: 'npm' });
+        try {
+            await installUpdate(latest, this.options.verbose);
+            appendUpdateLog(this.options.paths, { event: 'update_completed', from, to: latest });
+            console.log(`Updated to v${latest} successfully.`);
+            console.log('Restarting...');
+        }
+        catch (err) {
+            const error = err instanceof Error ? err.message : 'Unknown error';
+            appendUpdateLog(this.options.paths, { event: 'update_failed', from, to: latest, error });
+            console.error(`Update failed: ${error}`);
+            if (!isGloballyInstalled()) {
+                console.error('Try: npx @web-to-figma/desktop@latest start');
+            }
+            this.installing = false;
+        }
+    }
+    dispose() {
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = null;
+        }
+        if (this.keypressHandler) {
+            process.stdin.off('keypress', this.keypressHandler);
+            this.keypressHandler = null;
+        }
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(false);
+            process.stdin.pause();
+        }
+    }
+}
+export function printUnsupportedVersionMessage(currentVersion, minSupportedVersion) {
+    const updateKey = os.platform() === 'darwin' ? 'Cmd+U' : 'Ctrl+U';
+    console.error('');
+    console.error('This version is no longer supported.');
+    console.error(`Installed: v${currentVersion}  Minimum: v${minSupportedVersion}`);
+    console.error(`Press ${updateKey} to update, or run:`);
+    console.error('  npm install -g @web-to-figma/desktop@latest');
+    console.error('Web to Figma will not run until updated.');
+    console.error('');
+}

package/dist/updater/types.d.ts

@@ -0,0 +1,29 @@
+export type UpdateInfo = {
+    latest: string;
+    integrity?: string;
+};
+export type UpdateLogEvent = {
+    event: 'update_check_failed';
+    error: string;
+} | {
+    event: 'update_available';
+    from: string;
+    to: string;
+} | {
+    event: 'update_started';
+    from: string;
+    to: string;
+    method: 'npm';
+} | {
+    event: 'update_completed';
+    from: string;
+    to: string;
+} | {
+    event: 'update_failed';
+    from: string;
+    to: string;
+    error: string;
+} | {
+    event: 'update_deferred';
+    reason: 'capture_in_progress';
+};

package/dist/updater/types.js

@@ -0,0 +1 @@
+export {};

package/dist/updater/updateLog.d.ts

@@ -0,0 +1,3 @@
+import type { ResolvedPaths } from '../config.js';
+import type { UpdateLogEvent } from './types.js';
+export declare function appendUpdateLog(paths: ResolvedPaths, entry: UpdateLogEvent): void;

package/dist/updater/updateLog.js

@@ -0,0 +1,7 @@
+import fs from 'fs';
+import path from 'node:path';
+export function appendUpdateLog(paths, entry) {
+    fs.mkdirSync(paths.logsDir, { recursive: true });
+    const line = JSON.stringify({ ...entry, at: new Date().toISOString() }) + '\n';
+    fs.appendFileSync(path.join(paths.logsDir, 'update.log'), line);
+}

package/dist/updater/versionCheck.d.ts

@@ -0,0 +1,5 @@
+import type { UpdateInfo } from './types.js';
+export declare const REGISTRY_URL = "https://registry.npmjs.org/@web-to-figma/desktop/latest";
+export declare const CHECK_INTERVAL_MS: number;
+export declare function checkForUpdate(currentVersion: string): Promise<UpdateInfo | null>;
+export declare function isBelowMinSupported(currentVersion: string, minSupportedVersion: string): boolean;

package/dist/updater/versionCheck.js

@@ -0,0 +1,59 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import semver from 'semver';
+const execFileAsync = promisify(execFile);
+export const REGISTRY_URL = 'https://registry.npmjs.org/@web-to-figma/desktop/latest';
+export const CHECK_INTERVAL_MS = 6 * 60 * 60 * 1000;
+export async function checkForUpdate(currentVersion) {
+    const latest = await fetchLatestVersion();
+    if (!latest?.version || !semver.valid(latest.version) || !semver.valid(currentVersion)) {
+        return null;
+    }
+    if (semver.gt(latest.version, currentVersion)) {
+        return { latest: latest.version, integrity: latest.dist?.integrity };
+    }
+    return null;
+}
+async function fetchLatestVersion() {
+    try {
+        const response = await fetch(REGISTRY_URL, {
+            headers: { Accept: 'application/json' },
+        });
+        if (!response.ok) {
+            return await fetchLatestViaNpmCli();
+        }
+        return (await response.json());
+    }
+    catch {
+        return await fetchLatestViaNpmCli();
+    }
+}
+async function fetchLatestViaNpmCli() {
+    try {
+        const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+        const { stdout } = await execFileAsync(npmCmd, [
+            'view',
+            '@web-to-figma/desktop',
+            'version',
+            'dist.integrity',
+            '--json',
+        ]);
+        const parsed = JSON.parse(stdout);
+        if (typeof parsed === 'string') {
+            return { version: parsed };
+        }
+        if (Array.isArray(parsed) && parsed.length >= 1) {
+            return { version: parsed[0], dist: { integrity: parsed[1] } };
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+export function isBelowMinSupported(currentVersion, minSupportedVersion) {
+    if (!semver.valid(currentVersion) || !semver.valid(minSupportedVersion)) {
+        return false;
+    }
+    return semver.lt(currentVersion, minSupportedVersion);
+}

package/dist/utils.d.ts

@@ -0,0 +1,9 @@
+export declare const LOCAL_USER_ID = 1;
+export declare const CUSTOM_USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36";
+export declare function nowIso(): string;
+export declare function randSeq(n: number): string;
+export declare function marshalString(data: unknown): string;
+export declare function parseJsonSafe<T>(value: string | null | undefined, fallback: T): T;
+export declare function isValidArtifactKey(key: string): boolean;
+export declare function contentTypeForPath(filePath: string): string;
+export declare function freeDiskBytes(dir: string): number;

package/dist/utils.js

@@ -0,0 +1,55 @@
+const LETTERS = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890';
+export const LOCAL_USER_ID = 1;
+export const CUSTOM_USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36';
+export function nowIso() {
+    return new Date().toISOString();
+}
+export function randSeq(n) {
+    let result = '';
+    for (let i = 0; i < n; i++) {
+        result += LETTERS[Math.floor(Math.random() * LETTERS.length)];
+    }
+    return result;
+}
+export function marshalString(data) {
+    return JSON.stringify(data);
+}
+export function parseJsonSafe(value, fallback) {
+    if (!value) {
+        return fallback;
+    }
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return fallback;
+    }
+}
+export function isValidArtifactKey(key) {
+    return /^[a-zA-Z0-9_-]+\/[a-zA-Z0-9_.-]+$/.test(key);
+}
+export function contentTypeForPath(filePath) {
+    if (filePath.endsWith('.json')) {
+        return 'application/json';
+    }
+    if (filePath.endsWith('.jpeg') || filePath.endsWith('.jpg')) {
+        return 'image/jpeg';
+    }
+    if (filePath.endsWith('.png')) {
+        return 'image/png';
+    }
+    if (filePath.endsWith('.webp')) {
+        return 'image/webp';
+    }
+    return 'application/octet-stream';
+}
+import { statfsSync } from 'node:fs';
+export function freeDiskBytes(dir) {
+    try {
+        const stats = statfsSync(dir);
+        return stats.bavail * stats.bsize;
+    }
+    catch {
+        return Number.MAX_SAFE_INTEGER;
+    }
+}

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@web-to-figma/desktop",
+  "version": "1.0.0",
+  "description": "Web to Figma Desktop - Convert any website or HTML code to design",
+  "license": "UNLICENSED",
+  "type": "module",
+  "bin": {
+    "web-to-figma": "./bin/web-to-figma.js"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "db/migrations",
+    "assets/extension",
+    "assets/chrome-version.json"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "wtfDesktop": {
+    "minSupportedVersion": "0.1.0",
+    "sentryDsn": "https://77e3bca116c40372a0c1a95a23f58eeb@o4511590414286848.ingest.us.sentry.io/4511590419070976"
+  },
+  "scripts": {
+    "build": "tsc",
+    "build:release": "npm run build && node scripts/inject-secret.js && node scripts/obfuscate.js",
+    "obfuscate": "node scripts/obfuscate.js",
+    "inject-secret": "node scripts/inject-secret.js",
+    "pack:check": "npm pack --dry-run",
+    "start": "npm run build && node bin/web-to-figma.js start",
+    "dev": "npm run build && node bin/web-to-figma.js start --verbose",
+    "doctor": "npm run build && node bin/web-to-figma.js doctor",
+    "test": "npm run build && npm run test:run",
+    "test:run": "node --test dist/test/versionCheck.test.js dist/test/captureStatus.test.js dist/test/desktopJwt.test.js dist/test/uploadBody.test.js dist/test/checkServer.test.js dist/test/headedBrowserState.test.js dist/test/crxUtils.test.js",
+    "smoke": "npm run build && npm run smoke:run",
+    "smoke:run": "node scripts/smoke-test.js",
+    "prepack": "node scripts/prepack.js",
+    "gen-tag-migration": "node scripts/gen-tag-migration.js",
+    "upload-chrome-s3": "node scripts/upload-chrome-to-s3.js",
+    "upload-chrome-s3:dry-run": "node scripts/upload-chrome-to-s3.js --dry-run"
+  },
+  "dependencies": {
+    "@fastify/cors": "^9.0.1",
+    "@sentry/node": "^7.120.4",
+    "better-sqlite3": "^11.5.0",
+    "commander": "^12.1.0",
+    "dotenv": "^16.3.1",
+    "fastify": "^4.28.1",
+    "jsonwebtoken": "^9.0.2",
+    "ora": "^8.2.0",
+    "pino": "^9.4.0",
+    "selenium-webdriver": "^4.25.0",
+    "semver": "^7.6.3",
+    "sharp": "^0.33.5",
+    "uuid": "^10.0.0"
+  },
+  "devDependencies": {
+    "@aws-sdk/client-s3": "^3.758.0",
+    "@types/better-sqlite3": "^7.6.11",
+    "@types/jsonwebtoken": "^9.0.7",
+    "@types/node": "^20.14.0",
+    "@types/selenium-webdriver": "^4.35.6",
+    "@types/semver": "^7.5.8",
+    "@types/uuid": "^10.0.0",
+    "javascript-obfuscator": "^4.1.1",
+    "typescript": "^5.5.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}