autoglm.js 0.0.1

package/dist/cli.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/cli.mjs

@@ -0,0 +1,372 @@
+#!/usr/bin/env node
+import { _ as __commonJSMin, c as Se, d as xe, f as pD, g as cyan, h as bold, i as spinner_default, l as he, m as setAgentConfig, n as checkSystemRequirements, o as Ce, p as $t, r as PhoneAgent, s as Ie, t as checkModelApi, u as ve, v as __toESM } from "./check-Ox_8ktAc.mjs";
+import path from "node:path";
+import process from "node:process";
+import fs from "node:fs";
+import cfonts from "cfonts";
+
+//#region node_modules/.pnpm/minimist@1.2.8/node_modules/minimist/index.js
+var require_minimist = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function hasKey(obj, keys) {
+		var o = obj;
+		keys.slice(0, -1).forEach(function(key) {
+			o = o[key] || {};
+		});
+		return keys[keys.length - 1] in o;
+	}
+	function isNumber(x) {
+		if (typeof x === "number") return true;
+		if (/^0x[0-9a-f]+$/i.test(x)) return true;
+		return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x);
+	}
+	function isConstructorOrProto(obj, key) {
+		return key === "constructor" && typeof obj[key] === "function" || key === "__proto__";
+	}
+	module.exports = function(args, opts) {
+		if (!opts) opts = {};
+		var flags = {
+			bools: {},
+			strings: {},
+			unknownFn: null
+		};
+		if (typeof opts.unknown === "function") flags.unknownFn = opts.unknown;
+		if (typeof opts.boolean === "boolean" && opts.boolean) flags.allBools = true;
+		else [].concat(opts.boolean).filter(Boolean).forEach(function(key$1) {
+			flags.bools[key$1] = true;
+		});
+		var aliases = {};
+		function aliasIsBoolean(key$1) {
+			return aliases[key$1].some(function(x) {
+				return flags.bools[x];
+			});
+		}
+		Object.keys(opts.alias || {}).forEach(function(key$1) {
+			aliases[key$1] = [].concat(opts.alias[key$1]);
+			aliases[key$1].forEach(function(x) {
+				aliases[x] = [key$1].concat(aliases[key$1].filter(function(y) {
+					return x !== y;
+				}));
+			});
+		});
+		[].concat(opts.string).filter(Boolean).forEach(function(key$1) {
+			flags.strings[key$1] = true;
+			if (aliases[key$1]) [].concat(aliases[key$1]).forEach(function(k) {
+				flags.strings[k] = true;
+			});
+		});
+		var defaults = opts.default || {};
+		var argv = { _: [] };
+		function argDefined(key$1, arg$1) {
+			return flags.allBools && /^--[^=]+$/.test(arg$1) || flags.strings[key$1] || flags.bools[key$1] || aliases[key$1];
+		}
+		function setKey(obj, keys, value$1) {
+			var o = obj;
+			for (var i$1 = 0; i$1 < keys.length - 1; i$1++) {
+				var key$1 = keys[i$1];
+				if (isConstructorOrProto(o, key$1)) return;
+				if (o[key$1] === void 0) o[key$1] = {};
+				if (o[key$1] === Object.prototype || o[key$1] === Number.prototype || o[key$1] === String.prototype) o[key$1] = {};
+				if (o[key$1] === Array.prototype) o[key$1] = [];
+				o = o[key$1];
+			}
+			var lastKey = keys[keys.length - 1];
+			if (isConstructorOrProto(o, lastKey)) return;
+			if (o === Object.prototype || o === Number.prototype || o === String.prototype) o = {};
+			if (o === Array.prototype) o = [];
+			if (o[lastKey] === void 0 || flags.bools[lastKey] || typeof o[lastKey] === "boolean") o[lastKey] = value$1;
+			else if (Array.isArray(o[lastKey])) o[lastKey].push(value$1);
+			else o[lastKey] = [o[lastKey], value$1];
+		}
+		function setArg(key$1, val, arg$1) {
+			if (arg$1 && flags.unknownFn && !argDefined(key$1, arg$1)) {
+				if (flags.unknownFn(arg$1) === false) return;
+			}
+			var value$1 = !flags.strings[key$1] && isNumber(val) ? Number(val) : val;
+			setKey(argv, key$1.split("."), value$1);
+			(aliases[key$1] || []).forEach(function(x) {
+				setKey(argv, x.split("."), value$1);
+			});
+		}
+		Object.keys(flags.bools).forEach(function(key$1) {
+			setArg(key$1, defaults[key$1] === void 0 ? false : defaults[key$1]);
+		});
+		var notFlags = [];
+		if (args.indexOf("--") !== -1) {
+			notFlags = args.slice(args.indexOf("--") + 1);
+			args = args.slice(0, args.indexOf("--"));
+		}
+		for (var i = 0; i < args.length; i++) {
+			var arg = args[i];
+			var key;
+			var next;
+			if (/^--.+=/.test(arg)) {
+				var m = arg.match(/^--([^=]+)=([\s\S]*)$/);
+				key = m[1];
+				var value = m[2];
+				if (flags.bools[key]) value = value !== "false";
+				setArg(key, value, arg);
+			} else if (/^--no-.+/.test(arg)) {
+				key = arg.match(/^--no-(.+)/)[1];
+				setArg(key, false, arg);
+			} else if (/^--.+/.test(arg)) {
+				key = arg.match(/^--(.+)/)[1];
+				next = args[i + 1];
+				if (next !== void 0 && !/^(-|--)[^-]/.test(next) && !flags.bools[key] && !flags.allBools && (aliases[key] ? !aliasIsBoolean(key) : true)) {
+					setArg(key, next, arg);
+					i += 1;
+				} else if (/^(true|false)$/.test(next)) {
+					setArg(key, next === "true", arg);
+					i += 1;
+				} else setArg(key, flags.strings[key] ? "" : true, arg);
+			} else if (/^-[^-]+/.test(arg)) {
+				var letters = arg.slice(1, -1).split("");
+				var broken = false;
+				for (var j = 0; j < letters.length; j++) {
+					next = arg.slice(j + 2);
+					if (next === "-") {
+						setArg(letters[j], next, arg);
+						continue;
+					}
+					if (/[A-Za-z]/.test(letters[j]) && next[0] === "=") {
+						setArg(letters[j], next.slice(1), arg);
+						broken = true;
+						break;
+					}
+					if (/[A-Za-z]/.test(letters[j]) && /-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) {
+						setArg(letters[j], next, arg);
+						broken = true;
+						break;
+					}
+					if (letters[j + 1] && letters[j + 1].match(/\W/)) {
+						setArg(letters[j], arg.slice(j + 2), arg);
+						broken = true;
+						break;
+					} else setArg(letters[j], flags.strings[letters[j]] ? "" : true, arg);
+				}
+				key = arg.slice(-1)[0];
+				if (!broken && key !== "-") if (args[i + 1] && !/^(-|--)[^-]/.test(args[i + 1]) && !flags.bools[key] && (aliases[key] ? !aliasIsBoolean(key) : true)) {
+					setArg(key, args[i + 1], arg);
+					i += 1;
+				} else if (args[i + 1] && /^(true|false)$/.test(args[i + 1])) {
+					setArg(key, args[i + 1] === "true", arg);
+					i += 1;
+				} else setArg(key, flags.strings[key] ? "" : true, arg);
+			} else {
+				if (!flags.unknownFn || flags.unknownFn(arg) !== false) argv._.push(flags.strings._ || !isNumber(arg) ? arg : Number(arg));
+				if (opts.stopEarly) {
+					argv._.push.apply(argv._, args.slice(i + 1));
+					break;
+				}
+			}
+		}
+		Object.keys(defaults).forEach(function(k) {
+			if (!hasKey(argv, k.split("."))) {
+				setKey(argv, k.split("."), defaults[k]);
+				(aliases[k] || []).forEach(function(x) {
+					setKey(argv, x.split("."), defaults[k]);
+				});
+			}
+		});
+		if (opts["--"]) argv["--"] = notFlags.slice();
+		else notFlags.forEach(function(k) {
+			argv._.push(k);
+		});
+		return argv;
+	};
+}));
+
+//#endregion
+//#region package.json
+var import_minimist = /* @__PURE__ */ __toESM(require_minimist(), 1);
+var version = "0.0.1";
+
+//#endregion
+//#region src/cli/helpMessage.ts
+const helpMessage = `
+AutoGLM.js CLI v${version}
+
+Usage:
+  $ autoglm [options] <message>
+
+Options:
+  --help, -h      Show this help message
+  --config, -c    Path to configuration file (JSON format)
+`;
+
+//#endregion
+//#region src/cli/config/loader.ts
+/**
+* 加载并解析配置文件
+*/
+function loadConfigFile(configPath) {
+	let resolvedPath;
+	if (path.isAbsolute(configPath)) resolvedPath = configPath;
+	else resolvedPath = path.resolve(process.cwd(), configPath);
+	if (!fs.existsSync(resolvedPath)) throw new Error($t("config.errors.fileNotFound") + resolvedPath);
+	const ext = path.extname(resolvedPath).toLowerCase();
+	if (ext !== ".json") throw new Error($t("config.errors.invalidFormat") + ext);
+	try {
+		const fileContent = fs.readFileSync(resolvedPath, "utf-8");
+		return JSON.parse(fileContent);
+	} catch (error) {
+		throw new Error($t("config.errors.genericReadError") + (error instanceof Error ? error.message : String(error)));
+	}
+}
+
+//#endregion
+//#region src/cli/action.ts
+const actions = {
+	help: () => {
+		console.log(helpMessage);
+		process.exit(0);
+	},
+	config: (configPath) => {
+		return loadConfigFile(configPath);
+	}
+};
+function commandAction(argv) {
+	if (argv.help) actions.help();
+	if (argv.config) return actions.config(argv.config);
+}
+
+//#endregion
+//#region src/cli/banner.ts
+function printBanner() {
+	cfonts.say("AutoGLM.js", {
+		font: "block",
+		align: "left",
+		colors: ["blue", "cyan"],
+		background: "transparent",
+		letterSpacing: 1,
+		lineHeight: 1,
+		space: true,
+		maxLength: "0",
+		gradient: false,
+		independentGradient: false,
+		transitionGradient: false,
+		rawMode: false,
+		env: "node"
+	});
+}
+
+//#endregion
+//#region src/cli/config/prompts/agent.ts
+async function maxSteps() {
+	const result = await he({
+		message: $t("prompt.maxSteps"),
+		placeholder: "100",
+		defaultValue: "100"
+	});
+	return typeof result === "string" ? Number.parseInt(result, 10) : 100;
+}
+
+//#endregion
+//#region src/cli/config/prompts/cancel.ts
+function printCancel() {
+	xe($t("prompt.cancel"));
+	process.exit(0);
+}
+
+//#endregion
+//#region src/cli/config/prompts/language.ts
+var language_default = async () => {
+	const lang = await ve({
+		message: "Please select the language:",
+		options: [{
+			value: "cn",
+			label: "中文"
+		}, {
+			value: "en",
+			label: "English"
+		}]
+	});
+	setAgentConfig({ lang });
+	return lang;
+};
+
+//#endregion
+//#region src/cli/config/prompts/model.ts
+function model() {
+	return he({
+		message: $t("prompt.model"),
+		placeholder: "autoglm-phone",
+		defaultValue: "autoglm-phone"
+	});
+}
+function baseUrl() {
+	return he({
+		message: $t("prompt.baseURL"),
+		placeholder: "https://open.bigmodel.cn/api/paas/v4/",
+		defaultValue: "https://open.bigmodel.cn/api/paas/v4/"
+	});
+}
+function apiKey() {
+	return he({
+		message: $t("prompt.apiKey"),
+		placeholder: ""
+	});
+}
+
+//#endregion
+//#region src/cli/config/prompts/index.ts
+async function getConfig() {
+	Ie(cyan(`Config Your AutoGLM.js`));
+	const config = await Ce({
+		lang: language_default,
+		model,
+		baseUrl,
+		apiKey,
+		maxSteps
+	}, { onCancel() {
+		printCancel();
+	} });
+	spinner_default.start($t("prompt.checking"));
+	return config;
+}
+
+//#endregion
+//#region src/cli.ts
+/**
+* AutoGLM.js CLI
+*/
+async function main() {
+	printBanner();
+	const config = commandAction((0, import_minimist.default)(process.argv.slice(2), { alias: {
+		help: "h",
+		config: "c"
+	} })) || await getConfig();
+	setAgentConfig({
+		...config,
+		mode: "cli"
+	});
+	await checkSystemRequirements();
+	await checkModelApi();
+	if (!config) {
+		spinner_default.stop($t("prompt.checking"));
+		Se($t("prompt.done"));
+	}
+	const agent = new PhoneAgent();
+	Ie(bold(cyan(`🤖 ${$t("prompt.interactiveMode")}`)));
+	let isFirstTask = true;
+	while (true) {
+		const task = await he({
+			message: bold(`💬 ${$t("prompt.task")}`),
+			placeholder: isFirstTask ? $t("prompt.placeholder") : void 0
+		});
+		if (pD(task)) {
+			xe($t("prompt.cancel"));
+			process.exit(0);
+		}
+		if (task) {
+			await agent.run(task);
+			isFirstTask = false;
+		}
+	}
+}
+main().catch((error) => {
+	console.error("CLI执行错误:", error);
+	process.exit(1);
+});
+
+//#endregion
+export {  };

