@bubblydoo/photoshop-mcp 0.0.2

package/dist-schemas/@adobe-uxp-types/uxp/src/internal/versions.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Version information. To get an instance: require("uxp").versions.
+ * @see https://developer.adobe.com/photoshop/uxp/2022/uxp/reference-js/Modules/uxp/Versions/Versions/
+ */
+interface Versions {
+  /**
+   * Returns the version of UXP.
+   * For example, uxp-6.0.0.
+   */
+  uxp: string;
+  /**
+   * Returns the version of the plugin.
+   * This matches the version as specified in your plugin's manifest.
+   */
+  plugin: string;
+}
+
+export const versions: Versions;

package/dist-schemas/@bubblydoo/uxp-toolkit/dist/commands-library/index.d.ts

@@ -0,0 +1,109 @@
+import { P as PsLayerRef, a as UTCommandModifying, b as UTCommandNonModifying } from '../psLayerRef-BJKcxKbm.js';
+export { i as createMultiGetDocumentCommand } from '../psLayerRef-BJKcxKbm.js';
+import 'photoshop';
+import 'zod';
+
+declare function createAddLayerToSelectionCommand(layerRef: PsLayerRef, previousLayerRef: PsLayerRef): UTCommandModifying<unknown>;
+
+declare function createSelectLayerMaskCommand(layerId: number): UTCommandModifying<unknown>;
+declare function createDeleteChannelAndApplyCommand(): UTCommandModifying<unknown>;
+
+declare function createConvertModeCommand(depth: 8 | 16): UTCommandModifying<unknown>;
+
+declare function createColorLookupAdjustmentLayerCommand(): UTCommandModifying<unknown>;
+
+declare function createExpandFolderCommand(layerRef: PsLayerRef): UTCommandModifying<unknown>;
+
+type LUTExportFormat = 'CUBE' | 'ICC' | '3DL' | 'CSP';
+interface ExportLUTsOptions {
+    description?: string;
+    gridPoints?: number;
+    copyright?: string;
+    exportFormats?: LUTExportFormat[];
+    lowercaseExtension?: boolean;
+}
+declare function createExportLUTsCommand(path: string, options?: ExportLUTsOptions): UTCommandModifying<unknown>;
+
+declare function createGetDocumentCommand(documentId: number): UTCommandNonModifying<{
+    title: string;
+    documentID: number;
+    visible: boolean;
+    hasBackgroundLayer: boolean;
+}>;
+declare function createGetDocumentHasBackgroundLayerCommand(documentId: number): UTCommandNonModifying<{
+    hasBackgroundLayer: boolean;
+}>;
+
+declare function createGetLayerCommand(layerRef: PsLayerRef): UTCommandNonModifying<{
+    name: string;
+    visible: boolean;
+    group: boolean;
+    layerSection: {
+        _value: "layerSectionStart" | "layerSectionEnd" | "layerSectionContent";
+        _enum: "layerSectionType";
+    };
+    layerKind: number;
+    itemIndex: number;
+    background: boolean;
+    mode: {
+        _enum: "blendMode";
+        _value: string;
+    };
+    layerID: number;
+    layerEffects?: Record<string, {
+        enabled?: boolean | undefined;
+    } | {
+        enabled: boolean;
+    }[]> | undefined;
+}>;
+declare function createGetBackgroundLayerCommand(docId: number): UTCommandNonModifying<{
+    name: string;
+    visible: boolean;
+    group: boolean;
+    layerSection: {
+        _value: "layerSectionStart" | "layerSectionEnd" | "layerSectionContent";
+        _enum: "layerSectionType";
+    };
+    layerKind: number;
+    itemIndex: number;
+    background: boolean;
+    mode: {
+        _enum: "blendMode";
+        _value: string;
+    };
+    layerID: number;
+    layerEffects?: Record<string, {
+        enabled?: boolean | undefined;
+    } | {
+        enabled: boolean;
+    }[]> | undefined;
+}>;
+
+declare function createHasVectorMaskCommand(layerId: number): UTCommandNonModifying<{
+    hasVectorMask: boolean;
+}>;
+
+declare function createLoadLayerMaskAsSelectionCommand(layerId: number): UTCommandModifying<unknown>;
+
+declare function createRasterizeLayerStyleCommand(psLayerRef: PsLayerRef): UTCommandModifying<unknown>;
+
+declare function createRasterizeVectorMaskCommand(): UTCommandModifying<unknown>;
+
+declare function createDeleteChannelCommand(): UTCommandModifying<unknown>;
+
+declare function createRenameLayerCommand(layerRef: PsLayerRef, newName: string): UTCommandModifying<unknown>;
+
+declare function createRenderGridCommand(gridPoints: number): UTCommandModifying<unknown>;
+
+declare function createSelectLayerCommand(layerRef: PsLayerRef): UTCommandModifying<unknown>;
+
+type LUTFormatType = 'LUTFormatCUBE' | 'LUTFormat3DL' | 'LUTFormatCSP';
+interface Set3DLUTColorLookupOptions {
+    lutPath: string;
+    lutFormat?: LUTFormatType;
+    profileBase64?: string;
+    lutFileDataBase64?: string;
+}
+declare function createSet3DLUTColorLookupCommand(options: Set3DLUTColorLookupOptions): UTCommandModifying<unknown>;
+
+export { type ExportLUTsOptions, type LUTExportFormat, type LUTFormatType, type Set3DLUTColorLookupOptions, createAddLayerToSelectionCommand, createColorLookupAdjustmentLayerCommand, createConvertModeCommand, createDeleteChannelAndApplyCommand, createDeleteChannelCommand, createExpandFolderCommand, createExportLUTsCommand, createGetBackgroundLayerCommand, createGetDocumentCommand, createGetDocumentHasBackgroundLayerCommand, createGetLayerCommand, createHasVectorMaskCommand, createLoadLayerMaskAsSelectionCommand, createRasterizeLayerStyleCommand, createRasterizeVectorMaskCommand, createRenameLayerCommand, createRenderGridCommand, createSelectLayerCommand, createSelectLayerMaskCommand, createSet3DLUTColorLookupCommand };

