uigraph 1.0.0 → 1.0.2

package/dist/dist-BRyghrKX.mjs

@@ -1,404 +0,0 @@
-import path from "path";
-import { promises, statSync } from "fs";
-import os from "os";
-import { spawn } from "child_process";
-import { createRequire } from "module";
-import readline from "readline";
-//#region node_modules/.pnpm/@openai+codex-sdk@0.160.1/node_modules/@openai/codex-sdk/dist/index.js
-async function createOutputSchemaFile(schema) {
-	if (schema === void 0) return { cleanup: async () => {} };
-	if (!isJsonObject(schema)) throw new Error("outputSchema must be a plain JSON object");
-	const schemaDir = await promises.mkdtemp(path.join(os.tmpdir(), "codex-output-schema-"));
-	const schemaPath = path.join(schemaDir, "schema.json");
-	const cleanup = async () => {
-		try {
-			await promises.rm(schemaDir, {
-				recursive: true,
-				force: true
-			});
-		} catch {}
-	};
-	try {
-		await promises.writeFile(schemaPath, JSON.stringify(schema), "utf8");
-		return {
-			schemaPath,
-			cleanup
-		};
-	} catch (error) {
-		await cleanup();
-		throw error;
-	}
-}
-function isJsonObject(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-var Thread = class {
-	_exec;
-	_options;
-	_id;
-	_threadOptions;
-	/** Returns the ID of the thread. Populated after the first turn starts. */
-	get id() {
-		return this._id;
-	}
-	constructor(exec, options, threadOptions, id = null) {
-		this._exec = exec;
-		this._options = options;
-		this._id = id;
-		this._threadOptions = threadOptions;
-	}
-	/** Provides the input to the agent and streams events as they are produced during the turn. */
-	async runStreamed(input, turnOptions = {}) {
-		return { events: this.runStreamedInternal(input, turnOptions) };
-	}
-	async *runStreamedInternal(input, turnOptions = {}) {
-		const { schemaPath, cleanup } = await createOutputSchemaFile(turnOptions.outputSchema);
-		const options = this._threadOptions;
-		const { prompt, images } = normalizeInput(input);
-		const generator = this._exec.run({
-			input: prompt,
-			baseUrl: this._options.baseUrl,
-			apiKey: this._options.apiKey,
-			threadId: this._id,
-			images,
-			model: options?.model,
-			threadSource: options?.threadSource,
-			sandboxMode: options?.sandboxMode,
-			workingDirectory: options?.workingDirectory,
-			skipGitRepoCheck: options?.skipGitRepoCheck,
-			outputSchemaFile: schemaPath,
-			modelReasoningEffort: options?.modelReasoningEffort,
-			signal: turnOptions.signal,
-			networkAccessEnabled: options?.networkAccessEnabled,
-			webSearchMode: options?.webSearchMode,
-			webSearchEnabled: options?.webSearchEnabled,
-			approvalPolicy: options?.approvalPolicy,
-			additionalDirectories: options?.additionalDirectories
-		});
-		try {
-			for await (const item of generator) {
-				let parsed;
-				try {
-					parsed = JSON.parse(item);
-				} catch (error) {
-					throw new Error(`Failed to parse item: ${item}`, { cause: error });
-				}
-				if (parsed.type === "thread.started") this._id = parsed.thread_id;
-				else if (parsed.type === "turn.completed") parsed.usage.cache_write_input_tokens ??= 0;
-				yield parsed;
-			}
-		} finally {
-			await cleanup();
-		}
-	}
-	/** Provides the input to the agent and returns the completed turn. */
-	async run(input, turnOptions = {}) {
-		const generator = this.runStreamedInternal(input, turnOptions);
-		const items = [];
-		let finalResponse = "";
-		let usage = null;
-		let turnFailure = null;
-		for await (const event of generator) if (event.type === "item.completed") {
-			if (event.item.type === "agent_message") finalResponse = event.item.text;
-			items.push(event.item);
-		} else if (event.type === "turn.completed") usage = event.usage;
-		else if (event.type === "turn.failed") {
-			turnFailure = event.error;
-			break;
-		}
-		if (turnFailure) throw new Error(turnFailure.message);
-		return {
-			items,
-			finalResponse,
-			usage
-		};
-	}
-};
-function normalizeInput(input) {
-	if (typeof input === "string") return {
-		prompt: input,
-		images: []
-	};
-	const promptParts = [];
-	const images = [];
-	for (const item of input) if (item.type === "text") promptParts.push(item.text);
-	else if (item.type === "local_image") images.push(item.path);
-	return {
-		prompt: promptParts.join("\n\n"),
-		images
-	};
-}
-var INTERNAL_ORIGINATOR_ENV = "CODEX_INTERNAL_ORIGINATOR_OVERRIDE";
-var TYPESCRIPT_SDK_ORIGINATOR = "codex_sdk_ts";
-var CODEX_NPM_NAME = "@openai/codex";
-var PLATFORM_PACKAGE_BY_TARGET = {
-	"x86_64-unknown-linux-musl": "@openai/codex-linux-x64",
-	"aarch64-unknown-linux-musl": "@openai/codex-linux-arm64",
-	"x86_64-apple-darwin": "@openai/codex-darwin-x64",
-	"aarch64-apple-darwin": "@openai/codex-darwin-arm64",
-	"x86_64-pc-windows-msvc": "@openai/codex-win32-x64",
-	"aarch64-pc-windows-msvc": "@openai/codex-win32-arm64"
-};
-var moduleRequire = createRequire(import.meta.url);
-var CodexExec = class {
-	executablePath;
-	pathDirs;
-	envOverride;
-	configOverrides;
-	rawConfigOverrides;
-	constructor(executablePath = null, env, configOverrides, rawConfigOverrides) {
-		if (executablePath) {
-			this.executablePath = executablePath;
-			this.pathDirs = [];
-		} else {
-			const resolved = findCodexPath();
-			this.executablePath = resolved.executablePath;
-			this.pathDirs = resolved.pathDirs;
-		}
-		this.envOverride = env;
-		this.configOverrides = configOverrides;
-		this.rawConfigOverrides = rawConfigOverrides;
-	}
-	async *run(args) {
-		const commandArgs = ["exec", "--experimental-json"];
-		if (this.configOverrides) for (const override of serializeConfigOverrides(this.configOverrides)) commandArgs.push("--config", override);
-		if (this.rawConfigOverrides) for (const override of this.rawConfigOverrides) commandArgs.push("--config", override);
-		if (args.baseUrl) commandArgs.push("--config", `openai_base_url=${toTomlValue(args.baseUrl, "openai_base_url")}`);
-		if (args.model) commandArgs.push("--model", args.model);
-		if (args.threadSource !== void 0 && !args.threadId) commandArgs.push("--thread-source", args.threadSource);
-		if (args.sandboxMode) commandArgs.push("--sandbox", args.sandboxMode);
-		if (args.workingDirectory) commandArgs.push("--cd", args.workingDirectory);
-		if (args.additionalDirectories?.length) for (const dir of args.additionalDirectories) commandArgs.push("--add-dir", dir);
-		if (args.skipGitRepoCheck) commandArgs.push("--skip-git-repo-check");
-		if (args.outputSchemaFile) commandArgs.push("--output-schema", args.outputSchemaFile);
-		if (args.modelReasoningEffort) commandArgs.push("--config", `model_reasoning_effort="${args.modelReasoningEffort}"`);
-		if (args.networkAccessEnabled !== void 0) commandArgs.push("--config", `sandbox_workspace_write.network_access=${args.networkAccessEnabled}`);
-		if (args.webSearchMode) commandArgs.push("--config", `web_search="${args.webSearchMode}"`);
-		else if (args.webSearchEnabled === true) commandArgs.push("--config", `web_search="live"`);
-		else if (args.webSearchEnabled === false) commandArgs.push("--config", `web_search="disabled"`);
-		if (args.approvalPolicy) commandArgs.push("--config", `approval_policy="${args.approvalPolicy}"`);
-		if (args.threadId) commandArgs.push("resume", args.threadId);
-		if (args.images?.length) for (const image of args.images) commandArgs.push("--image", image);
-		const env = {};
-		if (this.envOverride) Object.assign(env, this.envOverride);
-		else for (const [key, value] of Object.entries(process.env)) if (value !== void 0) env[key] = value;
-		if (!env[INTERNAL_ORIGINATOR_ENV]) env[INTERNAL_ORIGINATOR_ENV] = TYPESCRIPT_SDK_ORIGINATOR;
-		if (args.apiKey) env.CODEX_API_KEY = args.apiKey;
-		if (this.pathDirs.length > 0) prependPathDirs(env, this.pathDirs);
-		const child = spawn(this.executablePath, commandArgs, {
-			env,
-			signal: args.signal
-		});
-		let spawnError = null;
-		child.once("error", (err) => spawnError = err);
-		if (!child.stdin) {
-			child.kill();
-			throw new Error("Child process has no stdin");
-		}
-		child.stdin.write(args.input);
-		child.stdin.end();
-		if (!child.stdout) {
-			child.kill();
-			throw new Error("Child process has no stdout");
-		}
-		const stderrChunks = [];
-		if (child.stderr) child.stderr.on("data", (data) => {
-			stderrChunks.push(data);
-		});
-		const exitPromise = new Promise((resolve) => {
-			child.once("exit", (code, signal) => {
-				resolve({
-					code,
-					signal
-				});
-			});
-		});
-		const rl = readline.createInterface({
-			input: child.stdout,
-			crlfDelay: Infinity
-		});
-		try {
-			for await (const line of rl) yield line;
-			if (spawnError) throw spawnError;
-			const { code, signal } = await exitPromise;
-			if (code !== 0 || signal) {
-				const stderrBuffer = Buffer.concat(stderrChunks);
-				const detail = signal ? `signal ${signal}` : `code ${code ?? 1}`;
-				throw new Error(`Codex Exec exited with ${detail}: ${stderrBuffer.toString("utf8")}`);
-			}
-		} finally {
-			rl.close();
-			child.removeAllListeners();
-			try {
-				if (!child.killed) child.kill();
-			} catch {}
-		}
-	}
-};
-function serializeConfigOverrides(configOverrides) {
-	const overrides = [];
-	flattenConfigOverrides(configOverrides, "", overrides);
-	return overrides;
-}
-function flattenConfigOverrides(value, prefix, overrides) {
-	if (!isPlainObject(value)) {
-		if (prefix) {
-			overrides.push(`${prefix}=${toTomlValue(value, prefix)}`);
-			return;
-		} else throw new Error("Codex config overrides must be a plain object");
-	}
-	const entries = Object.entries(value);
-	if (!prefix && entries.length === 0) return;
-	if (prefix && entries.length === 0) {
-		overrides.push(`${prefix}={}`);
-		return;
-	}
-	for (const [key, child] of entries) {
-		if (!key) throw new Error("Codex config override keys must be non-empty strings");
-		if (child === void 0) continue;
-		const path3 = prefix ? `${prefix}.${key}` : key;
-		if (isPlainObject(child)) flattenConfigOverrides(child, path3, overrides);
-		else overrides.push(`${path3}=${toTomlValue(child, path3)}`);
-	}
-}
-function toTomlValue(value, path3) {
-	if (typeof value === "string") return JSON.stringify(value);
-	else if (typeof value === "number") {
-		if (!Number.isFinite(value)) throw new Error(`Codex config override at ${path3} must be a finite number`);
-		return `${value}`;
-	} else if (typeof value === "boolean") return value ? "true" : "false";
-	else if (Array.isArray(value)) return `[${value.map((item, index) => toTomlValue(item, `${path3}[${index}]`)).join(", ")}]`;
-	else if (isPlainObject(value)) {
-		const parts = [];
-		for (const [key, child] of Object.entries(value)) {
-			if (!key) throw new Error("Codex config override keys must be non-empty strings");
-			if (child === void 0) continue;
-			parts.push(`${formatTomlKey(key)} = ${toTomlValue(child, `${path3}.${key}`)}`);
-		}
-		return `{${parts.join(", ")}}`;
-	} else if (value === null) throw new Error(`Codex config override at ${path3} cannot be null`);
-	else throw new Error(`Unsupported Codex config override value at ${path3}: ${typeof value}`);
-}
-var TOML_BARE_KEY = /^[A-Za-z0-9_-]+$/;
-function formatTomlKey(key) {
-	return TOML_BARE_KEY.test(key) ? key : JSON.stringify(key);
-}
-function isPlainObject(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function findCodexPath() {
-	const { platform, arch } = process;
-	let targetTriple = null;
-	switch (platform) {
-		case "linux":
-		case "android":
-			switch (arch) {
-				case "x64":
-					targetTriple = "x86_64-unknown-linux-musl";
-					break;
-				case "arm64": targetTriple = "aarch64-unknown-linux-musl";
-			}
-			break;
-		case "darwin":
-			switch (arch) {
-				case "x64":
-					targetTriple = "x86_64-apple-darwin";
-					break;
-				case "arm64": targetTriple = "aarch64-apple-darwin";
-			}
-			break;
-		case "win32": switch (arch) {
-			case "x64":
-				targetTriple = "x86_64-pc-windows-msvc";
-				break;
-			case "arm64": targetTriple = "aarch64-pc-windows-msvc";
-		}
-	}
-	if (!targetTriple) throw new Error(`Unsupported platform: ${platform} (${arch})`);
-	const platformPackage = PLATFORM_PACKAGE_BY_TARGET[targetTriple];
-	if (!platformPackage) throw new Error(`Unsupported target triple: ${targetTriple}`);
-	let vendorRoot;
-	try {
-		const codexPackageJsonPath = moduleRequire.resolve(`${CODEX_NPM_NAME}/package.json`);
-		const platformPackageJsonPath = createRequire(codexPackageJsonPath).resolve(`${platformPackage}/package.json`);
-		vendorRoot = path.join(path.dirname(platformPackageJsonPath), "vendor");
-	} catch {
-		throw new Error(`Unable to locate Codex CLI binaries. Ensure ${CODEX_NPM_NAME} is installed with optional dependencies.`);
-	}
-	const codexBinaryName = process.platform === "win32" ? "codex.exe" : "codex";
-	const nativePackage = resolveNativePackage(vendorRoot, targetTriple, codexBinaryName);
-	if (!nativePackage) throw new Error(`Unable to locate Codex CLI binaries for ${targetTriple}. Ensure ${CODEX_NPM_NAME} is installed with optional dependencies.`);
-	return nativePackage;
-}
-function resolveNativePackage(vendorRoot, targetTriple, codexBinaryName) {
-	const packageRoot = path.join(vendorRoot, targetTriple);
-	const packageBinaryPath = path.join(packageRoot, "bin", codexBinaryName);
-	if (isFile(packageBinaryPath) && isFile(path.join(packageRoot, "codex-package.json"))) return {
-		executablePath: packageBinaryPath,
-		pathDirs: existingDirs(path.join(packageRoot, "codex-path"))
-	};
-	const legacyBinaryPath = path.join(packageRoot, "codex", codexBinaryName);
-	if (isFile(legacyBinaryPath)) return {
-		executablePath: legacyBinaryPath,
-		pathDirs: existingDirs(path.join(packageRoot, "path"))
-	};
-	return null;
-}
-function existingDirs(...dirs) {
-	return dirs.filter(isDirectory);
-}
-function prependPathDirs(env, pathDirs, platform = process.platform) {
-	const pathKey = pathEnvKey(env, platform);
-	if (platform === "win32") {
-		for (const key of Object.keys(env)) if (key.toLowerCase() === "path" && key !== pathKey) delete env[key];
-	}
-	const existingEntries = (env[pathKey] ?? "").split(path.delimiter).filter((entry) => entry.length > 0 && !pathDirs.includes(entry));
-	env[pathKey] = [...pathDirs, ...existingEntries].join(path.delimiter);
-}
-function pathEnvKey(env, platform) {
-	if (platform !== "win32") return "PATH";
-	const matchingKeys = Object.keys(env).filter((key) => key.toLowerCase() === "path");
-	return matchingKeys.includes("Path") ? "Path" : matchingKeys.at(-1) ?? "PATH";
-}
-function isFile(filePath) {
-	try {
-		return statSync(filePath).isFile();
-	} catch {
-		return false;
-	}
-}
-function isDirectory(filePath) {
-	try {
-		return statSync(filePath).isDirectory();
-	} catch {
-		return false;
-	}
-}
-var Codex = class {
-	exec;
-	options;
-	constructor(options = {}) {
-		const { codexPathOverride, env, config, configOverrides } = options;
-		this.exec = new CodexExec(codexPathOverride, env, config, configOverrides);
-		this.options = options;
-	}
-	/**
-	* Starts a new conversation with an agent.
-	* @returns A new thread instance.
-	*/
-	startThread(options = {}) {
-		return new Thread(this.exec, this.options, options);
-	}
-	/**
-	* Resumes a conversation with an agent based on the thread id.
-	* Threads are persisted in ~/.codex/sessions.
-	*
-	* @param id The id of the thread to resume.
-	* @returns A new thread instance.
-	*/
-	resumeThread(id, options = {}) {
-		return new Thread(this.exec, this.options, options, id);
-	}
-};
-//#endregion
-export { Codex };