xshat-lite 1.0.0

package/src/utils/config.mjs

@@ -0,0 +1,257 @@
+import fs from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import defaultConfig from '../config/default.mjs';
+import {
+  readJsonSafeSync,
+  writeJsonAtomicSync
+} from './storage.mjs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageRootDir = resolve(__dirname, '..', '..');
+const runtimeRootDir = process.env.XSHAT_HOME
+  ? resolve(process.env.XSHAT_HOME)
+  : packageRootDir;
+
+function cloneProviders(providers) {
+  return providers.map((provider) => ({
+    ...provider,
+    enabled: provider.enabled !== false,
+    status: provider.status || 'experimental',
+    steps: {
+      preflight: {
+        ...(provider.steps?.preflight || {})
+      },
+      input: { ...(provider.steps?.input || {}) },
+      send: { ...(provider.steps?.send || {}) },
+      read: { ...(provider.steps?.read || {}) },
+      complete: {
+        ...(provider.steps?.complete || {}),
+        selectors: {
+          ...(provider.steps?.complete?.selectors || {})
+        }
+      }
+    }
+  }));
+}
+
+function deepMerge(base, override) {
+  if (!override || typeof override !== 'object' || Array.isArray(override)) {
+    return base;
+  }
+
+  const result = Array.isArray(base) ? [...base] : { ...base };
+
+  for (const [key, value] of Object.entries(override)) {
+    if (
+      value &&
+      typeof value === 'object' &&
+      !Array.isArray(value) &&
+      result[key] &&
+      typeof result[key] === 'object' &&
+      !Array.isArray(result[key])
+    ) {
+      result[key] = deepMerge(result[key], value);
+      continue;
+    }
+
+    result[key] = value;
+  }
+
+  return result;
+}
+
+const userConfigPath = resolve(runtimeRootDir, 'runtime', 'config', 'user.json');
+
+function loadUserConfig() {
+  if (!fs.existsSync(userConfigPath)) {
+    return {};
+  }
+
+  return readJsonSafeSync(userConfigPath, {});
+}
+
+function buildBaseConfig() {
+  return {
+    ...defaultConfig,
+    providers: cloneProviders(defaultConfig.providers),
+    api: { ...(defaultConfig.api || {}) },
+    providersRuntime: { ...(defaultConfig.providersRuntime || {}) },
+    browser: { ...defaultConfig.browser },
+    chat: { ...defaultConfig.chat },
+    session: { ...defaultConfig.session },
+    tasks: { ...defaultConfig.tasks },
+    storage: { ...(defaultConfig.storage || {}) },
+    logger: { ...defaultConfig.logger },
+    agent: { ...(defaultConfig.agent || {}) },
+    debug: { ...(defaultConfig.debug || {}) }
+  };
+}
+
+function normalizeResolvedPaths(config) {
+  config.browser.userDataDir = resolve(runtimeRootDir, config.browser.userDataDir);
+  config.logger.dir = resolve(runtimeRootDir, config.logger.dir);
+  config.session.dir = resolve(runtimeRootDir, config.session.dir);
+  config.tasks.dir = resolve(runtimeRootDir, config.tasks.dir);
+  config.storage.archiveDir = resolve(runtimeRootDir, config.storage.archiveDir);
+  return config;
+}
+
+function loadConfig() {
+  const config = deepMerge(buildBaseConfig(), loadUserConfig());
+
+  if (process.env.DEFAULT_PROVIDER) {
+    config.defaultProvider = process.env.DEFAULT_PROVIDER;
+  }
+
+  if (process.env.BROWSER_HEADLESS) {
+    config.browser.headless = process.env.BROWSER_HEADLESS === 'true';
+  }
+
+  if (process.env.USER_DATA_DIR) {
+    config.browser.userDataDir = process.env.USER_DATA_DIR;
+  }
+
+  if (process.env.BROWSER_GOTO_TIMEOUT) {
+    config.browser.gotoTimeout = Number.parseInt(
+      process.env.BROWSER_GOTO_TIMEOUT,
+      10
+    );
+  }
+
+  if (process.env.XSHAT_BROWSER_ALLOW_VISIBLE) {
+    config.browser.allowVisibleBrowser =
+      process.env.XSHAT_BROWSER_ALLOW_VISIBLE === 'true';
+  }
+
+  if (process.env.XSHAT_BROWSER_SHARE_AUTH_STATE) {
+    config.browser.shareAuthState =
+      process.env.XSHAT_BROWSER_SHARE_AUTH_STATE === 'true';
+  }
+
+  if (process.env.LOG_DIR) {
+    config.logger.dir = process.env.LOG_DIR;
+  }
+
+  if (process.env.SESSION_DIR) {
+    config.session.dir = process.env.SESSION_DIR;
+  }
+
+  if (process.env.TASK_DIR) {
+    config.tasks.dir = process.env.TASK_DIR;
+  }
+
+  if (process.env.XSHAT_DEBUG) {
+    config.debug.enabled = process.env.XSHAT_DEBUG === 'true';
+  }
+
+  if (process.env.XSHAT_AGENT_ENABLED) {
+    config.agent.enabled = process.env.XSHAT_AGENT_ENABLED === 'true';
+  }
+
+  if (process.env.XSHAT_AGENT_AUTO_EXECUTE) {
+    config.agent.autoExecuteCommands =
+      process.env.XSHAT_AGENT_AUTO_EXECUTE === 'true';
+  }
+
+  if (process.env.XSHAT_AGENT_ALLOW_SHELL) {
+    config.agent.allowShell = process.env.XSHAT_AGENT_ALLOW_SHELL === 'true';
+  }
+
+  if (process.env.XSHAT_AGENT_ALLOW_FILE_WRITE) {
+    config.agent.allowFileWrite =
+      process.env.XSHAT_AGENT_ALLOW_FILE_WRITE === 'true';
+  }
+
+  if (process.env.XSHAT_AGENT_MULTI_AGENT) {
+    config.agent.multiAgent = process.env.XSHAT_AGENT_MULTI_AGENT === 'true';
+  }
+
+  if (process.env.OPENAI_API_KEY) {
+    config.api.apiKey = process.env.OPENAI_API_KEY;
+  }
+
+  if (process.env.OPENAI_BASE_URL) {
+    config.api.baseUrl = process.env.OPENAI_BASE_URL;
+  }
+
+  if (process.env.OPENAI_MODEL) {
+    config.api.model = process.env.OPENAI_MODEL;
+  }
+
+  return normalizeResolvedPaths(config);
+}
+
+const config = loadConfig();
+let userConfigOverrides = loadUserConfig();
+
+function setNestedValue(target, path, value) {
+  const keys = Array.isArray(path) ? path : String(path).split('.').filter(Boolean);
+  if (keys.length === 0) {
+    return target;
+  }
+
+  let cursor = target;
+  for (let index = 0; index < keys.length - 1; index++) {
+    const key = keys[index];
+    if (!cursor[key] || typeof cursor[key] !== 'object' || Array.isArray(cursor[key])) {
+      cursor[key] = {};
+    }
+    cursor = cursor[key];
+  }
+
+  cursor[keys[keys.length - 1]] = value;
+  return target;
+}
+
+function refreshConfig() {
+  const nextConfig = loadConfig();
+
+  for (const key of Object.keys(config)) {
+    delete config[key];
+  }
+
+  Object.assign(config, nextConfig);
+}
+
+export function getUserConfigPath() {
+  return userConfigPath;
+}
+
+export function getUserConfigOverrides() {
+  return JSON.parse(JSON.stringify(userConfigOverrides));
+}
+
+export function saveConfigOverrides(overrides = userConfigOverrides) {
+  fs.mkdirSync(dirname(userConfigPath), { recursive: true });
+  writeJsonAtomicSync(userConfigPath, overrides);
+  userConfigOverrides = overrides;
+  refreshConfig();
+  return config;
+}
+
+export function updateConfigValue(path, value) {
+  const nextOverrides = getUserConfigOverrides();
+  setNestedValue(nextOverrides, path, value);
+  return saveConfigOverrides(nextOverrides);
+}
+
+export function listProviders({ includeDisabled = false } = {}) {
+  if (includeDisabled) {
+    return config.providers;
+  }
+
+  return config.providers.filter((provider) => provider.enabled !== false);
+}
+
+export function getProvider(id) {
+  const providerId = id || config.defaultProvider;
+  const provider = config.providers.find((item) => item.id === providerId);
+  if (!provider) {
+    throw new Error(`未找到 AI 提供方: ${providerId}`);
+  }
+  return provider;
+}
+
+export default config;