package/dist-schemas/@bubblydoo/uxp-toolkit/dist/index.d.ts

@@ -0,0 +1,153 @@
+import { c as createModifyingBatchPlayContext, P as PsLayerRef } from './psLayerRef-BJKcxKbm.js';
+export { U as UTCommandBase, a as UTCommandModifying, b as UTCommandNonModifying, d as UTCommandResult, e as batchPlay, f as batchPlayCommand, g as batchPlayCommands, h as createCommand, i as createMultiGetDocumentCommand } from './psLayerRef-BJKcxKbm.js';
+import * as photoshop from 'photoshop';
+import { ExecutionContext, ExecuteAsModalOptions, Document, Layer } from 'photoshop';
+import ErrorStackParser from 'error-stack-parser';
+import { Entry, File, Folder } from 'uxp';
+import { z } from 'zod';
+
+type ExtendedExecutionContext = Omit<ExecutionContext, 'onCancel'> & ReturnType<typeof createModifyingBatchPlayContext> & {
+    signal: AbortSignal;
+};
+type OptionsWithoutCommandName = Omit<ExecuteAsModalOptions, 'commandName'>;
+declare function executeAsModal<T>(commandName: string, fn: (executionContext: ExtendedExecutionContext) => Promise<T>, opts?: OptionsWithoutCommandName): Promise<T>;
+
+interface SuspendHistoryContext {
+}
+declare function suspendHistory<T>(document: Document, historyStateName: string, fn: (context: SuspendHistoryContext) => Promise<T>): Promise<T>;
+
+type CombinedFn<T> = (executionContext: ExtendedExecutionContext, suspendHistoryContext: SuspendHistoryContext) => Promise<T>;
+declare function executeAsModalAndSuspendHistory<T>(commandName: string, document: Document, fn: CombinedFn<T>): Promise<T>;
+
+declare function getFlattenedDomLayersList(layers: Layer[]): Layer[];
+
+type Tree<TRef = unknown> = {
+    ref: TRef;
+    name: string;
+    children?: Tree<TRef>;
+}[];
+
+declare function photoshopDomLayersToTree(layers: Layer[]): Tree<Layer>;
+
+type BasicStackFrame = Pick<ErrorStackParser.StackFrame, 'functionName' | 'fileName' | 'lineNumber' | 'columnNumber'>;
+declare function parseUxpErrorSourcemaps(error: Error, opts?: {
+    unsourcemappedHeaderLines?: number;
+}): Promise<BasicStackFrame[]>;
+declare function getBasicStackFrameAbsoluteFilePath(frame: BasicStackFrame): Promise<string>;
+
+declare function isFile(entry: Entry): entry is File;
+declare function isFolder(entry: Entry): entry is Folder;
+
+declare function openFileByPath(path: string): Promise<photoshop.Document>;
+
+declare function flattenTree<T>(tree: Tree<T>): Tree<T>[0][];
+
+interface LayerRef {
+    id: number;
+    docId: number;
+}
+
+declare function mapTree<TRef, TMappedRef>(tree: Tree<TRef>, mapFn: (node: TRef) => TMappedRef): Tree<TMappedRef>;
+
+declare function mapTreeRef<TRef, TMappedRef>(tree: Tree<TRef>, mapFn: (node: TRef) => TMappedRef): Tree<TMappedRef>;
+
+declare function photoshopGetApplicationInfo(): Promise<{
+    active: boolean;
+    autoShowHomeScreen: boolean;
+    available: number;
+    buildNumber: string;
+    documentArea: {
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+    };
+    hostName: string;
+    hostVersion: {
+        versionMajor: number;
+        versionMinor: number;
+        versionFix: number;
+    };
+    localeInfo: {
+        decimalPoint: string;
+    };
+    osVersion: string;
+    panelList: {
+        ID: string;
+        name: string;
+        obscured: boolean;
+        visible: boolean;
+    }[];
+}>;
+
+declare function copyToClipboard(text: string): Promise<void>;
+declare function readFromClipboard(): Promise<string>;
+
+declare const uxpEntrypointsSchema: z.ZodObject<{
+    _pluginInfo: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+
+declare function getDocumentLayerDescriptors(documentId: number): Promise<{
+    docId: number;
+    name: string;
+    layerID: number;
+    visible: boolean;
+    group: boolean;
+    layerSection: {
+        _value: "layerSectionStart" | "layerSectionEnd" | "layerSectionContent";
+        _enum: "layerSectionType";
+    };
+    layerKind: number;
+    itemIndex: number;
+    background: boolean;
+    mode: {
+        _enum: "blendMode";
+        _value: string;
+    };
+    layerEffects?: Record<string, {
+        enabled?: boolean | undefined;
+    } | {
+        enabled: boolean;
+    }[]> | undefined;
+}[]>;
+type LayerDescriptor = Awaited<ReturnType<typeof getDocumentLayerDescriptors>>[number];
+
+declare function getLayerEffects(layerRef: PsLayerRef): Promise<Record<string, boolean>>;
+
+type UTLayerKind = 'pixel' | 'adjustment-layer' | 'text' | 'curves' | 'smartObject' | 'video' | 'group' | 'threeD' | 'gradientFill' | 'pattern' | 'solidColor' | 'background';
+type UTBlendMode = 'normal' | 'dissolve' | 'darken' | 'multiply' | 'colorBurn' | 'linearBurn' | 'darkerColor' | 'lighten' | 'screen' | 'colorDodge' | 'linearDodge' | 'lighterColor' | 'overlay' | 'softLight' | 'hardLight' | 'vividLight' | 'linearLight' | 'pinLight' | 'hardMix' | 'difference' | 'exclusion' | 'blendSubtraction' | 'blendDivide' | 'hue' | 'saturation' | 'color' | 'luminosity' | 'passThrough';
+interface UTLayerBuilder {
+    name: string;
+    docId: number;
+    id: number;
+    visible: boolean;
+    kind: UTLayerKind;
+    blendMode: UTBlendMode;
+    effects: Record<string, boolean>;
+    isClippingMask: boolean;
+    background: boolean;
+    layers?: UTLayerBuilder[];
+}
+type UTLayer = Readonly<Omit<UTLayerBuilder, 'layers'>> & {
+    layers?: UTLayer[];
+};
+declare function photoshopLayerDescriptorsToUTLayers(layers: LayerDescriptor[]): UTLayer[];
+
+type UTLayerPickKeys<TKey extends keyof Omit<UTLayer, 'layers'>> = Pick<Omit<UTLayer, 'layers'>, TKey> & {
+    layers?: UTLayerPickKeys<TKey>[];
+};
+
+type MinimalUTLayer = UTLayerPickKeys<'effects' | 'visible' | 'isClippingMask' | 'kind' | 'blendMode' | 'name'>;
+declare function utLayersToText(tree: MinimalUTLayer[], depth?: number): string;
+
+type UTLayerWithoutChildren = Omit<UTLayer, 'layers'>;
+declare function utLayersToTree(layer: UTLayer[]): Tree<UTLayerWithoutChildren>;
+
+declare function utLayerToDomLayer(layer: UTLayer): Layer;
+declare function utLayersToDomLayers(layers: UTLayer[]): Layer[];
+
+export { type BasicStackFrame, type ExtendedExecutionContext, type LayerDescriptor, type LayerRef, PsLayerRef, type SuspendHistoryContext, type Tree, type UTLayer, type UTLayerPickKeys, type UTLayerWithoutChildren, copyToClipboard, createModifyingBatchPlayContext, executeAsModal, executeAsModalAndSuspendHistory, flattenTree, getBasicStackFrameAbsoluteFilePath, getDocumentLayerDescriptors, getFlattenedDomLayersList, getLayerEffects, isFile, isFolder, mapTree, mapTreeRef, openFileByPath, parseUxpErrorSourcemaps, photoshopDomLayersToTree, photoshopGetApplicationInfo, photoshopLayerDescriptorsToUTLayers, readFromClipboard, suspendHistory, utLayerToDomLayer, utLayersToDomLayers, utLayersToText, utLayersToTree, uxpEntrypointsSchema };

package/dist-schemas/@bubblydoo/uxp-toolkit/dist/psLayerRef-BJKcxKbm.d.ts

@@ -0,0 +1,66 @@
+import * as photoshop from 'photoshop';
+import { action, ActionDescriptor } from 'photoshop';
+import { z } from 'zod';
+
+declare function createMultiGetDocumentCommand(docId: number): UTCommandNonModifying<{
+    list: {
+        name: string;
+        layerID: number;
+        visible: boolean;
+        group: boolean;
+        layerSection: {
+            _value: "layerSectionStart" | "layerSectionEnd" | "layerSectionContent";
+            _enum: "layerSectionType";
+        };
+        layerKind: number;
+        itemIndex: number;
+        background: boolean;
+        mode: {
+            _enum: "blendMode";
+            _value: string;
+        };
+        layerEffects?: Record<string, {
+            enabled?: boolean | undefined;
+        } | {
+            enabled: boolean;
+        }[]> | undefined;
+    }[];
+}>;
+
+type P = Parameters<typeof action.batchPlay>;
+declare function batchPlay(actions: P[0], options?: P[1]): Promise<photoshop.ActionDescriptor[]>;
+
+interface UTCommandBase<T> {
+    descriptor: ActionDescriptor;
+    schema: z.ZodSchema<T>;
+}
+interface UTCommandModifying<T> extends UTCommandBase<T> {
+    modifying: true;
+}
+interface UTCommandNonModifying<T> extends UTCommandBase<T> {
+    modifying: false;
+}
+declare function createCommand<TReturn, TModifying extends boolean>(obj: {
+    descriptor: ActionDescriptor;
+    schema: z.ZodSchema<TReturn>;
+    modifying: TModifying;
+}): TModifying extends true ? UTCommandModifying<TReturn> : UTCommandNonModifying<TReturn>;
+type UTCommandResult<C> = C extends UTCommandBase<infer T> ? T : never;
+type BatchPlayOptions = Parameters<typeof batchPlay>[1];
+declare function batchPlayCommandBase<T>(command: UTCommandBase<T>, options?: BatchPlayOptions): Promise<T>;
+declare function batchPlayCommandsBase<TCommands extends Array<UTCommandBase<any>>>(commands: readonly [...TCommands], options?: BatchPlayOptions): Promise<{
+    [K in keyof TCommands]: UTCommandResult<TCommands[K]>;
+}>;
+declare function batchPlayCommand<T>(command: UTCommandNonModifying<T>, options?: BatchPlayOptions): Promise<T>;
+declare function batchPlayCommands<TCommands extends Array<UTCommandNonModifying<any>>>(commands: readonly [...TCommands], options?: BatchPlayOptions): Promise<{ [K in keyof TCommands]: UTCommandResult<TCommands[K]>; }>;
+declare function createModifyingBatchPlayContext(): {
+    batchPlayCommand: typeof batchPlayCommandBase;
+    batchPlayCommands: typeof batchPlayCommandsBase;
+};
+
+interface PsLayerRef {
+    id: number;
+    docId: number;
+}
+
+export { type PsLayerRef as P, type UTCommandBase as U, type UTCommandModifying as a, type UTCommandNonModifying as b, createModifyingBatchPlayContext as c, type UTCommandResult as d, batchPlay as e, batchPlayCommand as f, batchPlayCommands as g, createCommand as h, createMultiGetDocumentCommand as i };

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@bubblydoo/photoshop-mcp",
+  "type": "module",
+  "version": "0.0.2",
+  "description": "MCP server for Photoshop automation via Chrome DevTools Protocol",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "photoshop-mcp": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "dist-readmes",
+    "dist-runtime",
+    "dist-schemas"
+  ],
+  "dependencies": {
+    "@hono/mcp": "^0.2.3",
+    "@hono/node-server": "^1.19.9",
+    "@modelcontextprotocol/sdk": "^1.25.3",
+    "chrome-remote-interface": "^0.33.3",
+    "esbuild": "^0.27.0",
+    "hono": "^4.11.7",
+    "zod": "^3.25.0",
+    "@bubblydoo/uxp-cli-common": "0.0.2"
+  },
+  "devDependencies": {
+    "@types/chrome-remote-interface": "^0.33.0",
+    "@types/node": "^20.8.7",
+    "glob": "^13.0.0",
+    "tsup": "^8.3.5",
+    "tsx": "^4.21.0",
+    "typescript": "^5.8.3",
+    "@adobe-uxp-types/photoshop": "0.1.3",
+    "@adobe-uxp-types/uxp": "0.1.1",
+    "@bubblydoo/tsconfig": "0.0.3",
+    "@bubblydoo/uxp-toolkit": "0.0.11"
+  },
+  "scripts": {
+    "build": "tsup && tsup --config tsup-runtime.config.ts && tsx collect-schemas.ts && tsx collect-readmes.ts",
+    "dev": "tsx watch src/index.ts"
+  }
+}