@invect/version-control 0.0.1

package/dist/backend/index.cjs

@@ -0,0 +1,1045 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let node_crypto = require("node:crypto");
+//#region src/backend/schema.ts
+const SYNC_MODES = [
+	"direct-commit",
+	"pr-per-save",
+	"pr-per-publish"
+];
+const SYNC_DIRECTIONS = [
+	"push",
+	"pull",
+	"bidirectional"
+];
+const SYNC_ACTIONS = [
+	"push",
+	"pull",
+	"pr-created",
+	"pr-merged",
+	"conflict"
+];
+const VC_SCHEMA = {
+	vcSyncConfig: {
+		tableName: "vc_sync_config",
+		order: 10,
+		fields: {
+			id: {
+				type: "string",
+				primaryKey: true
+			},
+			flowId: {
+				type: "string",
+				required: true,
+				unique: true,
+				references: {
+					table: "flows",
+					field: "id",
+					onDelete: "cascade"
+				},
+				index: true
+			},
+			provider: {
+				type: "string",
+				required: true
+			},
+			repo: {
+				type: "string",
+				required: true
+			},
+			branch: {
+				type: "string",
+				required: true
+			},
+			filePath: {
+				type: "string",
+				required: true
+			},
+			mode: {
+				type: [...SYNC_MODES],
+				required: true
+			},
+			syncDirection: {
+				type: [...SYNC_DIRECTIONS],
+				required: true,
+				defaultValue: "push"
+			},
+			lastSyncedAt: {
+				type: "date",
+				required: false
+			},
+			lastCommitSha: {
+				type: "string",
+				required: false
+			},
+			lastSyncedVersion: {
+				type: "number",
+				required: false
+			},
+			draftBranch: {
+				type: "string",
+				required: false
+			},
+			activePrNumber: {
+				type: "number",
+				required: false
+			},
+			activePrUrl: {
+				type: "string",
+				required: false
+			},
+			enabled: {
+				type: "boolean",
+				required: true,
+				defaultValue: true
+			},
+			createdAt: {
+				type: "date",
+				required: true,
+				defaultValue: "now()"
+			},
+			updatedAt: {
+				type: "date",
+				required: true,
+				defaultValue: "now()"
+			}
+		}
+	},
+	vcSyncHistory: {
+		tableName: "vc_sync_history",
+		order: 20,
+		fields: {
+			id: {
+				type: "uuid",
+				primaryKey: true,
+				defaultValue: "uuid()"
+			},
+			flowId: {
+				type: "string",
+				required: true,
+				references: {
+					table: "flows",
+					field: "id",
+					onDelete: "cascade"
+				},
+				index: true
+			},
+			action: {
+				type: [...SYNC_ACTIONS],
+				required: true
+			},
+			commitSha: {
+				type: "string",
+				required: false
+			},
+			prNumber: {
+				type: "number",
+				required: false
+			},
+			version: {
+				type: "number",
+				required: false
+			},
+			message: {
+				type: "string",
+				required: false
+			},
+			createdAt: {
+				type: "date",
+				required: true,
+				defaultValue: "now()"
+			},
+			createdBy: {
+				type: "string",
+				required: false
+			}
+		}
+	}
+};
+//#endregion
+//#region src/backend/flow-serializer.ts
+/**
+* Serializes an InvectDefinition to a readable .flow.ts file.
+*
+* The output uses the Option A (declarative) format from the SDK plan:
+*   defineFlow({ name, nodes: [...], edges: [...] })
+*
+* NOTE: This is a standalone serializer — it doesn't depend on the SDK being
+* implemented yet. It generates the .flow.ts text directly from the definition JSON.
+* When the SDK ships, this will import the actual helpers instead.
+*/
+function serializeFlowToTs(definition, metadata) {
+	const lines = [];
+	const helpers = /* @__PURE__ */ new Set();
+	const providerImports = /* @__PURE__ */ new Map();
+	for (const node of definition.nodes) {
+		const { helperName, providerNs } = resolveHelper(node.type);
+		if (providerNs) {
+			if (!providerImports.has(providerNs)) providerImports.set(providerNs, /* @__PURE__ */ new Set());
+			providerImports.get(providerNs)?.add(helperName);
+		} else helpers.add(helperName);
+	}
+	helpers.add("defineFlow");
+	const coreHelpers = [...helpers].sort();
+	lines.push(`import { ${coreHelpers.join(", ")} } from '@invect/core/sdk';`);
+	for (const [ns, _methods] of providerImports) lines.push(`import { ${ns} } from '@invect/core/sdk/providers';`);
+	lines.push("");
+	lines.push("export default defineFlow({");
+	lines.push(`  name: ${JSON.stringify(metadata.name)},`);
+	if (metadata.description) lines.push(`  description: ${JSON.stringify(metadata.description)},`);
+	if (metadata.tags && metadata.tags.length > 0) lines.push(`  tags: ${JSON.stringify(metadata.tags)},`);
+	lines.push("");
+	lines.push("  nodes: [");
+	for (const node of definition.nodes) {
+		const ref = node.referenceId || node.id;
+		const { helperCall } = resolveHelper(node.type);
+		const params = serializeParams(node.params);
+		lines.push(`    ${helperCall}(${JSON.stringify(ref)}, ${params}),`);
+		lines.push("");
+	}
+	lines.push("  ],");
+	lines.push("");
+	lines.push("  edges: [");
+	for (const edge of definition.edges) {
+		const source = resolveNodeRef(edge.source, definition.nodes);
+		const target = resolveNodeRef(edge.target, definition.nodes);
+		if (edge.sourceHandle) lines.push(`    [${JSON.stringify(source)}, ${JSON.stringify(target)}, ${JSON.stringify(edge.sourceHandle)}],`);
+		else lines.push(`    [${JSON.stringify(source)}, ${JSON.stringify(target)}],`);
+	}
+	lines.push("  ],");
+	lines.push("});");
+	lines.push("");
+	return lines.join("\n");
+}
+/** Map action IDs to SDK helper function names */
+const ACTION_TO_HELPER = {
+	"core.input": { helperName: "input" },
+	"core.output": { helperName: "output" },
+	"core.model": { helperName: "model" },
+	"core.jq": { helperName: "jq" },
+	"core.if_else": { helperName: "ifElse" },
+	"core.template_string": { helperName: "template" },
+	"core.javascript": { helperName: "javascript" },
+	"core.loop": { helperName: "loop" },
+	"http.request": { helperName: "httpRequest" },
+	AGENT: { helperName: "agent" }
+};
+function resolveHelper(nodeType) {
+	const known = ACTION_TO_HELPER[nodeType];
+	if (known) return {
+		helperName: known.helperName,
+		helperCall: known.providerNs ? `${known.providerNs}.${known.helperName}` : known.helperName,
+		providerNs: known.providerNs
+	};
+	const dotIdx = nodeType.indexOf(".");
+	if (dotIdx > 0) {
+		const ns = nodeType.substring(0, dotIdx);
+		const camel = snakeToCamel(nodeType.substring(dotIdx + 1));
+		return {
+			helperName: camel,
+			helperCall: `${ns}.${camel}`,
+			providerNs: ns
+		};
+	}
+	return {
+		helperName: "node",
+		helperCall: "node"
+	};
+}
+function snakeToCamel(s) {
+	return s.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}
+/** Resolve a node ID (e.g. "node-classify") back to its referenceId ("classify") */
+function resolveNodeRef(nodeId, nodes) {
+	const node = nodes.find((n) => n.id === nodeId);
+	if (node?.referenceId) return node.referenceId;
+	if (nodeId.startsWith("node-")) return nodeId.substring(5);
+	return nodeId;
+}
+/** Serialize params object to formatted string, filtering out credentials by ID */
+function serializeParams(params) {
+	const cleaned = { ...params };
+	if (typeof cleaned.credentialId === "string" && !cleaned.credentialId.startsWith("{{")) cleaned.credentialId = `{{env.${toEnvName(cleaned.credentialId)}}}`;
+	return formatObject(cleaned, 4);
+}
+function toEnvName(credentialId) {
+	const name = credentialId.replace(/^cred[_-]?/i, "").replace(/[_-]?\d+$/g, "").toUpperCase();
+	return name ? `${name}_CREDENTIAL` : "CREDENTIAL";
+}
+/** Format a JS value as readable code (not JSON — no quoting keys where unnecessary) */
+function formatObject(value, indent) {
+	if (value === null || value === void 0) return "null";
+	if (typeof value === "string") return JSON.stringify(value);
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	if (Array.isArray(value)) {
+		if (value.length === 0) return "[]";
+		if (value.every((v) => typeof v === "string" || typeof v === "number")) return `[${value.map((v) => JSON.stringify(v)).join(", ")}]`;
+		return `[\n${value.map((v) => `${" ".repeat(indent + 2)}${formatObject(v, indent + 2)}`).join(",\n")}\n${" ".repeat(indent)}]`;
+	}
+	if (typeof value === "object") {
+		const obj = value;
+		const entries = Object.entries(obj).filter(([, v]) => v !== void 0);
+		if (entries.length === 0) return "{}";
+		return `{\n${entries.map(([key, val]) => {
+			const k = isValidIdentifier(key) ? key : JSON.stringify(key);
+			return `${" ".repeat(indent + 2)}${k}: ${formatObject(val, indent + 2)}`;
+		}).join(",\n")}\n${" ".repeat(indent)}}`;
+	}
+	return JSON.stringify(value);
+}
+function isValidIdentifier(s) {
+	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(s);
+}
+//#endregion
+//#region src/backend/sync-service.ts
+var VcSyncService = class {
+	constructor(provider, options, logger) {
+		this.provider = provider;
+		this.options = options;
+		this.logger = logger;
+	}
+	async configureSyncForFlow(db, flowId, input) {
+		const flows = await db.query("SELECT id, name FROM flows WHERE id = ?", [flowId]);
+		if (flows.length === 0) throw new Error(`Flow not found: ${flowId}`);
+		const flow = flows[0];
+		const id = (0, node_crypto.randomUUID)();
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const repo = input.repo ?? this.options.repo;
+		const branch = input.branch ?? this.options.defaultBranch ?? "main";
+		const mode = input.mode ?? this.options.mode ?? "direct-commit";
+		const syncDirection = input.syncDirection ?? this.options.syncDirection ?? "push";
+		const filePath = input.filePath ?? this.buildFilePath(flow.name);
+		await db.execute("DELETE FROM vc_sync_config WHERE flow_id = ?", [flowId]);
+		await db.execute(`INSERT INTO vc_sync_config (id, flow_id, provider, repo, branch, file_path, mode, sync_direction, enabled, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+			id,
+			flowId,
+			this.provider.id,
+			repo,
+			branch,
+			filePath,
+			mode,
+			syncDirection,
+			true,
+			now,
+			now
+		]);
+		return this.getSyncConfig(db, flowId);
+	}
+	async getSyncConfig(db, flowId) {
+		const rows = await db.query("SELECT * FROM vc_sync_config WHERE flow_id = ?", [flowId]);
+		if (rows.length === 0) return null;
+		return mapSyncConfigRow(rows[0]);
+	}
+	async disconnectFlow(db, flowId) {
+		const config = await this.getSyncConfig(db, flowId);
+		if (!config) return;
+		if (config.activePrNumber) try {
+			await this.provider.closePullRequest(config.repo, config.activePrNumber, "Sync disconnected — flow unlinked from version control.");
+		} catch (err) {
+			this.logger.warn("Failed to close PR on disconnect", { error: err.message });
+		}
+		if (config.draftBranch) try {
+			await this.provider.deleteBranch(config.repo, config.draftBranch);
+		} catch {}
+		await db.execute("DELETE FROM vc_sync_config WHERE flow_id = ?", [flowId]);
+	}
+	async pushFlow(db, flowId, identity) {
+		const config = await this.requireConfig(db, flowId);
+		const { content, version } = await this.exportFlow(db, flowId);
+		try {
+			if (config.mode === "direct-commit") return await this.directCommit(db, config, content, version, identity);
+			else if (config.mode === "pr-per-save") return await this.commitToPrBranch(db, config, content, version, identity, true);
+			else return await this.commitToDraftBranch(db, config, content, version, identity);
+		} catch (err) {
+			const message = err.message;
+			if (message.includes("409") || message.includes("sha")) {
+				await this.recordHistory(db, flowId, "conflict", {
+					version,
+					message,
+					createdBy: identity
+				});
+				return {
+					success: false,
+					error: "Conflict: remote file has changed. Use force-push or force-pull.",
+					action: "conflict"
+				};
+			}
+			throw err;
+		}
+	}
+	async forcePushFlow(db, flowId, identity) {
+		const config = await this.requireConfig(db, flowId);
+		const { content, version } = await this.exportFlow(db, flowId);
+		const sha = (await this.provider.getFileContent(config.repo, config.filePath, config.branch))?.sha;
+		const result = await this.provider.createOrUpdateFile(config.repo, config.filePath, content, `chore(flow): force-push ${this.flowFileName(config.filePath)} v${version}`, {
+			branch: config.branch,
+			sha
+		});
+		await this.updateConfigAfterSync(db, flowId, result.commitSha, version);
+		await this.recordHistory(db, flowId, "push", {
+			commitSha: result.commitSha,
+			version,
+			message: "Force push (local wins)",
+			createdBy: identity
+		});
+		return {
+			success: true,
+			commitSha: result.commitSha,
+			action: "push"
+		};
+	}
+	async pullFlow(db, flowId, identity) {
+		const config = await this.requireConfig(db, flowId);
+		const remote = await this.provider.getFileContent(config.repo, config.filePath, config.branch);
+		if (!remote) return {
+			success: false,
+			error: "Remote file not found",
+			action: "pull"
+		};
+		if (config.lastCommitSha && remote.sha === config.lastCommitSha) return {
+			success: true,
+			action: "pull"
+		};
+		await this.importFlowContent(db, flowId, remote.content, identity);
+		await this.updateConfigAfterSync(db, flowId, remote.sha, null);
+		await this.recordHistory(db, flowId, "pull", {
+			commitSha: remote.sha,
+			message: "Pulled from remote",
+			createdBy: identity
+		});
+		return {
+			success: true,
+			commitSha: remote.sha,
+			action: "pull"
+		};
+	}
+	async forcePullFlow(db, flowId, identity) {
+		const config = await this.requireConfig(db, flowId);
+		const remote = await this.provider.getFileContent(config.repo, config.filePath, config.branch);
+		if (!remote) return {
+			success: false,
+			error: "Remote file not found",
+			action: "pull"
+		};
+		await this.importFlowContent(db, flowId, remote.content, identity);
+		await this.updateConfigAfterSync(db, flowId, remote.sha, null);
+		await this.recordHistory(db, flowId, "pull", {
+			commitSha: remote.sha,
+			message: "Force pull (remote wins)",
+			createdBy: identity
+		});
+		return {
+			success: true,
+			commitSha: remote.sha,
+			action: "pull"
+		};
+	}
+	async publishFlow(db, flowId, identity) {
+		const config = await this.requireConfig(db, flowId);
+		if (config.mode !== "pr-per-publish") return {
+			success: false,
+			error: "Publish is only available in pr-per-publish mode",
+			action: "pr-created"
+		};
+		if (!config.draftBranch) return {
+			success: false,
+			error: "No draft branch found — push changes first",
+			action: "pr-created"
+		};
+		if (config.activePrNumber) {
+			if ((await this.provider.getPullRequest(config.repo, config.activePrNumber)).state === "open") return {
+				success: true,
+				prNumber: config.activePrNumber,
+				prUrl: config.activePrUrl ?? void 0,
+				action: "pr-created"
+			};
+		}
+		const fileName = this.flowFileName(config.filePath);
+		const pr = await this.provider.createPullRequest(config.repo, {
+			title: `feat(flow): publish ${fileName}`,
+			body: `Automated PR from Invect — publishing flow changes for \`${fileName}\`.`,
+			head: config.draftBranch,
+			base: config.branch
+		});
+		await db.execute("UPDATE vc_sync_config SET active_pr_number = ?, active_pr_url = ?, updated_at = ? WHERE flow_id = ?", [
+			pr.number,
+			pr.url,
+			(/* @__PURE__ */ new Date()).toISOString(),
+			flowId
+		]);
+		await this.recordHistory(db, flowId, "pr-created", {
+			prNumber: pr.number,
+			message: `PR #${pr.number} created`,
+			createdBy: identity
+		});
+		return {
+			success: true,
+			prNumber: pr.number,
+			prUrl: pr.url,
+			action: "pr-created"
+		};
+	}
+	async getFlowSyncStatus(db, flowId) {
+		const config = await this.getSyncConfig(db, flowId);
+		if (!config) return {
+			status: "not-connected",
+			config: null,
+			lastSync: null
+		};
+		const history = await db.query("SELECT * FROM vc_sync_history WHERE flow_id = ? ORDER BY created_at DESC LIMIT 1", [flowId]);
+		const lastSync = history.length > 0 ? mapHistoryRow(history[0]) : null;
+		let status = "synced";
+		if (!config.enabled) status = "not-connected";
+		else if (lastSync?.action === "conflict") status = "conflict";
+		else if (!config.lastSyncedAt) status = "pending";
+		else {
+			const latestVersion = (await db.query("SELECT MAX(version) as version FROM flow_versions WHERE flow_id = ?", [flowId]))[0]?.version;
+			if (latestVersion && config.lastSyncedVersion && latestVersion > config.lastSyncedVersion) status = "pending";
+		}
+		return {
+			status,
+			config,
+			lastSync
+		};
+	}
+	async getSyncHistory(db, flowId, limit = 20) {
+		return (await db.query("SELECT * FROM vc_sync_history WHERE flow_id = ? ORDER BY created_at DESC LIMIT ?", [flowId, limit])).map(mapHistoryRow);
+	}
+	async listSyncedFlows(db) {
+		return (await db.query(`SELECT vc_sync_config.*, flows.name as flow_name
+       FROM vc_sync_config
+       JOIN flows ON flows.id = vc_sync_config.flow_id
+       ORDER BY vc_sync_config.updated_at DESC`)).map((r) => ({
+			...mapSyncConfigRow(r),
+			flowName: r.flow_name
+		}));
+	}
+	async onFlowDeleted(db, flowId) {
+		const config = await this.getSyncConfig(db, flowId);
+		if (!config) return;
+		try {
+			const remote = await this.provider.getFileContent(config.repo, config.filePath, config.branch);
+			if (remote) {
+				await this.provider.deleteFile(config.repo, config.filePath, `chore(flow): delete ${this.flowFileName(config.filePath)}`, {
+					branch: config.branch,
+					sha: remote.sha
+				});
+				this.logger.info("Deleted flow file from remote", {
+					flowId,
+					filePath: config.filePath
+				});
+			}
+		} catch (err) {
+			this.logger.warn("Failed to delete flow file from remote", {
+				flowId,
+				error: err.message
+			});
+		}
+		if (config.activePrNumber) try {
+			await this.provider.closePullRequest(config.repo, config.activePrNumber, "Flow deleted — closing PR.");
+		} catch {}
+		if (config.draftBranch) try {
+			await this.provider.deleteBranch(config.repo, config.draftBranch);
+		} catch {}
+	}
+	async directCommit(db, config, content, version, identity) {
+		let remoteSha = config.lastCommitSha ?? void 0;
+		if (!remoteSha) remoteSha = (await this.provider.getFileContent(config.repo, config.filePath, config.branch))?.sha;
+		const result = await this.provider.createOrUpdateFile(config.repo, config.filePath, content, `chore(flow): update ${this.flowFileName(config.filePath)} v${version}`, {
+			branch: config.branch,
+			sha: remoteSha
+		});
+		await this.updateConfigAfterSync(db, config.flowId, result.commitSha, version);
+		await this.recordHistory(db, config.flowId, "push", {
+			commitSha: result.commitSha,
+			version,
+			message: `Direct commit v${version}`,
+			createdBy: identity
+		});
+		return {
+			success: true,
+			commitSha: result.commitSha,
+			action: "push"
+		};
+	}
+	async commitToPrBranch(db, config, content, version, identity, openPr = true) {
+		const branchName = config.draftBranch ?? `invect/flow/${this.flowSlug(config.filePath)}`;
+		if (!await this.provider.getBranch(config.repo, branchName)) await this.provider.createBranch(config.repo, branchName, config.branch);
+		const remote = await this.provider.getFileContent(config.repo, config.filePath, branchName);
+		const result = await this.provider.createOrUpdateFile(config.repo, config.filePath, content, `chore(flow): update ${this.flowFileName(config.filePath)} v${version}`, {
+			branch: branchName,
+			sha: remote?.sha
+		});
+		await db.execute("UPDATE vc_sync_config SET draft_branch = ?, updated_at = ? WHERE flow_id = ?", [
+			branchName,
+			(/* @__PURE__ */ new Date()).toISOString(),
+			config.flowId
+		]);
+		let prNumber = config.activePrNumber ?? void 0;
+		let prUrl = config.activePrUrl ?? void 0;
+		if (openPr && !prNumber) {
+			const pr = await this.provider.createPullRequest(config.repo, {
+				title: `feat(flow): update ${this.flowFileName(config.filePath)}`,
+				body: `Automated PR from Invect — flow changes for \`${this.flowFileName(config.filePath)}\`.`,
+				head: branchName,
+				base: config.branch
+			});
+			prNumber = pr.number;
+			prUrl = pr.url;
+			await db.execute("UPDATE vc_sync_config SET active_pr_number = ?, active_pr_url = ?, updated_at = ? WHERE flow_id = ?", [
+				prNumber,
+				prUrl,
+				(/* @__PURE__ */ new Date()).toISOString(),
+				config.flowId
+			]);
+			await this.recordHistory(db, config.flowId, "pr-created", {
+				commitSha: result.commitSha,
+				prNumber,
+				version,
+				message: `PR #${prNumber} created`,
+				createdBy: identity
+			});
+		} else await this.recordHistory(db, config.flowId, "push", {
+			commitSha: result.commitSha,
+			version,
+			message: `Updated PR branch v${version}`,
+			createdBy: identity
+		});
+		await this.updateConfigAfterSync(db, config.flowId, result.commitSha, version);
+		return {
+			success: true,
+			commitSha: result.commitSha,
+			prNumber,
+			prUrl,
+			action: prNumber ? "pr-created" : "push"
+		};
+	}
+	async commitToDraftBranch(db, config, content, version, identity) {
+		return this.commitToPrBranch(db, config, content, version, identity, false);
+	}
+	async exportFlow(db, flowId) {
+		const flows = await db.query("SELECT id, name, description, tags FROM flows WHERE id = ?", [flowId]);
+		if (flows.length === 0) throw new Error(`Flow not found: ${flowId}`);
+		const flow = flows[0];
+		const versions = await db.query("SELECT flow_id, version, invect_definition FROM flow_versions WHERE flow_id = ? ORDER BY version DESC LIMIT 1", [flowId]);
+		if (versions.length === 0) throw new Error(`No versions found for flow: ${flowId}`);
+		const fv = versions[0];
+		const definition = typeof fv.invectDefinition === "string" ? JSON.parse(fv.invectDefinition) : fv.invectDefinition;
+		let tags;
+		if (flow.tags) try {
+			tags = typeof flow.tags === "string" ? JSON.parse(flow.tags) : flow.tags;
+		} catch {
+			tags = void 0;
+		}
+		return {
+			content: serializeFlowToTs(definition, {
+				name: flow.name,
+				description: flow.description ?? void 0,
+				tags
+			}),
+			version: fv.version
+		};
+	}
+	async importFlowContent(db, flowId, content, identity) {
+		const { writeFileSync, unlinkSync, mkdtempSync } = await import("node:fs");
+		const { join } = await import("node:path");
+		const { tmpdir } = await import("node:os");
+		const tmpDir = mkdtempSync(join(tmpdir(), "invect-vc-"));
+		const tmpFile = join(tmpDir, "import.flow.ts");
+		try {
+			writeFileSync(tmpFile, content, "utf-8");
+			const { createJiti } = await import("jiti");
+			const result = await createJiti(require("url").pathToFileURL(__filename).href, { interopDefault: true }).import(tmpFile);
+			const definition = result.default ?? result;
+			if (!definition || typeof definition !== "object" || !("nodes" in definition) || !("edges" in definition)) throw new Error("Imported .flow.ts file did not produce a valid InvectDefinition. Expected an object with \"nodes\" and \"edges\" arrays.");
+			const nextVersion = ((await db.query("SELECT MAX(version) as version FROM flow_versions WHERE flow_id = ?", [flowId]))[0]?.version ?? 0) + 1;
+			const defJson = typeof definition === "string" ? definition : JSON.stringify(definition);
+			await db.execute(`INSERT INTO flow_versions (flow_id, version, invect_definition, created_at, created_by)
+         VALUES (?, ?, ?, ?, ?)`, [
+				flowId,
+				nextVersion,
+				defJson,
+				(/* @__PURE__ */ new Date()).toISOString(),
+				identity ?? null
+			]);
+			await db.execute("UPDATE flows SET live_version_number = ?, updated_at = ? WHERE id = ?", [
+				nextVersion,
+				(/* @__PURE__ */ new Date()).toISOString(),
+				flowId
+			]);
+			this.logger.info("Flow imported from remote", {
+				flowId,
+				version: nextVersion
+			});
+		} finally {
+			try {
+				unlinkSync(tmpFile);
+				const { rmdirSync } = await import("node:fs");
+				rmdirSync(tmpDir);
+			} catch {}
+		}
+	}
+	buildFilePath(flowName) {
+		return `${this.options.path ?? "workflows/"}${flowName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "")}.flow.ts`;
+	}
+	flowFileName(filePath) {
+		return filePath.split("/").pop() ?? filePath;
+	}
+	flowSlug(filePath) {
+		return this.flowFileName(filePath).replace(/\.flow\.ts$/, "");
+	}
+	async requireConfig(db, flowId) {
+		const config = await this.getSyncConfig(db, flowId);
+		if (!config) throw new Error(`Flow ${flowId} is not connected to version control`);
+		if (!config.enabled) throw new Error(`Version control sync is disabled for flow ${flowId}`);
+		return config;
+	}
+	async updateConfigAfterSync(db, flowId, commitSha, version) {
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		if (version !== null) await db.execute("UPDATE vc_sync_config SET last_synced_at = ?, last_commit_sha = ?, last_synced_version = ?, updated_at = ? WHERE flow_id = ?", [
+			now,
+			commitSha,
+			version,
+			now,
+			flowId
+		]);
+		else await db.execute("UPDATE vc_sync_config SET last_synced_at = ?, last_commit_sha = ?, updated_at = ? WHERE flow_id = ?", [
+			now,
+			commitSha,
+			now,
+			flowId
+		]);
+	}
+	async recordHistory(db, flowId, action, opts) {
+		await db.execute(`INSERT INTO vc_sync_history (id, flow_id, action, commit_sha, pr_number, version, message, created_at, created_by)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+			(0, node_crypto.randomUUID)(),
+			flowId,
+			action,
+			opts.commitSha ?? null,
+			opts.prNumber ?? null,
+			opts.version ?? null,
+			opts.message ?? null,
+			(/* @__PURE__ */ new Date()).toISOString(),
+			opts.createdBy ?? null
+		]);
+	}
+};
+function mapSyncConfigRow(r) {
+	return {
+		id: r.id,
+		flowId: r.flow_id,
+		provider: r.provider,
+		repo: r.repo,
+		branch: r.branch,
+		filePath: r.file_path,
+		mode: r.mode,
+		syncDirection: r.sync_direction,
+		lastSyncedAt: r.last_synced_at,
+		lastCommitSha: r.last_commit_sha,
+		lastSyncedVersion: r.last_synced_version,
+		draftBranch: r.draft_branch,
+		activePrNumber: r.active_pr_number,
+		activePrUrl: r.active_pr_url,
+		enabled: r.enabled === true || r.enabled === 1
+	};
+}
+function mapHistoryRow(r) {
+	return {
+		id: r.id,
+		flowId: r.flow_id,
+		action: r.action,
+		commitSha: r.commit_sha,
+		prNumber: r.pr_number,
+		version: r.version,
+		message: r.message,
+		createdAt: r.created_at,
+		createdBy: r.created_by
+	};
+}
+//#endregion
+//#region src/backend/plugin.ts
+/**
+* Create the Version Control plugin.
+*
+* Syncs Invect flows to a Git remote as readable `.flow.ts` files.
+*
+* ```ts
+* import { versionControl } from '@invect/version-control';
+* import { githubProvider } from '@invect/version-control/providers/github';
+*
+* new Invect({
+*   plugins: [
+*     versionControl({
+*       provider: githubProvider({ auth: { type: 'token', token: process.env.GITHUB_TOKEN! } }),
+*       repo: 'acme/workflows',
+*       mode: 'pr-per-publish',
+*     }),
+*   ],
+* });
+* ```
+*/
+function versionControl(options) {
+	let syncService;
+	let pluginLogger = console;
+	return {
+		id: "version-control",
+		name: "Version Control",
+		schema: VC_SCHEMA,
+		setupInstructions: "Run `npx invect-cli generate` then `npx invect-cli migrate` to create the vc_sync_config and vc_sync_history tables.",
+		init: async (ctx) => {
+			pluginLogger = ctx.logger;
+			syncService = new VcSyncService(options.provider, options, ctx.logger);
+			ctx.logger.info(`Version control plugin initialized (provider: ${options.provider.id}, repo: ${options.repo})`);
+		},
+		endpoints: [
+			{
+				method: "POST",
+				path: "/vc/flows/:flowId/configure",
+				handler: async (ctx) => {
+					const { flowId } = ctx.params;
+					const input = ctx.body;
+					return {
+						status: 200,
+						body: await syncService.configureSyncForFlow(ctx.database, flowId, input)
+					};
+				}
+			},
+			{
+				method: "GET",
+				path: "/vc/flows/:flowId/status",
+				handler: async (ctx) => {
+					const { flowId } = ctx.params;
+					return {
+						status: 200,
+						body: {
+							flowId,
+							...await syncService.getFlowSyncStatus(ctx.database, flowId)
+						}
+					};
+				}
+			},
+			{
+				method: "DELETE",
+				path: "/vc/flows/:flowId/disconnect",
+				handler: async (ctx) => {
+					const { flowId } = ctx.params;
+					await syncService.disconnectFlow(ctx.database, flowId);
+					return {
+						status: 200,
+						body: { success: true }
+					};
+				}
+			},
+			{
+				method: "POST",
+				path: "/vc/flows/:flowId/push",
+				handler: async (ctx) => {
+					const { flowId } = ctx.params;
+					const identity = ctx.identity?.id;
+					const result = await syncService.pushFlow(ctx.database, flowId, identity);
+					return {
+						status: result.success ? 200 : 409,
+						body: result
+					};
+				}
+			},
+			{
+				method: "POST",
+				path: "/vc/flows/:flowId/pull",
+				handler: async (ctx) => {
+					const { flowId } = ctx.params;
+					const identity = ctx.identity?.id;
+					const result = await syncService.pullFlow(ctx.database, flowId, identity);
+					return {
+						status: result.success ? 200 : 404,
+						body: result
+					};
+				}
+			},
+			{
+				method: "POST",
+				path: "/vc/flows/:flowId/publish",
+				handler: async (ctx) => {
+					const { flowId } = ctx.params;
+					const identity = ctx.identity?.id;
+					const result = await syncService.publishFlow(ctx.database, flowId, identity);
+					return {
+						status: result.success ? 200 : 400,
+						body: result
+					};
+				}
+			},
+			{
+				method: "POST",
+				path: "/vc/flows/:flowId/force-push",
+				handler: async (ctx) => {
+					const { flowId } = ctx.params;
+					const identity = ctx.identity?.id;
+					return {
+						status: 200,
+						body: await syncService.forcePushFlow(ctx.database, flowId, identity)
+					};
+				}
+			},
+			{
+				method: "POST",
+				path: "/vc/flows/:flowId/force-pull",
+				handler: async (ctx) => {
+					const { flowId } = ctx.params;
+					const identity = ctx.identity?.id;
+					const result = await syncService.forcePullFlow(ctx.database, flowId, identity);
+					return {
+						status: result.success ? 200 : 404,
+						body: result
+					};
+				}
+			},
+			{
+				method: "POST",
+				path: "/vc/push-all",
+				handler: async (ctx) => {
+					const configs = await syncService.listSyncedFlows(ctx.database);
+					const identity = ctx.identity?.id;
+					const results = [];
+					for (const config of configs) {
+						if (!config.enabled) continue;
+						try {
+							const result = await syncService.pushFlow(ctx.database, config.flowId, identity);
+							results.push({
+								flowId: config.flowId,
+								flowName: config.flowName,
+								...result
+							});
+						} catch (err) {
+							results.push({
+								flowId: config.flowId,
+								flowName: config.flowName,
+								success: false,
+								error: err.message,
+								action: "push"
+							});
+						}
+					}
+					return {
+						status: 200,
+						body: { results }
+					};
+				}
+			},
+			{
+				method: "POST",
+				path: "/vc/pull-all",
+				handler: async (ctx) => {
+					const configs = await syncService.listSyncedFlows(ctx.database);
+					const identity = ctx.identity?.id;
+					const results = [];
+					for (const config of configs) {
+						if (!config.enabled) continue;
+						try {
+							const result = await syncService.pullFlow(ctx.database, config.flowId, identity);
+							results.push({
+								flowId: config.flowId,
+								flowName: config.flowName,
+								...result
+							});
+						} catch (err) {
+							results.push({
+								flowId: config.flowId,
+								flowName: config.flowName,
+								success: false,
+								error: err.message,
+								action: "pull"
+							});
+						}
+					}
+					return {
+						status: 200,
+						body: { results }
+					};
+				}
+			},
+			{
+				method: "POST",
+				path: "/vc/webhook",
+				isPublic: true,
+				handler: async (ctx) => {
+					if (!options.webhookSecret) return {
+						status: 400,
+						body: { error: "Webhook secret not configured" }
+					};
+					const signature = ctx.headers["x-hub-signature-256"] ?? "";
+					const body = JSON.stringify(ctx.body);
+					if (!options.provider.verifyWebhookSignature(body, signature, options.webhookSecret)) return {
+						status: 401,
+						body: { error: "Invalid webhook signature" }
+					};
+					const action = ctx.body.action;
+					const pullRequest = ctx.body.pull_request;
+					if (action === "closed" && pullRequest?.merged) await handlePrMerged(ctx.database, pullRequest.number);
+					return {
+						status: 200,
+						body: { received: true }
+					};
+				}
+			},
+			{
+				method: "GET",
+				path: "/vc/flows",
+				handler: async (ctx) => {
+					return {
+						status: 200,
+						body: { flows: await syncService.listSyncedFlows(ctx.database) }
+					};
+				}
+			},
+			{
+				method: "GET",
+				path: "/vc/flows/:flowId/history",
+				handler: async (ctx) => {
+					const { flowId } = ctx.params;
+					const limit = ctx.query.limit ? parseInt(ctx.query.limit, 10) : 20;
+					return {
+						status: 200,
+						body: {
+							flowId,
+							history: await syncService.getSyncHistory(ctx.database, flowId, limit)
+						}
+					};
+				}
+			}
+		],
+		hooks: {}
+	};
+	async function handlePrMerged(db, prNumber) {
+		const rows = await db.query("SELECT flow_id FROM vc_sync_config WHERE active_pr_number = ?", [prNumber]);
+		for (const row of rows) {
+			await db.execute(`UPDATE vc_sync_config
+         SET active_pr_number = NULL, active_pr_url = NULL, draft_branch = NULL, updated_at = ?
+         WHERE flow_id = ?`, [(/* @__PURE__ */ new Date()).toISOString(), row.flow_id]);
+			const { randomUUID } = await import("node:crypto");
+			await db.execute(`INSERT INTO vc_sync_history (id, flow_id, action, pr_number, message, created_at)
+         VALUES (?, ?, ?, ?, ?, ?)`, [
+				randomUUID(),
+				row.flow_id,
+				"pr-merged",
+				prNumber,
+				`PR #${prNumber} merged`,
+				(/* @__PURE__ */ new Date()).toISOString()
+			]);
+			const configs = await db.query("SELECT draft_branch, repo FROM vc_sync_config WHERE flow_id = ?", [row.flow_id]);
+			if (configs[0]?.draft_branch) try {
+				await options.provider.deleteBranch(configs[0].repo, configs[0].draft_branch);
+			} catch {}
+			pluginLogger.info("PR merged — sync updated", {
+				flowId: row.flow_id,
+				prNumber
+			});
+		}
+	}
+}
+//#endregion
+exports.VC_SCHEMA = VC_SCHEMA;
+exports.versionControl = versionControl;
+
+//# sourceMappingURL=index.cjs.map