package/src/utils/key-input.mjs

@@ -0,0 +1,86 @@
+function normalizeChunk(chunk) {
+  const value = Buffer.isBuffer(chunk) ? chunk.toString('utf8') : String(chunk || '');
+
+  switch (value) {
+  case '\u0003':
+    return 'ctrl_c';
+  case '\r':
+  case '\n':
+    return 'enter';
+  case '\u001b':
+    return 'escape';
+  case '\u001b[A':
+    return 'up';
+  case '\u001b[B':
+    return 'down';
+  case '\u001b[C':
+    return 'right';
+  case '\u001b[D':
+    return 'left';
+  case '\u0008':
+  case '\u007f':
+    return 'backspace';
+  default:
+    if (value.length === 1) {
+      return value.toLowerCase();
+    }
+    return value.toLowerCase();
+  }
+}
+
+export async function waitForKeypress() {
+  return new Promise((resolve, reject) => {
+    const stdin = process.stdin;
+    const canUseRawMode = Boolean(stdin.isTTY && typeof stdin.setRawMode === 'function');
+
+    const cleanup = () => {
+      stdin.off('data', onData);
+      stdin.off('error', onError);
+      if (canUseRawMode) {
+        stdin.setRawMode(false);
+      }
+      stdin.pause();
+    };
+
+    const onError = (error) => {
+      cleanup();
+      reject(error);
+    };
+
+    const onData = (chunk) => {
+      const key = normalizeChunk(chunk);
+      cleanup();
+      if (key === 'ctrl_c') {
+        const error = new Error('AbortError');
+        error.name = 'AbortError';
+        reject(error);
+        return;
+      }
+      resolve(key);
+    };
+
+    if (canUseRawMode) {
+      stdin.setRawMode(true);
+    }
+    stdin.resume();
+    stdin.on('data', onData);
+    stdin.on('error', onError);
+  });
+}
+
+export function decodeKeypressChunk(chunk) {
+  const value = Buffer.isBuffer(chunk) ? chunk.toString('utf8') : String(chunk || '');
+  const key = normalizeChunk(value);
+  return {
+    key,
+    raw: value,
+    printable:
+      value.length === 1 &&
+      key !== 'enter' &&
+      key !== 'escape' &&
+      key !== 'ctrl_c' &&
+      key !== 'backspace'
+        ? value
+        : ''
+  };
+}

