309 lines
11 KiB
JavaScript
309 lines
11 KiB
JavaScript
// clipboard.js - what the composer asks the system for: the clipboard, the
|
||
// file picker, the sizes of files, and the old files of the paste folder.
|
||
//
|
||
// Pure: no gpui-kit, no gpui-base, no herdr. The scripts are PowerShell text
|
||
// (run by main.js with `exec("powershell", ["-NoProfile", "-STA", "-Command",
|
||
// script])` - `-Command`, because running script files is off on this
|
||
// machine), and the parsers read what the scripts print, so both halves are
|
||
// tested in plain Node (tests/clipboard.test.mjs).
|
||
//
|
||
// The mods have no `stat` (fs/promises: no size, no mtime), so the SIZE of
|
||
// every file comes from PowerShell, in the same call that finds the file.
|
||
//
|
||
// The scripts print one fact per line, the fields separated by a tab:
|
||
// FILES<TAB><path><TAB><bytes> (one line per file) - files from the Explorer
|
||
// IMAGE<TAB><path><TAB><bytes> - an image, saved as a PNG
|
||
// DIR<TAB><path> - a folder (not carried)
|
||
// NONE - nothing to paste
|
||
// An empty or missing <bytes> means the size could not be read: the caller
|
||
// does not let such a file through (fail closed).
|
||
|
||
/** How long a pasted image stays in the paste folder. */
|
||
export const PASTE_MAX_AGE_MS = 7 * 864e5;
|
||
|
||
/** The programs that take an image (Global Constraints). */
|
||
const IMAGE_APPS = new Set(["claude-code", "codex", "gemini", "opencode"]);
|
||
|
||
/**
|
||
* The PowerShell that reads the clipboard: files first (folders apart), then
|
||
* an image (saved as `<outDir>\paste-<stamp>.png`), otherwise `NONE`.
|
||
*
|
||
* @param {string} outDir - where a pasted image is saved
|
||
* @param {string} stamp - what makes the file name its own (a moment)
|
||
* @returns {string}
|
||
*/
|
||
export function clipboardScript(outDir, stamp) {
|
||
const dir = decode(outDir);
|
||
const name = `paste-${String(stamp).replace(/[^\w-]/g, "")}.png`;
|
||
|
||
return [
|
||
"Add-Type -AssemblyName System.Windows.Forms",
|
||
"Add-Type -AssemblyName System.Drawing",
|
||
"[Console]::OutputEncoding = [System.Text.Encoding]::UTF8",
|
||
"$tab = [char]9",
|
||
"$files = [System.Windows.Forms.Clipboard]::GetFileDropList()",
|
||
"if ($files -ne $null -and $files.Count -gt 0) {",
|
||
" foreach ($f in $files) {",
|
||
" if (Test-Path -LiteralPath $f -PathType Container) {",
|
||
' Write-Output ("DIR" + $tab + $f)',
|
||
" } else {",
|
||
" $len = ''",
|
||
" try { $len = (Get-Item -LiteralPath $f -ErrorAction Stop).Length } catch { }",
|
||
' Write-Output ("FILES" + $tab + $f + $tab + $len)',
|
||
" }",
|
||
" }",
|
||
" exit 0",
|
||
"}",
|
||
"$img = [System.Windows.Forms.Clipboard]::GetImage()",
|
||
"if ($img -ne $null) {",
|
||
` $dir = ${dir}`,
|
||
" New-Item -ItemType Directory -Force -Path $dir | Out-Null",
|
||
` $path = Join-Path $dir '${name}'`,
|
||
" $img.Save($path, [System.Drawing.Imaging.ImageFormat]::Png)",
|
||
" $len = ''",
|
||
" try { $len = (Get-Item -LiteralPath $path -ErrorAction Stop).Length } catch { }",
|
||
' Write-Output ("IMAGE" + $tab + $path + $tab + $len)',
|
||
" exit 0",
|
||
"}",
|
||
"Write-Output 'NONE'",
|
||
].join("\n");
|
||
}
|
||
|
||
/**
|
||
* What the clipboard script printed.
|
||
*
|
||
* `files` are the things to attach (an image comes as one file); `dirs` are
|
||
* folders, which are not carried. Only folders: `{kind:"dirs"}`.
|
||
*
|
||
* @param {{code?:number, stdout?:string, stderr?:string}|null} res
|
||
* @returns {{kind:"image"|"files", files:{path:string, bytes:number|null}[], dirs:string[]}
|
||
* | {kind:"dirs", dirs:string[]} | {kind:"none"} | {kind:"error", message:string}}
|
||
*/
|
||
export function parseClipboardResult(res) {
|
||
if (!res || typeof res !== "object") return { kind: "error", message: "Brak wyniku z PowerShell" };
|
||
|
||
if (res.code !== 0) {
|
||
const stderr = String(res.stderr ?? "").trim();
|
||
return { kind: "error", message: stderr || `PowerShell zakończył się kodem ${res.code}` };
|
||
}
|
||
|
||
const files = [];
|
||
const dirs = [];
|
||
let image = null;
|
||
for (const line of lines(res.stdout)) {
|
||
const [kind, path, size] = fields(line);
|
||
if (!path) continue;
|
||
if (kind === "FILES") files.push({ path, bytes: toBytes(size) });
|
||
if (kind === "IMAGE" && image === null) image = { path, bytes: toBytes(size) };
|
||
if (kind === "DIR") dirs.push(path);
|
||
}
|
||
|
||
if (files.length > 0) return { kind: "files", files, dirs };
|
||
if (image) return { kind: "image", files: [image], dirs };
|
||
if (dirs.length > 0) return { kind: "dirs", dirs };
|
||
return { kind: "none" };
|
||
}
|
||
|
||
/**
|
||
* The PowerShell that opens the file dialog (several files may be picked) and
|
||
* prints `<path><TAB><bytes>` per line. Cancel prints nothing.
|
||
*
|
||
* @returns {string}
|
||
*/
|
||
export function pickerScript() {
|
||
return [
|
||
"Add-Type -AssemblyName System.Windows.Forms",
|
||
"[Console]::OutputEncoding = [System.Text.Encoding]::UTF8",
|
||
"$tab = [char]9",
|
||
"$dialog = New-Object System.Windows.Forms.OpenFileDialog",
|
||
"$dialog.Multiselect = $true",
|
||
"$dialog.Title = 'Wybierz pliki'",
|
||
"if ($dialog.ShowDialog() -eq [System.Windows.Forms.DialogResult]::OK) {",
|
||
" foreach ($f in $dialog.FileNames) {",
|
||
" $len = ''",
|
||
" try { $len = (Get-Item -LiteralPath $f -ErrorAction Stop).Length } catch { }",
|
||
' Write-Output ($f + $tab + $len)',
|
||
" }",
|
||
"}",
|
||
].join("\n");
|
||
}
|
||
|
||
/**
|
||
* The files the dialog printed; cancel, or a failed run, is no file at all.
|
||
*
|
||
* @param {{code?:number, stdout?:string}|null} res
|
||
* @returns {{path:string, bytes:number|null}[]}
|
||
*/
|
||
export function parsePickerResult(res) {
|
||
if (!res || typeof res !== "object" || res.code !== 0) return [];
|
||
return lines(res.stdout).map((line) => {
|
||
const [path, size] = fieldsLast(line);
|
||
return { path, bytes: toBytes(size) };
|
||
});
|
||
}
|
||
|
||
/**
|
||
* The PowerShell that measures a batch of paths in one call: `SIZE` for a
|
||
* file, `DIR` for a folder, `MISSING` for what is not there.
|
||
*
|
||
* @param {string[]} paths
|
||
* @returns {string}
|
||
*/
|
||
export function sizeScript(paths) {
|
||
const list = (Array.isArray(paths) ? paths : []).map(String).join("\n");
|
||
return [
|
||
"[Console]::OutputEncoding = [System.Text.Encoding]::UTF8",
|
||
"$tab = [char]9",
|
||
// One path per line (a file name has no newline), as Base64: no byte of
|
||
// a name is ever part of the script itself.
|
||
`$paths = @(${decode(list)}.Split([char]10) | Where-Object { $_ -ne '' })`,
|
||
"foreach ($p in $paths) {",
|
||
" if (Test-Path -LiteralPath $p -PathType Container) {",
|
||
' Write-Output ("DIR" + $tab + $p)',
|
||
" } elseif (Test-Path -LiteralPath $p -PathType Leaf) {",
|
||
" $len = ''",
|
||
" try { $len = (Get-Item -LiteralPath $p -ErrorAction Stop).Length } catch { }",
|
||
' Write-Output ("SIZE" + $tab + $p + $tab + $len)',
|
||
" } else {",
|
||
' Write-Output ("MISSING" + $tab + $p)',
|
||
" }",
|
||
"}",
|
||
].join("\n");
|
||
}
|
||
|
||
/**
|
||
* What `sizeScript` printed. A run that failed has no sizes at all: `error`
|
||
* says why, and the caller does not attach anything on a guess.
|
||
*
|
||
* @param {{code?:number, stdout?:string, stderr?:string}|null} res
|
||
* @returns {{files:{path:string, bytes:number|null}[], dirs:string[], missing:string[], error:string|null}}
|
||
*/
|
||
export function parseSizeResult(res) {
|
||
const empty = { files: [], dirs: [], missing: [], error: null };
|
||
if (!res || typeof res !== "object") return { ...empty, error: "Brak wyniku z PowerShell" };
|
||
if (res.code !== 0) {
|
||
const stderr = String(res.stderr ?? "").trim();
|
||
return { ...empty, error: stderr || `PowerShell zakończył się kodem ${res.code}` };
|
||
}
|
||
|
||
const out = { files: [], dirs: [], missing: [], error: null };
|
||
for (const line of lines(res.stdout)) {
|
||
const [kind, path, size] = fields(line);
|
||
if (!path) continue;
|
||
if (kind === "SIZE") out.files.push({ path, bytes: toBytes(size) });
|
||
if (kind === "DIR") out.dirs.push(path);
|
||
if (kind === "MISSING") out.missing.push(path);
|
||
}
|
||
return out;
|
||
}
|
||
|
||
/**
|
||
* Which files of the paste folder are old enough to go.
|
||
*
|
||
* @param {{path:string, mtimeMs:number}[]} entries
|
||
* @param {number} now
|
||
* @param {number} [maxAgeMs] - 7 days by default
|
||
* @returns {string[]}
|
||
*/
|
||
export function staleFiles(entries, now, maxAgeMs = PASTE_MAX_AGE_MS) {
|
||
if (!Array.isArray(entries)) return [];
|
||
return entries
|
||
.filter((entry) => entry && Number.isFinite(entry.mtimeMs) && now - entry.mtimeMs > maxAgeMs)
|
||
.map((entry) => entry.path);
|
||
}
|
||
|
||
/**
|
||
* Does the agent's program take an image?
|
||
*
|
||
* @param {string|null} app - `AgentInfo.app`
|
||
* @returns {boolean}
|
||
*/
|
||
export function supportsImages(app) {
|
||
return typeof app === "string" && IMAGE_APPS.has(app.trim());
|
||
}
|
||
|
||
/** The non-empty lines of an output; a BOM in front of it is not part of it. */
|
||
function lines(text) {
|
||
return String(text ?? "")
|
||
.replace(/^/, "")
|
||
.split(/\r?\n/)
|
||
.map((line) => line.replace(/\r$/, ""))
|
||
.filter((line) => line.trim() !== "");
|
||
}
|
||
|
||
/** `KIND<TAB>path<TAB>size` -> [kind, path, size]. */
|
||
function fields(line) {
|
||
const first = line.indexOf("\t");
|
||
if (first < 0) return [line, "", ""];
|
||
const rest = line.slice(first + 1);
|
||
const second = rest.indexOf("\t");
|
||
return second < 0
|
||
? [line.slice(0, first), rest.trim(), ""]
|
||
: [line.slice(0, first), rest.slice(0, second).trim(), rest.slice(second + 1).trim()];
|
||
}
|
||
|
||
/** `path<TAB>size` -> [path, size] (the size is behind the last tab). */
|
||
function fieldsLast(line) {
|
||
const at = line.lastIndexOf("\t");
|
||
return at < 0 ? [line.trim(), ""] : [line.slice(0, at).trim(), line.slice(at + 1).trim()];
|
||
}
|
||
|
||
/** A size in bytes, or null when it is not a size. */
|
||
function toBytes(text) {
|
||
if (typeof text !== "string" || text.trim() === "") return null;
|
||
const value = Number(text);
|
||
return Number.isFinite(value) && value >= 0 ? value : null;
|
||
}
|
||
|
||
/**
|
||
* PowerShell that yields `text` - without the text itself being in the
|
||
* script.
|
||
*
|
||
* A path or a name comes from the outside, and PowerShell reads more than the
|
||
* ASCII apostrophe as a quote (U+2018, U+2019, U+201A, U+201B too), so no
|
||
* quoting is safe enough. The text goes in as Base64 of its UTF-8 bytes - an
|
||
* alphabet with no quote, no `$`, no space - and is decoded by PowerShell.
|
||
*
|
||
* @param {string} text
|
||
* @returns {string}
|
||
*/
|
||
function decode(text) {
|
||
return `[System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String('${base64(utf8(text))}'))`;
|
||
}
|
||
|
||
/** The UTF-8 bytes of a text (a lone surrogate becomes U+FFFD). */
|
||
function utf8(text) {
|
||
const bytes = [];
|
||
for (const char of String(text)) {
|
||
let code = char.codePointAt(0);
|
||
if (code >= 0xd800 && code <= 0xdfff) code = 0xfffd;
|
||
if (code < 0x80) {
|
||
bytes.push(code);
|
||
} else if (code < 0x800) {
|
||
bytes.push(0xc0 | (code >> 6), 0x80 | (code & 63));
|
||
} else if (code < 0x10000) {
|
||
bytes.push(0xe0 | (code >> 12), 0x80 | ((code >> 6) & 63), 0x80 | (code & 63));
|
||
} else {
|
||
bytes.push(0xf0 | (code >> 18), 0x80 | ((code >> 12) & 63), 0x80 | ((code >> 6) & 63), 0x80 | (code & 63));
|
||
}
|
||
}
|
||
return bytes;
|
||
}
|
||
|
||
const BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
||
|
||
/** Base64 of bytes (no Buffer, no btoa: the mods do not have to have them). */
|
||
function base64(bytes) {
|
||
let out = "";
|
||
for (let i = 0; i < bytes.length; i += 3) {
|
||
const a = bytes[i];
|
||
const b = bytes[i + 1];
|
||
const c = bytes[i + 2];
|
||
out += BASE64[a >> 2];
|
||
out += BASE64[((a & 3) << 4) | ((b ?? 0) >> 4)];
|
||
out += b === undefined ? "=" : BASE64[((b & 15) << 2) | ((c ?? 0) >> 6)];
|
||
out += c === undefined ? "=" : BASE64[c & 63];
|
||
}
|
||
return out;
|
||
}
|