dineway 0.1.49 → 0.2.1

package/dist/forgeway-seo-client-G5ddhVHd.mjs

@@ -0,0 +1,456 @@
+import { i as getProjectEnvValue } from "./project-env-DKibmuP8.mjs";
+import { randomUUID } from "node:crypto";
+import { z } from "zod";
+import { join } from "node:path";
+import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+
+//#region src/cli/commands/deploy/utils/forgeway-secrets.ts
+const DINEWAY_USER_CONFIG_DIR_NAME = "dineway";
+const TRAILING_SLASH_PATTERN$1 = /\/$/;
+function getDinewayUserConfigDir() {
+	return join(process.env.XDG_CONFIG_HOME || join(homedir(), ".config"), DINEWAY_USER_CONFIG_DIR_NAME);
+}
+function getForgewayAccountSecretPath() {
+	return join(getDinewayUserConfigDir(), "forgeway.json");
+}
+function normalizePlatformApiUrl(platformApiUrl) {
+	return platformApiUrl.replace(TRAILING_SLASH_PATTERN$1, "");
+}
+function normalizeEmail$1(email) {
+	return email.trim().toLowerCase();
+}
+function accountKey(platformApiUrl, email) {
+	return `${normalizePlatformApiUrl(platformApiUrl)}#${normalizeEmail$1(email)}`;
+}
+function normalizeLookup(lookup) {
+	if (typeof lookup === "string") return { cwd: lookup };
+	return lookup ?? {};
+}
+async function readAccountStore() {
+	try {
+		const raw = await readFile(getForgewayAccountSecretPath(), "utf-8");
+		return JSON.parse(raw);
+	} catch {
+		return { version: 1 };
+	}
+}
+async function writeAccountStore(store) {
+	await mkdir(getDinewayUserConfigDir(), {
+		recursive: true,
+		mode: 448
+	});
+	const file = getForgewayAccountSecretPath();
+	await writeFile(file, JSON.stringify({
+		...store,
+		version: 1
+	}, null, "	") + "\n", {
+		encoding: "utf-8",
+		mode: 384
+	});
+	await chmod(file, 384);
+}
+function accountMatches(credentials, lookup) {
+	if (lookup.platformApiUrl && normalizePlatformApiUrl(credentials.platformApiUrl) !== normalizePlatformApiUrl(lookup.platformApiUrl)) return false;
+	if (lookup.email && normalizeEmail$1(credentials.user?.email ?? "") !== normalizeEmail$1(lookup.email)) return false;
+	return true;
+}
+async function readForgewayCredentials(lookup) {
+	const normalizedLookup = normalizeLookup(lookup);
+	const store = await readAccountStore();
+	const accounts = Object.values(store.accounts ?? {}).filter((credentials) => accountMatches(credentials, normalizedLookup));
+	if (normalizedLookup.platformApiUrl && normalizedLookup.email) return store.accounts?.[accountKey(normalizedLookup.platformApiUrl, normalizedLookup.email)] ?? null;
+	if (accounts.length === 1) return accounts[0] ?? null;
+	return null;
+}
+async function writeForgewayCredentials(credentials, lookup) {
+	const normalizedLookup = normalizeLookup(lookup);
+	const platformApiUrl = normalizePlatformApiUrl(normalizedLookup.platformApiUrl ?? credentials.platformApiUrl);
+	const email = normalizeEmail$1(normalizedLookup.email ?? credentials.user?.email ?? "");
+	if (!email) throw new Error("Forgeway credentials require a user email before they can be stored.");
+	const key = accountKey(platformApiUrl, email);
+	const store = await readAccountStore();
+	store.accounts = {
+		...store.accounts,
+		[key]: {
+			...credentials,
+			platformApiUrl
+		}
+	};
+	store.lastAccountKey = key;
+	await writeAccountStore(store);
+}
+async function listForgewayCredentials(platformApiUrl) {
+	const lookup = platformApiUrl ? { platformApiUrl } : {};
+	const store = await readAccountStore();
+	return Object.values(store.accounts ?? {}).filter((credentials) => accountMatches(credentials, lookup));
+}
+
+//#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/seo/provider-evidence.ts
+const httpUrlSchema = z.string().trim().min(1).max(2048).refine((value) => {
+	try {
+		const url = new URL(value);
+		return url.protocol === "http:" || url.protocol === "https:";
+	} catch {
+		return false;
+	}
+}, "URL must use http or https");
+const boundedText = (label, max) => z.string().trim().min(1, `${label} is required`).max(max);
+const forceRefreshSchema = z.boolean().default(false);
+const formatSchema = boundedText("format", 50);
+const formatsSchema = z.array(formatSchema).min(1).max(10).default(["markdown"]);
+const limitSchema = z.number().int().min(1).max(1e3);
+const deviceSchema = z.enum(["desktop", "mobile"]);
+const firecrawlScrapeInputSchema = z.object({
+	url: httpUrlSchema,
+	formats: formatsSchema,
+	onlyMainContent: z.boolean().default(true),
+	timeoutMs: z.number().int().min(1e3).max(12e4).default(6e4),
+	forceRefresh: forceRefreshSchema
+}).strict();
+const firecrawlMapInputSchema = z.object({
+	url: httpUrlSchema,
+	search: boundedText("search", 500).optional(),
+	sitemap: z.enum([
+		"skip",
+		"include",
+		"only"
+	]).default("include"),
+	limit: limitSchema.default(100),
+	includeSubdomains: z.boolean().default(false),
+	ignoreQueryParameters: z.boolean().default(true),
+	forceRefresh: forceRefreshSchema
+}).strict();
+const firecrawlCrawlStartInputSchema = z.object({
+	url: httpUrlSchema,
+	limit: limitSchema.default(25),
+	maxDiscoveryDepth: z.number().int().min(0).max(20).default(3),
+	allowExternalLinks: z.boolean().default(false),
+	allowSubdomains: z.boolean().default(false),
+	scrapeFormats: formatsSchema,
+	forceRefresh: forceRefreshSchema
+}).strict();
+const firecrawlCrawlStatusInputSchema = z.object({ id: boundedText("crawl id", 500) }).strict();
+const firecrawlSearchInputSchema = z.object({
+	query: boundedText("query", 1e3),
+	limit: limitSchema.default(10),
+	scrape: z.boolean().default(false),
+	forceRefresh: forceRefreshSchema
+}).strict();
+const dataForSeoCommonShape = {
+	locationCode: z.number().int().min(1).max(1e7).default(2840),
+	languageCode: boundedText("language code", 20).default("en"),
+	device: deviceSchema.default("desktop"),
+	forceRefresh: forceRefreshSchema
+};
+const dataForSeoSerpInputSchema = z.object({
+	keyword: boundedText("keyword", 1e3),
+	depth: z.number().int().min(1).max(100).default(10),
+	...dataForSeoCommonShape
+}).strict();
+const dataForSeoMapsInputSchema = z.object({
+	keyword: boundedText("keyword", 1e3),
+	depth: z.number().int().min(1).max(100).default(10),
+	...dataForSeoCommonShape
+}).strict();
+const dataForSeoKeywordsInputSchema = z.object({
+	keyword: boundedText("keyword", 1e3),
+	limit: limitSchema.default(20),
+	...dataForSeoCommonShape
+}).strict();
+const dataForSeoCompetitorsInputSchema = z.object({
+	domain: boundedText("domain", 253),
+	limit: limitSchema.default(20),
+	...dataForSeoCommonShape
+}).strict();
+const dataForSeoAiScrapeInputSchema = z.object({
+	keyword: boundedText("keyword", 1e3),
+	platform: z.enum([
+		"chat_gpt",
+		"gemini",
+		"perplexity"
+	]).default("chat_gpt"),
+	...dataForSeoCommonShape
+}).strict();
+const dataForSeoAiMentionsInputSchema = z.object({
+	domain: boundedText("domain", 253).optional(),
+	keyword: boundedText("keyword", 1e3).optional(),
+	platform: z.enum(["google", "chat_gpt"]).default("google"),
+	limit: limitSchema.default(20),
+	...dataForSeoCommonShape
+}).strict().refine((value) => value.domain || value.keyword, { message: "domain or keyword is required" });
+var SeoProviderEvidenceService = class {
+	constructor(transport) {
+		this.transport = transport;
+	}
+	async firecrawlScrape(input) {
+		const parsed = firecrawlScrapeInputSchema.parse(input);
+		return this.transport.request("/api/firecrawl/scrape", parsed);
+	}
+	async firecrawlMap(input) {
+		const parsed = firecrawlMapInputSchema.parse(input);
+		return this.transport.request("/api/firecrawl/map", {
+			url: parsed.url,
+			...parsed.search ? { search: parsed.search } : {},
+			sitemap: parsed.sitemap,
+			limit: parsed.limit,
+			includeSubdomains: parsed.includeSubdomains,
+			ignoreQueryParameters: parsed.ignoreQueryParameters,
+			forceRefresh: parsed.forceRefresh
+		});
+	}
+	async firecrawlCrawlStart(input) {
+		const parsed = firecrawlCrawlStartInputSchema.parse(input);
+		return this.transport.request("/api/firecrawl/crawl", parsed);
+	}
+	async firecrawlCrawlStatus(input) {
+		const parsed = firecrawlCrawlStatusInputSchema.parse(input);
+		return this.transport.request(`/api/firecrawl/crawl/${encodeURIComponent(parsed.id)}`, void 0, { method: "GET" });
+	}
+	async firecrawlSearch(input) {
+		const parsed = firecrawlSearchInputSchema.parse(input);
+		return this.transport.request("/api/firecrawl/search", parsed);
+	}
+	async dataForSeoSerp(input) {
+		const parsed = dataForSeoSerpInputSchema.parse(input);
+		return this.transport.request("/api/dataforseo/serp", parsed);
+	}
+	async dataForSeoMaps(input) {
+		const parsed = dataForSeoMapsInputSchema.parse(input);
+		return this.transport.request("/api/dataforseo/maps", parsed);
+	}
+	async dataForSeoKeywords(input) {
+		const parsed = dataForSeoKeywordsInputSchema.parse(input);
+		return this.transport.request("/api/dataforseo/keywords", {
+			keyword: parsed.keyword,
+			limit: parsed.limit,
+			includeSerpInfo: true,
+			includeSeedKeyword: true,
+			locationCode: parsed.locationCode,
+			languageCode: parsed.languageCode,
+			device: parsed.device,
+			forceRefresh: parsed.forceRefresh
+		});
+	}
+	async dataForSeoCompetitors(input) {
+		const parsed = dataForSeoCompetitorsInputSchema.parse(input);
+		return this.transport.request("/api/dataforseo/competitors", {
+			targetDomain: parsed.domain,
+			limit: parsed.limit,
+			locationCode: parsed.locationCode,
+			languageCode: parsed.languageCode,
+			device: parsed.device,
+			forceRefresh: parsed.forceRefresh
+		});
+	}
+	async dataForSeoAiScrape(input) {
+		const parsed = dataForSeoAiScrapeInputSchema.parse(input);
+		return this.transport.request("/api/dataforseo/ai-scrape", parsed);
+	}
+	async dataForSeoAiMentions(input) {
+		const parsed = dataForSeoAiMentionsInputSchema.parse(input);
+		return this.transport.request("/api/dataforseo/ai-mentions", {
+			...parsed.domain ? { targetDomain: parsed.domain } : {},
+			...parsed.keyword ? { keyword: parsed.keyword } : {},
+			platform: parsed.platform,
+			limit: parsed.limit,
+			locationCode: parsed.locationCode,
+			languageCode: parsed.languageCode,
+			device: parsed.device,
+			forceRefresh: parsed.forceRefresh
+		});
+	}
+};
+
+//#endregion
+//#region src/cli/forgeway-seo-client.ts
+const DEFAULT_DINEWAY_API_BASE_URL = "https://api.dineway.ai";
+const TRAILING_SLASH_PATTERN = /\/$/;
+const SHADOW_EMAIL_PATTERN = /^shadow_[a-f0-9]{16}@dineway\.ai$/i;
+var ForgewaySeoApiError = class extends Error {
+	constructor(message, status, body) {
+		super(message);
+		this.status = status;
+		this.body = body;
+		this.name = "ForgewaySeoApiError";
+	}
+};
+function normalizeApiUrl(value) {
+	return (value || DEFAULT_DINEWAY_API_BASE_URL).replace(TRAILING_SLASH_PATTERN, "");
+}
+function resolveForgewaySeoApiUrl(savedPlatformApiUrl, cwd = process.cwd()) {
+	return normalizeApiUrl(getProjectEnvValue("DINEWAY_API_BASE_URL", cwd) ?? (typeof savedPlatformApiUrl === "string" ? savedPlatformApiUrl : void 0));
+}
+function normalizeEmail(value) {
+	return value?.trim().toLowerCase() ?? "";
+}
+function isShadowEmail(email) {
+	return Boolean(email && SHADOW_EMAIL_PATTERN.test(email));
+}
+function assertFormalUser(user) {
+	if (!user || user.emailVerified !== true || isShadowEmail(user.email)) throw new Error("Forgeway SEO provider access requires verified formal Forgeway credentials. Run `dineway deploy forgeway` and complete email verification first.");
+	return user;
+}
+function normalizeForgewayUser(user, fallback) {
+	if (!user?.id || !user.email) return fallback;
+	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
+	};
+}
+async function parseJsonResponse(response) {
+	const text = await response.text();
+	if (!text) return {};
+	try {
+		return JSON.parse(text);
+	} catch {
+		return { message: text };
+	}
+}
+function errorMessage(body, fallback) {
+	if (typeof body !== "object" || body === null) return fallback;
+	const record = body;
+	if (typeof record.message === "string") return record.message;
+	if (typeof record.error === "string") return record.error;
+	const nestedError = record.error;
+	if (typeof nestedError === "object" && nestedError !== null) {
+		const message = nestedError.message;
+		if (typeof message === "string") return message;
+	}
+	return fallback;
+}
+var ForgewaySeoGatewayClient = class {
+	fetchImpl;
+	readCredentials;
+	writeCredentials;
+	cwd;
+	constructor(deps = {}) {
+		this.fetchImpl = deps.fetch ?? fetch;
+		this.readCredentials = deps.readCredentials ?? readForgewayCredentials;
+		this.writeCredentials = deps.writeCredentials ?? writeForgewayCredentials;
+		this.cwd = deps.cwd ?? process.cwd();
+	}
+	async loadCredentials() {
+		const metadata = await readForgewayDeployMetadata(this.cwd).catch(() => ({}));
+		const platformApiUrl = resolveForgewaySeoApiUrl(metadata.platformApiUrl, this.cwd);
+		const credentials = await this.readCredentials({
+			cwd: this.cwd,
+			platformApiUrl,
+			email: typeof metadata.publisherEmail === "string" ? metadata.publisherEmail : void 0
+		});
+		if (!credentials?.accessToken) throw new Error("Forgeway SEO provider access requires stored Forgeway credentials. Run `dineway deploy forgeway` first.");
+		assertFormalUser(credentials.user);
+		if (!credentials.refreshToken) throw new Error("Forgeway SEO provider access requires a stored formal-account refresh token. Run `dineway deploy forgeway` again.");
+		return {
+			...credentials,
+			platformApiUrl: resolveForgewaySeoApiUrl(credentials.platformApiUrl, this.cwd)
+		};
+	}
+	async refreshAccessToken(credentials) {
+		const response = await this.fetchImpl(`${credentials.platformApiUrl}/api/auth/refresh?client_type=server`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ refreshToken: credentials.refreshToken })
+		});
+		const body = await parseJsonResponse(response);
+		if (!response.ok) throw new ForgewaySeoApiError(errorMessage(body, "Failed to refresh Forgeway formal account credentials. Run `dineway deploy forgeway` again."), response.status, body);
+		if (!body.accessToken) throw new Error("Forgeway refresh response was missing accessToken.");
+		const user = assertFormalUser(normalizeForgewayUser(body.user, credentials.user));
+		if (credentials.user?.email && normalizeEmail(user.email) !== normalizeEmail(credentials.user.email)) throw new Error("Forgeway refresh returned credentials for a different email.");
+		const updated = {
+			...credentials,
+			accessToken: body.accessToken,
+			refreshToken: body.refreshToken ?? credentials.refreshToken,
+			user
+		};
+		await this.writeCredentials(updated, {
+			cwd: this.cwd,
+			platformApiUrl: updated.platformApiUrl,
+			email: user.email
+		});
+		return updated;
+	}
+	async request(path, body, init) {
+		const credentials = await this.refreshAccessToken(await this.loadCredentials());
+		const method = init?.method ?? "POST";
+		const response = await this.fetchImpl(`${credentials.platformApiUrl}${path}`, {
+			method,
+			headers: {
+				Authorization: `Bearer ${credentials.accessToken}`,
+				"Content-Type": "application/json",
+				"Idempotency-Key": init?.idempotencyKey ?? randomUUID()
+			},
+			body: method === "GET" ? void 0 : JSON.stringify(body ?? {})
+		});
+		const payload = await parseJsonResponse(response);
+		if (!response.ok) throw new ForgewaySeoApiError(errorMessage(payload, `Forgeway SEO request failed with status ${response.status}.`), response.status, payload);
+		return payload;
+	}
+};
+
+//#endregion
+export { readSavedDeployTarget as a, listForgewayCredentials as c, readForgewayDeployMetadata as i, readForgewayCredentials as l, SeoProviderEvidenceService as n, writeDeployTarget as o, readDeployPackageJson as r, writeForgewayDeployMetadata as s, ForgewaySeoGatewayClient as t, writeForgewayCredentials as u };