package/src/utils/storage.mjs

@@ -0,0 +1,55 @@
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+
+function buildTempPath(targetPath) {
+  const suffix = `${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}`;
+  return `${targetPath}.${suffix}.tmp`;
+}
+
+export async function writeTextAtomic(targetPath, content, encoding = 'utf-8') {
+  const directory = dirname(targetPath);
+  const tempPath = buildTempPath(targetPath);
+
+  await fsp.mkdir(directory, { recursive: true });
+  await fsp.writeFile(tempPath, content, encoding);
+  await fsp.rename(tempPath, targetPath);
+}
+
+export async function writeJsonAtomic(targetPath, value) {
+  const content = `${JSON.stringify(value, null, 2)}\n`;
+  await writeTextAtomic(targetPath, content, 'utf-8');
+}
+
+export function writeJsonAtomicSync(targetPath, value) {
+  const directory = dirname(targetPath);
+  const tempPath = buildTempPath(targetPath);
+  const content = `${JSON.stringify(value, null, 2)}\n`;
+
+  fs.mkdirSync(directory, { recursive: true });
+  fs.writeFileSync(tempPath, content, 'utf-8');
+  fs.renameSync(tempPath, targetPath);
+}
+
+export async function readJsonSafe(targetPath, fallback = null) {
+  try {
+    const raw = await fsp.readFile(targetPath, 'utf-8');
+    return JSON.parse(raw);
+  } catch {
+    return fallback;
+  }
+}
+
+export function readJsonSafeSync(targetPath, fallback = null) {
+  try {
+    const raw = fs.readFileSync(targetPath, 'utf-8');
+    return JSON.parse(raw);
+  } catch {
+    return fallback;
+  }
+}
+
+export function resolveSiblingPath(baseDir, name) {
+  return resolve(baseDir, name);
+}
+