glimmervoid 0.0.0-stage → 0.30.0

package/dist/chunks/adapters-zPDx1Xox.js

@@ -0,0 +1,575 @@
+import { o as relayPath } from "./runtime-paths-Ci_ksSkj.js";
+import { _ as toolDetailFieldValue, c as PendingPromptQuestion, g as firstDetailLine, o as PROMPT_DETAIL_HIDDEN_CHARACTERS } from "./session-Cez8aIWg.js";
+import { r as execFileSync } from "./child-process-safe-DRGsp0TE.js";
+import { n as resolveAgentCommand, t as buildAgentSpawnCommand } from "./spawn-command-Cc40FiZI.js";
+import { i as isSpinnerChar, n as classifyAgentTitle, r as isBrailleChar, s as buildAgentEnv, t as grok } from "./grok-DuU8xVLZ.js";
+import { t as buildHookCommand } from "./hook-command-core-DclEoE9e.js";
+import "./contracts-DGkKNh9W.js";
+import { n as mergeCodexPreToolUse, t as HOOK_TOOLS } from "./hook-tools-pSJia7ks.js";
+import fs from "node:fs";
+//#region session/core/anti-slop-prompt.ts
+var ANTI_SLOP_NOTE = [
+	"Code hygiene for this session:",
+	"Write comments only to explain why, never narration that restates the code (no Now-we, This-function, or Step-1 openers).",
+	"Do not leave debug statements (console.log, print, debugger) in committed code.",
+	"Never swallow exceptions: no empty catch blocks and no catch that only logs and continues.",
+	"No placeholder stubs or in-a-real-implementation hand-waving; implement the real thing or stop and ask.",
+	"Do not silence type or lint errors with as-any, ts-ignore, or eslint-disable; fix the cause.",
+	"Avoid speculative wrappers and single-use indirection. Prefer deleting code over adding it."
+].join(" ");
+function buildAntiSlopArgs(enabled) {
+	return enabled ? ["--append-system-prompt", ANTI_SLOP_NOTE] : [];
+}
+//#endregion
+//#region session/adapters/claude-code.ts
+var ID$1 = "claude-code";
+var COMMAND_NAME$1 = "claude";
+var envProfile$2 = {
+	scrub: [
+		"CLAUDECODE",
+		"CLAUDE_CODE_SSE_PORT",
+		"CLAUDE_CODE_ENTRYPOINT",
+		"CLAUDE_CODE_CHILD_SESSION"
+	],
+	set: {
+		CLAUDE_CODE_NO_FLICKER: "1",
+		FORCE_HYPERLINK: "1"
+	}
+};
+var KNOWN_IDLE_CODEPOINTS = /* @__PURE__ */ new Set([10035]);
+function isKnownIdleChar(char) {
+	if (!char) return false;
+	return KNOWN_IDLE_CODEPOINTS.has(char.codePointAt(0) ?? 0);
+}
+var titleProfile$1 = {
+	isSpinnerChar,
+	isIdleChar: isKnownIdleChar,
+	dropsLeadingAscii: true,
+	unknownGlyphHint: "If this is a new idle glyph, add it to KNOWN_IDLE_CODEPOINTS.",
+	taskTitle: {
+		readsTranscriptTitle: true,
+		genericTitles: ["Claude Code"],
+		agentSuffix: null
+	}
+};
+function notificationType(payload) {
+	return String(payload && (payload.notification_type || payload.notificationType) || "").toLowerCase();
+}
+function mapHookConfidence$1(event, payload) {
+	if (String(event || "").toLowerCase() === "notification" && notificationType(payload) === "idle_prompt") return "low";
+	return null;
+}
+function mapHookPromptKind$1(event, payload) {
+	const e = String(event || "").toLowerCase();
+	if (e === "permissionrequest") {
+		if (String(payload?.tool_name || "") === "ExitPlanMode") return "plan";
+		return "permission";
+	}
+	if (e === "notification") {
+		const t = notificationType(payload);
+		if (t === "permission_prompt") return "permission";
+		if (t.startsWith("elicitation")) return "elicitation";
+	}
+	return null;
+}
+function mapHookPromptDetail(event, payload) {
+	if (String(event || "").toLowerCase() !== "permissionrequest") return null;
+	if (mapHookPromptKind$1(event, payload) !== "permission") return null;
+	const toolName = payload?.tool_name;
+	if (typeof toolName !== "string" || !toolName) return null;
+	const fieldValue = toolDetailFieldValue(toolName, payload?.tool_input);
+	const summary = fieldValue === null ? "" : firstDetailLine(fieldValue);
+	const isComplete = isWholeBashCommandShown(toolName, payload?.tool_input, fieldValue, summary);
+	return {
+		toolName: firstDetailLine(toolName),
+		summary,
+		isComplete,
+		question: answerableQuestionOf(toolName, payload?.tool_input)
+	};
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function answerableQuestionOf(toolName, toolInput) {
+	if (toolName !== "AskUserQuestion" || !isRecord(toolInput)) return null;
+	const questions = toolInput.questions;
+	if (!Array.isArray(questions) || questions.length !== 1) return null;
+	const [entry] = questions;
+	if (!isRecord(entry) || typeof entry.question !== "string" || !Array.isArray(entry.options)) return null;
+	const optionLabels = entry.options.flatMap((option) => isRecord(option) && typeof option.label === "string" ? [option.label] : []);
+	if (optionLabels.length !== entry.options.length) return null;
+	const parsedQuestion = PendingPromptQuestion.safeParse({
+		text: entry.question,
+		options: optionLabels,
+		multiSelect: entry.multiSelect === true
+	});
+	return parsedQuestion.success ? parsedQuestion.data : null;
+}
+var DISPLAY_IRRELEVANT_BASH_INPUT_KEYS = /* @__PURE__ */ new Set([
+	"command",
+	"description",
+	"timeout"
+]);
+function hasOnlyDisplayIrrelevantBashInputKeys(toolInput) {
+	if (!toolInput || typeof toolInput !== "object") return false;
+	return Reflect.ownKeys(toolInput).every((key) => typeof key === "string" && DISPLAY_IRRELEVANT_BASH_INPUT_KEYS.has(key));
+}
+function isWholeBashCommandShown(toolName, toolInput, fieldValue, summary) {
+	if (toolName !== "Bash" || fieldValue === null) return false;
+	if (!hasOnlyDisplayIrrelevantBashInputKeys(toolInput)) return false;
+	if (PROMPT_DETAIL_HIDDEN_CHARACTERS.test(fieldValue)) return false;
+	return summary === fieldValue;
+}
+function mapHookToSignal$1(event, payload) {
+	switch (String(event || "").toLowerCase()) {
+		case "sessionstart": return "session-start";
+		case "sessionend": return "session-end";
+		case "userpromptsubmit": return "resume";
+		case "stop": return "ready";
+		case "subagentstart": return "subagent-start";
+		case "subagentstop": return "subagent-stop";
+		case "taskcreated": return "task-created";
+		case "taskcompleted": return "task-completed";
+		case "teammateidle": return "teammate-idle";
+		case "permissionrequest": return "awaiting-input";
+		case "posttooluse": {
+			const tool = String(payload?.tool_name || "");
+			if (tool === "ScheduleWakeup") return "wakeup-scheduled";
+			if (tool === "CronCreate") return "cron-created";
+			if (tool === "CronDelete") return "cron-deleted";
+			return null;
+		}
+		case "notification": {
+			const t = notificationType(payload);
+			if (t === "idle_prompt") return "ready";
+			if (t === "permission_prompt" || t.startsWith("elicitation")) return "awaiting-input";
+			return null;
+		}
+		default: return null;
+	}
+}
+var hooks$1 = {
+	mapSignal: mapHookToSignal$1,
+	mapConfidence: mapHookConfidence$1,
+	mapPromptKind: mapHookPromptKind$1,
+	mapPromptDetail: mapHookPromptDetail,
+	injection: { kind: "settings-file" }
+};
+function resolveCommand$1({ platform, execFile = execFileSync, pathExists = fs.existsSync } = {}) {
+	return resolveAgentCommand({
+		name: COMMAND_NAME$1,
+		platform: platform || process.platform,
+		execFile,
+		pathExists
+	});
+}
+function buildSpawnCommand$1({ platform, resolved, settingsArgs: injectedSettingsArgs = [], agentArgs = [] }) {
+	return buildAgentSpawnCommand({
+		name: COMMAND_NAME$1,
+		platform,
+		resolved,
+		argGroups: [injectedSettingsArgs, agentArgs]
+	});
+}
+function buildEnv$1(baseEnv, extraEnv, options) {
+	return buildAgentEnv(baseEnv, extraEnv, envProfile$2, options);
+}
+var settingsArgs = (settingsPath) => ["--settings", settingsPath];
+function buildArgs$1({ dangerouslySkipPermissions = false, resumeSessionId = null, extraArgs = [], antiSlopPrompt = false, initialPrompt = null } = {}) {
+	const args = dangerouslySkipPermissions ? ["--dangerously-skip-permissions"] : [];
+	if (resumeSessionId) args.push("--resume", resumeSessionId);
+	if (extraArgs.length > 0) args.push(...extraArgs);
+	args.push(...buildAntiSlopArgs(antiSlopPrompt));
+	if (initialPrompt != null) args.push(initialPrompt);
+	return args;
+}
+var claudeCode = {
+	id: ID$1,
+	label: "Claude Code",
+	usageVendor: "claude",
+	commandName: COMMAND_NAME$1,
+	envProfile: envProfile$2,
+	titleProfile: titleProfile$1,
+	hooks: hooks$1,
+	resolveCommand: resolveCommand$1,
+	buildSpawnCommand: buildSpawnCommand$1,
+	buildEnv: buildEnv$1,
+	buildArgs: buildArgs$1,
+	settingsArgs,
+	capabilities: {
+		hooks: true,
+		awaitingInput: true,
+		backgroundAgents: true,
+		resume: true,
+		statusLine: true,
+		rtk: true,
+		saneYolo: true,
+		antiSlop: true,
+		compactQuiet: true,
+		skipPermissionsFlag: true,
+		headless: true
+	},
+	isBrailleChar,
+	isSpinnerChar,
+	isKnownIdleChar,
+	mapHookToSignal: mapHookToSignal$1,
+	mapHookConfidence: mapHookConfidence$1,
+	mapHookPromptKind: mapHookPromptKind$1,
+	mapHookPromptDetail
+};
+//#endregion
+//#region session/adapters/codex.ts
+var ID = "codex";
+var COMMAND_NAME = "codex";
+var RELAY_PATH = relayPath("hook-relay");
+var HOOK_TOOL_RELAY_PATH = relayPath("hook-tool-relay");
+var HOOK_EVENTS = [
+	"SessionStart",
+	"SessionEnd",
+	"UserPromptSubmit",
+	"Stop",
+	"PermissionRequest"
+];
+var envProfile$1 = {
+	scrub: [],
+	set: {}
+};
+var ACTION_REQUIRED_RE = /^\[\s*[.!]\s*\]\s*Action Required\b/;
+function classifyActionRequired(title, cwdBasename) {
+	if (!ACTION_REQUIRED_RE.test(title)) return null;
+	return title.trimEnd().endsWith(cwdBasename) ? "awaiting-input" : "unknown";
+}
+function classifyTitle(title, { cwdBasename = null } = {}) {
+	return classifyAgentTitle(title, { cwdBasename }, {
+		isSpinnerChar: isBrailleChar,
+		classifyAgainstCwdBasename: classifyActionRequired
+	});
+}
+var titleProfile = {
+	classifyTitle,
+	quietUntilFirstPrompt: true,
+	taskTitle: {
+		readsTranscriptTitle: false,
+		genericTitles: [ID],
+		agentSuffix: ` - ${ID}`
+	}
+};
+function mapHookToSignal(event) {
+	switch (String(event || "").toLowerCase()) {
+		case "sessionstart": return "session-start";
+		case "sessionend": return "session-end";
+		case "userpromptsubmit": return "resume";
+		case "stop": return "ready";
+		case "permissionrequest": return "awaiting-input";
+		default: return null;
+	}
+}
+function mapHookConfidence() {
+	return null;
+}
+function mapHookPromptKind(event) {
+	return String(event || "").toLowerCase() === "permissionrequest" ? "permission" : null;
+}
+function sessionIdOf(payload) {
+	return payload?.session_id;
+}
+var TRUST_BYPASS_FLAG = "--dangerously-bypass-hook-trust";
+var PROJECT_CONFIG_CANDIDATES = Object.freeze([Object.freeze({
+	relPath: ".codex/config.toml",
+	presenceIsHit: false
+}), Object.freeze({
+	relPath: ".codex/hooks.json",
+	presenceIsHit: true
+})]);
+var HOOKS_DECLARATION_RE = /^[^\S\r\n]*(?:\[{1,2}[^\S\r\n]*["']?hooks\b|hooks[.\w"'-]*[^\S\r\n]*=|extends[^\S\r\n]*=)/m;
+function mayContributeHooks(configText) {
+	if (typeof configText !== "string") return false;
+	return HOOKS_DECLARATION_RE.test(configText);
+}
+function buildHookArgs({ relayPath = RELAY_PATH, events = HOOK_EVENTS, bypassHookTrust = false, hookTools = [], hookToolRelayPath = HOOK_TOOL_RELAY_PATH } = {}) {
+	const args = bypassHookTrust ? [TRUST_BYPASS_FLAG] : [];
+	const preToolUseGroups = [];
+	for (const event of events) {
+		const command = buildHookCommand(relayPath, event);
+		if (!command) return null;
+		if (event === "PreToolUse") {
+			preToolUseGroups.push(`{hooks=[{type='command',command='${command}'}]}`);
+			continue;
+		}
+		args.push("-c", `hooks.${event}=[{hooks=[{type='command',command='${command}'}]}]`);
+	}
+	const groups = hookTools.flatMap((tool) => {
+		const group = HOOK_TOOLS[tool.id].codexGroup(tool, hookToolRelayPath);
+		return group ? [group] : [];
+	});
+	args.push(...mergeCodexPreToolUse([...preToolUseGroups, ...groups]));
+	return args;
+}
+var hooks = {
+	mapSignal: mapHookToSignal,
+	mapConfidence: mapHookConfidence,
+	mapPromptKind: mapHookPromptKind,
+	injection: {
+		kind: "argv-config",
+		relayPath: RELAY_PATH,
+		events: HOOK_EVENTS,
+		buildHookArgs,
+		projectConfigCandidates: PROJECT_CONFIG_CANDIDATES,
+		mayContributeHooks
+	}
+};
+function resolveCommand({ platform, execFile = execFileSync, pathExists = fs.existsSync } = {}) {
+	return resolveAgentCommand({
+		name: COMMAND_NAME,
+		platform: platform || process.platform,
+		execFile,
+		pathExists
+	});
+}
+function buildSpawnCommand({ platform, resolved, settingsArgs = [], agentArgs = [] }) {
+	return buildAgentSpawnCommand({
+		name: COMMAND_NAME,
+		platform,
+		resolved,
+		argGroups: [settingsArgs, agentArgs]
+	});
+}
+function buildEnv(baseEnv, extraEnv, options) {
+	return buildAgentEnv(baseEnv, extraEnv, envProfile$1, options);
+}
+var UPDATE_CHECK_ARGS = ["-c", "check_for_update_on_startup=false"];
+var SKIP_PERMISSIONS_ARGS = [
+	"-a",
+	"never",
+	"-s",
+	"workspace-write"
+];
+function buildArgs({ dangerouslySkipPermissions = false, resumeSessionId = null, extraArgs = [], initialPrompt = null } = {}) {
+	const args = [...UPDATE_CHECK_ARGS];
+	if (resumeSessionId) args.push("resume", resumeSessionId);
+	if (dangerouslySkipPermissions) args.push(...SKIP_PERMISSIONS_ARGS);
+	if (extraArgs.length > 0) args.push(...extraArgs);
+	if (initialPrompt != null) args.push(initialPrompt);
+	return args;
+}
+var codex = {
+	id: ID,
+	label: "Codex CLI",
+	usageVendor: "codex",
+	commandName: COMMAND_NAME,
+	envProfile: envProfile$1,
+	titleProfile,
+	hooks,
+	resolveCommand,
+	buildSpawnCommand,
+	buildEnv,
+	buildArgs,
+	buildHookArgs,
+	buildHookCommand,
+	mayContributeHooks,
+	PROJECT_CONFIG_CANDIDATES,
+	classifyTitle,
+	mapHookToSignal,
+	mapHookConfidence,
+	mapHookPromptKind,
+	sessionIdOf,
+	HOOK_EVENTS,
+	RELAY_PATH,
+	HOOK_TOOL_RELAY_PATH,
+	TRUST_BYPASS_FLAG,
+	SKIP_PERMISSIONS_ARGS,
+	UPDATE_CHECK_ARGS,
+	capabilities: {
+		hooks: true,
+		awaitingInput: true,
+		backgroundAgents: false,
+		resume: true,
+		statusLine: false,
+		rtk: true,
+		saneYolo: true,
+		antiSlop: false,
+		compactQuiet: false,
+		skipPermissionsFlag: true,
+		headless: true
+	}
+};
+//#endregion
+//#region session/adapters/custom.ts
+var envProfile = {
+	scrub: [],
+	set: {}
+};
+var TITLE_ONLY_CAPABILITIES = Object.freeze({
+	hooks: false,
+	awaitingInput: false,
+	backgroundAgents: false,
+	resume: false,
+	statusLine: false,
+	rtk: false,
+	saneYolo: false,
+	antiSlop: false,
+	compactQuiet: false,
+	skipPermissionsFlag: false,
+	headless: false
+});
+function createCustomAdapter(declaration) {
+	const declaredArgs = Object.freeze([...declaration.args]);
+	const busyTitle = declaration.busyTitle?.trim() || null;
+	const idleTitle = declaration.idleTitle?.trim() || null;
+	function classifyTitle(title, { cwdBasename = null } = {}) {
+		return classifyAgentTitle(title, { cwdBasename }, {
+			isSpinnerChar,
+			busyTitle,
+			idleTitle
+		});
+	}
+	const titleProfile = {
+		classifyTitle,
+		taskTitle: {
+			readsTranscriptTitle: false,
+			genericTitles: [declaration.id],
+			agentSuffix: ` - ${declaration.id}`
+		}
+	};
+	function resolveCommand({ platform, execFile = execFileSync, pathExists = fs.existsSync } = {}) {
+		return resolveAgentCommand({
+			name: declaration.command,
+			platform: platform || process.platform,
+			execFile,
+			pathExists
+		});
+	}
+	function buildSpawnCommand({ platform, resolved, settingsArgs = [], agentArgs = [] }) {
+		return buildAgentSpawnCommand({
+			name: declaration.command,
+			platform,
+			resolved,
+			argGroups: [settingsArgs, agentArgs]
+		});
+	}
+	function buildEnv(baseEnv, extraEnv, options) {
+		return buildAgentEnv(baseEnv, extraEnv, envProfile, options);
+	}
+	function buildArgs({ initialPrompt = null } = {}) {
+		const args = [...declaredArgs];
+		if (initialPrompt != null) args.push(initialPrompt);
+		return args;
+	}
+	return {
+		id: declaration.id,
+		label: declaration.label,
+		usageVendor: declaration.id,
+		commandName: declaration.command,
+		envProfile,
+		titleProfile,
+		hooks: null,
+		capabilities: TITLE_ONLY_CAPABILITIES,
+		resolveCommand,
+		buildSpawnCommand,
+		buildEnv,
+		buildArgs
+	};
+}
+//#endregion
+//#region session/adapters/index.ts
+var DEFAULT_AGENT_ID = claudeCode.id;
+var adapterEntries = [
+	[claudeCode.id, claudeCode],
+	[codex.id, codex],
+	[grok.id, grok]
+];
+var ADAPTERS = new Map(adapterEntries);
+var customAdapters = /* @__PURE__ */ new Map();
+var customAgentFingerprints = /* @__PURE__ */ new Map();
+var resolvedCommands = /* @__PURE__ */ new Map();
+function declarationFingerprint(declaration) {
+	return JSON.stringify([
+		declaration.command,
+		declaration.args,
+		declaration.idleTitle ?? null,
+		declaration.busyTitle ?? null
+	]);
+}
+function customAgentFingerprint(agentId) {
+	if (agentId == null) return null;
+	return customAgentFingerprints.get(agentId) ?? null;
+}
+function setCustomAgents(declared) {
+	const nextFingerprintById = /* @__PURE__ */ new Map();
+	for (const declaration of declared) nextFingerprintById.set(declaration.id, declarationFingerprint(declaration));
+	for (const [customId, previousFingerprint] of customAgentFingerprints) {
+		if (nextFingerprintById.get(customId) === previousFingerprint) continue;
+		resolvedCommands.delete(customId);
+	}
+	customAdapters.clear();
+	customAgentFingerprints.clear();
+	for (const declaration of declared) {
+		customAdapters.set(declaration.id, createCustomAdapter(declaration));
+		customAgentFingerprints.set(declaration.id, nextFingerprintById.get(declaration.id) ?? declarationFingerprint(declaration));
+	}
+}
+function hookProfileOf(adapter) {
+	if (!adapter.capabilities.hooks) return null;
+	return adapter.hooks;
+}
+function listAgentIds() {
+	return [...ADAPTERS.keys(), ...customAdapters.keys()];
+}
+function isKnownAgentId(agentId) {
+	if (typeof agentId !== "string") return false;
+	return ADAPTERS.has(agentId) || customAdapters.has(agentId);
+}
+function getAdapter(agentId) {
+	if (agentId == null) return ADAPTERS.get(DEFAULT_AGENT_ID) ?? null;
+	return ADAPTERS.get(agentId) ?? customAdapters.get(agentId) ?? null;
+}
+function resolveAdapter(agentId, { warn = console.warn, label = "" } = {}) {
+	const adapter = getAdapter(agentId);
+	if (adapter) return adapter;
+	warn(`[glimmervoid]${label ? ` ${label}:` : ""} unknown agent "${agentId}", falling back to ${DEFAULT_AGENT_ID}`);
+	return ADAPTERS.get(DEFAULT_AGENT_ID) ?? null;
+}
+function commandFor(adapterOrId, options) {
+	const adapter = typeof adapterOrId === "string" ? resolveAdapter(adapterOrId) : adapterOrId;
+	if (!adapter) throw new TypeError("default agent adapter is unavailable");
+	const cached = resolvedCommands.get(adapter.id);
+	if (cached) return cached;
+	const resolved = adapter.resolveCommand(options);
+	resolvedCommands.set(adapter.id, resolved);
+	return resolved;
+}
+function describeAgentResolvability(agentId) {
+	const adapter = getAdapter(agentId);
+	if (!adapter) return {
+		label: agentId,
+		path: null,
+		resolvable: false
+	};
+	const resolvedPath = commandFor(adapter)?.path ?? null;
+	return {
+		label: adapter.label || agentId,
+		path: resolvedPath,
+		resolvable: !!resolvedPath
+	};
+}
+function cachedAgentResolvability(agentId) {
+	const adapter = getAdapter(agentId);
+	if (!adapter) return {
+		label: agentId,
+		path: null,
+		resolvable: false
+	};
+	const cached = resolvedCommands.get(adapter.id);
+	if (!cached) return {
+		label: adapter.label || agentId,
+		path: null,
+		resolvable: null
+	};
+	return {
+		label: adapter.label || agentId,
+		path: cached.path ?? null,
+		resolvable: !!cached.path
+	};
+}
+//#endregion
+export { describeAgentResolvability as a, isKnownAgentId as c, setCustomAgents as d, claudeCode as f, customAgentFingerprint as i, listAgentIds as l, cachedAgentResolvability as n, getAdapter as o, commandFor as r, hookProfileOf as s, DEFAULT_AGENT_ID as t, resolveAdapter as u };

package/dist/chunks/agent-api-cli-D0MmtEdz.js

@@ -0,0 +1,71 @@
+import { n as AGENT_URL_ENV } from "./session-Cez8aIWg.js";
+import { i as resolveHookTarget } from "./hook-relay-core-BHfYFnYV.js";
+import { a as isAgentApiVerb } from "./agent-api-core-Dz0r21y9.js";
+//#region server/agent-api-cli.ts
+var AGENT_PATH_PREFIX = "/agent/";
+var BODY_BUILDERS = {
+	spawn: (rest) => {
+		const prompt = rest.join(" ").trim();
+		return prompt ? { prompt } : null;
+	},
+	attention: (rest) => {
+		const note = rest.join(" ").trim();
+		return note ? { note } : null;
+	},
+	board: () => ({})
+};
+function bodySaysOk(text) {
+	try {
+		const parsed = JSON.parse(text);
+		return typeof parsed === "object" && parsed !== null && parsed.ok === true;
+	} catch {
+		return false;
+	}
+}
+function verbEndpoint(rawUrl, verb) {
+	const target = resolveHookTarget(rawUrl, verb, AGENT_PATH_PREFIX);
+	if (!target.url) return { ok: false };
+	const endpoint = new URL(target.url);
+	const token = endpoint.searchParams.get("t") || "";
+	endpoint.search = "";
+	return {
+		ok: true,
+		endpoint,
+		token
+	};
+}
+async function runAgentApiCli(args) {
+	const verb = args[0];
+	if (!verb || !isAgentApiVerb(verb)) {
+		console.error(`glimmervoid: ${verb || "that"} is not an agent command`);
+		return 1;
+	}
+	const body = BODY_BUILDERS[verb](args.slice(1));
+	if (!body) {
+		console.error(`glimmervoid ${verb}: this command needs text, for example "glimmervoid ${verb} check the failing test"`);
+		return 1;
+	}
+	const rawUrl = process.env[AGENT_URL_ENV];
+	if (!rawUrl) {
+		console.error(`glimmervoid: ${AGENT_URL_ENV} is not set, so this is not a Glimmervoid session with the agent API turned on`);
+		return 1;
+	}
+	const target = verbEndpoint(rawUrl, verb);
+	if (!target.ok) {
+		console.error(`glimmervoid: ${AGENT_URL_ENV} must be a loopback http url under ${AGENT_PATH_PREFIX}, so nothing was sent`);
+		return 1;
+	}
+	const response = await fetch(target.endpoint, {
+		method: "POST",
+		headers: {
+			"content-type": "application/json",
+			authorization: `Bearer ${target.token}`
+		},
+		body: JSON.stringify(body)
+	});
+	const text = await response.text();
+	console.log(text);
+	return response.ok && bodySaysOk(text) ? 0 : 1;
+}
+//#endregion
+export { runAgentApiCli };