package/dist/index.d.mts

@@ -0,0 +1,42 @@
+import * as mitt0 from "mitt";
+
+//#region src/utils/events.d.ts
+interface EventData {
+  message: any;
+  time: string;
+}
+//#endregion
+//#region src/config/types.d.ts
+interface AgentConfigType {
+  mode: 'cli' | 'api';
+  maxSteps: number;
+  lang: 'cn' | 'en';
+  deviceId?: string;
+  systemPrompt?: string;
+  baseUrl: string;
+  apiKey: string;
+  model: string;
+  maxTokens: number;
+  temperature: number;
+  topP: number;
+  frequencyPenalty: number;
+}
+//#endregion
+//#region src/index.d.ts
+declare class AutoGLM {
+  private phoneAgent;
+  private constructor();
+  static createAgent(config: AgentConfigType): Promise<AutoGLM>;
+  run(task: string): mitt0.Emitter<{
+    thinking: EventData;
+    action: EventData;
+    task_complete: EventData;
+  }>;
+  checkModelApi(): Promise<void>;
+  checkSystemRequirements(): Promise<{
+    success: boolean;
+    message: string;
+  } | undefined>;
+}
+//#endregion
+export { AutoGLM };

package/dist/index.mjs

@@ -0,0 +1,36 @@
+import { a as emitter, m as setAgentConfig, n as checkSystemRequirements, r as PhoneAgent, t as checkModelApi } from "./check-Ox_8ktAc.mjs";
+
+//#region src/index.ts
+var AutoGLM = class AutoGLM {
+	phoneAgent;
+	constructor(config) {
+		config && setAgentConfig({
+			...config,
+			mode: "api"
+		});
+		this.phoneAgent = new PhoneAgent();
+	}
+	static async createAgent(config) {
+		setAgentConfig({
+			...config,
+			mode: "api"
+		});
+		const instance = new AutoGLM();
+		await checkSystemRequirements();
+		await checkModelApi();
+		return instance;
+	}
+	run(task) {
+		this.phoneAgent.run(task);
+		return emitter;
+	}
+	checkModelApi() {
+		return checkModelApi();
+	}
+	checkSystemRequirements() {
+		return checkSystemRequirements();
+	}
+};
+
+//#endregion
+export { AutoGLM };