Skip to content

Beautiful, AI-native markdown IDE and LLM wiki

Consolidate image copy behind one copyImage service (PRD-8925) (#5292)

Andrew Mikofalvy49baea66b6ad
diff --git a/.changeset/copy-image-only.md b/.changeset/copy-image-only.md
new file mode 100644
index 000000000..f70bf0b53
--- /dev/null
+++ b/.changeset/copy-image-only.md
@@ -0,0 +1,5 @@
+---
+"@inkeep/open-knowledge": patch
+---
+
+Copying an image in the browser now puts only the image on the clipboard, matching the desktop app, so it pastes as an image in Google Docs and other apps instead of a placeholder or a link.
diff --git a/packages/app/src/editor/clipboard/copy-image.dom.test.ts b/packages/app/src/editor/clipboard/copy-image.dom.test.ts
new file mode 100644
index 000000000..1472a1afb
--- /dev/null
+++ b/packages/app/src/editor/clipboard/copy-image.dom.test.ts
@@ -0,0 +1,73 @@
+import { afterEach, beforeAll, describe, expect, test, vi } from 'vitest';
+
+const copyImage = vi.fn();
+vi.mock('@/lib/copy-image', () => ({ copyImage }));
+
+beforeAll(async () => {
+ await import('./copy-image.ts');
+});
+
+afterEach(() => {
+ document.body.innerHTML = '';
+ copyImage.mockReset();
+ vi.restoreAllMocks();
+});
+
+function copyFrom(target: Element): Event {
+ const event = new Event('copy', { bubbles: true, cancelable: true });
+ target.dispatchEvent(event);
+ return event;
+}
+
+function editorImage(attrs: { src: string }): HTMLImageElement {
+ const editor = document.createElement('div');
+ editor.className = 'ProseMirror';
+ const img = document.createElement('img');
+ img.src = attrs.src;
+ editor.append(img);
+ document.body.append(editor);
+ return img;
+}
+
+describe('copy-image listener', () => {
+ test('a copy on an editor image hands its src to the copy-image service', () => {
+ copyImage.mockResolvedValue({ ok: true, via: 'browser' });
+ const event = copyFrom(editorImage({ src: 'http://localhost:5173/a.png' }));
+ expect(event.defaultPrevented).toBe(true);
+ expect(copyImage).toHaveBeenCalledWith({ src: 'http://localhost:5173/a.png' });
+ });
+
+ test('an image outside the editor keeps the default copy', () => {
+ const img = document.createElement('img');
+ img.src = 'http://localhost:5173/a.png';
+ document.body.append(img);
+ const event = copyFrom(img);
+ expect(event.defaultPrevented).toBe(false);
+ expect(copyImage).not.toHaveBeenCalled();
+ });
+
+ test('a copy of editor text keeps the default copy', () => {
+ const editor = document.createElement('div');
+ editor.className = 'ProseMirror';
+ const p = document.createElement('p');
+ p.textContent = 'hello';
+ editor.append(p);
+ document.body.append(editor);
+ const event = copyFrom(p);
+ expect(event.defaultPrevented).toBe(false);
+ expect(copyImage).not.toHaveBeenCalled();
+ });
+
+ test('a desktop fallback and a failed browser write are both logged', async () => {
+ const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+ copyImage.mockResolvedValue({
+ ok: false,
+ reason: 'write-error',
+ detail: 'NotAllowedError',
+ desktopFailure: { ok: false, reason: 'empty-image', detail: 'svg' },
+ });
+ copyFrom(editorImage({ src: 'http://localhost:5173/a.svg' }));
+ await vi.waitFor(() => expect(warn).toHaveBeenCalledTimes(2));
+ expect(warn.mock.calls.map((call) => call[1])).toEqual(['empty-image', 'write-error']);
+ });
+});
diff --git a/packages/app/src/editor/clipboard/copy-image.ts b/packages/app/src/editor/clipboard/copy-image.ts
index 852e036e4..93ecec307 100644
--- a/packages/app/src/editor/clipboard/copy-image.ts
+++ b/packages/app/src/editor/clipboard/copy-image.ts
@@ -1,21 +1,4 @@
-interface DesktopClipboardBridge {
- copyImage(params: { readonly src: string; readonly alt: string }): Promise<
- | { ok: true }
- | {
- ok: false;
- reason: 'fetch-failed' | 'path-escape' | 'empty-image' | 'read-error' | 'write-error';
- detail?: string;
- }
- >;
-}
-
-function getDesktopClipboard(): DesktopClipboardBridge | null {
- if (typeof window === 'undefined') return null;
- const bridge = (window as unknown as { okDesktop?: { clipboard?: unknown } }).okDesktop;
- const c = bridge?.clipboard as { copyImage?: unknown } | undefined;
- if (!c || typeof c.copyImage !== 'function') return null;
- return c as DesktopClipboardBridge;
-}
+import { copyImage } from '@/lib/copy-image';
let installed = false;
if (typeof window !== 'undefined' && !installed) {
@@ -27,62 +10,20 @@ function onDocCopy(ev: ClipboardEvent): void {
const target = ev.target;
if (!(target instanceof HTMLImageElement)) return;
if (!target.closest('.ProseMirror')) return;
- const resolvedSrc = target.currentSrc || target.src;
- if (!resolvedSrc) return;
- const alt = target.getAttribute('alt') ?? '';
+ const src = target.currentSrc || target.src;
+ if (!src) return;
ev.preventDefault();
ev.stopImmediatePropagation();
- const bridge = getDesktopClipboard();
- if (bridge) {
- void bridge
- .copyImage({ src: resolvedSrc, alt })
- .then((res) => {
- if (res.ok) return;
- console.warn('[copy-image] desktop write declined, falling back', res.reason, res.detail);
- void webCopyFromImgEl(alt, resolvedSrc);
- })
- .catch((err) => {
- console.warn('[copy-image] desktop bridge threw, falling back', err);
- void webCopyFromImgEl(alt, resolvedSrc);
- });
- return;
- }
- void webCopyFromImgEl(alt, resolvedSrc);
-}
-
-async function webCopyFromImgEl(alt: string, resolvedSrc: string): Promise<void> {
- if (typeof navigator === 'undefined' || !navigator.clipboard?.write) {
- console.warn('[copy-image] navigator.clipboard.write unavailable — skipping web fallback');
- return;
- }
- const html = `<img src="${escapeAttr(resolvedSrc)}" alt="${escapeAttr(alt)}">`;
- const escapedAlt = alt.replaceAll('\\', '\\\\').replaceAll('[', '\\[').replaceAll(']', '\\]');
- const escapedSrc = resolvedSrc.replaceAll('(', '%28').replaceAll(')', '%29');
- const markdown = `![${escapedAlt}](${escapedSrc})`;
- try {
- const blob = await fetch(resolvedSrc, { signal: AbortSignal.timeout(10_000) }).then(
- async (res) => {
- if (!res.ok) throw new Error(`copy-image fetch failed: ${res.status}`);
- const b = await res.blob();
- return b.type === 'image/png' ? b : new Blob([b], { type: 'image/png' });
- },
- );
- await navigator.clipboard.write([
- new ClipboardItem({
- 'image/png': blob,
- 'text/plain': new Blob([markdown], { type: 'text/plain' }),
- 'text/html': new Blob([html], { type: 'text/html' }),
- }),
- ]);
- } catch (err) {
- console.warn('[copy-image] web clipboard write failed', err);
- }
-}
-
-function escapeAttr(s: string): string {
- return s
- .replaceAll('&', '&amp;')
- .replaceAll('"', '&quot;')
- .replaceAll('<', '&lt;')
- .replaceAll('>', '&gt;');
+ void copyImage({ src }).then((outcome) => {
+ if (outcome.desktopFailure) {
+ console.warn(
+ '[copy-image] desktop write declined, fell back to the browser clipboard',
+ outcome.desktopFailure.reason,
+ outcome.desktopFailure.detail,
+ );
+ }
+ if (!outcome.ok) {
+ console.warn('[copy-image] browser clipboard write failed', outcome.reason, outcome.detail);
+ }
+ });
}
diff --git a/packages/app/src/lib/copy-image.test.ts b/packages/app/src/lib/copy-image.test.ts
new file mode 100644
index 000000000..36c9ff87c
--- /dev/null
+++ b/packages/app/src/lib/copy-image.test.ts
@@ -0,0 +1,187 @@
+import type { CopyImageResult } from '@inkeep/open-knowledge-core/desktop-bridge';
+import { afterEach, describe, expect, test, vi } from 'vitest';
+import { type CopyImageEnv, copyImage } from './copy-image.ts';
+
+const REQUEST = { src: 'http://localhost:5173/assets/pic.jpg' };
+
+class FakeClipboardItem {
+ constructor(readonly items: Record<string, Blob>) {}
+}
+
+function env(overrides: Partial<CopyImageEnv> = {}): CopyImageEnv {
+ return {
+ desktopCopyImage: null,
+ writeClipboard: vi.fn(async () => {}),
+ createClipboardItem: (items) => new FakeClipboardItem(items) as unknown as ClipboardItem,
+ fetch: vi.fn(
+ async () => new Response(new Blob([new Uint8Array([0xff, 0xd8])]), { status: 200 }),
+ ),
+ ...overrides,
+ };
+}
+
+function writtenItems(write: CopyImageEnv['writeClipboard']): Record<string, Blob> {
+ const calls = (write as ReturnType<typeof vi.fn>).mock.calls;
+ expect(calls).toHaveLength(1);
+ const [items] = calls[0] as [FakeClipboardItem[]];
+ expect(items).toHaveLength(1);
+ return items[0].items;
+}
+
+describe('copyImage — desktop first', () => {
+ test('a desktop success does not touch the browser clipboard', async () => {
+ const e = env({
+ desktopCopyImage: vi.fn(async (): Promise<CopyImageResult> => ({ ok: true })),
+ });
+ await expect(copyImage(REQUEST, e)).resolves.toEqual({ ok: true, via: 'desktop' });
+ expect(e.desktopCopyImage).toHaveBeenCalledWith(REQUEST);
+ expect(e.writeClipboard).not.toHaveBeenCalled();
+ expect(e.fetch).not.toHaveBeenCalled();
+ });
+
+ test('a declined desktop write falls back to the browser and reports why', async () => {
+ const e = env({
+ desktopCopyImage: vi.fn(
+ async (): Promise<CopyImageResult> => ({ ok: false, reason: 'empty-image', detail: 'svg' }),
+ ),
+ });
+ await expect(copyImage(REQUEST, e)).resolves.toEqual({
+ ok: true,
+ via: 'browser',
+ desktopFailure: { ok: false, reason: 'empty-image', detail: 'svg' },
+ });
+ expect(writtenItems(e.writeClipboard)['image/png'].type).toBe('image/png');
+ });
+
+ test('a throwing desktop bridge falls back to the browser', async () => {
+ const e = env({
+ desktopCopyImage: vi.fn(async (): Promise<CopyImageResult> => {
+ throw new Error('ipc gone');
+ }),
+ });
+ await expect(copyImage(REQUEST, e)).resolves.toEqual({
+ ok: true,
+ via: 'browser',
+ desktopFailure: { ok: false, reason: 'bridge-threw', detail: 'ipc gone' },
+ });
+ });
+});
+
+describe('copyImage — browser clipboard', () => {
+ test('writes the fetched image under image/png', async () => {
+ const e = env();
+ await expect(copyImage(REQUEST, e)).resolves.toEqual({ ok: true, via: 'browser' });
+ expect(e.fetch).toHaveBeenCalledWith(
+ REQUEST.src,
+ expect.objectContaining({ signal: expect.anything() }),
+ );
+ const written = writtenItems(e.writeClipboard);
+ expect(Object.keys(written)).toEqual(['image/png']);
+ const png = written['image/png'];
+ expect(png.type).toBe('image/png');
+ expect(Buffer.from(await png.arrayBuffer())).toEqual(Buffer.from([0xff, 0xd8]));
+ });
+
+ test('no clipboard API is reported, not thrown', async () => {
+ const e = env({ writeClipboard: null });
+ await expect(copyImage(REQUEST, e)).resolves.toMatchObject({
+ ok: false,
+ reason: 'clipboard-unavailable',
+ });
+ expect(e.fetch).not.toHaveBeenCalled();
+ });
+
+ test('a non-2xx fetch is a fetch-failed outcome', async () => {
+ const e = env({ fetch: vi.fn(async () => new Response(null, { status: 404 })) });
+ await expect(copyImage(REQUEST, e)).resolves.toEqual({
+ ok: false,
+ reason: 'fetch-failed',
+ detail: 'HTTP 404',
+ });
+ expect(e.writeClipboard).not.toHaveBeenCalled();
+ });
+
+ test('a rejected fetch is a fetch-failed outcome with no clipboard write', async () => {
+ const e = env({
+ fetch: vi.fn(async () => {
+ throw new TypeError('Failed to fetch');
+ }),
+ });
+ await expect(copyImage(REQUEST, e)).resolves.toEqual({
+ ok: false,
+ reason: 'fetch-failed',
+ detail: 'Failed to fetch',
+ });
+ expect(e.writeClipboard).not.toHaveBeenCalled();
+ });
+
+ test('a throwing ClipboardItem constructor is a write-error outcome', async () => {
+ const e = env({
+ createClipboardItem: () => {
+ throw new TypeError('ClipboardItem is not defined');
+ },
+ });
+ await expect(copyImage(REQUEST, e)).resolves.toEqual({
+ ok: false,
+ reason: 'write-error',
+ detail: 'ClipboardItem is not defined',
+ });
+ expect(e.writeClipboard).not.toHaveBeenCalled();
+ });
+
+ test('a rejected clipboard write is a write-error outcome', async () => {
+ const e = env({
+ writeClipboard: vi.fn(async () => {
+ throw new Error('NotAllowedError');
+ }),
+ });
+ await expect(copyImage(REQUEST, e)).resolves.toEqual({
+ ok: false,
+ reason: 'write-error',
+ detail: 'NotAllowedError',
+ });
+ });
+});
+
+describe('copyImage — default environment', () => {
+ afterEach(() => {
+ vi.unstubAllGlobals();
+ });
+
+ function stubBrowser(clipboard: { write?: (items: ClipboardItem[]) => Promise<void> }) {
+ vi.stubGlobal('window', {});
+ vi.stubGlobal('navigator', { clipboard });
+ vi.stubGlobal('ClipboardItem', FakeClipboardItem);
+ vi.stubGlobal(
+ 'fetch',
+ vi.fn(async () => new Response(new Blob([new Uint8Array([0x89, 0x50])]), { status: 200 })),
+ );
+ }
+
+ test('uses the desktop bridge on window.okDesktop when it is present', async () => {
+ const copy = vi.fn(async (): Promise<CopyImageResult> => ({ ok: true }));
+ const write = vi.fn(async () => {});
+ stubBrowser({ write });
+ vi.stubGlobal('window', { okDesktop: { clipboard: { copyImage: copy } } });
+ await expect(copyImage(REQUEST)).resolves.toEqual({ ok: true, via: 'desktop' });
+ expect(copy).toHaveBeenCalledWith(REQUEST);
+ expect(write).not.toHaveBeenCalled();
+ });
+
+ test('writes only image/png through navigator.clipboard without a desktop bridge', async () => {
+ const write = vi.fn(async (_items: ClipboardItem[]) => {});
+ stubBrowser({ write });
+ await expect(copyImage(REQUEST)).resolves.toEqual({ ok: true, via: 'browser' });
+ expect(fetch).toHaveBeenCalledWith(REQUEST.src, expect.anything());
+ expect(writtenItems(write)['image/png'].type).toBe('image/png');
+ });
+
+ test('reports a browser with no clipboard write as clipboard-unavailable', async () => {
+ stubBrowser({});
+ await expect(copyImage(REQUEST)).resolves.toMatchObject({
+ ok: false,
+ reason: 'clipboard-unavailable',
+ });
+ expect(fetch).not.toHaveBeenCalled();
+ });
+});
diff --git a/packages/app/src/lib/copy-image.ts b/packages/app/src/lib/copy-image.ts
new file mode 100644
index 000000000..03aa28747
--- /dev/null
+++ b/packages/app/src/lib/copy-image.ts
@@ -0,0 +1,82 @@
+import type { CopyImageRequest, CopyImageResult } from '@inkeep/open-knowledge-core/desktop-bridge';
+
+export type CopyImageOutcome =
+ | { ok: true; via: 'desktop' | 'browser'; desktopFailure?: CopyImageDesktopFailure }
+ | {
+ ok: false;
+ reason: 'clipboard-unavailable' | 'fetch-failed' | 'write-error';
+ detail: string;
+ desktopFailure?: CopyImageDesktopFailure;
+ };
+
+type CopyImageDesktopFailure =
+ | Extract<CopyImageResult, { ok: false }>
+ | { ok: false; reason: 'bridge-threw'; detail: string };
+
+export interface CopyImageEnv {
+ readonly desktopCopyImage: ((request: CopyImageRequest) => Promise<CopyImageResult>) | null;
+ readonly writeClipboard: ((items: ClipboardItem[]) => Promise<void>) | null;
+ readonly createClipboardItem: (items: Record<string, Blob>) => ClipboardItem;
+ readonly fetch: typeof fetch;
+}
+
+export async function copyImage(
+ request: CopyImageRequest,
+ env: CopyImageEnv = browserCopyImageEnv(),
+): Promise<CopyImageOutcome> {
+ let desktopFailure: CopyImageDesktopFailure | undefined;
+ if (env.desktopCopyImage) {
+ try {
+ const result = await env.desktopCopyImage(request);
+ if (result.ok) return { ok: true, via: 'desktop' };
+ desktopFailure = result;
+ } catch (err) {
+ desktopFailure = { ok: false, reason: 'bridge-threw', detail: errorMessage(err) };
+ }
+ }
+ const outcome = await copyImageInBrowser(request, env);
+ return desktopFailure ? { ...outcome, desktopFailure } : outcome;
+}
+
+async function copyImageInBrowser(
+ request: CopyImageRequest,
+ env: CopyImageEnv,
+): Promise<CopyImageOutcome> {
+ if (!env.writeClipboard) {
+ return {
+ ok: false,
+ reason: 'clipboard-unavailable',
+ detail: 'navigator.clipboard.write unavailable',
+ };
+ }
+ let png: Blob;
+ try {
+ const res = await env.fetch(request.src, { signal: AbortSignal.timeout(10_000) });
+ if (!res.ok) return { ok: false, reason: 'fetch-failed', detail: `HTTP ${res.status}` };
+ const fetched = await res.blob();
+ png = fetched.type === 'image/png' ? fetched : new Blob([fetched], { type: 'image/png' });
+ } catch (err) {
+ return { ok: false, reason: 'fetch-failed', detail: errorMessage(err) };
+ }
+ try {
+ await env.writeClipboard([env.createClipboardItem({ 'image/png': png })]);
+ } catch (err) {
+ return { ok: false, reason: 'write-error', detail: errorMessage(err) };
+ }
+ return { ok: true, via: 'browser' };
+}
+
+function browserCopyImageEnv(): CopyImageEnv {
+ const desktop = typeof window === 'undefined' ? undefined : window.okDesktop?.clipboard;
+ const clipboard = typeof navigator === 'undefined' ? undefined : navigator.clipboard;
+ return {
+ desktopCopyImage: desktop ? (request) => desktop.copyImage(request) : null,
+ writeClipboard: clipboard?.write ? (items) => clipboard.write(items) : null,
+ createClipboardItem: (items) => new ClipboardItem(items),
+ fetch: (input, init) => fetch(input, init),
+ };
+}
+
+function errorMessage(err: unknown): string {
+ return err instanceof Error ? err.message : String(err);
+}
diff --git a/packages/core/src/desktop-bridge.ts b/packages/core/src/desktop-bridge.ts
index 610c03c99..c630a7555 100644
--- a/packages/core/src/desktop-bridge.ts
+++ b/packages/core/src/desktop-bridge.ts
@@ -1047,6 +1047,21 @@ export interface CliReadiness {
readonly okServerConfigured?: boolean;
}
+export interface CopyImageRequest {
+ readonly src: string;
+}
+
+export type CopyImageFailureReason =
+ | 'fetch-failed'
+ | 'path-escape'
+ | 'empty-image'
+ | 'read-error'
+ | 'write-error';
+
+export type CopyImageResult =
+ | { ok: true }
+ | { ok: false; reason: CopyImageFailureReason; detail?: string };
+
export interface OkDesktopBridge {
readonly config: OkDesktopConfig;
@@ -1132,14 +1147,7 @@ export interface OkDesktopBridge {
clipboard: {
writeText(text: string): Promise<void>;
- copyImage(params: { readonly src: string; readonly alt: string }): Promise<
- | { ok: true }
- | {
- ok: false;
- reason: 'fetch-failed' | 'path-escape' | 'empty-image' | 'read-error' | 'write-error';
- detail?: string;
- }
- >;
+ copyImage(request: CopyImageRequest): Promise<CopyImageResult>;
};
project: {
diff --git a/packages/desktop/src/main/copy-image-clipboard.test.ts b/packages/desktop/src/main/copy-image-clipboard.test.ts
index e1c755a6a..efef8537b 100644
--- a/packages/desktop/src/main/copy-image-clipboard.test.ts
+++ b/packages/desktop/src/main/copy-image-clipboard.test.ts
@@ -34,7 +34,7 @@ describe('copyImageToClipboard — same-origin path handling', () => {
clipboard: { write },
resolveCanonical: () => '/etc/passwd',
}),
- { src: 'http://localhost:5173/%2E%2E/%2E%2E/etc/passwd', alt: 'x' },
+ { src: 'http://localhost:5173/%2E%2E/%2E%2E/etc/passwd' },
);
expect(result).toEqual({
ok: false,
@@ -53,7 +53,7 @@ describe('copyImageToClipboard — same-origin path handling', () => {
clipboard: { write },
resolveCanonical,
}),
- { src: 'http://localhost:5173/C:/Windows/System32/passwd', alt: 'x' },
+ { src: 'http://localhost:5173/C:/Windows/System32/passwd' },
);
expect(result).toEqual({
ok: false,
@@ -73,7 +73,7 @@ describe('copyImageToClipboard — same-origin path handling', () => {
throw Object.assign(new Error('no such file'), { code: 'ENOENT' });
},
}),
- { src: 'http://localhost:5173/assets/missing.png', alt: 'x' },
+ { src: 'http://localhost:5173/assets/missing.png' },
);
expect(result).toEqual({
ok: false,
@@ -92,7 +92,7 @@ describe('copyImageToClipboard — same-origin path handling', () => {
throw Object.assign(new Error('permission denied'), { code: 'EACCES' });
},
}),
- { src: 'http://localhost:5173/assets/logo.png', alt: 'x' },
+ { src: 'http://localhost:5173/assets/logo.png' },
);
expect(result).toEqual({
ok: false,
@@ -110,7 +110,7 @@ describe('copyImageToClipboard — same-origin path handling', () => {
clipboard: { write },
readFile,
}),
- { src: 'http://localhost:5173/.ok/config.yml', alt: 'x' },
+ { src: 'http://localhost:5173/.ok/config.yml' },
);
expect(result).toEqual({
ok: false,
@@ -128,7 +128,7 @@ describe('copyImageToClipboard — same-origin path handling', () => {
clipboard: { write },
resolveCanonical: () => '/etc/passwd',
}),
- { src: 'http://localhost:5173/assets/logo.png', alt: 'x' },
+ { src: 'http://localhost:5173/assets/logo.png' },
);
expect(result).toEqual({
ok: false,
@@ -147,7 +147,7 @@ describe('copyImageToClipboard — cross-origin fetch', () => {
clipboard: { write },
fetch: vi.fn(async () => new Response('', { status: 404 })),
}),
- { src: 'https://cdn.example.com/missing.png', alt: 'x' },
+ { src: 'https://cdn.example.com/missing.png' },
);
expect(result).toEqual({
ok: false,
@@ -166,7 +166,7 @@ describe('copyImageToClipboard — cross-origin fetch', () => {
throw new Error('boom');
}),
}),
- { src: 'https://cdn.example.com/foo.png', alt: 'x' },
+ { src: 'https://cdn.example.com/foo.png' },
);
expect(result).toEqual({
ok: false,
@@ -187,7 +187,7 @@ describe('copyImageToClipboard — decode + write', () => {
createFromBuffer: () => ({ isEmpty: () => true, toPNG: () => Buffer.alloc(0) }),
},
}),
- { src: 'https://cdn.example.com/x.svg', alt: 'x' },
+ { src: 'https://cdn.example.com/x.svg' },
);
expect(result.ok).toBe(false);
if (!result.ok) {
@@ -200,7 +200,6 @@ describe('copyImageToClipboard — decode + write', () => {
const write = vi.fn(async () => {});
const result = await copyImageToClipboard(baseDeps({ clipboard: { write } }), {
src: 'https://cdn.example.com/pic.jpg',
- alt: 'x',
});
expect(result).toEqual({ ok: true });
expect(write).toHaveBeenCalledTimes(1);
@@ -218,7 +217,6 @@ describe('copyImageToClipboard — decode + write', () => {
});
const result = await copyImageToClipboard(baseDeps({ clipboard: { write } }), {
src: 'https://cdn.example.com/pic.png',
- alt: 'x',
});
expect(result).toEqual({
ok: false,
diff --git a/packages/desktop/src/main/copy-image-clipboard.ts b/packages/desktop/src/main/copy-image-clipboard.ts
index 3c37e7c47..9eaf82506 100644
--- a/packages/desktop/src/main/copy-image-clipboard.ts
+++ b/packages/desktop/src/main/copy-image-clipboard.ts
@@ -3,19 +3,16 @@ import { readFile } from 'node:fs/promises';
import { resolve as resolvePath } from 'node:path';
import * as pathPosix from 'node:path/posix';
import * as pathWin32 from 'node:path/win32';
+import type {
+ CopyImageFailureReason,
+ CopyImageRequest,
+ CopyImageResult,
+} from '@inkeep/open-knowledge-core/desktop-bridge';
import type { Clipboard, ClipboardItem, NativeImage } from 'electron';
import { isPathWithinProject } from './ipc-handlers.ts';
const CLIPBOARD_IMAGE_EXTS: ReadonlySet<string> = new Set(['png', 'jpg', 'jpeg']);
-type CopyImageResult =
- | { ok: true }
- | {
- ok: false;
- reason: 'fetch-failed' | 'path-escape' | 'empty-image' | 'read-error' | 'write-error';
- detail?: string;
- };
-
export interface CopyImageToClipboardDeps {
readonly projectPath: string;
readonly platform: NodeJS.Platform;
@@ -30,14 +27,9 @@ export interface CopyImageToClipboardDeps {
readonly readFile?: (path: string) => Promise<Buffer>;
}
-export interface CopyImageInput {
- readonly src: string;
- readonly alt: string;
-}
-
export async function copyImageToClipboard(
deps: CopyImageToClipboardDeps,
- input: CopyImageInput,
+ input: CopyImageRequest,
): Promise<CopyImageResult> {
const fetchImpl = deps.fetch ?? globalThis.fetch;
const bytesResult = await loadImageBytes(deps, input.src, fetchImpl);
@@ -68,7 +60,11 @@ async function loadImageBytes(
fetchImpl: typeof fetch,
): Promise<
| { ok: true; bytes: Buffer; ext: string }
- | { ok: false; reason: 'fetch-failed' | 'path-escape' | 'read-error'; detail?: string }
+ | {
+ ok: false;
+ reason: Extract<CopyImageFailureReason, 'fetch-failed' | 'path-escape' | 'read-error'>;
+ detail?: string;
+ }
> {
let url: URL;
try {
diff --git a/packages/desktop/src/main/index.ts b/packages/desktop/src/main/index.ts
index 102a3655d..a8bacbf42 100644
--- a/packages/desktop/src/main/index.ts
+++ b/packages/desktop/src/main/index.ts
@@ -4414,7 +4414,7 @@ function registerIpcHandlers() {
return undefined;
});
- handle('ok:clipboard:copy-image', async (event, { src, alt }) => {
+ handle('ok:clipboard:copy-image', async (event, { src }) => {
const callerWin = BrowserWindow.fromWebContents(event.sender);
if (!callerWin || !wm) {
return { ok: false as const, reason: 'read-error' as const, detail: 'no window context' };
@@ -4432,7 +4432,7 @@ function registerIpcHandlers() {
ClipboardItem,
nativeImage,
},
- { src, alt },
+ { src },
);
if (!result.ok) {
getLogger('copy-image').warn(
diff --git a/packages/desktop/src/shared/ipc-channels.ts b/packages/desktop/src/shared/ipc-channels.ts
index 5fee6150b..6e88360c4 100644
--- a/packages/desktop/src/shared/ipc-channels.ts
+++ b/packages/desktop/src/shared/ipc-channels.ts
@@ -35,6 +35,8 @@ import type {
OkCheckTargetExistsResult as CheckTargetExistsResult,
ClaudeReadiness,
CliReadiness,
+ CopyImageRequest,
+ CopyImageResult,
OkHeadBranchInfo as HeadBranchInfo,
OkAssetUploadResult,
OkChromeColors,
@@ -422,16 +424,7 @@ export interface RequestChannels {
};
};
'ok:clipboard:write-text': { args: [text: string]; result: undefined };
- 'ok:clipboard:copy-image': {
- args: [params: { readonly src: string; readonly alt: string }];
- result:
- | { ok: true }
- | {
- ok: false;
- reason: 'fetch-failed' | 'path-escape' | 'empty-image' | 'read-error' | 'write-error';
- detail?: string;
- };
- };
+ 'ok:clipboard:copy-image': { args: [request: CopyImageRequest]; result: CopyImageResult };
'ok:project:get-info': { args: []; result: OkDesktopConfig };
'ok:sharing:dispatch': {