dineway 0.2.1 → 0.2.3

package/dist/cli/index.mjs

@@ -1,41 +1,41 @@
 #!/usr/bin/env node
-import { i as runMigrations, n as getMigrationStatus, t as getMigrationFingerprint } from "../runner-BgmttQmD.mjs";
+import { i as runMigrations, n as getMigrationStatus, t as getMigrationFingerprint } from "../runner-BfWbi9YY.mjs";
 import { t as createDatabase } from "../connection-CiJWiWya.mjs";
 import { t as validateIdentifier } from "../validate-VPnKoIzW.mjs";
 import { l as listTablesLike } from "../dialect-helpers-fk43GbDb.mjs";
 import { n as getI18nConfig, r as isI18nEnabled } from "../config-CVssduLe.mjs";
 import { i as encodeBase64url } from "../base64-F8-DUraK.mjs";
-import "../types-ChxYDRvx.mjs";
-import { o as isMissingTableError } from "../loader-aWkkc1_o.mjs";
+import "../types-Bshd_6wQ.mjs";
+import { o as isMissingTableError } from "../loader-WHf22FwU.mjs";
 import "../object-cache-D51qOseS.mjs";
 import { n as slugify } from "../slugify-KSsVD_D3.mjs";
-import { t as ContentRepository } from "../content-DJcAYFhz.mjs";
-import { t as MediaRepository } from "../media-CVMOoywq.mjs";
-import { t as TaxonomyRepository } from "../taxonomy-0k_vRVsD.mjs";
+import { t as ContentRepository } from "../content-Cbl8HbIR.mjs";
+import { t as MediaRepository } from "../media-B4m-cnmj.mjs";
+import { t as TaxonomyRepository } from "../taxonomy-CCo2plmV.mjs";
 import { t as OptionsRepository } from "../options-DQPTH5n0.mjs";
-import "../redirect-ubhEqQCQ.mjs";
+import "../redirect-DoDgOWIA.mjs";
 import "../request-cache-CBFjCwSt.mjs";
 import "../byline-registry-Ba54M74c.mjs";
-import "../field-defs-cache-DL-T2XVS.mjs";
-import { t as BylineRepository } from "../byline-7xR185Ly.mjs";
-import "../content-refresh-B4ZCmxgd.mjs";
-import "../fts-manager-ewTGohf4.mjs";
-import { n as SchemaRegistry } from "../registry-BYYyb2tF.mjs";
-import "../settings-BECcAIRH.mjs";
-import { n as VERSION } from "../version-C3iVRuaF.mjs";
-import { a as reconcileManifestAccess, i as pluginManifestSchema } from "../manifest-schema-uA6pRFXi.mjs";
-import { n as resolveAndValidateExternalUrl, t as SsrfError } from "../ssrf-FJqwQzj4.mjs";
-import { n as fingerprintKey, r as generateEncryptionKey, t as DinewaySecretsError } from "../secrets-ZV5rd8yV.mjs";
-import { t as validateSeed } from "../validate-D1HL-oLR.mjs";
-import { t as applySeed } from "../apply-DjTqq6Ae.mjs";
-import { a as readSavedDeployTarget, c as listForgewayCredentials, i as readForgewayDeployMetadata, l as readForgewayCredentials, n as SeoProviderEvidenceService, o as writeDeployTarget, r as readDeployPackageJson, s as writeForgewayDeployMetadata, t as ForgewaySeoGatewayClient, u as writeForgewayCredentials } from "../forgeway-seo-client-G5ddhVHd.mjs";
-import { n as output, t as configureOutputMode } from "../output-DhBe5_Pi.mjs";
+import "../field-defs-cache-CiXP3eO3.mjs";
+import { t as BylineRepository } from "../byline-BJa1MyKB.mjs";
+import "../content-refresh-BmkilU5M.mjs";
+import "../fts-manager-Zo9uhGel.mjs";
+import { n as SchemaRegistry } from "../registry-SEJqFliS.mjs";
+import "../settings-SVDAB7_W.mjs";
+import { n as VERSION } from "../version-O6Zw1eqK.mjs";
+import { i as parseEncryptionKeys, n as fingerprintKey, r as generateEncryptionKey, t as DinewaySecretsError } from "../secrets-CpGpyGcO.mjs";
+import { t as IntegrationCredentialStore } from "../store-CCfMD6nw.mjs";
+import { a as reconcileManifestAccess, i as pluginManifestSchema } from "../manifest-schema-DKa3ZaJL.mjs";
+import { n as resolveAndValidateExternalUrl, t as SsrfError } from "../ssrf-BZHvtFEv.mjs";
+import { t as validateSeed } from "../validate-qKzI3BCv.mjs";
+import { t as applySeed } from "../apply-DHT0l398.mjs";
+import { _ as readForgewayCredentials, a as InvalidForgewayAccountCredentialsError, c as getForgewayDinewayAccount, d as normalizeForgewayEmail, f as readStoredForgewayAccount, g as listForgewayCredentials, h as sendForgewayAccountLoginLink, i as DEFAULT_FORGEWAY_API_BASE_URL, l as normalizeDinewayWebUrl, m as removeStoredForgewayAccount, n as DinewayToolsService, o as completeForgewayAccountLogin, p as refreshForgewayAccountCredentials, r as DEFAULT_DINEWAY_WEB_URL, s as createForgewayAccountClient, t as DinewayToolsError, u as normalizeForgewayApiUrl, v as writeForgewayCredentials } from "../service-DbHMAoiN.mjs";
+import { n as output, t as configureOutputMode } from "../output-BbqsKnS_.mjs";
 import { createHeaderAwareFetch, isRedirectResponse, resolveCustomHeaders } from "../client/external-auth-headers.mjs";
-import { t as convertDataForRead } from "../portable-text-BASHceim.mjs";
-import { a as getMarketplaceCredential, c as resolveCredentialKey, i as getCredentials, l as saveCredentials, n as connectionArgs, o as removeCredentials, r as createClientFromArgs, s as removeMarketplaceCredential, u as saveMarketplaceCredential } from "../client-factory-BDD9azPJ.mjs";
-import { a as resolveDinewayBaseUrl, n as ensureProjectGitignoreDinewayLocalState, o as resolveDinewayToken, r as ensureProjectGitignoreEntry, s as upsertProjectEnv, t as DEFAULT_DINEWAY_URL } from "../project-env-DKibmuP8.mjs";
+import { t as convertDataForRead } from "../portable-text-y8QVqTzd.mjs";
+import { _ as saveMarketplaceCredential, a as ensureProjectGitignoreDinewayLocalState, c as resolveDinewayBaseUrl, d as getCredentials, f as getMarketplaceCredential, g as saveCredentials, h as resolveCredentialKey, i as DEFAULT_DINEWAY_URL, l as resolveDinewayToken, m as removeMarketplaceCredential, n as connectionArgs, o as ensureProjectGitignoreEntry, p as removeCredentials, r as createClientFromArgs, s as readProjectEnv, u as upsertProjectEnv } from "../client-factory-DEtHApCc.mjs";
 import { LocalStorage } from "../storage/local.mjs";
