What vercel-3 runs automatically, and when. A hook is a command Claude Code fires at a fixed moment, without you asking for it.
Claude Code
> /plugin marketplace add vercel/vercel-plugin> /plugin install vercel-plugin@vercel
Cursor
Cursor also runs Claude Code hooks from .claude/settings.json, so copy these hooks there to use them in Cursor.
What fires, and when
SessionStart
Fires once when a session begins, and again after a context compaction. It is where a plugin sets up its environment, or restores state the compaction dropped.
startup|resume|clear|compactnode "${CLAUDE_PLUGIN_ROOT}/hooks/session-start-seen-skills.mjs"node "${CLAUDE_PLUGIN_ROOT}/hooks/session-start-profiler.mjs"node "${CLAUDE_PLUGIN_ROOT}/hooks/inject-claude-md.mjs"PostToolUse
Skillnode "${CLAUDE_PLUGIN_ROOT}/hooks/posttooluse-skill-telemetry.mjs"SessionEnd
node "${CLAUDE_PLUGIN_ROOT}/hooks/session-end-cleanup.mjs"Where it lives
// hooks/src/compat.mts
import { appendFileSync } from "fs";
var cursorSessionEnv = /* @__PURE__ */ new Map();
var currentHookEventName;
function isRecord(value) {
return typeof value === "object" && value !== null && !Array.isArray(value);
}
function readString(value) {
return typeof value === "string" ? value : void 0;
}
function readRecord(value) {
return isRecord(value) ? value : void 0;
}
function readWorkspaceRoot(raw) {
if (!Array.isArray(raw.workspace_roots)) return void 0;
const firstRoot = raw.workspace_roots[0];
return typeof firstRoot === "string" ? firstRoot : void 0;
}
function normalizeToolOutputValue(value) {
if (typeof value === "undefined") return void 0;
if (typeof value === "string") return value;
try {
return JSON.stringify(value);
} catch {
return String(value);
}
}
function escapeShellEnvValue(value) {
return value.replace(/(["\\$`])/g, "\\$1");
}
function drainCursorSessionEnv() {
if (cursorSessionEnv.size === 0) return void 0;
const env = Object.fromEntries(cursorSessionEnv);
cursorSessionEnv.clear();
return env;
}
function detectPlatform(raw) {
if ("conversation_id" in raw || "workspace_roots" in raw || "cursor_version" in raw) {
return "cursor";
}
return "claude-code";
}
function normalizeInput(raw) {
const platform = detectPlatform(raw);
const sessionId = readString(raw.session_id ?? raw.conversation_id) ?? "";
const cwd = readString(raw.cwd) ?? readWorkspaceRoot(raw) ?? process.env.CURSOR_PROJECT_DIR ?? process.env.CLAUDE_PROJECT_DIR ?? process.cwd();
const hookEvent = readString(raw.hook_event_name) ?? "";
const toolOutput = normalizeToolOutputValue(raw.tool_output ?? raw.tool_response);
currentHookEventName = hookEvent || void 0;
return {
platform,
sessionId,
cwd,
hookEvent,
toolName: readString(raw.tool_name),
toolInput: readRecord(raw.tool_input),
toolOutput,
prompt: readString(raw.prompt),
raw
};
}
function formatOutput(platform, internal) {
if (platform === "cursor") {
const env = {
...drainCursorSessionEnv() ?? {},
...internal.env ?? {}
};
const output = {};
if (typeof internal.additionalContext !== "undefined") {
output.additional_context = internal.additionalContext;
}
if (typeof internal.permission !== "undefined") {
output.permission = internal.permission;
}
if (Object.keys(env).length > 0) {
output.env = env;
}
if (typeof internal.userMessage !== "undefined") {
output.user_message = internal.userMessage;
}
return output;
}
const hookSpecificOutput = {};
if (typeof internal.additionalContext !== "undefined") {
if (currentHookEventName) {
hookSpecificOutput.hookEventName = currentHookEventName;
}
hookSpecificOutput.additionalContext = internal.additionalContext;
}
if (typeof internal.permission !== "undefined") {
if (currentHookEventName) {
hookSpecificOutput.hookEventName = currentHookEventName;
}
hookSpecificOutput.permissionDecision = internal.permission;
}
if (Object.keys(hookSpecificOutput).length === 0) {
return {};
}
return { hookSpecificOutput };
}
function getEnvFilePath() {
return process.env.CLAUDE_ENV_FILE || null;
}
function setSessionEnv(platform, key, value) {
if (platform === "cursor") {
cursorSessionEnv.set(key, value);
return;
}
const envFile = getEnvFilePath();
if (!envFile) return;
appendFileSync(envFile, `export ${key}="${escapeShellEnvValue(value)}"
`);
}
function getProjectRoot() {
return process.env.CLAUDE_PROJECT_ROOT ?? process.env.CURSOR_PROJECT_DIR ?? process.cwd();
}
export {
detectPlatform,
formatOutput,
getEnvFilePath,
getProjectRoot,
normalizeInput,
setSessionEnv
};
#!/usr/bin/env node
// hooks/src/inject-claude-md.mts
import { existsSync, readFileSync } from "fs";
import { join, resolve } from "path";
import { fileURLToPath } from "url";
import { formatOutput } from "./compat.mjs";
import { pluginRoot, safeReadFile } from "./hook-env.mjs";
import { hasSessionStartActivationMarkers, isGreenfieldDirectory } from "./session-start-activation.mjs";
var INJECT_CLAUDE_MD_PART_BUDGET = 9e3;
var PART_FLAG = "--part";
var PART_SEPARATOR = "\n\n";
var GREENFIELD_CONTEXT = `<!-- vercel-plugin:greenfield-execution -->
## Greenfield execution mode
This directory is empty.
Do not stop in planning mode or spin up a read-only planning subagent.
Choose sensible defaults immediately.
Start executing with real tool calls.
Use non-interactive scaffolding commands (--yes) where available.
Only ask follow-up questions when blocked by missing credentials or irreversible decisions.`;
function parseInjectClaudeMdInput(raw) {
try {
if (!raw.trim()) return null;
return JSON.parse(raw);
} catch {
return null;
}
}
function detectInjectClaudeMdPlatform(input, _env = process.env) {
if (input && ("conversation_id" in input || "cursor_version" in input)) {
return "cursor";
}
return "claude-code";
}
function buildInjectClaudeMdParts(content, env = process.env, knowledgeUpdate = null, greenfield = env.VERCEL_PLUGIN_GREENFIELD === "true") {
const parts = [];
if (content !== null) {
parts.push(content);
}
if (greenfield) {
parts.push(GREENFIELD_CONTEXT);
}
if (knowledgeUpdate !== null) {
parts.push(knowledgeUpdate);
}
return parts;
}
var FENCE_PATTERN = /^ {0,3}(```|~~~)/;
var LIST_ITEM_PATTERN = /^(?:[-*+]|\d+[.)])\s/;
function trimBlankLines(text) {
return text.replace(/^(?:[ \t]*\n)+/, "").trimEnd();
}
function lineStarts(lines, isStart) {
const starts = [];
let inFence = false;
lines.forEach((line, index) => {
const isFence = FENCE_PATTERN.test(line);
if (!inFence && !isFence && isStart(line, lines[index - 1])) {
starts.push(index);
}
if (isFence) {
inFence = !inFence;
}
});
return starts;
}
function splitMarkdownSections(markdown) {
const lines = markdown.split("\n");
const boundaries = [0, ...lineStarts(lines, (line) => line.startsWith("## ")).filter((index) => index > 0)];
return boundaries.map((start, i) => trimBlankLines(lines.slice(start, boundaries[i + 1] ?? lines.length).join("\n"))).filter(Boolean);
}
function splitLongSection(section, limit) {
const lines = section.split("\n");
const heading = lines[0].startsWith("## ") ? lines[0] : null;
const boundaries = [
0,
...lineStarts(
lines,
(line, previous) => line.trim() !== "" && !/^\s/.test(line) && (LIST_ITEM_PATTERN.test(line) || previous?.trim() === "")
).filter((index) => index > (heading === null ? 0 : 1))
];
const render = (from, to) => {
const body = trimBlankLines(lines.slice(boundaries[from], boundaries[to + 1] ?? lines.length).join("\n"));
return from === 0 || heading === null ? body : `${heading} (continued)${PART_SEPARATOR}${body}`;
};
const pieces = [];
for (let from = 0; from < boundaries.length; ) {
let to = from;
while (to + 1 < boundaries.length && render(from, to + 1).length <= limit) {
to++;
}
pieces.push(render(from, to));
from = to + 1;
}
return pieces;
}
function knowledgeUpdateBlocks(knowledgeUpdate, budget) {
const title = knowledgeUpdate.split("\n", 1)[0];
const continuationHeader = title.startsWith("# ") ? `${title} (continued)` : null;
const limit = budget - (continuationHeader === null ? 0 : continuationHeader.length + PART_SEPARATOR.length);
return splitMarkdownSections(knowledgeUpdate).flatMap((section) => section.length <= limit ? [section] : splitLongSection(section, limit)).map((text, index) => ({ text, continuationHeader: index === 0 ? null : continuationHeader }));
}
function packBlocks(blocks, budget) {
const parts = [];
let current = null;
for (const block of blocks) {
if (current !== null) {
const joined = `${current}${PART_SEPARATOR}${block.text}`;
if (joined.length <= budget) {
current = joined;
continue;
}
parts.push(current);
}
current = block.continuationHeader === null ? block.text : `${block.continuationHeader}${PART_SEPARATOR}${block.text}`;
}
if (current !== null) {
parts.push(current);
}
return parts;
}
function buildInjectClaudeMdOutputs(content, env = process.env, knowledgeUpdate = null, greenfield = env.VERCEL_PLUGIN_GREENFIELD === "true", budget = INJECT_CLAUDE_MD_PART_BUDGET) {
const blocks = buildInjectClaudeMdParts(content, env, null, greenfield).map((text) => ({ text, continuationHeader: null }));
if (knowledgeUpdate !== null) {
blocks.push(...knowledgeUpdateBlocks(knowledgeUpdate, budget));
}
return packBlocks(blocks, budget);
}
function parseInjectClaudeMdPart(args) {
const flagIndex = args.indexOf(PART_FLAG);
if (flagIndex === -1) return null;
const match = /^(\d+)\/(\d+)$/.exec(args[flagIndex + 1] ?? "");
if (!match) return null;
const index = Number(match[1]);
const count = Number(match[2]);
return index >= 1 && index <= count ? { index, count } : null;
}
function selectInjectClaudeMdPart(outputs, part) {
if (part === null) return outputs.join(PART_SEPARATOR);
if (part.index < part.count) return outputs[part.index - 1] ?? "";
return outputs.slice(part.count - 1).join(PART_SEPARATOR);
}
function formatInjectClaudeMdOutput(platform, content) {
if (platform === "cursor") {
return JSON.stringify(formatOutput(platform, { additionalContext: content }));
}
return content;
}
function resolveInjectClaudeMdProjectRoot(env = process.env) {
return env.CLAUDE_PROJECT_ROOT ?? env.CURSOR_PROJECT_DIR ?? process.cwd();
}
function stripFrontmatter(content) {
const match = content.match(/^---\n[\s\S]*?\n---\n?([\s\S]*)$/);
return match ? match[1].trim() : content.trim();
}
funct#!/usr/bin/env node
// hooks/src/posttooluse-skill-telemetry.mts
import { existsSync, readdirSync, readFileSync } from "fs";
import { join, resolve } from "path";
import { fileURLToPath } from "url";
import { normalizeInput } from "./compat.mjs";
import { pluginRoot } from "./hook-env.mjs";
import { createLogger, logCaughtError } from "./logger.mjs";
import {
buildSkillTelemetryPayload,
parseSendPayload,
spawnDetachedSkillTelemetrySender
} from "./skill-telemetry.mjs";
import {
SKILL_INVOKED_EVENT_KEY,
normalizeSkillInvocation,
trackSkillEvents
} from "./telemetry.mjs";
var log = createLogger();
var SKILL_TOOL_NAMES = /* @__PURE__ */ new Set(["Skill"]);
function parseSkillTelemetryHookInput(raw) {
try {
if (!raw.trim()) return null;
const parsed = JSON.parse(raw);
return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
} catch {
return null;
}
}
function loadKnownPluginSkills(root = pluginRoot(import.meta.url)) {
const known = /* @__PURE__ */ new Set();
try {
for (const entry of readdirSync(join(root, "skills"), { withFileTypes: true })) {
if (entry.isDirectory() && existsSync(join(root, "skills", entry.name, "SKILL.md"))) {
known.add(entry.name);
}
}
} catch (error) {
logCaughtError(log, "skill-telemetry:read-skills-dir-failed", error, { root });
}
try {
for (const entry of readdirSync(join(root, "commands"), { withFileTypes: true })) {
if (entry.isFile() && entry.name.endsWith(".md") && !entry.name.startsWith("_")) {
known.add(entry.name.slice(0, -".md".length));
}
}
} catch (error) {
logCaughtError(log, "skill-telemetry:read-commands-dir-failed", error, { root });
}
return known;
}
function buildSkillInvocationPayload(input, knownSkills, env = process.env) {
if (!input) return null;
const normalized = normalizeInput(input);
if (!normalized.toolName || !SKILL_TOOL_NAMES.has(normalized.toolName)) return null;
const skill = normalizeSkillInvocation(normalized.toolInput?.skill, knownSkills);
if (!skill) return null;
return buildSkillTelemetryPayload(SKILL_INVOKED_EVENT_KEY, [skill], normalized.sessionId || null, env);
}
async function main(entrypoint) {
const sendPayload = parseSendPayload(process.argv);
if (sendPayload) {
await trackSkillEvents(sendPayload.key, sendPayload.skills, {
telemetrySessionId: sendPayload.telemetrySessionId,
agentHarness: sendPayload.agentHarness
}).catch(() => false);
process.exit(0);
}
const input = parseSkillTelemetryHookInput(readFileSync(0, "utf8"));
const payload = buildSkillInvocationPayload(input, loadKnownPluginSkills());
if (payload) {
log.debug("skill-telemetry:queued", { key: payload.key, skills: payload.skills, agentHarness: payload.agentHarness });
spawnDetachedSkillTelemetrySender(payload, entrypoint);
}
process.exit(0);
}
var SKILL_TELEMETRY_ENTRYPOINT = fileURLToPath(import.meta.url);
var isSkillTelemetryEntrypoint = process.argv[1] ? resolve(process.argv[1]) === SKILL_TELEMETRY_ENTRYPOINT : false;
if (isSkillTelemetryEntrypoint) {
main(SKILL_TELEMETRY_ENTRYPOINT);
}
export {
buildSkillInvocationPayload,
loadKnownPluginSkills,
parseSkillTelemetryHookInput
};
#!/usr/bin/env node
// hooks/src/session-end-cleanup.mts
import { createHash } from "crypto";
import { readdirSync, readFileSync, rmSync, unlinkSync } from "fs";
import { tmpdir } from "os";
import { join, resolve } from "path";
import { fileURLToPath } from "url";
var SAFE_SESSION_ID_RE = /^[a-zA-Z0-9_-]+$/;
function tempSessionIdSegment(sessionId) {
if (SAFE_SESSION_ID_RE.test(sessionId)) {
return sessionId;
}
return createHash("sha256").update(sessionId).digest("hex");
}
function removeFileIfPresent(path) {
try {
unlinkSync(path);
} catch {
}
}
function removeDirIfPresent(path) {
try {
rmSync(path, { recursive: true, force: true });
} catch {
}
}
function parseSessionEndHookInput(raw) {
try {
if (!raw.trim()) return null;
return JSON.parse(raw);
} catch {
return null;
}
}
function normalizeSessionEndSessionId(input) {
if (!input) return null;
const sessionId = input.session_id ?? input.conversation_id ?? "";
return typeof sessionId === "string" && sessionId.length > 0 ? sessionId : null;
}
function parseSessionIdFromStdin() {
return normalizeSessionEndSessionId(parseSessionEndHookInput(readFileSync(0, "utf8")));
}
function main() {
const sessionId = parseSessionIdFromStdin();
if (sessionId === null) {
process.exit(0);
}
const tempRoot = tmpdir();
const prefix = `vercel-plugin-${tempSessionIdSegment(sessionId)}-`;
let entries = [];
try {
entries = readdirSync(tempRoot).filter((name) => name.startsWith(prefix));
} catch {
}
for (const entry of entries) {
const fullPath = join(tempRoot, entry);
if (entry.endsWith(".d")) {
removeDirIfPresent(fullPath);
} else {
removeFileIfPresent(fullPath);
}
}
process.exit(0);
}
var SESSION_END_CLEANUP_ENTRYPOINT = fileURLToPath(import.meta.url);
var isSessionEndCleanupEntrypoint = process.argv[1] ? resolve(process.argv[1]) === SESSION_END_CLEANUP_ENTRYPOINT : false;
if (isSessionEndCleanupEntrypoint) {
main();
}
export {
normalizeSessionEndSessionId,
parseSessionEndHookInput
};
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
}) : x)(function(x) {
if (typeof require !== "undefined") return require.apply(this, arguments);
throw Error('Dynamic require of "' + x + '" is not supported');
});
var __commonJS = (cb, mod) => function __require2() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
// node_modules/detect-agent/dist/index.js
var require_dist = __commonJS({
"node_modules/detect-agent/dist/index.js"(exports, module) {
"use strict";
var __defProp2 = Object.defineProperty;
var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
var __getOwnPropNames2 = Object.getOwnPropertyNames;
var __hasOwnProp2 = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp2(target, name, { get: all[name], enumerable: true });
};
var __copyProps2 = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames2(from))
if (!__hasOwnProp2.call(to, key) && key !== except)
__defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
var index_exports = {};
__export(index_exports, {
KNOWN_AGENTS: () => KNOWN_AGENTS,
determineAgent: () => determineAgent
});
module.exports = __toCommonJS(index_exports);
var agents_default = {
$schema: "./agents.schema.json",
version: 1,
description: "Language-agnostic specification for detecting AI agents and automated development environments. Agents are evaluated in array order; the first agent whose `match` condition is satisfied wins. Every agent's `match` is a combinator (`anyOf`/`allOf`) whose `conditions` are evaluated as a tree: combinators nest, and `env_set`/`env_value`/`file_exists` are leaf checks. See agents.schema.json for the full structure.",
aiAgentVar: "AI_AGENT",
agents: [
{
key: "CURSOR",
name: "cursor",
match: {
type: "anyOf",
conditions: [{ type: "env_set", name: "CURSOR_TRACE_ID" }]
}
},
{
key: "CURSOR_CLI",
name: "cursor-cli",
match: {
type: "anyOf",
conditions: [
{ type: "env_set", name: "CURSOR_AGENT" },
{
type: "env_value",
name: "CURSOR_EXTENSION_HOST_ROLE",
value: "agent-exec"
}
]
}
},
{
key: "KIMI",
name: "kimi",
description: "Kimi Code plugin hooks. KIMI_CODE_HOME may be configured outside an active Kimi session, so detection uses the plugin-scoped KIMI_PLUGIN_ROOT marker.",
match: {
type: "anyOf",
conditions: [{ type: "env_set", name: "KIMI_PLUGIN_ROOT" }]
}
},
{
key: "GROK",
name: "grok",
description: "Grok Build plugin hooks. Evaluated before Claude Code because Grok supports Claude Code plugins and may expose compatibility markers.",
match: {
type: "anyOf",
conditions: [
{ type: "env_set", name: "GROK_PLUGIN_ROOT" },
{ type: "env_set", name: "GROK_PLUGIN_DATA" }
]
}
},
{
key: "GEMINI",
name: "gemini_cli",
match: {
type: "anyOf",
conditions: [{ type: "env_set", name: "GEMINI_CLI" }]
}
},
{
key: "CLINE",
name: "cline",
match: {
type: "anyOf",
conditions: [{ type: "env_set", name: "CLINE_ACTIVE" }]
}
},
{
key: "CODEX",
name: "codex_cli",
match: {
type: "anyOf",
conditions: [
{ type: "env_set", name: "CODEX_SANDBOX" },
{ type: "env_set", name: "CODEX_CI" },
{ type: "env_set", name: "CODEX_THREAD_ID" },
{ type: "env_set", name: "CODEX_SANDBOX_NETWORK_DISABLED" }
]
}
},
{
key: "ANTIGRAVITY",
name: "antigravity",
match: {
type: "anyOf",
conditions: [
{ type: "env_set", name: "ANTIGRAVITY_AGENT" },
{ type: "env_set", name: "ANTIGRAVITY_CLI_ALIAS" }
]
}
#!/usr/bin/env node
// hooks/src/session-start-seen-skills.mts
import { readFileSync } from "fs";
import { resolve } from "path";
import { fileURLToPath } from "url";
import {
formatOutput
} from "./compat.mjs";
import {
removeAllSessionDedupArtifacts
} from "./hook-env.mjs";
import { createLogger } from "./logger.mjs";
var CONTEXT_CLEARING_SOURCES = /* @__PURE__ */ new Set(["clear", "compact"]);
function parseSessionStartSeenSkillsInput(raw) {
try {
if (!raw.trim()) return null;
return JSON.parse(raw);
} catch {
return null;
}
}
function detectSessionStartSeenSkillsPlatform(input, _env = process.env) {
if (input && ("conversation_id" in input || "cursor_version" in input)) {
return "cursor";
}
return "claude-code";
}
function formatSessionStartSeenSkillsCursorOutput() {
return JSON.stringify(formatOutput("cursor", {
env: {
VERCEL_PLUGIN_SEEN_SKILLS: ""
}
}));
}
function resetDedupStateForSession(sessionId) {
return removeAllSessionDedupArtifacts(sessionId);
}
function main() {
const log = createLogger();
const input = parseSessionStartSeenSkillsInput(readFileSync(0, "utf8"));
const platform = detectSessionStartSeenSkillsPlatform(input);
if (platform === "cursor") {
process.stdout.write(formatSessionStartSeenSkillsCursorOutput());
return;
}
const source = input?.source ?? "";
const sessionId = input?.session_id ?? "";
const resetTriggered = CONTEXT_CLEARING_SOURCES.has(source) && !!sessionId;
let removedFiles = 0;
let removedDirs = 0;
if (resetTriggered) {
const result = resetDedupStateForSession(sessionId);
removedFiles = result.removedFiles;
removedDirs = result.removedDirs;
}
log.debug("session-start-seen-skills:decision", {
source: source || "unknown",
sessionId: sessionId || "none",
resetTriggered,
removedFiles,
removedDirs
});
}
var SESSION_START_SEEN_SKILLS_ENTRYPOINT = fileURLToPath(import.meta.url);
var isSessionStartSeenSkillsEntrypoint = process.argv[1] ? resolve(process.argv[1]) === SESSION_START_SEEN_SKILLS_ENTRYPOINT : false;
if (isSessionStartSeenSkillsEntrypoint) {
main();
}
export {
detectSessionStartSeenSkillsPlatform,
formatSessionStartSeenSkillsCursorOutput,
parseSessionStartSeenSkillsInput,
resetDedupStateForSession
};
All 34 scripts are listed above. The source is inlined for 6 of them, starting with whatever hooks.json actually runs. See all of them in the repo.
Read the script before you install anything that runs on your machine. This is the one part of a plugin that acts without being asked.
Comprehensive Vercel ecosystem plugin — relational knowledge graph, skills for every major product, specialized agents, and Vercel conventions. Turns any AI agent into a Vercel expert.
Stars on GitHub
Gives your AI coding agent working knowledge of Vercel's products, so it can deploy, configure caching and serverless functions, and manage environment variables without you looking up the conventions. It also includes benchmark skills for testing how the plugin performs.
@vercel-labs-2Unofficial, community-maintained Agent Skill for driving ArvanCloud's APIs (CDN, DNS, Cloud Server / IaaS, Object Storage, Edge Computing, Cloud Container, VOD/Live/Video Ads) and issuing Let's Encrypt wildcard TLS certs via acme.sh's dns_arvan plugin, from.
@erfnzdeh