package/dist/{fts-manager-B5l_qwrA.mjs → fts-manager-ewTGohf4.mjs}

@@ -1,4 +1,4 @@
-import { a as __exportAll } from "./runner-DzIpHGND.mjs";
+import { a as __exportAll } from "./runner-BgmttQmD.mjs";
 import { t as validateIdentifier } from "./validate-VPnKoIzW.mjs";
 import { s as isSqlite, u as tableExists } from "./dialect-helpers-fk43GbDb.mjs";
 import { sql } from "kysely";

package/dist/{hitl-requests-7NlzVeUA.mjs → hitl-requests-DEFj8e6u.mjs}

@@ -1,5 +1,5 @@
-import { t as ExperimentalSiteContextWorkflowDisabledError } from "./experimental-workflows-CSMffP6q.mjs";
-import { n as HitlRequestService } from "./site-context-C8Az_P_I.mjs";
+import { b as HitlRequestService } from "./site-context-B8T1kpUP.mjs";
+import { t as ExperimentalSiteContextWorkflowDisabledError } from "./experimental-workflows-GVhUgzEs.mjs";
 
 //#region src/api/handlers/hitl-requests.ts
 const HITL_NOT_FOUND_RE = /not found/i;

package/dist/{hitl-route-helpers-k---_H3-.mjs → hitl-route-helpers-C23JHaWz.mjs}

@@ -1,7 +1,8 @@
-import { t as apiError } from "./error-DCSuUAZW.mjs";
-import { t as ExperimentalSiteContextWorkflowDisabledError } from "./experimental-workflows-CSMffP6q.mjs";
-import { t as WorkflowHitlCoordinator } from "./site-context-C8Az_P_I.mjs";
-import { T as resolveActorIdentity, p as logSiteActivitySafely } from "./activity-events-CwM7yxPW.mjs";
+import { t as WorkflowHitlCoordinator } from "./site-context-B8T1kpUP.mjs";
+import { t as apiError } from "./error-CSVaQNZy.mjs";
+import { n as resolveActorIdentity } from "./actor-0QJ1Gbtf.mjs";
+import { p as logSiteActivitySafely } from "./activity-events-CJDvE2uc.mjs";
+import { t as ExperimentalSiteContextWorkflowDisabledError } from "./experimental-workflows-GVhUgzEs.mjs";
 import { Role } from "@dineway-ai/auth";
 
 //#region src/api/hitl-route-helpers.ts