1984 lines
64 KiB
JavaScript
1984 lines
64 KiB
JavaScript
#!/usr/bin/env node
|
|
import { a as previewCdnTransform, c as agentLabel, d as detectAvailableAgents, h as detectProject, i as hasFrameworkEntryPoint, l as installSkill, n as installPackages, o as previewOptionsTransform, r as applyTransform, s as previewTransform, t as getPackagesToInstall, u as removeSkill, y as findReactProjects } from "./install-Car5vKPk.js";
|
|
import { Command } from "commander";
|
|
import path, { join, relative, resolve } from "node:path";
|
|
import pc from "picocolors";
|
|
import fs, { existsSync, readFileSync } from "node:fs";
|
|
import { fileURLToPath } from "node:url";
|
|
import basePrompts from "prompts";
|
|
import ora from "ora";
|
|
import { spawn, spawnSync } from "node:child_process";
|
|
import { createHash } from "node:crypto";
|
|
//#region src/utils/is-non-interactive.ts
|
|
const AGENT_ENVIRONMENT_VARIABLES = [
|
|
"CI",
|
|
"CLAUDECODE",
|
|
"CURSOR_AGENT",
|
|
"CODEX_CI",
|
|
"OPENCODE",
|
|
"AMP_HOME",
|
|
"AMI"
|
|
];
|
|
const isEnvironmentVariableSet = (variable) => Boolean(process.env[variable]);
|
|
const detectNonInteractive = (yesFlag) => yesFlag || AGENT_ENVIRONMENT_VARIABLES.some(isEnvironmentVariableSet) || !process.stdin.isTTY;
|
|
//#endregion
|
|
//#region src/utils/highlighter.ts
|
|
const highlighter = {
|
|
error: pc.red,
|
|
warn: pc.yellow,
|
|
info: pc.cyan,
|
|
success: pc.green,
|
|
dim: pc.dim
|
|
};
|
|
//#endregion
|
|
//#region src/utils/logger.ts
|
|
const logger = {
|
|
error(...args) {
|
|
console.log(highlighter.error(args.join(" ")));
|
|
},
|
|
warn(...args) {
|
|
console.log(highlighter.warn(args.join(" ")));
|
|
},
|
|
success(...args) {
|
|
console.log(highlighter.success(args.join(" ")));
|
|
},
|
|
log(...args) {
|
|
console.log(args.join(" "));
|
|
},
|
|
break() {
|
|
console.log("");
|
|
}
|
|
};
|
|
//#endregion
|
|
//#region src/utils/handle-error.ts
|
|
const handleError = (error) => {
|
|
logger.break();
|
|
logger.error("Something went wrong. Please check the error below for more details.");
|
|
logger.error("If the problem persists, please open an issue on GitHub.");
|
|
logger.error("");
|
|
if (error instanceof Error) logger.error(error.message);
|
|
logger.break();
|
|
process.exit(1);
|
|
};
|
|
//#endregion
|
|
//#region src/utils/unref-stdin.ts
|
|
const unrefStdin = () => {
|
|
if (process.stdin.isTTY) return;
|
|
process.stdin.unref?.();
|
|
};
|
|
//#endregion
|
|
//#region src/utils/prompts.ts
|
|
const onCancel = () => {
|
|
logger.break();
|
|
logger.log("Cancelled.");
|
|
logger.break();
|
|
process.exit(0);
|
|
};
|
|
const prompts = (questions) => {
|
|
return basePrompts(questions, { onCancel }).finally(unrefStdin);
|
|
};
|
|
//#endregion
|
|
//#region src/utils/spinner.ts
|
|
const spinner = (text) => ora({ text });
|
|
//#endregion
|
|
//#region src/utils/prompt-skill-install.ts
|
|
const promptSkillInstall = async ({ yes = false, global = false, cwd = process.cwd() } = {}) => {
|
|
const detectedAgents = await detectAvailableAgents();
|
|
if (detectedAgents.length === 0) {
|
|
logger.warn("No supported agents detected.");
|
|
return false;
|
|
}
|
|
let selectedAgents = detectedAgents;
|
|
if (!yes) {
|
|
const { confirmed } = await prompts({
|
|
type: "confirm",
|
|
name: "confirmed",
|
|
message: `Install the React Grab skill (${global ? "global" : "this project"})?`,
|
|
initial: true
|
|
});
|
|
if (!confirmed) return false;
|
|
const { agents } = await prompts({
|
|
type: "multiselect",
|
|
name: "agents",
|
|
message: `Install the React Grab skill (${global ? "global" : "this project"}) for:`,
|
|
choices: detectedAgents.map((agent) => ({
|
|
title: agentLabel(agent),
|
|
value: agent,
|
|
selected: true
|
|
})),
|
|
instructions: false,
|
|
min: 1
|
|
});
|
|
selectedAgents = agents ?? [];
|
|
if (selectedAgents.length === 0) return false;
|
|
}
|
|
const installSpinner = spinner("Installing React Grab skill.").start();
|
|
const { installed, failed } = await installSkill({
|
|
agents: selectedAgents,
|
|
global,
|
|
cwd
|
|
});
|
|
if (installed.length === 0) {
|
|
installSpinner.fail("Failed to install React Grab skill.");
|
|
return false;
|
|
}
|
|
installSpinner.succeed(`Installed React Grab skill for ${installed.map((record) => agentLabel(record.agent)).join(", ")}.`);
|
|
for (const record of failed) logger.log(` ${highlighter.error("✗")} ${agentLabel(record.agent)} ${record.error}`);
|
|
return true;
|
|
};
|
|
//#endregion
|
|
//#region src/commands/add.ts
|
|
const VERSION$5 = "0.1.50";
|
|
const add = new Command().name("add").alias("install").description("install the React Grab skill for your agent").option("-y, --yes", "skip confirmation prompts", false).option("-c, --cwd <cwd>", "working directory (defaults to current directory)", process.cwd()).option("-g, --global", "install the skill globally instead of in the project", false).action(async (opts) => {
|
|
console.log(`${pc.magenta("✿")} ${pc.bold("React Grab")} ${pc.gray(VERSION$5)}`);
|
|
console.log();
|
|
try {
|
|
const isNonInteractive = detectNonInteractive(opts.yes);
|
|
const preflightSpinner = spinner("Preflight checks.").start();
|
|
if (!(await detectProject(opts.cwd)).hasReactGrab) {
|
|
preflightSpinner.fail("React Grab is not installed.");
|
|
logger.break();
|
|
logger.error(`Run ${highlighter.info("react-grab init")} first to install React Grab.`);
|
|
logger.break();
|
|
process.exit(1);
|
|
}
|
|
preflightSpinner.succeed();
|
|
logger.break();
|
|
if (!await promptSkillInstall({
|
|
yes: isNonInteractive,
|
|
global: opts.global,
|
|
cwd: resolve(opts.cwd)
|
|
}) && isNonInteractive) {
|
|
logger.break();
|
|
process.exit(1);
|
|
}
|
|
logger.break();
|
|
} catch (error) {
|
|
handleError(error);
|
|
}
|
|
});
|
|
//#endregion
|
|
//#region src/utils/diff.ts
|
|
const RED = "\x1B[31m";
|
|
const GREEN = "\x1B[32m";
|
|
const GRAY = "\x1B[90m";
|
|
const RESET = "\x1B[0m";
|
|
const BOLD = "\x1B[1m";
|
|
const generateDiff = (originalContent, newContent) => {
|
|
const originalLines = originalContent.split("\n");
|
|
const newLines = newContent.split("\n");
|
|
const diff = [];
|
|
let originalIndex = 0;
|
|
let newIndex = 0;
|
|
while (originalIndex < originalLines.length || newIndex < newLines.length) {
|
|
const originalLine = originalLines[originalIndex];
|
|
const newLine = newLines[newIndex];
|
|
if (originalLine === newLine) {
|
|
diff.push({
|
|
type: "unchanged",
|
|
content: originalLine,
|
|
lineNumber: newIndex + 1
|
|
});
|
|
originalIndex++;
|
|
newIndex++;
|
|
} else if (originalLine === void 0) {
|
|
diff.push({
|
|
type: "added",
|
|
content: newLine,
|
|
lineNumber: newIndex + 1
|
|
});
|
|
newIndex++;
|
|
} else if (newLine === void 0) {
|
|
diff.push({
|
|
type: "removed",
|
|
content: originalLine
|
|
});
|
|
originalIndex++;
|
|
} else {
|
|
const originalInNew = newLines.indexOf(originalLine, newIndex);
|
|
const newInOriginal = originalLines.indexOf(newLine, originalIndex);
|
|
if (originalInNew !== -1 && (newInOriginal === -1 || originalInNew - newIndex < newInOriginal - originalIndex)) while (newIndex < originalInNew) {
|
|
diff.push({
|
|
type: "added",
|
|
content: newLines[newIndex],
|
|
lineNumber: newIndex + 1
|
|
});
|
|
newIndex++;
|
|
}
|
|
else if (newInOriginal !== -1) while (originalIndex < newInOriginal) {
|
|
diff.push({
|
|
type: "removed",
|
|
content: originalLines[originalIndex]
|
|
});
|
|
originalIndex++;
|
|
}
|
|
else {
|
|
diff.push({
|
|
type: "removed",
|
|
content: originalLine
|
|
});
|
|
diff.push({
|
|
type: "added",
|
|
content: newLine,
|
|
lineNumber: newIndex + 1
|
|
});
|
|
originalIndex++;
|
|
newIndex++;
|
|
}
|
|
}
|
|
}
|
|
return diff;
|
|
};
|
|
const formatDiff = (diff, contextLines = 3) => {
|
|
const lines = [];
|
|
let lastPrintedIndex = -1;
|
|
let hasChanges = false;
|
|
const changedIndices = diff.map((line, index) => line.type !== "unchanged" ? index : -1).filter((index) => index !== -1);
|
|
if (changedIndices.length === 0) return `${GRAY}No changes${RESET}`;
|
|
for (const changedIndex of changedIndices) {
|
|
const startContext = Math.max(0, changedIndex - contextLines);
|
|
const endContext = Math.min(diff.length - 1, changedIndex + contextLines);
|
|
if (startContext > lastPrintedIndex + 1 && lastPrintedIndex !== -1) lines.push(`${GRAY} ...${RESET}`);
|
|
for (let lineIndex = Math.max(startContext, lastPrintedIndex + 1); lineIndex <= endContext; lineIndex++) {
|
|
const diffLine = diff[lineIndex];
|
|
if (diffLine.type === "added") {
|
|
lines.push(`${GREEN}+ ${diffLine.content}${RESET}`);
|
|
hasChanges = true;
|
|
} else if (diffLine.type === "removed") {
|
|
lines.push(`${RED}- ${diffLine.content}${RESET}`);
|
|
hasChanges = true;
|
|
} else lines.push(`${GRAY} ${diffLine.content}${RESET}`);
|
|
lastPrintedIndex = lineIndex;
|
|
}
|
|
}
|
|
return hasChanges ? lines.join("\n") : `${GRAY}No changes${RESET}`;
|
|
};
|
|
const printDiff = (filePath, originalContent, newContent) => {
|
|
console.log(`\n${BOLD}File: ${filePath}${RESET}`);
|
|
console.log("─".repeat(60));
|
|
const diff = generateDiff(originalContent, newContent);
|
|
console.log(formatDiff(diff));
|
|
console.log("─".repeat(60));
|
|
};
|
|
//#endregion
|
|
//#region src/utils/cli-helpers.ts
|
|
const applyTransformWithFeedback = (result, message) => {
|
|
const writeSpinner = spinner(message ?? `Applying changes to ${result.filePath}.`).start();
|
|
const writeResult = applyTransform(result);
|
|
if (!writeResult.success) {
|
|
writeSpinner.fail();
|
|
logger.break();
|
|
logger.error(writeResult.error || "Failed to write file.");
|
|
logger.break();
|
|
process.exit(1);
|
|
}
|
|
writeSpinner.succeed();
|
|
};
|
|
const installPackagesWithFeedback = async (packages, packageManager, projectRoot) => {
|
|
if (packages.length === 0) return;
|
|
const installSpinner = spinner(`Installing ${packages.join(", ")}.`).start();
|
|
try {
|
|
await installPackages(packages, {
|
|
packageManager,
|
|
cwd: projectRoot
|
|
});
|
|
installSpinner.succeed();
|
|
} catch (error) {
|
|
installSpinner.fail();
|
|
handleError(error);
|
|
}
|
|
};
|
|
//#endregion
|
|
//#region src/utils/constants.ts
|
|
const MAX_KEY_HOLD_DURATION_MS = 2e3;
|
|
const DEFAULT_WATCH_DIR = ".react-grab";
|
|
const DEFAULT_GRAB_AGE_MS = 300 * 1e3;
|
|
const MAX_READ_HISTORY_BYTES = 128 * 1024 * 1024;
|
|
const MIGRATION_SCAN_CHUNK_BYTES = 1024 * 1024;
|
|
//#endregion
|
|
//#region src/utils/format-activation-key.ts
|
|
const formatActivationKeyDisplay = (activationKey) => {
|
|
const defaultLabel = process.platform === "darwin" ? "Option" : "Alt";
|
|
if (!activationKey) return `Default (${defaultLabel})`;
|
|
return activationKey.split("+").map((part) => {
|
|
const lower = part.toLowerCase();
|
|
if (lower === "meta") return process.platform === "darwin" ? "⌘" : "Win";
|
|
if (lower === "alt") return process.platform === "darwin" ? "⌥" : "Alt";
|
|
if (lower === "ctrl") return "Ctrl";
|
|
if (lower === "shift") return "Shift";
|
|
if (lower === "space" || lower === " ") return "Space";
|
|
return part.toUpperCase();
|
|
}).join(" + ");
|
|
};
|
|
//#endregion
|
|
//#region src/commands/configure.ts
|
|
const VERSION$4 = "0.1.50";
|
|
const isMac = process.platform === "darwin";
|
|
const META_LABEL = isMac ? "Cmd" : "Win";
|
|
const ALT_LABEL = isMac ? "Option" : "Alt";
|
|
const MODIFIER_ALIASES = {
|
|
cmd: "meta",
|
|
command: "meta",
|
|
win: "meta",
|
|
windows: "meta",
|
|
meta: "meta",
|
|
ctrl: "ctrl",
|
|
control: "ctrl",
|
|
shift: "shift",
|
|
alt: "alt",
|
|
option: "alt",
|
|
opt: "alt"
|
|
};
|
|
const MODIFIERS = [
|
|
"meta",
|
|
"ctrl",
|
|
"shift",
|
|
"alt"
|
|
];
|
|
const BASE_KEYS = [
|
|
{
|
|
key: " ",
|
|
aliases: ["space", "spacebar"]
|
|
},
|
|
{
|
|
key: "Enter",
|
|
aliases: ["enter", "return"]
|
|
},
|
|
{
|
|
key: "Escape",
|
|
aliases: ["escape", "esc"]
|
|
},
|
|
{
|
|
key: "Tab",
|
|
aliases: ["tab"]
|
|
},
|
|
{
|
|
key: "Backspace",
|
|
aliases: ["backspace", "back"]
|
|
},
|
|
{
|
|
key: "Delete",
|
|
aliases: ["delete", "del"]
|
|
},
|
|
{
|
|
key: "Insert",
|
|
aliases: ["insert", "ins"]
|
|
},
|
|
{
|
|
key: "Home",
|
|
aliases: ["home"]
|
|
},
|
|
{
|
|
key: "End",
|
|
aliases: ["end"]
|
|
},
|
|
{
|
|
key: "PageUp",
|
|
aliases: ["pageup", "pgup"]
|
|
},
|
|
{
|
|
key: "PageDown",
|
|
aliases: [
|
|
"pagedown",
|
|
"pgdn",
|
|
"pgdown"
|
|
]
|
|
},
|
|
{
|
|
key: "ArrowUp",
|
|
aliases: ["arrowup", "up"]
|
|
},
|
|
{
|
|
key: "ArrowDown",
|
|
aliases: ["arrowdown", "down"]
|
|
},
|
|
{
|
|
key: "ArrowLeft",
|
|
aliases: ["arrowleft", "left"]
|
|
},
|
|
{
|
|
key: "ArrowRight",
|
|
aliases: ["arrowright", "right"]
|
|
},
|
|
...Array.from({ length: 12 }, (_, i) => ({
|
|
key: `F${i + 1}`,
|
|
aliases: [`f${i + 1}`]
|
|
})),
|
|
...Array.from({ length: 26 }, (_, i) => {
|
|
const letter = String.fromCharCode(97 + i);
|
|
return {
|
|
key: letter,
|
|
aliases: [letter]
|
|
};
|
|
}),
|
|
...Array.from({ length: 10 }, (_, i) => ({
|
|
key: String(i),
|
|
aliases: [String(i)]
|
|
})),
|
|
{
|
|
key: "`",
|
|
aliases: [
|
|
"backtick",
|
|
"grave",
|
|
"`"
|
|
]
|
|
},
|
|
{
|
|
key: "-",
|
|
aliases: [
|
|
"minus",
|
|
"dash",
|
|
"-"
|
|
]
|
|
},
|
|
{
|
|
key: "=",
|
|
aliases: [
|
|
"equals",
|
|
"equal",
|
|
"="
|
|
]
|
|
},
|
|
{
|
|
key: "[",
|
|
aliases: [
|
|
"leftbracket",
|
|
"lbracket",
|
|
"["
|
|
]
|
|
},
|
|
{
|
|
key: "]",
|
|
aliases: [
|
|
"rightbracket",
|
|
"rbracket",
|
|
"]"
|
|
]
|
|
},
|
|
{
|
|
key: "\\",
|
|
aliases: ["backslash", "\\"]
|
|
},
|
|
{
|
|
key: ";",
|
|
aliases: ["semicolon", ";"]
|
|
},
|
|
{
|
|
key: "'",
|
|
aliases: [
|
|
"quote",
|
|
"apostrophe",
|
|
"'"
|
|
]
|
|
},
|
|
{
|
|
key: ",",
|
|
aliases: ["comma", ","]
|
|
},
|
|
{
|
|
key: ".",
|
|
aliases: [
|
|
"period",
|
|
"dot",
|
|
"."
|
|
]
|
|
},
|
|
{
|
|
key: "/",
|
|
aliases: [
|
|
"slash",
|
|
"forwardslash",
|
|
"/"
|
|
]
|
|
}
|
|
];
|
|
const formatCombo = (combo) => {
|
|
const parts = [];
|
|
if (combo.metaKey) parts.push(META_LABEL);
|
|
if (combo.ctrlKey) parts.push("Ctrl");
|
|
if (combo.shiftKey) parts.push("Shift");
|
|
if (combo.altKey) parts.push(ALT_LABEL);
|
|
const keyDisplay = combo.key === " " ? "Space" : combo.key.length === 1 ? combo.key.toUpperCase() : combo.key;
|
|
parts.push(keyDisplay);
|
|
return parts.join("+");
|
|
};
|
|
const parseInput = (input) => {
|
|
const parts = input.toLowerCase().replace(/\s+/g, "").split(/[+-]/);
|
|
const modifiers = /* @__PURE__ */ new Set();
|
|
let partial = "";
|
|
for (const part of parts) {
|
|
if (!part) continue;
|
|
const modifierKey = MODIFIER_ALIASES[part];
|
|
if (modifierKey) modifiers.add(modifierKey);
|
|
else partial = part;
|
|
}
|
|
return {
|
|
modifiers,
|
|
partial
|
|
};
|
|
};
|
|
const POPULAR_KEYS = [
|
|
"g",
|
|
"k",
|
|
"e",
|
|
"d",
|
|
"b",
|
|
" ",
|
|
"Escape",
|
|
"Enter"
|
|
];
|
|
const generateSuggestions = (input) => {
|
|
const { modifiers, partial } = parseInput(input);
|
|
const suggestions = [];
|
|
if (!partial && modifiers.size === 0 && !input) {
|
|
for (const mod of MODIFIERS) {
|
|
const label = mod === "meta" ? META_LABEL : mod === "alt" ? ALT_LABEL : mod.charAt(0).toUpperCase() + mod.slice(1);
|
|
for (const popularKey of POPULAR_KEYS) {
|
|
const keyDisplay = popularKey === " " ? "Space" : popularKey.length === 1 ? popularKey.toUpperCase() : popularKey;
|
|
suggestions.push({
|
|
title: `${label}+${keyDisplay}`,
|
|
value: {
|
|
key: popularKey,
|
|
...mod === "meta" ? { metaKey: true } : {},
|
|
...mod === "ctrl" ? { ctrlKey: true } : {},
|
|
...mod === "shift" ? { shiftKey: true } : {},
|
|
...mod === "alt" ? { altKey: true } : {}
|
|
}
|
|
});
|
|
}
|
|
}
|
|
for (const baseKey of BASE_KEYS) suggestions.push({
|
|
title: baseKey.key === " " ? "Space" : baseKey.key.length === 1 ? baseKey.key.toUpperCase() : baseKey.key,
|
|
value: { key: baseKey.key }
|
|
});
|
|
return suggestions;
|
|
}
|
|
const buildCombo = (key, mods, extraMod) => ({
|
|
key,
|
|
...mods.has("meta") || extraMod === "meta" ? { metaKey: true } : {},
|
|
...mods.has("ctrl") || extraMod === "ctrl" ? { ctrlKey: true } : {},
|
|
...mods.has("shift") || extraMod === "shift" ? { shiftKey: true } : {},
|
|
...mods.has("alt") || extraMod === "alt" ? { altKey: true } : {}
|
|
});
|
|
for (const baseKey of BASE_KEYS) if (partial ? baseKey.aliases.some((alias) => alias.startsWith(partial)) : true) {
|
|
const combo = buildCombo(baseKey.key, modifiers);
|
|
suggestions.push({
|
|
title: formatCombo(combo),
|
|
value: combo
|
|
});
|
|
}
|
|
if (!partial) {
|
|
const unusedMods = MODIFIERS.filter((m) => !modifiers.has(m));
|
|
for (const mod of unusedMods) for (const popularKey of POPULAR_KEYS) {
|
|
const combo = buildCombo(popularKey, modifiers, mod);
|
|
suggestions.push({
|
|
title: formatCombo(combo),
|
|
value: combo
|
|
});
|
|
}
|
|
}
|
|
return suggestions.slice(0, 30);
|
|
};
|
|
const CONFIG_OPTIONS = [
|
|
{
|
|
id: "activationKey",
|
|
title: "Shortcut",
|
|
description: "The shortcut used to activate React Grab (e.g., g, k, space)"
|
|
},
|
|
{
|
|
id: "activationMode",
|
|
title: "Activation Mode",
|
|
description: "Toggle (press to activate/deactivate) or Hold (hold key)"
|
|
},
|
|
{
|
|
id: "keyHoldDuration",
|
|
title: "Key Hold Duration",
|
|
description: "Milliseconds to hold the key before activation (hold mode)"
|
|
},
|
|
{
|
|
id: "allowActivationInsideInput",
|
|
title: "Allow Activation Inside Input",
|
|
description: "Whether to allow activation when focused on input fields"
|
|
},
|
|
{
|
|
id: "maxContextLines",
|
|
title: "Max Context Lines",
|
|
description: "Max source-location lines in copied context (raise for large apps)"
|
|
}
|
|
];
|
|
const comboToString = (combo) => {
|
|
const parts = [];
|
|
if (combo.metaKey) parts.push("Meta");
|
|
if (combo.ctrlKey) parts.push("Ctrl");
|
|
if (combo.shiftKey) parts.push("Shift");
|
|
if (combo.altKey) parts.push("Alt");
|
|
if (combo.key) {
|
|
const keyDisplay = combo.key === " " ? "Space" : combo.key;
|
|
parts.push(keyDisplay);
|
|
}
|
|
return parts.join("+");
|
|
};
|
|
const configure = new Command().name("configure").alias("config").description("configure React Grab options").option("-y, --yes", "skip confirmation prompts", false).option("-k, --key <key>", "shortcut (e.g., Meta+K, Ctrl+Shift+G, Space)").option("-m, --mode <mode>", "activation mode (toggle, hold)").option("--hold-duration <ms>", "key hold duration in milliseconds (for hold mode)").option("--allow-input <boolean>", "allow activation inside input fields (true/false)").option("--context-lines <lines>", "max context lines to include").option("--cdn <domain>", "CDN domain (e.g., unpkg.com, custom.react-grab.com)").option("-c, --cwd <cwd>", "working directory (defaults to current directory)", process.cwd()).action(async (opts) => {
|
|
console.log(`${pc.magenta("✿")} ${pc.bold("React Grab")} ${pc.gray(VERSION$4)}`);
|
|
console.log();
|
|
try {
|
|
const cwd = opts.cwd;
|
|
const preflightSpinner = spinner("Preflight checks.").start();
|
|
const projectInfo = await detectProject(cwd);
|
|
if (!projectInfo.hasReactGrab) {
|
|
preflightSpinner.fail("React Grab is not installed.");
|
|
logger.break();
|
|
logger.error(`Run ${highlighter.info("react-grab init")} first to install React Grab.`);
|
|
logger.break();
|
|
process.exit(1);
|
|
}
|
|
if (!projectInfo.isReactGrabConfigured) {
|
|
preflightSpinner.fail("React Grab is installed, but setup is missing.");
|
|
logger.break();
|
|
logger.error(`Run ${highlighter.info("react-grab init")} to add the setup script/import before configuring options.`);
|
|
logger.break();
|
|
process.exit(1);
|
|
}
|
|
preflightSpinner.succeed();
|
|
if (opts.cdn) {
|
|
const result = previewCdnTransform(projectInfo.projectRoot, projectInfo.framework, projectInfo.nextRouterType, opts.cdn);
|
|
if (!result.success) {
|
|
logger.break();
|
|
logger.error(result.message);
|
|
logger.break();
|
|
process.exit(1);
|
|
}
|
|
if (result.noChanges) {
|
|
logger.break();
|
|
logger.log("No changes needed.");
|
|
logger.break();
|
|
process.exit(0);
|
|
}
|
|
logger.break();
|
|
printDiff(result.filePath, result.originalContent, result.newContent);
|
|
if (!opts.yes) {
|
|
logger.break();
|
|
const { proceed } = await prompts({
|
|
type: "confirm",
|
|
name: "proceed",
|
|
message: "Apply these changes?",
|
|
initial: true
|
|
});
|
|
if (!proceed) {
|
|
logger.break();
|
|
logger.log("Changes cancelled.");
|
|
logger.break();
|
|
process.exit(0);
|
|
}
|
|
}
|
|
applyTransformWithFeedback(result);
|
|
logger.break();
|
|
logger.log(`${highlighter.success("Success!")} CDN updated.`);
|
|
logger.break();
|
|
return;
|
|
}
|
|
const hasFlags = opts.key || opts.mode || opts.holdDuration || opts.allowInput || opts.contextLines;
|
|
logger.break();
|
|
logger.log(`Configure ${highlighter.info("React Grab")} options:`);
|
|
logger.break();
|
|
const collectedOptions = {};
|
|
if (hasFlags) {
|
|
if (opts.key) {
|
|
collectedOptions.activationKey = opts.key;
|
|
logger.log(` Shortcut: ${highlighter.info(formatActivationKeyDisplay(collectedOptions.activationKey))}`);
|
|
}
|
|
if (opts.mode) {
|
|
if (opts.mode !== "toggle" && opts.mode !== "hold") {
|
|
logger.error(`Invalid mode: ${opts.mode}. Use "toggle" or "hold".`);
|
|
logger.break();
|
|
process.exit(1);
|
|
}
|
|
collectedOptions.activationMode = opts.mode;
|
|
logger.log(` Activation mode: ${highlighter.info(opts.mode)}`);
|
|
}
|
|
if (opts.holdDuration) {
|
|
const duration = parseInt(opts.holdDuration, 10);
|
|
if (isNaN(duration) || duration < 0 || duration > 2e3) {
|
|
logger.error(`Invalid hold duration. Must be 0-${MAX_KEY_HOLD_DURATION_MS}ms.`);
|
|
logger.break();
|
|
process.exit(1);
|
|
}
|
|
collectedOptions.keyHoldDuration = duration;
|
|
logger.log(` Key hold duration: ${highlighter.info(`${duration}ms`)}`);
|
|
}
|
|
if (opts.allowInput !== void 0) {
|
|
const allowInput = opts.allowInput === "true" || opts.allowInput === true;
|
|
collectedOptions.allowActivationInsideInput = allowInput;
|
|
logger.log(` Allow activation inside input: ${highlighter.info(String(allowInput))}`);
|
|
}
|
|
if (opts.contextLines) {
|
|
const lines = parseInt(opts.contextLines, 10);
|
|
if (isNaN(lines) || lines < 0 || lines > 50) {
|
|
logger.error(`Invalid context lines. Must be 0-50.`);
|
|
logger.break();
|
|
process.exit(1);
|
|
}
|
|
collectedOptions.maxContextLines = lines;
|
|
logger.log(` Max context lines: ${highlighter.info(String(lines))}`);
|
|
}
|
|
} else {
|
|
const { selectedOption } = await prompts({
|
|
type: "autocomplete",
|
|
name: "selectedOption",
|
|
message: "Search for an option to configure:",
|
|
choices: CONFIG_OPTIONS.map((option) => ({
|
|
title: option.title,
|
|
value: option.id,
|
|
description: option.description
|
|
})),
|
|
suggest: (input, choices) => Promise.resolve(choices.filter((choice) => choice.title.toLowerCase().includes(input.toLowerCase()) || (choice.description?.toLowerCase().includes(input.toLowerCase()) ?? false)))
|
|
});
|
|
if (selectedOption === void 0) {
|
|
logger.break();
|
|
process.exit(1);
|
|
}
|
|
if (selectedOption === "activationKey") {
|
|
const { selectedCombo } = await prompts({
|
|
type: "autocomplete",
|
|
name: "selectedCombo",
|
|
message: "Type key combination (e.g. ctrl+shift+g):",
|
|
choices: generateSuggestions(""),
|
|
suggest: (input) => Promise.resolve(generateSuggestions(input))
|
|
});
|
|
if (selectedCombo === void 0) {
|
|
logger.break();
|
|
process.exit(1);
|
|
}
|
|
collectedOptions.activationKey = comboToString(selectedCombo);
|
|
logger.log(` Shortcut: ${highlighter.info(formatActivationKeyDisplay(collectedOptions.activationKey))}`);
|
|
}
|
|
if (selectedOption === "activationMode") {
|
|
const { activationMode } = await prompts({
|
|
type: "select",
|
|
name: "activationMode",
|
|
message: `Select ${highlighter.info("activation mode")}:`,
|
|
choices: [{
|
|
title: "Toggle (press to activate/deactivate)",
|
|
value: "toggle"
|
|
}, {
|
|
title: "Hold (hold key to keep active)",
|
|
value: "hold"
|
|
}],
|
|
initial: 0
|
|
});
|
|
if (activationMode === void 0) {
|
|
logger.break();
|
|
process.exit(1);
|
|
}
|
|
collectedOptions.activationMode = activationMode;
|
|
}
|
|
if (selectedOption === "keyHoldDuration") {
|
|
const { keyHoldDuration } = await prompts({
|
|
type: "number",
|
|
name: "keyHoldDuration",
|
|
message: `Enter ${highlighter.info("key hold duration")} in milliseconds:`,
|
|
initial: 150,
|
|
min: 0,
|
|
max: 2e3
|
|
});
|
|
if (keyHoldDuration === void 0) {
|
|
logger.break();
|
|
process.exit(1);
|
|
}
|
|
collectedOptions.keyHoldDuration = keyHoldDuration;
|
|
}
|
|
if (selectedOption === "allowActivationInsideInput") {
|
|
const { allowActivationInsideInput } = await prompts({
|
|
type: "confirm",
|
|
name: "allowActivationInsideInput",
|
|
message: `Allow activation ${highlighter.info("inside input fields")}?`,
|
|
initial: true
|
|
});
|
|
if (allowActivationInsideInput === void 0) {
|
|
logger.break();
|
|
process.exit(1);
|
|
}
|
|
collectedOptions.allowActivationInsideInput = allowActivationInsideInput;
|
|
}
|
|
if (selectedOption === "maxContextLines") {
|
|
const { maxContextLines } = await prompts({
|
|
type: "number",
|
|
name: "maxContextLines",
|
|
message: `Enter ${highlighter.info("max context lines")} to include:`,
|
|
initial: 3,
|
|
min: 0,
|
|
max: 50
|
|
});
|
|
if (maxContextLines === void 0) {
|
|
logger.break();
|
|
process.exit(1);
|
|
}
|
|
collectedOptions.maxContextLines = maxContextLines;
|
|
}
|
|
}
|
|
const result = previewOptionsTransform(projectInfo.projectRoot, projectInfo.framework, projectInfo.nextRouterType, collectedOptions);
|
|
if (!result.success) {
|
|
logger.break();
|
|
logger.warn(result.message);
|
|
logger.break();
|
|
const configJson = JSON.stringify(collectedOptions);
|
|
logger.log(`Add this to your ${highlighter.info("init()")} call or ${highlighter.info("data-options")} attribute:`);
|
|
logger.break();
|
|
console.log(` ${pc.cyan(configJson)}`);
|
|
logger.break();
|
|
process.exit(1);
|
|
}
|
|
if (!result.noChanges && result.originalContent && result.newContent) {
|
|
logger.break();
|
|
printDiff(result.filePath, result.originalContent, result.newContent);
|
|
if (!opts.yes) {
|
|
logger.break();
|
|
const { proceed } = await prompts({
|
|
type: "confirm",
|
|
name: "proceed",
|
|
message: "Apply these changes?",
|
|
initial: true
|
|
});
|
|
if (!proceed) {
|
|
logger.break();
|
|
logger.log("Changes cancelled.");
|
|
logger.break();
|
|
process.exit(0);
|
|
}
|
|
}
|
|
applyTransformWithFeedback(result);
|
|
} else {
|
|
logger.break();
|
|
logger.log("No changes needed.");
|
|
}
|
|
logger.break();
|
|
logger.log(`${highlighter.success("Success!")} React Grab options have been configured.`);
|
|
logger.break();
|
|
} catch (error) {
|
|
handleError(error);
|
|
}
|
|
});
|
|
//#endregion
|
|
//#region src/utils/is-telemetry-enabled.ts
|
|
const isTelemetryEnabled = () => {
|
|
const doNotTrack = process.env.DO_NOT_TRACK;
|
|
return doNotTrack !== "1" && doNotTrack !== "true";
|
|
};
|
|
//#endregion
|
|
//#region src/commands/init.ts
|
|
const VERSION$3 = "0.1.50";
|
|
const REPORT_URL = "https://react-grab.com/api/report-cli";
|
|
const DOCS_URL = "https://github.com/aidenybai/react-grab";
|
|
const reportToCli = (type, config, error) => {
|
|
if (!isTelemetryEnabled()) return;
|
|
fetch(REPORT_URL, {
|
|
method: "POST",
|
|
headers: { "Content-Type": "application/json" },
|
|
body: JSON.stringify({
|
|
type,
|
|
version: VERSION$3,
|
|
config,
|
|
error: error ? {
|
|
message: error.message,
|
|
stack: error.stack
|
|
} : void 0,
|
|
timestamp: (/* @__PURE__ */ new Date()).toISOString()
|
|
})
|
|
}).catch(() => {});
|
|
};
|
|
const FRAMEWORK_NAMES = {
|
|
next: "Next.js",
|
|
vite: "Vite",
|
|
tanstack: "TanStack Start",
|
|
webpack: "Webpack",
|
|
unknown: "Unknown"
|
|
};
|
|
const PACKAGE_MANAGER_NAMES = {
|
|
npm: "npm",
|
|
yarn: "Yarn",
|
|
pnpm: "pnpm",
|
|
bun: "Bun"
|
|
};
|
|
const UNSUPPORTED_FRAMEWORK_NAMES = {
|
|
remix: "Remix",
|
|
astro: "Astro",
|
|
sveltekit: "SvelteKit",
|
|
gatsby: "Gatsby"
|
|
};
|
|
const sortProjectsByFramework = (projects) => [...projects].sort((projectA, projectB) => {
|
|
if (projectA.framework === "unknown" && projectB.framework !== "unknown") return 1;
|
|
if (projectA.framework !== "unknown" && projectB.framework === "unknown") return -1;
|
|
return 0;
|
|
});
|
|
const printSubprojects = (searchRoot, sortedProjects) => {
|
|
logger.break();
|
|
logger.log("Found the following projects:");
|
|
logger.break();
|
|
for (const project of sortedProjects) {
|
|
const frameworkLabel = project.framework !== "unknown" ? ` ${highlighter.dim(`(${FRAMEWORK_NAMES[project.framework]})`)}` : "";
|
|
const relativePath = relative(searchRoot, project.path);
|
|
logger.log(` ${highlighter.info(project.name)}${frameworkLabel} ${highlighter.dim(relativePath)}`);
|
|
}
|
|
logger.break();
|
|
logger.log(`Re-run with ${highlighter.info("-c <path>")} to specify a project:`);
|
|
logger.break();
|
|
logger.log(` ${highlighter.dim("$")} npx grab@latest init -c ${relative(searchRoot, sortedProjects[0].path)}`);
|
|
logger.break();
|
|
};
|
|
const SUPPORTED_FRAMEWORKS_LINE = "React Grab supports Next.js, Vite, TanStack Start, and Webpack projects.";
|
|
const failWithManualSetup = (failingSpinner, message, { listSupportedFrameworks = false } = {}) => {
|
|
failingSpinner.fail(message);
|
|
logger.break();
|
|
if (listSupportedFrameworks) logger.log(SUPPORTED_FRAMEWORKS_LINE);
|
|
logger.log(`Visit ${highlighter.info(DOCS_URL)} for manual setup.`);
|
|
logger.break();
|
|
process.exit(1);
|
|
};
|
|
const init = new Command().name("init").alias("setup").description("initialize React Grab in your project").option("-y, --yes", "skip confirmation prompts", false).option("-f, --force", "re-run setup checks even when React Grab is already configured", false).option("-k, --key <key>", "shortcut (e.g., Meta+K, Ctrl+Shift+G, Space)").option("--skip-install", "skip package installation", false).option("--pkg <pkg>", "custom package URL for CLI (e.g., grab)").option("-c, --cwd <cwd>", "working directory (defaults to current directory)", process.cwd()).option("-g, --global", "install the skill globally instead of in the project", false).action(async (opts) => {
|
|
console.log(`${pc.magenta("✿")} ${pc.bold("React Grab")} ${pc.gray(VERSION$3)}`);
|
|
console.log();
|
|
try {
|
|
const cwd = resolve(opts.cwd);
|
|
const isNonInteractive = detectNonInteractive(opts.yes);
|
|
if (!existsSync(cwd)) {
|
|
logger.break();
|
|
logger.error(`Directory does not exist: ${highlighter.info(cwd)}`);
|
|
logger.break();
|
|
process.exit(1);
|
|
}
|
|
const preflightSpinner = spinner("Preflight checks.").start();
|
|
const projectInfo = await detectProject(cwd);
|
|
if (projectInfo.isReactGrabConfigured && !opts.force) {
|
|
preflightSpinner.succeed();
|
|
if (isNonInteractive) {
|
|
logger.break();
|
|
logger.warn("React Grab is already installed.");
|
|
logger.log(`Use ${highlighter.info("--force")} to re-run setup checks, or remove ${highlighter.info("--yes")} for interactive mode.`);
|
|
logger.break();
|
|
process.exit(0);
|
|
}
|
|
logger.break();
|
|
logger.success("React Grab is already installed.");
|
|
logger.break();
|
|
const { wantCustomizeOptions } = await prompts({
|
|
type: "confirm",
|
|
name: "wantCustomizeOptions",
|
|
message: `Would you like to customize ${highlighter.info("options")}?`,
|
|
initial: false
|
|
});
|
|
if (wantCustomizeOptions === void 0) {
|
|
logger.break();
|
|
process.exit(1);
|
|
}
|
|
if (wantCustomizeOptions || opts.key) {
|
|
logger.break();
|
|
logger.log(`Configure ${highlighter.info("React Grab")} options:`);
|
|
logger.break();
|
|
const collectedOptions = {};
|
|
if (opts.key) {
|
|
collectedOptions.activationKey = opts.key;
|
|
logger.log(` Shortcut: ${highlighter.info(formatActivationKeyDisplay(collectedOptions.activationKey))}`);
|
|
} else {
|
|
const { wantActivationKey } = await prompts({
|
|
type: "confirm",
|
|
name: "wantActivationKey",
|
|
message: `Configure ${highlighter.info("shortcut")}?`,
|
|
initial: false
|
|
});
|
|
if (wantActivationKey === void 0) {
|
|
logger.break();
|
|
process.exit(1);
|
|
}
|
|
if (wantActivationKey) {
|
|
const { key } = await prompts({
|
|
type: "text",
|
|
name: "key",
|
|
message: "Enter the shortcut (e.g., g, k, space):",
|
|
initial: ""
|
|
});
|
|
if (key === void 0) {
|
|
logger.break();
|
|
process.exit(1);
|
|
}
|
|
collectedOptions.activationKey = key ? key.toLowerCase() : void 0;
|
|
logger.log(` Shortcut: ${highlighter.info(formatActivationKeyDisplay(collectedOptions.activationKey))}`);
|
|
}
|
|
}
|
|
const { activationMode } = await prompts({
|
|
type: "select",
|
|
name: "activationMode",
|
|
message: `Select ${highlighter.info("activation mode")}:`,
|
|
choices: [{
|
|
title: "Toggle (press to activate/deactivate)",
|
|
value: "toggle"
|
|
}, {
|
|
title: "Hold (hold key to keep active)",
|
|
value: "hold"
|
|
}],
|
|
initial: 0
|
|
});
|
|
if (activationMode === void 0) {
|
|
logger.break();
|
|
process.exit(1);
|
|
}
|
|
collectedOptions.activationMode = activationMode;
|
|
if (activationMode === "hold") {
|
|
const { keyHoldDuration } = await prompts({
|
|
type: "number",
|
|
name: "keyHoldDuration",
|
|
message: `Enter ${highlighter.info("key hold duration")} in milliseconds:`,
|
|
initial: 150,
|
|
min: 0,
|
|
max: 2e3
|
|
});
|
|
if (keyHoldDuration === void 0) {
|
|
logger.break();
|
|
process.exit(1);
|
|
}
|
|
collectedOptions.keyHoldDuration = keyHoldDuration;
|
|
}
|
|
const { allowActivationInsideInput } = await prompts({
|
|
type: "confirm",
|
|
name: "allowActivationInsideInput",
|
|
message: `Allow activation ${highlighter.info("inside input fields")}?`,
|
|
initial: true
|
|
});
|
|
if (allowActivationInsideInput === void 0) {
|
|
logger.break();
|
|
process.exit(1);
|
|
}
|
|
collectedOptions.allowActivationInsideInput = allowActivationInsideInput;
|
|
const { maxContextLines } = await prompts({
|
|
type: "number",
|
|
name: "maxContextLines",
|
|
message: `Enter ${highlighter.info("max context lines")} to include:`,
|
|
initial: 3,
|
|
min: 0,
|
|
max: 50
|
|
});
|
|
if (maxContextLines === void 0) {
|
|
logger.break();
|
|
process.exit(1);
|
|
}
|
|
collectedOptions.maxContextLines = maxContextLines;
|
|
const optionsResult = previewOptionsTransform(projectInfo.projectRoot, projectInfo.framework, projectInfo.nextRouterType, collectedOptions);
|
|
if (!optionsResult.success) {
|
|
logger.break();
|
|
logger.error(optionsResult.message);
|
|
logger.break();
|
|
process.exit(1);
|
|
}
|
|
if (!optionsResult.noChanges && optionsResult.originalContent && optionsResult.newContent) {
|
|
logger.break();
|
|
printDiff(optionsResult.filePath, optionsResult.originalContent, optionsResult.newContent);
|
|
logger.break();
|
|
const { proceed } = await prompts({
|
|
type: "confirm",
|
|
name: "proceed",
|
|
message: "Apply these changes?",
|
|
initial: true
|
|
});
|
|
if (!proceed) {
|
|
logger.break();
|
|
logger.log("Options configuration cancelled.");
|
|
} else {
|
|
applyTransformWithFeedback(optionsResult);
|
|
logger.break();
|
|
logger.success("React Grab options have been configured.");
|
|
}
|
|
} else {
|
|
logger.break();
|
|
logger.log("No option changes needed.");
|
|
}
|
|
}
|
|
logger.break();
|
|
await promptSkillInstall({
|
|
yes: isNonInteractive,
|
|
global: opts.global,
|
|
cwd
|
|
});
|
|
logger.break();
|
|
process.exit(0);
|
|
}
|
|
preflightSpinner.succeed();
|
|
const frameworkSpinner = spinner("Verifying framework.").start();
|
|
if (projectInfo.unsupportedFramework) {
|
|
const frameworkName = UNSUPPORTED_FRAMEWORK_NAMES[projectInfo.unsupportedFramework];
|
|
frameworkSpinner.fail(`Found ${highlighter.info(frameworkName)}.`);
|
|
logger.break();
|
|
logger.log(`${frameworkName} is not yet supported by automatic setup.`);
|
|
logger.log(`Visit ${highlighter.info(DOCS_URL)} for manual setup.`);
|
|
logger.break();
|
|
process.exit(1);
|
|
}
|
|
if (projectInfo.framework === "unknown" || projectInfo.isMonorepo && !hasFrameworkEntryPoint(projectInfo.projectRoot, projectInfo.framework, projectInfo.nextRouterType)) {
|
|
let searchRoot = cwd;
|
|
let reactProjects = findReactProjects(searchRoot);
|
|
if (reactProjects.length === 0 && cwd !== process.cwd()) {
|
|
searchRoot = process.cwd();
|
|
reactProjects = findReactProjects(searchRoot);
|
|
}
|
|
if (reactProjects.length > 0) {
|
|
frameworkSpinner.info(`Verifying framework. Found ${reactProjects.length} project${reactProjects.length === 1 ? "" : "s"}.`);
|
|
const sortedProjects = sortProjectsByFramework(reactProjects);
|
|
if (isNonInteractive) {
|
|
printSubprojects(searchRoot, sortedProjects);
|
|
process.exit(1);
|
|
}
|
|
logger.break();
|
|
const { selectedProject } = await prompts({
|
|
type: "select",
|
|
name: "selectedProject",
|
|
message: "Select a project to install React Grab:",
|
|
choices: [...sortedProjects.map((project) => {
|
|
const frameworkLabel = project.framework !== "unknown" ? ` ${highlighter.dim(`(${FRAMEWORK_NAMES[project.framework]})`)}` : "";
|
|
return {
|
|
title: `${project.name}${frameworkLabel}`,
|
|
value: project.path
|
|
};
|
|
}), {
|
|
title: "Skip",
|
|
value: "skip"
|
|
}]
|
|
});
|
|
if (!selectedProject || selectedProject === "skip") {
|
|
logger.break();
|
|
process.exit(0);
|
|
}
|
|
process.chdir(selectedProject);
|
|
const newProjectInfo = await detectProject(selectedProject);
|
|
Object.assign(projectInfo, newProjectInfo);
|
|
const newFrameworkSpinner = spinner("Verifying framework.").start();
|
|
if (newProjectInfo.framework === "unknown") failWithManualSetup(newFrameworkSpinner, "Could not detect a supported framework in this project.", { listSupportedFrameworks: true });
|
|
newFrameworkSpinner.succeed(`Verifying framework. Found ${highlighter.info(FRAMEWORK_NAMES[newProjectInfo.framework])}.`);
|
|
} else if (projectInfo.framework !== "unknown") failWithManualSetup(frameworkSpinner, `Verifying framework. Found ${highlighter.info(FRAMEWORK_NAMES[projectInfo.framework])}, but could not find an entry file.`);
|
|
else failWithManualSetup(frameworkSpinner, "Could not detect a supported framework.", { listSupportedFrameworks: true });
|
|
} else frameworkSpinner.succeed(`Verifying framework. Found ${highlighter.info(FRAMEWORK_NAMES[projectInfo.framework])}.`);
|
|
if (projectInfo.framework === "next") spinner("Detecting router type.").start().succeed(`Detecting router type. Found ${highlighter.info(projectInfo.nextRouterType === "app" ? "App Router" : "Pages Router")}.`);
|
|
spinner("Detecting package manager.").start().succeed(`Detecting package manager. Found ${highlighter.info(PACKAGE_MANAGER_NAMES[projectInfo.packageManager])}.`);
|
|
const finalFramework = projectInfo.framework;
|
|
const finalPackageManager = projectInfo.packageManager;
|
|
const finalNextRouterType = projectInfo.nextRouterType;
|
|
let didInstallSkill = false;
|
|
if (!isNonInteractive) {
|
|
logger.break();
|
|
didInstallSkill = await promptSkillInstall({
|
|
yes: isNonInteractive,
|
|
global: opts.global,
|
|
cwd
|
|
});
|
|
}
|
|
const result = previewTransform(projectInfo.projectRoot, finalFramework, finalNextRouterType, projectInfo.isReactGrabConfigured);
|
|
if (!result.success) {
|
|
logger.break();
|
|
logger.error(result.message);
|
|
logger.error(`Visit ${highlighter.info(DOCS_URL)} for manual setup.`);
|
|
logger.break();
|
|
process.exit(1);
|
|
}
|
|
const hasLayoutChanges = !result.noChanges && result.originalContent && result.newContent;
|
|
if (hasLayoutChanges) {
|
|
logger.break();
|
|
printDiff(result.filePath, result.originalContent, result.newContent);
|
|
logger.break();
|
|
logger.warn("Auto-detection may not be 100% accurate.");
|
|
logger.warn("Please verify the changes before committing.");
|
|
if (!isNonInteractive) {
|
|
logger.break();
|
|
const { proceed } = await prompts({
|
|
type: "confirm",
|
|
name: "proceed",
|
|
message: "Apply these changes?",
|
|
initial: true
|
|
});
|
|
if (!proceed) {
|
|
logger.break();
|
|
logger.log("Changes cancelled.");
|
|
logger.break();
|
|
process.exit(0);
|
|
}
|
|
}
|
|
}
|
|
const shouldInstallReactGrab = !projectInfo.hasReactGrab;
|
|
if (!opts.skipInstall && shouldInstallReactGrab) await installPackagesWithFeedback(getPackagesToInstall(shouldInstallReactGrab), finalPackageManager, projectInfo.projectRoot);
|
|
if (hasLayoutChanges) applyTransformWithFeedback(result);
|
|
logger.break();
|
|
if (hasLayoutChanges) logger.log(`${highlighter.success("Success!")} React Grab has been installed.`);
|
|
else logger.log(`${highlighter.success("Success!")} ${result.message}.`);
|
|
logger.log("You may now start your development server.");
|
|
logger.break();
|
|
reportToCli("completed", {
|
|
framework: finalFramework,
|
|
packageManager: finalPackageManager,
|
|
router: finalNextRouterType,
|
|
agent: didInstallSkill ? "skill" : void 0,
|
|
isMonorepo: projectInfo.isMonorepo
|
|
});
|
|
} catch (error) {
|
|
handleError(error);
|
|
reportToCli("error", void 0, error);
|
|
}
|
|
});
|
|
//#endregion
|
|
//#region src/utils/sleep.ts
|
|
const sleep = (durationMs) => new Promise((resolve) => setTimeout(resolve, durationMs));
|
|
//#endregion
|
|
//#region src/utils/clipboard.ts
|
|
const HISTORY_FILE_NAME = "history.jsonl";
|
|
const NO_READER_MESSAGE = "no clipboard reader available. Linux: install xclip or wl-clipboard. macOS: install Xcode CLI tools (swiftc) or rely on pbpaste. Windows: ensure PowerShell is on PATH.";
|
|
const READERS_DIR = path.dirname(fileURLToPath(import.meta.url));
|
|
const READ_TIMEOUT_MS = 2500;
|
|
const MAX_CLIPBOARD_BYTES = 64 * 1024 * 1024;
|
|
const ID_RADIX = 36;
|
|
const HASH_LENGTH = 12;
|
|
const PICKLE_HEADER_BYTES = 4;
|
|
const PICKLE_ALIGN_BYTES = 4;
|
|
const SIGNATURE_SCAN_CHARS = 32 * 1024;
|
|
const GRAB_MIME = "application/x-react-grab";
|
|
const CHROMIUM_CUSTOM_FORMAT = "chromium/x-web-custom-data";
|
|
const GRAB_TEXT_SIGNATURE = /\bin\s+\S+\s+\(at\s+[^\n]{1,400}?:\d+:\d+\)/;
|
|
const shortHash = (text) => createHash("sha1").update(text).digest("hex").slice(0, HASH_LENGTH);
|
|
const alignUp = (value) => value + PICKLE_ALIGN_BYTES - 1 & ~(PICKLE_ALIGN_BYTES - 1);
|
|
const parseChromiumPickle = (buffer) => {
|
|
const formats = {};
|
|
if (!buffer || buffer.length < PICKLE_HEADER_BYTES + 4) return formats;
|
|
let offset = PICKLE_HEADER_BYTES;
|
|
const pairCount = buffer.readUInt32LE(offset);
|
|
offset += 4;
|
|
for (let pairIndex = 0; pairIndex < pairCount; pairIndex += 1) {
|
|
if (offset + 4 > buffer.length) break;
|
|
const formatCodeUnits = buffer.readUInt32LE(offset);
|
|
offset += 4;
|
|
if (offset + formatCodeUnits * 2 > buffer.length) break;
|
|
const format = buffer.toString("utf16le", offset, offset + formatCodeUnits * 2);
|
|
offset = alignUp(offset + formatCodeUnits * 2);
|
|
if (offset + 4 > buffer.length) break;
|
|
const dataCodeUnits = buffer.readUInt32LE(offset);
|
|
offset += 4;
|
|
if (offset + dataCodeUnits * 2 > buffer.length) break;
|
|
const value = buffer.toString("utf16le", offset, offset + dataCodeUnits * 2);
|
|
offset = alignUp(offset + dataCodeUnits * 2);
|
|
formats[format] = value;
|
|
}
|
|
return formats;
|
|
};
|
|
const extractGrab = (raw) => {
|
|
if (raw.grab) return raw.grab;
|
|
if (raw.pickleBase64) return parseChromiumPickle(Buffer.from(raw.pickleBase64, "base64"))[GRAB_MIME];
|
|
};
|
|
const isGrabText = (text) => GRAB_TEXT_SIGNATURE.test(text.length > SIGNATURE_SCAN_CHARS ? text.slice(0, SIGNATURE_SCAN_CHARS) : text);
|
|
const extractPrompt = (record) => {
|
|
const comments = (Array.isArray(record.entries) ? record.entries : []).map((entry) => entry?.commentText?.trim?.()).filter(Boolean);
|
|
if (comments.length > 0) return comments.join("\n");
|
|
const lines = (typeof record.content === "string" ? record.content : "").split("\n");
|
|
const firstReferenceLine = lines.findIndex((line) => line.startsWith("["));
|
|
if (firstReferenceLine <= 0) return void 0;
|
|
return lines.slice(0, firstReferenceLine).join("\n").trim() || void 0;
|
|
};
|
|
const hasCommand = (name) => {
|
|
return spawnSync(process.platform === "win32" ? "where" : "which", [name], { stdio: "ignore" }).status === 0;
|
|
};
|
|
const runText = (command, args) => {
|
|
const output = spawnSync(command, args, {
|
|
encoding: "utf8",
|
|
maxBuffer: MAX_CLIPBOARD_BYTES,
|
|
timeout: READ_TIMEOUT_MS
|
|
});
|
|
return output.status === 0 ? output.stdout : null;
|
|
};
|
|
const runBuffer = (command, args) => {
|
|
const output = spawnSync(command, args, {
|
|
maxBuffer: MAX_CLIPBOARD_BYTES,
|
|
timeout: READ_TIMEOUT_MS
|
|
});
|
|
return output.status === 0 && output.stdout?.length ? output.stdout : null;
|
|
};
|
|
const runJson = (command, args) => {
|
|
const output = spawnSync(command, args, {
|
|
encoding: "utf8",
|
|
maxBuffer: MAX_CLIPBOARD_BYTES,
|
|
timeout: READ_TIMEOUT_MS
|
|
});
|
|
if (output.status !== 0 || !output.stdout) return null;
|
|
try {
|
|
return JSON.parse(output.stdout);
|
|
} catch {
|
|
return null;
|
|
}
|
|
};
|
|
const compileSwiftReader = (readersDir, workDir) => {
|
|
if (!hasCommand("swiftc")) return null;
|
|
const source = path.join(readersDir, "read-clipboard.swift");
|
|
if (!fs.existsSync(source)) return null;
|
|
const binary = path.join(workDir, "pbread");
|
|
if ((!fs.existsSync(binary) || fs.statSync(source).mtimeMs > fs.statSync(binary).mtimeMs) && spawnSync("swiftc", [
|
|
"-O",
|
|
source,
|
|
"-o",
|
|
binary
|
|
]).status !== 0) return null;
|
|
return binary;
|
|
};
|
|
const createDarwinReader = (options) => {
|
|
const binary = options.textOnly ? null : compileSwiftReader(READERS_DIR, options.workDir);
|
|
if (binary) return {
|
|
mode: "darwin-native",
|
|
read: () => {
|
|
const raw = runJson(binary, []);
|
|
if (!raw) return null;
|
|
return {
|
|
changeCount: raw.changeCount ?? null,
|
|
text: raw.text,
|
|
grab: extractGrab(raw)
|
|
};
|
|
}
|
|
};
|
|
if (!hasCommand("pbpaste")) return null;
|
|
return {
|
|
mode: "darwin-text",
|
|
read: () => {
|
|
const text = runText("pbpaste", []);
|
|
return text == null ? null : {
|
|
changeCount: null,
|
|
text,
|
|
grab: void 0
|
|
};
|
|
}
|
|
};
|
|
};
|
|
const detectLinuxTool = () => {
|
|
if (Boolean(process.env.WAYLAND_DISPLAY) && hasCommand("wl-paste") || hasCommand("wl-paste") && !hasCommand("xclip")) return {
|
|
name: "wl-paste",
|
|
readText: () => runText("wl-paste", [
|
|
"-n",
|
|
"-t",
|
|
"text/plain"
|
|
]) ?? runText("wl-paste", ["-n"]),
|
|
readCustom: () => runBuffer("wl-paste", [
|
|
"-n",
|
|
"-t",
|
|
CHROMIUM_CUSTOM_FORMAT
|
|
])
|
|
};
|
|
if (hasCommand("xclip")) return {
|
|
name: "xclip",
|
|
readText: () => runText("xclip", [
|
|
"-selection",
|
|
"clipboard",
|
|
"-o"
|
|
]),
|
|
readCustom: () => runBuffer("xclip", [
|
|
"-selection",
|
|
"clipboard",
|
|
"-t",
|
|
CHROMIUM_CUSTOM_FORMAT,
|
|
"-o"
|
|
])
|
|
};
|
|
if (hasCommand("xsel")) return {
|
|
name: "xsel",
|
|
readText: () => runText("xsel", ["--clipboard", "--output"]),
|
|
readCustom: null
|
|
};
|
|
return null;
|
|
};
|
|
const createLinuxReader = (options) => {
|
|
const tool = detectLinuxTool();
|
|
if (!tool) return null;
|
|
const useCustom = !options.textOnly && Boolean(tool.readCustom);
|
|
return {
|
|
mode: useCustom ? `linux-${tool.name}` : `linux-${tool.name}-text`,
|
|
read: () => {
|
|
const text = tool.readText();
|
|
if (text == null) return null;
|
|
return {
|
|
changeCount: null,
|
|
text,
|
|
grab: useCustom && tool.readCustom ? parseChromiumPickle(tool.readCustom())[GRAB_MIME] : void 0
|
|
};
|
|
}
|
|
};
|
|
};
|
|
const detectPowershell = () => hasCommand("pwsh") ? "pwsh" : hasCommand("powershell") ? "powershell" : null;
|
|
const createWindowsReader = (options) => {
|
|
const shell = detectPowershell();
|
|
if (!shell) return null;
|
|
const scriptPath = path.join(READERS_DIR, "read-clipboard.ps1");
|
|
if (options.textOnly || !fs.existsSync(scriptPath)) return {
|
|
mode: "win-text",
|
|
read: () => {
|
|
const text = runText(shell, [
|
|
"-NoProfile",
|
|
"-Command",
|
|
"Get-Clipboard -Raw"
|
|
]);
|
|
return text == null ? null : {
|
|
changeCount: null,
|
|
text,
|
|
grab: void 0
|
|
};
|
|
}
|
|
};
|
|
const args = [
|
|
"-NoProfile",
|
|
"-ExecutionPolicy",
|
|
"Bypass",
|
|
"-File",
|
|
scriptPath
|
|
];
|
|
spawnSync(shell, args, {
|
|
stdio: "ignore",
|
|
maxBuffer: MAX_CLIPBOARD_BYTES
|
|
});
|
|
return {
|
|
mode: "win-native",
|
|
read: () => {
|
|
const raw = runJson(shell, args);
|
|
if (!raw) return null;
|
|
return {
|
|
changeCount: raw.changeCount ?? null,
|
|
text: raw.text ?? void 0,
|
|
grab: extractGrab(raw)
|
|
};
|
|
}
|
|
};
|
|
};
|
|
const createReader = (options) => {
|
|
if (process.platform === "darwin") return createDarwinReader(options);
|
|
if (process.platform === "linux") return createLinuxReader(options);
|
|
if (process.platform === "win32") return createWindowsReader(options);
|
|
return null;
|
|
};
|
|
const ensureSafeDir = (dir) => {
|
|
let stats;
|
|
try {
|
|
stats = fs.lstatSync(dir);
|
|
} catch {
|
|
return;
|
|
}
|
|
if (stats.isSymbolicLink()) throw new Error(`Refusing to use ${dir}: it is a symlink.`);
|
|
if (process.getuid && stats.uid !== process.getuid()) throw new Error(`Refusing to use ${dir}: owned by another user.`);
|
|
};
|
|
const prepareWorkDir = (dir) => {
|
|
ensureSafeDir(dir);
|
|
fs.mkdirSync(dir, {
|
|
recursive: true,
|
|
mode: 448
|
|
});
|
|
const gitignore = path.join(dir, ".gitignore");
|
|
if (!fs.existsSync(gitignore)) fs.writeFileSync(gitignore, "*\n");
|
|
};
|
|
const runWatchLoop = async (options) => {
|
|
const { reader, dir, intervalMs, replayLast, onWarn } = options;
|
|
const logPath = path.join(dir, HISTORY_FILE_NAME);
|
|
const { read } = reader;
|
|
let lastChangeCount = null;
|
|
let lastTimestamp = 0;
|
|
let lastTextHash = "";
|
|
let lastErrorMessage = "";
|
|
let sequence = 0;
|
|
const initial = read();
|
|
if (initial && !replayLast) {
|
|
lastChangeCount = initial.changeCount;
|
|
if (initial.text) lastTextHash = shortHash(initial.text);
|
|
if (initial.grab) try {
|
|
lastTimestamp = JSON.parse(initial.grab).timestamp ?? 0;
|
|
} catch {}
|
|
}
|
|
while (true) {
|
|
await sleep(intervalMs);
|
|
try {
|
|
const snapshot = read();
|
|
if (!snapshot) continue;
|
|
if (snapshot.changeCount !== null && snapshot.changeCount === lastChangeCount) continue;
|
|
const textHash = snapshot.text ? shortHash(snapshot.text) : "";
|
|
const didTextChange = textHash !== lastTextHash;
|
|
let record = null;
|
|
let nextTimestamp = lastTimestamp;
|
|
if (snapshot.grab) {
|
|
let parsed = null;
|
|
try {
|
|
parsed = JSON.parse(snapshot.grab);
|
|
} catch {}
|
|
if (parsed && typeof parsed.timestamp === "number" && parsed.timestamp > lastTimestamp) {
|
|
nextTimestamp = parsed.timestamp;
|
|
record = {
|
|
source: "custom",
|
|
timestamp: parsed.timestamp,
|
|
version: typeof parsed.version === "string" ? parsed.version : void 0,
|
|
content: typeof parsed.content === "string" ? parsed.content : "",
|
|
entries: Array.isArray(parsed.entries) ? parsed.entries : []
|
|
};
|
|
}
|
|
} else if (didTextChange && snapshot.text && isGrabText(snapshot.text)) record = {
|
|
source: "text",
|
|
timestamp: Date.now(),
|
|
content: snapshot.text,
|
|
entries: []
|
|
};
|
|
if (!record) {
|
|
lastChangeCount = snapshot.changeCount;
|
|
lastTextHash = textHash;
|
|
continue;
|
|
}
|
|
const prompt = extractPrompt(record);
|
|
if (prompt) record.prompt = prompt;
|
|
const captured = {
|
|
id: `${record.timestamp}-${(sequence += 1).toString(ID_RADIX)}`,
|
|
receivedAt: Date.now(),
|
|
...record
|
|
};
|
|
fs.appendFileSync(logPath, `${JSON.stringify(captured)}\n`);
|
|
lastChangeCount = snapshot.changeCount;
|
|
lastTextHash = textHash;
|
|
lastTimestamp = nextTimestamp;
|
|
} catch (error) {
|
|
const message = String(error?.message ?? error);
|
|
if (message !== lastErrorMessage) {
|
|
lastErrorMessage = message;
|
|
onWarn?.(message);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
//#endregion
|
|
//#region src/utils/daemon.ts
|
|
const PID_FILE_NAME = "watch.pid";
|
|
const pidFilePath = (dir) => path.join(dir, PID_FILE_NAME);
|
|
const cliEntryPath = () => process.argv[1] ?? fileURLToPath(import.meta.url);
|
|
const isProcessAlive = (pid) => {
|
|
if (!Number.isInteger(pid) || pid <= 0) return false;
|
|
try {
|
|
process.kill(pid, 0);
|
|
return true;
|
|
} catch (error) {
|
|
return error.code === "EPERM";
|
|
}
|
|
};
|
|
const readDaemonPid = (dir) => {
|
|
try {
|
|
const pid = Number.parseInt(fs.readFileSync(pidFilePath(dir), "utf8").trim(), 10);
|
|
return Number.isInteger(pid) && pid > 0 ? pid : null;
|
|
} catch {
|
|
return null;
|
|
}
|
|
};
|
|
const isDaemonRunning = (dir) => {
|
|
const pid = readDaemonPid(dir);
|
|
return pid !== null && isProcessAlive(pid);
|
|
};
|
|
const claimDaemon = (dir) => {
|
|
const file = pidFilePath(dir);
|
|
for (let attempt = 0; attempt < 50; attempt += 1) try {
|
|
const handle = fs.openSync(file, "wx");
|
|
fs.writeFileSync(handle, String(process.pid));
|
|
fs.closeSync(handle);
|
|
return readDaemonPid(dir) === process.pid;
|
|
} catch (error) {
|
|
if (error.code !== "EEXIST") throw error;
|
|
if (isDaemonRunning(dir)) return false;
|
|
try {
|
|
fs.rmSync(file, { force: true });
|
|
} catch {}
|
|
}
|
|
return false;
|
|
};
|
|
const releaseDaemon = (dir) => {
|
|
if (readDaemonPid(dir) === process.pid) try {
|
|
fs.rmSync(pidFilePath(dir), { force: true });
|
|
} catch {}
|
|
};
|
|
const stopDaemon = (dir) => {
|
|
const pid = readDaemonPid(dir);
|
|
if (pid === null) return null;
|
|
const wasAlive = isProcessAlive(pid);
|
|
if (wasAlive) try {
|
|
process.kill(pid, "SIGTERM");
|
|
} catch {}
|
|
if (readDaemonPid(dir) === pid) try {
|
|
fs.rmSync(pidFilePath(dir), { force: true });
|
|
} catch {}
|
|
return wasAlive ? pid : null;
|
|
};
|
|
const spawnDaemon = (options) => {
|
|
const args = [
|
|
cliEntryPath(),
|
|
"watch",
|
|
"--dir",
|
|
options.dir,
|
|
"--interval",
|
|
String(options.intervalMs)
|
|
];
|
|
if (options.textOnly) args.push("--text-only");
|
|
if (options.replayLast) args.push("--replay-last");
|
|
spawn(process.execPath, args, {
|
|
detached: true,
|
|
stdio: "ignore",
|
|
windowsHide: true
|
|
}).unref();
|
|
};
|
|
const ensureDaemon = (options) => {
|
|
if (isDaemonRunning(options.dir)) return "already-running";
|
|
if (!createReader({
|
|
textOnly: options.textOnly,
|
|
workDir: options.dir
|
|
})) return "no-reader";
|
|
spawnDaemon(options);
|
|
return "started";
|
|
};
|
|
//#endregion
|
|
//#region src/utils/grab-log.ts
|
|
const CURSOR_FILE_NAME = "cursor.txt";
|
|
const NEWLINE_BYTE = 10;
|
|
const cursorFilePath = (dir) => path.join(dir, CURSOR_FILE_NAME);
|
|
const historyFilePath = (dir) => path.join(dir, HISTORY_FILE_NAME);
|
|
const fileSize = (filePath) => {
|
|
try {
|
|
return fs.statSync(filePath).size;
|
|
} catch {
|
|
return 0;
|
|
}
|
|
};
|
|
const readHistoryRange = (dir, start, length) => {
|
|
if (length <= 0) return "";
|
|
const fd = fs.openSync(historyFilePath(dir), "r");
|
|
try {
|
|
const buffer = Buffer.allocUnsafe(length);
|
|
const bytesRead = fs.readSync(fd, buffer, 0, length, start);
|
|
return buffer.toString("utf8", 0, bytesRead);
|
|
} finally {
|
|
fs.closeSync(fd);
|
|
}
|
|
};
|
|
const writeGrabCursor = (dir, offset) => {
|
|
const target = cursorFilePath(dir);
|
|
const tempPath = `${target}.${process.pid}.tmp`;
|
|
fs.writeFileSync(tempPath, JSON.stringify({ offset }));
|
|
fs.renameSync(tempPath, target);
|
|
};
|
|
const byteOffsetAfterLines = (dir, lineCount) => {
|
|
const filePath = historyFilePath(dir);
|
|
const size = fileSize(filePath);
|
|
if (lineCount <= 0 || size === 0) return 0;
|
|
const fd = fs.openSync(filePath, "r");
|
|
try {
|
|
const buffer = Buffer.allocUnsafe(MIGRATION_SCAN_CHUNK_BYTES);
|
|
let position = 0;
|
|
let seen = 0;
|
|
while (position < size) {
|
|
const bytesRead = fs.readSync(fd, buffer, 0, MIGRATION_SCAN_CHUNK_BYTES, position);
|
|
if (bytesRead <= 0) break;
|
|
for (let index = 0; index < bytesRead; index += 1) {
|
|
if (buffer[index] !== NEWLINE_BYTE) continue;
|
|
seen += 1;
|
|
if (seen === lineCount) return position + index + 1;
|
|
}
|
|
position += bytesRead;
|
|
}
|
|
} finally {
|
|
fs.closeSync(fd);
|
|
}
|
|
return size;
|
|
};
|
|
const readGrabCursor = (dir) => {
|
|
let raw;
|
|
try {
|
|
raw = fs.readFileSync(cursorFilePath(dir), "utf8").trim();
|
|
} catch {
|
|
return 0;
|
|
}
|
|
if (raw === "") return 0;
|
|
let parsed;
|
|
try {
|
|
parsed = JSON.parse(raw);
|
|
} catch {
|
|
return 0;
|
|
}
|
|
if (typeof parsed === "number") {
|
|
if (!Number.isInteger(parsed) || parsed < 0) return 0;
|
|
const offset = byteOffsetAfterLines(dir, parsed);
|
|
writeGrabCursor(dir, offset);
|
|
return offset;
|
|
}
|
|
return typeof parsed.offset === "number" && Number.isInteger(parsed.offset) && parsed.offset >= 0 ? parsed.offset : 0;
|
|
};
|
|
const readCompleteGrabLines = (dir) => {
|
|
const size = fileSize(historyFilePath(dir));
|
|
if (size === 0) return [];
|
|
const raw = readHistoryRange(dir, 0, size);
|
|
const lastNewline = raw.lastIndexOf("\n");
|
|
if (lastNewline < 0) return [];
|
|
return raw.slice(0, lastNewline).split("\n").filter(Boolean);
|
|
};
|
|
const consumeGrabs = (dir, options) => {
|
|
if (options.all) return readCompleteGrabLines(dir);
|
|
const size = fileSize(historyFilePath(dir));
|
|
const cursor = readGrabCursor(dir);
|
|
const start = cursor > size ? 0 : cursor;
|
|
if (start >= size) {
|
|
if (start !== cursor) writeGrabCursor(dir, start);
|
|
return [];
|
|
}
|
|
const chunk = readHistoryRange(dir, start, Math.min(size - start, MAX_READ_HISTORY_BYTES));
|
|
const lastNewline = chunk.lastIndexOf("\n");
|
|
if (lastNewline < 0) return [];
|
|
const now = Date.now();
|
|
const fresh = [];
|
|
let consumedBytes = 0;
|
|
let lineStart = 0;
|
|
while (lineStart <= lastNewline && (options.limit <= 0 || fresh.length < options.limit)) {
|
|
const newlineIndex = chunk.indexOf("\n", lineStart);
|
|
const line = chunk.slice(lineStart, newlineIndex);
|
|
consumedBytes += Buffer.byteLength(chunk.slice(lineStart, newlineIndex + 1), "utf8");
|
|
lineStart = newlineIndex + 1;
|
|
if (line.length === 0) continue;
|
|
let parsed;
|
|
try {
|
|
parsed = JSON.parse(line);
|
|
} catch {
|
|
continue;
|
|
}
|
|
if (options.maxAgeMs > 0 && typeof parsed.receivedAt === "number") {
|
|
if (now - parsed.receivedAt > options.maxAgeMs) continue;
|
|
}
|
|
fresh.push(line);
|
|
}
|
|
const nextCursor = start + consumedBytes;
|
|
if (nextCursor !== cursor) writeGrabCursor(dir, nextCursor);
|
|
return fresh;
|
|
};
|
|
//#endregion
|
|
//#region src/utils/read-args.ts
|
|
const parseWaitMs = (raw) => {
|
|
if (raw === void 0) return 0;
|
|
const trimmed = raw.trim();
|
|
if (trimmed === "") return 0;
|
|
if (/^(inf|infinite|infinity|forever)$/i.test(trimmed)) return Number.POSITIVE_INFINITY;
|
|
const ms = Number(trimmed);
|
|
return Number.isFinite(ms) && ms >= 0 ? ms : null;
|
|
};
|
|
const parseNonNegativeInt = (raw) => {
|
|
if (raw === void 0) return null;
|
|
const trimmed = raw.trim();
|
|
if (trimmed === "") return null;
|
|
const value = Number(trimmed);
|
|
return Number.isInteger(value) && value >= 0 ? value : null;
|
|
};
|
|
//#endregion
|
|
//#region src/commands/pull.ts
|
|
const fail = (message) => {
|
|
process.stderr.write(`react-grab pull: ${message}\n`);
|
|
process.exit(1);
|
|
};
|
|
const emitAndExit = (lines) => {
|
|
process.stdout.write(`${lines.join("\n")}\n`, () => process.exit(0));
|
|
};
|
|
const pull = new Command().name("pull").description("start the watcher if needed, then wait for and print the next React Grab grab(s)").option("-d, --dir <dir>", "work dir for history.jsonl + watch.pid", DEFAULT_WATCH_DIR).option("-w, --wait <ms>", "how long to wait for a grab: ms, 'infinite', or 0 for none", "infinite").option("-n, --limit <count>", "max grabs to print per call (0 = no limit)", String(50)).option("--max-age <ms>", "skip grabs captured longer ago than <ms> (0 = never)", String(DEFAULT_GRAB_AGE_MS)).option("--text-only", "watcher uses the plain-text clipboard reader (ignored if already running)").option("--all", "print the whole history without advancing the cursor").action(async (options) => {
|
|
const dir = path.resolve(options.dir);
|
|
try {
|
|
prepareWorkDir(dir);
|
|
} catch (error) {
|
|
fail(String(error?.message ?? error));
|
|
}
|
|
const waitMs = parseWaitMs(options.wait);
|
|
if (waitMs === null) fail(`invalid --wait "${options.wait}" (use milliseconds or "infinite")`);
|
|
const limit = parseNonNegativeInt(options.limit);
|
|
if (limit === null) fail(`invalid --limit "${options.limit}" (use a non-negative integer)`);
|
|
const maxAgeMs = parseNonNegativeInt(options.maxAge);
|
|
if (maxAgeMs === null) fail(`invalid --max-age "${options.maxAge}" (use milliseconds, 0 to disable)`);
|
|
const all = Boolean(options.all);
|
|
if (ensureDaemon({
|
|
dir,
|
|
intervalMs: 800,
|
|
textOnly: Boolean(options.textOnly),
|
|
replayLast: false
|
|
}) === "no-reader") fail(NO_READER_MESSAGE);
|
|
unrefStdin();
|
|
const consume = () => consumeGrabs(dir, {
|
|
limit,
|
|
all,
|
|
maxAgeMs
|
|
});
|
|
const first = consume();
|
|
if (first.length > 0) {
|
|
emitAndExit(first);
|
|
return;
|
|
}
|
|
const deadline = Date.now() + waitMs;
|
|
while (Date.now() < deadline) {
|
|
await sleep(200);
|
|
const batch = consume();
|
|
if (batch.length > 0) {
|
|
emitAndExit(batch);
|
|
return;
|
|
}
|
|
}
|
|
process.exit(0);
|
|
});
|
|
//#endregion
|
|
//#region src/commands/remove.ts
|
|
const VERSION$2 = "0.1.50";
|
|
const remove = new Command().name("remove").description("uninstall the React Grab skill from your agent").option("-c, --cwd <cwd>", "working directory (defaults to current directory)", process.cwd()).option("-g, --global", "remove the globally-installed skill instead of the project's", false).action(async (opts) => {
|
|
console.log(`${pc.magenta("✿")} ${pc.bold("React Grab")} ${pc.gray(VERSION$2)}`);
|
|
console.log();
|
|
try {
|
|
logger.break();
|
|
const removedAgents = await removeSkill({
|
|
cwd: resolve(opts.cwd),
|
|
global: opts.global
|
|
});
|
|
for (const agent of removedAgents) logger.log(` ${highlighter.success("✓")} ${agentLabel(agent)}`);
|
|
logger.break();
|
|
if (removedAgents.length === 0) logger.log("React Grab skill is not installed in any detected agent.");
|
|
else logger.log(`${highlighter.success("Removed")} the React Grab skill from ${removedAgents.length} agent${removedAgents.length === 1 ? "" : "s"}.`);
|
|
logger.break();
|
|
} catch (error) {
|
|
handleError(error);
|
|
}
|
|
});
|
|
//#endregion
|
|
//#region src/commands/stop.ts
|
|
const stop = new Command().name("stop").description("stop the React Grab watcher for this dir").option("-d, --dir <dir>", "work dir holding watch.pid", DEFAULT_WATCH_DIR).action((options) => {
|
|
const dir = path.resolve(options.dir);
|
|
const stoppedPid = stopDaemon(dir);
|
|
process.stderr.write(stoppedPid ? `react-grab stop: stopped watcher (pid ${stoppedPid})\n` : `react-grab stop: no watcher running for ${dir}\n`);
|
|
process.exit(0);
|
|
});
|
|
//#endregion
|
|
//#region src/commands/upgrade.ts
|
|
const VERSION$1 = "0.1.50";
|
|
const NPM_REGISTRY_URL = "https://registry.npmjs.org/react-grab/latest";
|
|
const fetchLatestVersion = async () => {
|
|
try {
|
|
return (await (await fetch(NPM_REGISTRY_URL)).json()).version ?? null;
|
|
} catch {
|
|
return null;
|
|
}
|
|
};
|
|
const isDevDependency = (projectRoot) => {
|
|
const packageJsonPath = join(projectRoot, "package.json");
|
|
if (!existsSync(packageJsonPath)) return true;
|
|
try {
|
|
const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
|
|
if (packageJson.devDependencies?.["react-grab"]) return true;
|
|
if (packageJson.dependencies?.["react-grab"]) return false;
|
|
} catch {}
|
|
return true;
|
|
};
|
|
const upgrade = new Command().name("upgrade").alias("update").description("upgrade react-grab to the latest version").option("-c, --cwd <cwd>", "working directory (defaults to current directory)", process.cwd()).action(async (opts) => {
|
|
console.log(`${pc.magenta("✿")} ${pc.bold("React Grab")} ${pc.gray(VERSION$1)}`);
|
|
console.log();
|
|
try {
|
|
const cwd = resolve(opts.cwd);
|
|
const detectSpinner = spinner("Detecting project.").start();
|
|
const projectInfo = await detectProject(cwd);
|
|
if (!projectInfo.hasReactGrab) {
|
|
detectSpinner.fail("React Grab is not installed.");
|
|
logger.break();
|
|
logger.error(`Run ${highlighter.info("npx grab@latest init")} first to install React Grab.`);
|
|
logger.break();
|
|
process.exit(1);
|
|
}
|
|
detectSpinner.succeed();
|
|
const versionSpinner = spinner("Checking for updates.").start();
|
|
const latestVersion = await fetchLatestVersion();
|
|
if (!latestVersion) {
|
|
versionSpinner.fail("Could not check for updates.");
|
|
logger.break();
|
|
logger.error("Failed to reach the npm registry. Check your network connection.");
|
|
logger.break();
|
|
process.exit(1);
|
|
}
|
|
const installedVersion = projectInfo.reactGrabVersion;
|
|
if (installedVersion && installedVersion === latestVersion) {
|
|
versionSpinner.succeed(`Already on the latest version ${highlighter.info(`v${latestVersion}`)}.`);
|
|
logger.break();
|
|
process.exit(0);
|
|
}
|
|
const fromLabel = installedVersion ? `v${installedVersion}` : "unknown";
|
|
versionSpinner.succeed(`Update available: ${highlighter.dim(fromLabel)} → ${highlighter.info(`v${latestVersion}`)}.`);
|
|
const upgradeSpinner = spinner("Upgrading react-grab.").start();
|
|
try {
|
|
await installPackages(["react-grab@latest"], {
|
|
packageManager: projectInfo.packageManager,
|
|
cwd: projectInfo.projectRoot,
|
|
isDev: isDevDependency(projectInfo.projectRoot)
|
|
});
|
|
upgradeSpinner.succeed();
|
|
} catch {
|
|
upgradeSpinner.fail();
|
|
logger.break();
|
|
logger.error("Failed to upgrade. Check your network connection and try again.");
|
|
logger.break();
|
|
process.exit(1);
|
|
}
|
|
logger.break();
|
|
logger.log(`${highlighter.success("Success!")} React Grab has been upgraded to ${highlighter.info(`v${latestVersion}`)}.`);
|
|
logger.break();
|
|
} catch (error) {
|
|
handleError(error);
|
|
}
|
|
});
|
|
//#endregion
|
|
//#region src/commands/watch.ts
|
|
const writeStatus = (message) => {
|
|
process.stderr.write(`react-grab watch: ${message}\n`);
|
|
};
|
|
const watch = new Command().name("watch").description("run the React Grab capture daemon in the foreground (used internally by `pull`)").option("-d, --dir <dir>", "work dir for history.jsonl + watch.pid", DEFAULT_WATCH_DIR).option("-i, --interval <ms>", "clipboard poll interval in ms", String(800)).option("--text-only", "skip the native reader and use the plain-text fallback").option("--replay-last", "also capture the grab already on the clipboard at startup").action((options) => {
|
|
const dir = path.resolve(options.dir);
|
|
const intervalRaw = Number(options.interval);
|
|
const intervalMs = Number.isFinite(intervalRaw) && intervalRaw > 0 ? intervalRaw : 800;
|
|
try {
|
|
prepareWorkDir(dir);
|
|
} catch (error) {
|
|
writeStatus(String(error?.message ?? error));
|
|
process.exit(1);
|
|
}
|
|
if (!claimDaemon(dir)) process.exit(0);
|
|
process.on("exit", () => releaseDaemon(dir));
|
|
const reader = createReader({
|
|
textOnly: Boolean(options.textOnly),
|
|
workDir: dir
|
|
});
|
|
if (!reader) {
|
|
writeStatus(NO_READER_MESSAGE);
|
|
process.exit(1);
|
|
}
|
|
writeStatus(`watching clipboard via ${reader.mode}; history → ${path.join(dir, HISTORY_FILE_NAME)}`);
|
|
runWatchLoop({
|
|
reader,
|
|
dir,
|
|
intervalMs,
|
|
replayLast: Boolean(options.replayLast),
|
|
onWarn: writeStatus
|
|
}).catch((error) => {
|
|
writeStatus(String(error?.message ?? error));
|
|
process.exit(1);
|
|
});
|
|
});
|
|
//#endregion
|
|
//#region src/cli.ts
|
|
const VERSION = "0.1.50";
|
|
const VERSION_API_URL = "https://www.react-grab.com/api/version";
|
|
process.on("SIGINT", () => process.exit(0));
|
|
process.on("SIGTERM", () => process.exit(0));
|
|
try {
|
|
if (isTelemetryEnabled()) fetch(`${VERSION_API_URL}?source=cli&v=${VERSION}&t=${Date.now()}`).catch(() => {});
|
|
} catch {}
|
|
const program = new Command().name("grab").description("add React Grab to your project").version(VERSION, "-v, --version", "display the version number");
|
|
program.addCommand(init);
|
|
program.addCommand(add);
|
|
program.addCommand(remove);
|
|
program.addCommand(configure);
|
|
program.addCommand(upgrade);
|
|
program.addCommand(pull);
|
|
program.addCommand(stop);
|
|
program.addCommand(watch, { hidden: true });
|
|
const main = async () => {
|
|
await program.parseAsync();
|
|
};
|
|
main();
|
|
//#endregion
|
|
export {};
|
|
|
|
//# sourceMappingURL=cli.js.map
|