-import { r as fileExists$11, t as bundleCommand } from "../bundle-CEcdUa1s.mjs";
+import { r as fileExists$11, t as bundleCommand } from "../bundle-CIrUlrkQ.mjs";
 import { createRequire } from "node:module";
 import { createHash } from "node:crypto";
 import { sql } from "kysely";
@@ -48,134 +48,10 @@ import { defineCommand, runCommand, runMain } from "citty";
 import { createInterface } from "node:readline/promises";
 import consola, { consola as consola$1 } from "consola";
 import pc from "picocolors";
-import { ForgewayClient } from "@forgeway/sdk";
 import { access, mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
 import { spawn } from "node:child_process";
 import { parse } from "parse5";
 
-//#region src/cli/forgeway-account.ts
-const TRAILING_SLASH_PATTERN$1 = /\/$/;
-const SHADOW_EMAIL_PATTERN$1 = /^shadow_[a-f0-9]{16}@dineway\.ai$/i;
-const DEFAULT_FORGEWAY_API_BASE_URL = "https://api.dineway.ai";
-const DEFAULT_DINEWAY_WEB_URL = "https://dineway.ai";
-function normalizeForgewayApiUrl(value) {
-	return (value || DEFAULT_FORGEWAY_API_BASE_URL).replace(TRAILING_SLASH_PATTERN$1, "");
-}
-function normalizeDinewayWebUrl(value) {
-	return (value || DEFAULT_DINEWAY_WEB_URL).replace(TRAILING_SLASH_PATTERN$1, "");
-}
-function normalizeForgewayEmail(value) {
-	return value?.trim().toLowerCase() ?? "";
-}
-function isShadowForgewayEmail(email) {
-	return Boolean(email && SHADOW_EMAIL_PATTERN$1.test(email));
-}
-function createForgewayAccountClient(platformApiUrl, accessToken) {
-	return new ForgewayClient({
-		baseUrl: normalizeForgewayApiUrl(platformApiUrl),
-		accessToken,
-		isServerMode: true,
-		auth: { detectOAuthCallback: false }
-	});
-}
-function normalizeForgewayUser$1(user) {
-	if (!user?.id || !user.email) throw new Error("Forgeway session response did not include a user email.");
-	return {
-		id: user.id,
-		name: user.profile?.name ?? user.name ?? user.email,
-		email: user.email,
-		avatarUrl: user.profile?.avatar_url ?? user.avatarUrl ?? user.avatar_url ?? null,
-		emailVerified: user.emailVerified ?? user.email_verified ?? false
-	};
-}
-function assertFormalForgewayUser(user) {
-	if (!user || user.emailVerified !== true || isShadowForgewayEmail(user.email)) throw new Error("Dineway account commands require a verified Forgeway account.");
-	return user;
-}
-async function readStoredForgewayAccount(lookup = {}) {
-	const platformApiUrl = normalizeForgewayApiUrl(lookup.platformApiUrl);
-	const email = normalizeForgewayEmail(lookup.email);
-	if (email) return readForgewayCredentials({
-		platformApiUrl,
-		email
-	});
-	const stored = await readForgewayCredentials({ platformApiUrl });
-	if (stored) return stored;
-	const accounts = (await listForgewayCredentials(platformApiUrl)).filter((credentials) => {
-		try {
-			assertFormalForgewayUser(credentials.user);
-			return true;
-		} catch {
-			return false;
-		}
-	});
-	return accounts.length === 1 ? accounts[0] ?? null : null;
-}
-async function refreshForgewayAccountCredentials(credentials) {
-	const user = assertFormalForgewayUser(credentials.user);
-	if (!credentials.refreshToken) throw new Error("Stored Forgeway account is missing a refresh token. Run `dineway account login`.");
-	const { data, error } = await createForgewayAccountClient(credentials.platformApiUrl).auth.refreshSession({ refreshToken: credentials.refreshToken });
-	if (error || !data?.accessToken) throw new Error(error?.message || "Failed to refresh Forgeway account. Run `dineway account login`.");
-	const refreshedUser = normalizeForgewayUser$1(data.user);
-	if (normalizeForgewayEmail(refreshedUser.email) !== normalizeForgewayEmail(user.email)) throw new Error("Forgeway refresh returned credentials for a different account.");
-	const updated = {
-		...credentials,
-		platformApiUrl: normalizeForgewayApiUrl(credentials.platformApiUrl),
-		accessToken: data.accessToken,
-		refreshToken: data.refreshToken ?? credentials.refreshToken,
-		user: {
-			...refreshedUser,
-			emailVerified: true
-		}
-	};
-	await writeForgewayCredentials(updated, {
-		platformApiUrl: updated.platformApiUrl,
-		email: updated.user?.email
-	});
-	return updated;
-}
-async function sendForgewayAccountLoginLink(input) {
-	const platformApiUrl = normalizeForgewayApiUrl(input.platformApiUrl);
-	const webUrl = normalizeDinewayWebUrl(input.webUrl);
-	const redirectTo = new URL("/cli-auth", webUrl).toString();
-	const { error } = await createForgewayAccountClient(platformApiUrl).auth.sendPasswordlessSignInEmail({
-		email: input.email,
-		redirectTo
-	});
-	if (error) throw new Error(error.message || "Failed to send Forgeway account sign-in link.");
-}
-async function completeForgewayAccountLogin(input) {
-	const platformApiUrl = normalizeForgewayApiUrl(input.platformApiUrl);
-	const { data, error } = await createForgewayAccountClient(platformApiUrl).auth.signInWithPasswordlessToken({ token: input.token });
-	if (error || !data?.accessToken || !data.refreshToken) throw new Error(error?.message || "Forgeway sign-in token is invalid or expired.");
-	const user = normalizeForgewayUser$1(data.user);
-	if (input.email && normalizeForgewayEmail(user.email) !== normalizeForgewayEmail(input.email)) throw new Error("Forgeway sign-in returned credentials for a different email.");
-	const credentials = {
-		platformApiUrl,
-		accessToken: data.accessToken,
-		refreshToken: data.refreshToken,
-		user: {
-			...user,
-			emailVerified: true
-		}
-	};
-	await writeForgewayCredentials(credentials, {
-		platformApiUrl,
-		email: credentials.user?.email
-	});
-	return credentials;
-}
-async function getForgewayDinewayAccount(credentials) {
-	const refreshed = await refreshForgewayAccountCredentials(credentials);
-	const { data, error } = await createForgewayAccountClient(refreshed.platformApiUrl, refreshed.accessToken).dineway.getAccount();
-	if (error || !data) throw new Error(error?.message || "Failed to fetch Dineway account status from Forgeway.");
-	return {
-		credentials: refreshed,
-		account: data
-	};
-}
-
-//#endregion
 //#region src/cli/commands/account.ts
 async function promptLine(question) {
 	const readline = createInterface({
@@ -237,12 +113,14 @@ const accountLoginCommand = defineCommand({
 			consola$1.error("Email is required.");
 			process.exit(2);
 		}
+		let validatingStoredAccount = false;
 		try {
 			const existing = await readStoredForgewayAccount({
 				platformApiUrl,
 				email
 			});
 			if (existing && !args.token && !args["send-link"]) {
+				validatingStoredAccount = true;
 				const { account } = await getForgewayDinewayAccount(existing);
 				if (args.json) outputAccountJson({
 					loggedIn: true,
@@ -290,6 +168,15 @@ const accountLoginCommand = defineCommand({
 				consola$1.info(`Hosted sites: ${account.sites.usedHostedSites.toLocaleString()} / ${account.sites.hostedSiteLimitLabel}`);
 			}
 		} catch (error) {
+			if (validatingStoredAccount && error instanceof InvalidForgewayAccountCredentialsError) {
+				await removeStoredForgewayAccount({
+					platformApiUrl,
+					email
+				});
+				consola$1.error("Stored Dineway account credentials were invalid and have been cleared.");
+				consola$1.info(`Run ${pc.cyan(`dineway account login --email ${email}`)} again to sign in.`);
+				process.exit(2);
+			}
 			consola$1.error(error instanceof Error ? error.message : "Dineway account login failed");
 			process.exit(2);
 		}
@@ -1699,6 +1586,66 @@ const flyTarget = {
 	}
 };
 
+//#endregion
+//#region src/cli/commands/deploy/utils/config.ts
+const DINEWAY_DIR_NAME = ".dineway";
+const DEPLOY_STATE_FILE_NAME = "deploy.json";
+function deployStatePath(cwd) {
+	return join(cwd, DINEWAY_DIR_NAME, DEPLOY_STATE_FILE_NAME);
+}
+function emptyDeployState() {
+	return { version: 1 };
+}
+async function readDeployPackageJson(cwd) {
+	const content = await readFile(join(cwd, "package.json"), "utf-8");
+	return JSON.parse(content);
+}
+async function readDeployState(cwd) {
+	try {
+		const content = await readFile(deployStatePath(cwd), "utf-8");
+		return {
+			...emptyDeployState(),
+			...JSON.parse(content),
+			version: 1
+		};
+	} catch (error) {
+		if (error && typeof error === "object" && error.code === "ENOENT") return emptyDeployState();
+		throw error;
+	}
+}
+async function writeDeployState(cwd, state) {
+	await mkdir(join(cwd, DINEWAY_DIR_NAME), { recursive: true });
+	await writeFile(deployStatePath(cwd), JSON.stringify({
+		...state,
+		version: 1
+	}, null, "	") + "\n", "utf-8");
+}
+async function readSavedDeployTarget(cwd) {
+	return (await readDeployState(cwd)).target;
+}
+async function writeDeployTarget(cwd, target) {
+	await writeDeployState(cwd, {
+		...await readDeployState(cwd),
+		target
+	});
+}
+async function readForgewayDeployMetadata(cwd) {
+	return (await readDeployState(cwd)).targets?.forgeway ?? {};
+}
+async function writeForgewayDeployMetadata(cwd, metadata) {
+	const state = await readDeployState(cwd);
+	await writeDeployState(cwd, {
+		...state,
+		targets: {
+			...state.targets,
+			forgeway: {
+				...state.targets?.forgeway,
+				...metadata
+			}
+		}
+	});
+}
+
 //#endregion
 //#region src/cli/commands/deploy/targets/forgeway.ts
 const DEFAULT_DINEWAY_API_BASE_URL = "https://api.dineway.ai";
@@ -3550,7 +3497,7 @@ const devCommand = defineCommand({
 			const remoteUrl = pkg.dineway?.url || process.env.DINEWAY_URL;
 			if (!remoteUrl) consola.warn("No remote URL configured. Set DINEWAY_URL or dineway.url in package.json");
 			else try {
-				const { createClientFromArgs } = await import("../client-factory-BDD9azPJ.mjs").then((n) => n.t);
+				const { createClientFromArgs } = await import("../client-factory-DEtHApCc.mjs").then((n) => n.t);
 				const client = createClientFromArgs({ url: remoteUrl });
 				const schema = await client.schemaExport();
 				const types = await client.schemaTypes();
@@ -4256,6 +4203,76 @@ async function getTaxonomyAssignments(taxonomyRepo, collection, entryId) {
 	return result;
 }
 
+//#endregion
+//#region src/integration-credentials/environment-import.ts
+const INTEGRATION_CREDENTIAL_IMPORT_MARKER = "dineway:integration_credentials_environment_import_v1";
+const INTEGRATION_TOKEN_ENV_SOURCES = [
+	["akta", "AKTA_API_KEY"],
+	["apify", "APIFY_API_TOKEN"],
+	["apollo", "APOLLO_API_KEY"],
+	["bundle-social", "BUNDLE_SOCIAL_API_KEY"],
+	["context.dev", "CONTEXT_DEV_API_KEY"],
+	["elevenlabs", "ELEVENLABS_API_KEY"],
+	["exa", "EXA_API_KEY"],
+	["firecrawl", "FIRECRAWL_API_KEY"],
+	["google-places", "GOOGLE_PLACES_API_KEY"],
+	["minimax", "MINIMAX_API_KEY"],
+	["pdl", "PDL_API_KEY"],
+	["semrush", "SEMRUSH_V4_API_KEY"],
+	["tabapi", "TABAPI_API_KEY"],
+	["tikhub", "TIKHUB_API_KEY"]
+];
+async function importIntegrationCredentialsFromEnvironment(db, env) {
+	if (await new OptionsRepository(db).exists(INTEGRATION_CREDENTIAL_IMPORT_MARKER)) return {
+		status: "already_completed",
+		providers: []
+	};
+	const credentials = collectEnvironmentCredentials(env);
+	const keys = await parseEncryptionKeys(env.DINEWAY_ENCRYPTION_KEY);
+	if (credentials.length > 0 && (!keys || keys.length === 0)) throw new DinewaySecretsError("DINEWAY_ENCRYPTION_KEY is required to import Integration credentials.", "ENCRYPTION_KEY_REQUIRED");
+	await db.transaction().execute(async (trx) => {
+		const store = new IntegrationCredentialStore(trx, { keys: keys ?? [] });
+		for (const entry of credentials) await store.set(entry.provider, entry.credential, "environment");
+		await new OptionsRepository(trx).set(INTEGRATION_CREDENTIAL_IMPORT_MARKER, {
+			completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			providerCount: credentials.length
+		});
+	});
+	return {
+		status: credentials.length > 0 ? "imported" : "completed_empty",
+		providers: credentials.map((entry) => entry.provider)
+	};
+}
+function collectEnvironmentCredentials(env) {
+	const credentials = [];
+	for (const [provider, variable] of INTEGRATION_TOKEN_ENV_SOURCES) {
+		const value = nonEmpty(env[variable]);
+		if (value) credentials.push({
+			provider,
+			credential: {
+				type: "token",
+				value
+			}
+		});
+	}
+	const username = nonEmpty(env.DATAFORSEO_LOGIN);
+	const password = nonEmpty(env.DATAFORSEO_PASSWORD);
+	if (username && !password || !username && password) throw new DinewaySecretsError("DATAFORSEO_LOGIN and DATAFORSEO_PASSWORD must both be set for the initial Integration import.", "INCOMPLETE_INTEGRATION_CREDENTIAL");
+	if (username && password) credentials.push({
+		provider: "dataforseo",
+		credential: {
+			type: "basic",
+			username,
+			password
+		}
+	});
+	return credentials;
+}
+function nonEmpty(value) {
+	const trimmed = value?.trim();
+	return trimmed ? trimmed : null;
+}
+
 //#endregion
 //#region src/cli/commands/init.ts
 /**
@@ -4354,6 +4371,17 @@ const initCommand = defineCommand({
 			await db.destroy();
 			process.exit(1);
 		}
+		try {
+			const imported = await importIntegrationCredentialsFromEnvironment(db, {
+				...readProjectEnv(cwd),
+				...process.env
+			});
+			if (imported.status === "imported") consola.success(`Imported Integration configuration for ${imported.providers.length} providers`);
+		} catch (error) {
+			consola.error("Integration configuration import failed. No provider credentials were stored.", error);
+			await db.destroy();
+			process.exit(1);
+		}
 		const alreadyInitialized = await isAlreadyInitialized(db);
 		if (alreadyInitialized && !args.force) {
 			await db.destroy();
@@ -5463,7 +5491,7 @@ const publishCommand = defineCommand({
 			const pluginDir = resolve(args.dir);
 			try {
 				const { runCommand } = await import("citty");
-				const { bundleCommand } = await import("../bundle-CEcdUa1s.mjs").then((n) => n.n);
+				const { bundleCommand } = await import("../bundle-CIrUlrkQ.mjs").then((n) => n.n);
 				await runCommand(bundleCommand, { rawArgs: ["--dir", pluginDir] });
 			} catch {
 				consola.error("Build failed");
@@ -6939,31 +6967,6 @@ const jsonArgs = { json: {
 	type: "boolean",
 	description: "Output as JSON"
 } };
-const hostedProviderArgs = {
-	...jsonArgs,
-	"force-refresh": {
-		type: "boolean",
-		description: "Bypass Forgeway SEO provider cache"
-	}
-};
-const dataForSeoCommonArgs = {
-	...hostedProviderArgs,
-	"location-code": {
-		type: "string",
-		description: "DataForSEO location code",
-		default: "2840"
-	},
-	"language-code": {
-		type: "string",
-		description: "DataForSEO language code",
-		default: "en"
-	},
-	device: {
-		type: "string",
-		description: "Device type: desktop or mobile",
-		default: "desktop"
-	}
-};
 function toStringValue(value) {
 	return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
@@ -6973,9 +6976,6 @@ function toNumberValue(value, fallback) {
 	const parsed = Number(raw);
 	return Number.isFinite(parsed) ? parsed : fallback;
 }
-function forceRefresh(args) {
-	return args["force-refresh"] === true;
-}
 function formats(value) {
 	const raw = toStringValue(value);
 	if (!raw) return void 0;
@@ -7078,420 +7078,13 @@ const crawlCommand = defineCommand({
 		}
 	}) }
 });
-function dataForSeoDevice(value) {
-	const normalized = toStringValue(value) ?? "desktop";
-	if (normalized === "desktop" || normalized === "mobile") return normalized;
-	throw new Error("device must be desktop or mobile.");
-}
-function aiScrapePlatform(value) {
-	const normalized = toStringValue(value) ?? "chat_gpt";
-	if (normalized === "chat_gpt" || normalized === "gemini" || normalized === "perplexity") return normalized;
-	throw new Error("platform must be chat_gpt, gemini, or perplexity.");
-}
-function aiMentionPlatform(value) {
-	const normalized = toStringValue(value) ?? "google";
-	if (normalized === "google" || normalized === "chat_gpt") return normalized;
-	throw new Error("platform must be google or chat_gpt.");
-}
-function dataForSeoBase(args) {
-	return {
-		locationCode: toNumberValue(args["location-code"], 2840),
-		languageCode: toStringValue(args["language-code"]) ?? "en",
-		device: dataForSeoDevice(args.device),
-		forceRefresh: forceRefresh(args)
-	};
-}
-function createSeoCommand(options = {}) {
-	const providerService = options.providerService ?? new SeoProviderEvidenceService(new ForgewaySeoGatewayClient());
-	async function runSeoRequest(args, resource, request) {
-		configureOutputMode(args);
-		try {
-			output(await request(), args);
-		} catch (error) {
-			if (await handleCliPaywall({
-				error,
-				resource,
-				context: { providerPath: resource }
-			})) process.exit(2);
-			consola$1.error(error instanceof Error ? error.message : "Unknown error");
-			process.exit(1);
-		}
-	}
-	const firecrawlCommand = defineCommand({
-		meta: {
-			name: "firecrawl",
-			description: "Forgeway-hosted Firecrawl workflows"
-		},
-		subCommands: {
-			scrape: defineCommand({
-				meta: {
-					name: "scrape",
-					description: "Scrape one URL through Forgeway-hosted Firecrawl"
-				},
-				args: {
-					url: {
-						type: "positional",
-						description: "URL to scrape",
-						required: true
-					},
-					...hostedProviderArgs,
-					formats: {
-						type: "string",
-						description: "Comma-separated Firecrawl formats",
-						default: "markdown"
-					},
-					"only-main-content": {
-						type: "boolean",
-						description: "Return main content only",
-						default: true
-					},
-					"timeout-ms": {
-						type: "string",
-						description: "Provider timeout in milliseconds",
-						default: "60000"
-					}
-				},
-				async run({ args }) {
-					await runSeoRequest(args, "/api/firecrawl/scrape", () => providerService.firecrawlScrape({
-						url: requireArg(args.url, "url"),
-						formats: formats(args.formats) ?? ["markdown"],
-						onlyMainContent: args["only-main-content"] !== false,
-						timeoutMs: toNumberValue(args["timeout-ms"], 6e4),
-						forceRefresh: forceRefresh(args)
-					}));
-				}
-			}),
-			map: defineCommand({
-				meta: {
-					name: "map",
-					description: "Map URLs through Forgeway-hosted Firecrawl"
-				},
-				args: {
-					url: {
-						type: "positional",
-						description: "Base URL to map",
-						required: true
-					},
-					...hostedProviderArgs,
-					search: {
-						type: "string",
-						description: "Optional relevance search term"
-					},
-					sitemap: {
-						type: "string",
-						description: "Sitemap mode: skip, include, or only",
-						default: "include"
-					},
-					limit: {
-						type: "string",
-						description: "Maximum URLs",
-						default: "100"
-					},
-					"include-subdomains": {
-						type: "boolean",
-						description: "Include subdomains"
-					},
-					"ignore-query-parameters": {
-						type: "boolean",
-						description: "Ignore query parameters",
-						default: true
-					}
-				},
-				async run({ args }) {
-					await runSeoRequest(args, "/api/firecrawl/map", () => providerService.firecrawlMap({
-						url: requireArg(args.url, "url"),
-						search: toStringValue(args.search),
-						sitemap: sitemapMode(args.sitemap),
-						limit: toNumberValue(args.limit, 100),
-						includeSubdomains: args["include-subdomains"] === true,
-						ignoreQueryParameters: args["ignore-query-parameters"] !== false,
-						forceRefresh: forceRefresh(args)
-					}));
-				}
-			}),
-			crawl: defineCommand({
-				meta: {
-					name: "crawl",
-					description: "Start a bounded Firecrawl crawl, or check status with --id"
-				},
-				args: {
-					url: {
-						type: "positional",
-						description: "Base URL to crawl",
-						required: false
-					},
-					...hostedProviderArgs,
-					id: {
-						type: "string",
-						description: "Existing Firecrawl crawl id to check"
-					},
-					limit: {
-						type: "string",
-						description: "Maximum pages",
-						default: "25"
-					},
-					"max-depth": {
-						type: "string",
-						description: "Maximum discovery depth",
-						default: "3"
-					},
-					"allow-subdomains": {
-						type: "boolean",
-						description: "Allow subdomains"
-					},
-					"allow-external-links": {
-						type: "boolean",
-						description: "Allow external links"
-					},
-					formats: {
-						type: "string",
-						description: "Comma-separated scrape formats",
-						default: "markdown"
-					}
-				},
-				async run({ args }) {
-					const crawlId = toStringValue(args.id);
-					if (crawlId) {
-						await runSeoRequest(args, `/api/firecrawl/crawl/${crawlId}`, () => providerService.firecrawlCrawlStatus({ id: crawlId }));
-						return;
-					}
-					await runSeoRequest(args, "/api/firecrawl/crawl", () => providerService.firecrawlCrawlStart({
-						url: requireArg(args.url, "url"),
-						limit: toNumberValue(args.limit, 25),
-						maxDiscoveryDepth: toNumberValue(args["max-depth"], 3),
-						allowExternalLinks: args["allow-external-links"] === true,
-						allowSubdomains: args["allow-subdomains"] === true,
-						scrapeFormats: formats(args.formats) ?? ["markdown"],
-						forceRefresh: forceRefresh(args)
-					}));
-				}
-			}),
-			search: defineCommand({
-				meta: {
-					name: "search",
-					description: "Search through Forgeway-hosted Firecrawl"
-				},
-				args: {
-					query: {
-						type: "positional",
-						description: "Search query",
-						required: true
-					},
-					...hostedProviderArgs,
-					limit: {
-						type: "string",
-						description: "Maximum results",
-						default: "10"
-					},
-					scrape: {
-						type: "boolean",
-						description: "Scrape result markdown"
-					}
-				},
-				async run({ args }) {
-					await runSeoRequest(args, "/api/firecrawl/search", () => providerService.firecrawlSearch({
-						query: requireArg(args.query, "query"),
-						limit: toNumberValue(args.limit, 10),
-						scrape: args.scrape === true,
-						forceRefresh: forceRefresh(args)
-					}));
-				}
-			})
-		}
-	});
-	const dataForSeoSerpCommand = defineCommand({
-		meta: {
-			name: "serp",
-			description: "Fetch Google organic SERP data"
-		},
-		args: {
-			keyword: {
-				type: "positional",
-				description: "Keyword",
-				required: true
-			},
-			...dataForSeoCommonArgs,
-			depth: {
-				type: "string",
-				description: "SERP depth",
-				default: "10"
-			}
-		},
-		async run({ args }) {
-			await runSeoRequest(args, "/api/dataforseo/serp", () => providerService.dataForSeoSerp({
-				keyword: requireArg(args.keyword, "keyword"),
-				depth: toNumberValue(args.depth, 10),
-				...dataForSeoBase(args)
-			}));
-		}
-	});
-	const dataForSeoMapsCommand = defineCommand({
-		meta: {
-			name: "maps",
-			description: "Fetch Google Maps SERP data"
-		},
-		args: {
-			keyword: {
-				type: "positional",
-				description: "Keyword",
-				required: true
-			},
-			...dataForSeoCommonArgs,
-			depth: {
-				type: "string",
-				description: "Maps depth",
-				default: "10"
-			}
-		},
-		async run({ args }) {
-			await runSeoRequest(args, "/api/dataforseo/maps", () => providerService.dataForSeoMaps({
-				keyword: requireArg(args.keyword, "keyword"),
-				depth: toNumberValue(args.depth, 10),
-				...dataForSeoBase(args)
-			}));
-		}
-	});
-	const dataForSeoKeywordsCommand = defineCommand({
-		meta: {
-			name: "keywords",
-			description: "Fetch keyword suggestions"
-		},
-		args: {
-			keyword: {
-				type: "positional",
-				description: "Seed keyword",
-				required: true
-			},
-			...dataForSeoCommonArgs,
-			limit: {
-				type: "string",
-				description: "Maximum suggestions",
-				default: "20"
-			}
-		},
-		async run({ args }) {
-			await runSeoRequest(args, "/api/dataforseo/keywords", () => providerService.dataForSeoKeywords({
-				keyword: requireArg(args.keyword, "keyword"),
-				limit: toNumberValue(args.limit, 20),
-				...dataForSeoBase(args)
-			}));
-		}
-	});
-	const dataForSeoCompetitorsCommand = defineCommand({
-		meta: {
-			name: "competitors",
-			description: "Fetch competitor-domain data"
-		},
-		args: {
-			domain: {
-				type: "positional",
-				description: "Target domain",
-				required: true
-			},
-			...dataForSeoCommonArgs,
-			limit: {
-				type: "string",
-				description: "Maximum competitors",
-				default: "20"
-			}
-		},
-		async run({ args }) {
-			await runSeoRequest(args, "/api/dataforseo/competitors", () => providerService.dataForSeoCompetitors({
-				domain: requireArg(args.domain, "domain"),
-				limit: toNumberValue(args.limit, 20),
-				...dataForSeoBase(args)
-			}));
-		}
-	});
-	const dataForSeoAiScrapeCommand = defineCommand({
-		meta: {
-			name: "ai-scrape",
-			description: "Fetch DataForSEO AI scraper response data"
-		},
-		args: {
-			keyword: {
-				type: "positional",
-				description: "AI search keyword",
-				required: true
-			},
-			...dataForSeoCommonArgs,
-			platform: {
-				type: "string",
-				description: "AI platform: chat_gpt, gemini, or perplexity",
-				default: "chat_gpt"
-			}
-		},
-		async run({ args }) {
-			await runSeoRequest(args, "/api/dataforseo/ai-scrape", () => providerService.dataForSeoAiScrape({
-				keyword: requireArg(args.keyword, "keyword"),
-				platform: aiScrapePlatform(args.platform),
-				...dataForSeoBase(args)
-			}));
-		}
-	});
-	const dataForSeoAiMentionsCommand = defineCommand({
-		meta: {
-			name: "ai-mentions",
-			description: "Fetch DataForSEO LLM mention data"
-		},
-		args: {
-			...dataForSeoCommonArgs,
-			domain: {
-				type: "string",
-				description: "Target domain"
-			},
-			keyword: {
-				type: "string",
-				description: "Target keyword"
-			},
-			platform: {
-				type: "string",
-				description: "Mention platform: google or chat_gpt",
-				default: "google"
-			},
-			limit: {
-				type: "string",
-				description: "Maximum mentions",
-				default: "20"
-			}
-		},
-		async run({ args }) {
-			if (!toStringValue(args.domain) && !toStringValue(args.keyword)) {
-				consola$1.error("domain or keyword is required.");
-				process.exit(1);
-			}
-			await runSeoRequest(args, "/api/dataforseo/ai-mentions", () => providerService.dataForSeoAiMentions({
-				domain: toStringValue(args.domain),
-				keyword: toStringValue(args.keyword),
-				platform: aiMentionPlatform(args.platform),
-				limit: toNumberValue(args.limit, 20),
-				...dataForSeoBase(args)
-			}));
-		}
-	});
+function createSeoCommand() {
 	return defineCommand({
 		meta: {
 			name: "seo",
-			description: "Local site evidence and hosted SEO provider workflows"
+			description: "Deterministic local SEO evidence"
 		},
-		subCommands: {
-			crawl: crawlCommand,
-			firecrawl: firecrawlCommand,
-			dataforseo: defineCommand({
-				meta: {
-					name: "dataforseo",
-					description: "Forgeway-hosted DataForSEO workflows"
-				},
-				subCommands: {
-					serp: dataForSeoSerpCommand,
-					maps: dataForSeoMapsCommand,
-					keywords: dataForSeoKeywordsCommand,
-					competitors: dataForSeoCompetitorsCommand,
-					"ai-scrape": dataForSeoAiScrapeCommand,
-					"ai-mentions": dataForSeoAiMentionsCommand
-				}
-			})
-		}
+		subCommands: { crawl: crawlCommand }
 	});
 }
 const seoCommand = createSeoCommand();
@@ -7613,6 +7206,449 @@ const taxonomyCommand = defineCommand({
 	}
 });
 
+//#endregion
+//#region src/cli/commands/tools.ts
+const ENV_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const CREDENTIAL_HEADER_PATTERN = /^(authorization|proxy-authorization|x-api-key|api-key|apikey|token|access-token|private-key)$/i;
+const accountArgs = {
+	email: {
+		type: "string",
+		alias: "e",
+		description: "Forgeway account email"
+	},
+	"api-url": {
+		type: "string",
+		description: "Forgeway API URL",
+		default: DEFAULT_FORGEWAY_API_BASE_URL
+	},
+	json: {
+		type: "boolean",
+		description: "Output the complete JSON response"
+	}
+};
+const endpointArgs = {
+	provider: {
+		type: "string",
+		alias: "p",
+		description: "Provider slug",
+		required: true
+	},
+	endpoint: {
+		type: "string",
+		alias: "e",
+		description: "Provider endpoint path",
+		required: true
+	}
+};
+const credentialReferenceArgs = {
+	"credential-token-env": {
+		type: "string",
+		description: "Environment variable containing a request-scoped provider token"
+	},
+	"credential-basic-username-env": {
+		type: "string",
+		description: "Environment variable containing a request-scoped basic-auth username"
+	},
+	"credential-basic-password-env": {
+		type: "string",
+		description: "Environment variable containing a request-scoped basic-auth password"
+	}
+};
+function createToolsCommand(options = {}) {
+	const createService = options.createService ?? createCliToolsService;
+	return defineCommand({
+		meta: {
+			name: "tools",
+			description: "Discover, inspect, and run Forgeway Integration endpoints"
+		},
+		subCommands: {
+			discover: defineCommand({
+				meta: {
+					name: "discover",
+					description: "Find Forgeway Integration endpoints from a natural-language need"
+				},
+				args: {
+					...accountArgs,
+					query: {
+						type: "string",
+						alias: "q",
+						description: "Natural-language endpoint need",
+						required: true
+					},
+					limit: {
+						type: "string",
+						alias: "l",
+						description: "Maximum results (1-100)"
+					},
+					"min-score": {
+						type: "string",
+						description: "Minimum relevance score (0-1)"
+					}
+				},
+				async run({ args }) {
+					await executeToolsCommand(args, async (resolvedArgs) => {
+						const result = await (await createService(resolvedArgs)).discover({
+							query: requiredString(resolvedArgs.query, "query"),
+							limit: optionalNumber(resolvedArgs.limit, "limit", {
+								integer: true,
+								min: 1,
+								max: 100
+							}) ?? 10,
+							minScore: optionalNumber(resolvedArgs["min-score"], "min-score", {
+								min: 0,
+								max: 1
+							})
+						});
+						emitResult(result, discoverSummary(result), resolvedArgs);
+					});
+				}
+			}),
+			inspect: defineCommand({
+				meta: {
+					name: "inspect",
+					description: "Inspect an endpoint schema, output, credits, cache, and risk contract"
+				},
+				args: {
+					...accountArgs,
+					...endpointArgs
+				},
+				async run({ args }) {
+					await executeToolsCommand(args, async (resolvedArgs) => {
+						const result = await (await createService(resolvedArgs)).inspect(endpointRequest(resolvedArgs));
+						emitResult(result, inspectSummary(result), resolvedArgs);
+					});
+				}
+			}),
+			run: defineCommand({
+				meta: {
+					name: "run",
+					description: "Run one inspected Forgeway Integration endpoint"
+				},
+				args: {
+					...accountArgs,
+					...endpointArgs,
+					...credentialReferenceArgs,
+					input: {
+						type: "string",
+						alias: "i",
+						description: "Body JSON"
+					},
+					"input-file": {
+						type: "string",
+						alias: "f",
+						description: "Read body JSON from a file"
+					},
+					query: {
+						type: "string",
+						description: "Query parameters JSON object"
+					},
+					path: {
+						type: "string",
+						description: "Path parameters JSON object"
+					},
+					header: {
+						type: "string",
+						description: "Non-credential header parameters JSON object"
+					},
+					wait: {
+						type: "boolean",
+						alias: "w",
+						description: "Wait for a terminal run state"
+					},
+					"wait-timeout": {
+						type: "string",
+						description: "Maximum wait in seconds",
+						default: "300"
+					},
+					output: {
+						type: "string",
+						alias: "o",
+						description: "Write provider output as JSON"
+					},
+					"force-refresh": {
+						type: "boolean",
+						description: "Bypass eligible Forgeway cache"
+					},
+					"confirm-side-effect": {
+						type: "boolean",
+						description: "Confirm the inspected endpoint's external side effect"
+					},
+					"idempotency-key": {
+						type: "string",
+						description: "Stable idempotency key required for side-effecting endpoints"
+					}
+				},
+				async run({ args }) {
+					await executeToolsCommand(args, async (resolvedArgs) => {
+						if (resolvedArgs["confirm-side-effect"] && !resolvedArgs["idempotency-key"]) throw new DinewayToolsError("--confirm-side-effect requires --idempotency-key.", "IDEMPOTENCY_KEY_REQUIRED");
+						const service = await createService(resolvedArgs);
+						const result = await service.run({
+							...endpointRequest(resolvedArgs),
+							input: await parseEndpointInput(resolvedArgs),
+							credential: resolveInlineCredential(resolvedArgs),
+							forceRefresh: resolvedArgs["force-refresh"] === true,
+							confirmSideEffect: resolvedArgs["confirm-side-effect"] === true
+						}, { idempotencyKey: optionalString(resolvedArgs["idempotency-key"]) });
+						const finalResult = resolvedArgs.wait ? await service.waitForRun(result.runId, { timeoutMs: requiredNumber(resolvedArgs["wait-timeout"], "wait-timeout", { min: 1 }) * 1e3 }) : result;
+						if (resolvedArgs.output) await writeFile(resolvedArgs.output, JSON.stringify(finalResult.output ?? finalResult.artifact ?? finalResult, null, 2) + "\n", "utf-8");
+						emitResult(finalResult, runSummary(finalResult), resolvedArgs);
+					});
+				}
+			}),
+			runs: defineCommand({
+				meta: {
+					name: "runs",
+					description: "List, get, poll, and stop Integration runs"
+				},
+				subCommands: {
+					list: defineCommand({
+						meta: {
+							name: "list",
+							description: "List recent Forgeway Integration runs"
+						},
+						args: {
+							...accountArgs,
+							limit: {
+								type: "string",
+								alias: "l",
+								description: "Maximum runs (1-100)"
+							},
+							cursor: {
+								type: "string",
+								description: "Pagination cursor"
+							}
+						},
+						async run({ args }) {
+							await executeToolsCommand(args, async (resolvedArgs) => {
+								const result = await (await createService(resolvedArgs)).listRuns({
+									limit: optionalNumber(resolvedArgs.limit, "limit", {
+										integer: true,
+										min: 1,
+										max: 100
+									}),
+									cursor: optionalString(resolvedArgs.cursor)
+								});
+								emitResult(result, runsSummary(result.items, result.nextCursor), resolvedArgs);
+							});
+						}
+					}),
+					get: defineCommand({
+						meta: {
+							name: "get",
+							description: "Get or poll one Forgeway Integration run"
+						},
+						args: {
+							...accountArgs,
+							"run-id": {
+								type: "string",
+								alias: "r",
+								description: "Run ID",
+								required: true
+							},
+							wait: {
+								type: "boolean",
+								alias: "w",
+								description: "Wait for a terminal run state"
+							},
+							"wait-timeout": {
+								type: "string",
+								description: "Maximum wait in seconds",
+								default: "300"
+							}
+						},
+						async run({ args }) {
+							await executeToolsCommand(args, async (resolvedArgs) => {
+								const service = await createService(resolvedArgs);
+								const runId = requiredString(resolvedArgs["run-id"], "run-id");
+								const result = resolvedArgs.wait ? await service.waitForRun(runId, { timeoutMs: requiredNumber(resolvedArgs["wait-timeout"], "wait-timeout", { min: 1 }) * 1e3 }) : await service.getRun(runId);
+								emitResult(result, runSummary(result), resolvedArgs);
+							});
+						}
+					}),
+					stop: defineCommand({
+						meta: {
+							name: "stop",
+							description: "Request cancellation for a stoppable Integration run"
+						},
+						args: {
+							...accountArgs,
+							...credentialReferenceArgs,
+							"run-id": {
+								type: "string",
+								alias: "r",
+								description: "Run ID",
+								required: true
+							}
+						},
+						async run({ args }) {
+							await executeToolsCommand(args, async (resolvedArgs) => {
+								const result = await (await createService(resolvedArgs)).stopRun(requiredString(resolvedArgs["run-id"], "run-id"), { credential: resolveInlineCredential(resolvedArgs) });
+								emitResult(result, result, resolvedArgs);
+							});
+						}
+					})
+				}
+			})
+		}
+	});
+}
+const toolsCommand = createToolsCommand();
+async function createCliToolsService(args) {
+	const credentials = await readStoredForgewayAccount({
+		platformApiUrl: normalizeForgewayApiUrl(optionalString(args["api-url"]) ?? process.env["DINEWAY_API_BASE_URL"] ?? process.env["FORGEWAY_API_URL"]),
+		email: normalizeForgewayEmail(optionalString(args.email))
+	});
+	if (!credentials) throw new DinewayToolsError("Dineway Tools requires a verified Forgeway account. Run `dineway account login`.", "FORGEWAY_ACCOUNT_REQUIRED");
+	const refreshed = await refreshForgewayAccountCredentials(credentials);
+	return new DinewayToolsService(createForgewayAccountClient(refreshed.platformApiUrl, refreshed.accessToken).integration);
+}
+async function executeToolsCommand(args, operation) {
+	configureOutputMode(args);
+	try {
+		await operation(args);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Dineway Tools request failed.";
+		consola$1.error(message);
+		process.exitCode = 2;
+	}
+}
+function endpointRequest(args) {
+	const endpoint = requiredString(args.endpoint, "endpoint");
+	if (!endpoint.startsWith("/")) throw new DinewayToolsError("Endpoint must start with '/'.", "INVALID_ENDPOINT");
+	return {
+		provider: requiredString(args.provider, "provider"),
+		endpoint
+	};
+}
+async function parseEndpointInput(args) {
+	if (args.input && args["input-file"]) throw new DinewayToolsError("Choose either --input or --input-file, not both.", "DUPLICATE_BODY_INPUT");
+	const body = args["input-file"] ? parseJson(await readFile(args["input-file"], "utf-8"), "input-file") : args.input ? parseJson(args.input, "input") : void 0;
+	const queryParams = parseJsonObject(args.query, "query");
+	const pathParams = parseJsonObject(args.path, "path");
+	const headerParams = parseHeaderParams(args.header);
+	return {
+		...body === void 0 ? {} : { body },
+		...queryParams ? { queryParams } : {},
+		...pathParams ? { pathParams } : {},
+		...headerParams ? { headerParams } : {}
+	};
+}
+function resolveInlineCredential(args) {
+	const tokenEnv = optionalString(args["credential-token-env"]);
+	const usernameEnv = optionalString(args["credential-basic-username-env"]);
+	const passwordEnv = optionalString(args["credential-basic-password-env"]);
+	if (tokenEnv && (usernameEnv || passwordEnv)) throw new DinewayToolsError("Choose either token or basic credential environment references, not both.", "CREDENTIAL_MODE_CONFLICT");
+	if (usernameEnv && !passwordEnv || !usernameEnv && passwordEnv) throw new DinewayToolsError("Basic credential username and password environment references must be provided together.", "INCOMPLETE_BASIC_CREDENTIAL");
+	if (tokenEnv) return {
+		type: "token",
+		value: readCredentialEnvironmentValue(tokenEnv)
+	};
+	if (usernameEnv && passwordEnv) return {
+		type: "basic",
+		username: readCredentialEnvironmentValue(usernameEnv),
+		password: readCredentialEnvironmentValue(passwordEnv)
+	};
+}
+function readCredentialEnvironmentValue(name) {
+	if (!ENV_NAME_PATTERN.test(name)) throw new DinewayToolsError(`Invalid credential environment variable name: ${name}`, "INVALID_CREDENTIAL_ENV_NAME");
+	const value = process.env[name];
+	if (!value) throw new DinewayToolsError(`Credential environment variable ${name} is not set.`, "CREDENTIAL_ENV_MISSING");
+	return value;
+}
+function parseHeaderParams(raw) {
+	const value = parseJsonObject(raw, "header");
+	if (!value) return void 0;
+	for (const name of Object.keys(value)) if (CREDENTIAL_HEADER_PATTERN.test(name)) throw new DinewayToolsError("Credential headers are not allowed. Use environment credential references.", "CREDENTIAL_HEADER_FORBIDDEN");
+	return value;
+}
+function parseJsonObject(raw, label) {
+	if (raw === void 0) return void 0;
+	const value = parseJson(requiredString(raw, label), label);
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new DinewayToolsError(`--${label} must be a JSON object.`, "INVALID_JSON_OBJECT");
+	return value;
+}
+function parseJson(raw, label) {
+	try {
+		const value = JSON.parse(raw);
+		if (!isIntegrationJsonValue(value)) throw new Error("Unsupported JSON value");
+		return value;
+	} catch {
+		throw new DinewayToolsError(`--${label} contains invalid JSON.`, "INVALID_JSON");
+	}
+}
+function isIntegrationJsonValue(value) {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+	if (typeof value === "number") return Number.isFinite(value);
+	if (Array.isArray(value)) return value.every(isIntegrationJsonValue);
+	if (typeof value !== "object") return false;
+	return Object.values(value).every(isIntegrationJsonValue);
+}
+function requiredString(value, label) {
+	const resolved = optionalString(value);
+	if (!resolved) throw new DinewayToolsError(`--${label} is required.`, "MISSING_ARGUMENT");
+	return resolved;
+}
+function optionalString(value) {
+	return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function optionalNumber(value, label, options) {
+	return value === void 0 ? void 0 : requiredNumber(value, label, options);
+}
+function requiredNumber(value, label, options) {
+	const parsed = Number(value);
+	if (!Number.isFinite(parsed) || options.integer && !Number.isInteger(parsed) || options.min !== void 0 && parsed < options.min || options.max !== void 0 && parsed > options.max) throw new DinewayToolsError(`--${label} has an invalid numeric value.`, "INVALID_NUMBER");
+	return parsed;
+}
+function emitResult(full, human, args) {
+	output(args.json || !process.stdout.isTTY ? full : human, args);
+}
+function discoverSummary(result) {
+	return {
+		query: result.query,
+		count: result.count,
+		items: result.results.map(({ endpoint, score }) => ({
+			provider: endpoint.provider,
+			endpoint: endpoint.endpoint,
+			name: endpoint.displayName,
+			score: Number(score.toFixed(3)),
+			estimatedCredits: endpoint.pricing.estimatedCredits,
+			risk: endpoint.risk.level
+		}))
+	};
+}
+function inspectSummary(result) {
+	return {
+		provider: result.provider,
+		endpoint: result.endpoint,
+		method: result.method,
+		name: result.displayName,
+		pricing: result.pricing,
+		cache: result.cache,
+		risk: result.risk,
+		async: result.async,
+		input: result.input
+	};
+}
+function runSummary(result) {
+	return {
+		runId: result.runId,
+		provider: result.provider,
+		endpoint: result.endpoint,
+		status: result.status,
+		stoppable: result.stoppable,
+		cache: result.cache,
+		billing: result.billing,
+		artifact: result.artifact,
+		error: result.error
+	};
+}
+function runsSummary(items, nextCursor) {
+	return {
+		items: items.map(runSummary),
+		...nextCursor ? { nextCursor } : {}
+	};
+}
+
 //#endregion
 //#region src/cli/commands/types.ts
 /**
@@ -7789,6 +7825,7 @@ const builtInCommands = {
 	schema: schemaCommand,
 	media: mediaCommand,
 	search: searchCommand,
+	tools: toolsCommand,
 	seo: seoCommand,
 	taxonomy: taxonomyCommand,
 	menu: menuCommand,