@lasting-beauty/chat-hub 0.1.0-beta.1

package/cli/platform.mjs

@@ -0,0 +1,173 @@
+import { execFileSync } from 'node:child_process';
+
+export const platformServiceEnvironment = Object.freeze({
+  HOME: '/var/lib/chat-hub',
+  XDG_CONFIG_HOME: '/var/lib/chat-hub/.config',
+  XDG_DATA_HOME: '/var/lib/chat-hub/.local/share',
+  XDG_CACHE_HOME: '/var/lib/chat-hub/.cache',
+  DWS_CONFIG_DIR: '/var/lib/chat-hub/.dws',
+});
+
+export const larkReadDomains = 'im,mail,minutes,task,approval,calendar,drive,base,sheets';
+
+export class PlatformCommandError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.name = 'PlatformCommandError';
+    this.code = code;
+  }
+}
+
+export function platformCliSteps({ platform, action, larkMode, appId, device = true }) {
+  if (!['lark', 'dingtalk'].includes(platform)) {
+    throw new PlatformCommandError('platform_invalid', '平台必须是 lark 或 dingtalk');
+  }
+  if (!['login', 'status'].includes(action)) {
+    throw new PlatformCommandError('platform_action_invalid', '平台操作必须是 login 或 status');
+  }
+  if (action === 'status') {
+    return platform === 'lark'
+      ? [{ command: 'lark', args: ['whoami'], capture: true }]
+      : [{ command: 'dingtalk', args: ['auth', 'status', '--format', 'json'], capture: true }];
+  }
+  if (platform === 'dingtalk') {
+    return [
+      {
+        command: 'dingtalk',
+        args: ['auth', 'login', ...(device ? ['--device'] : []), '--recommend'],
+        capture: false,
+      },
+    ];
+  }
+  if (larkMode === 'new') {
+    return [
+      { command: 'lark', args: ['config', 'init', '--new'], capture: false },
+      {
+        command: 'lark',
+        args: ['auth', 'login', '--domain', larkReadDomains, '--recommend', '--json'],
+        capture: false,
+      },
+    ];
+  }
+  if (larkMode === 'existing') {
+    if (typeof appId !== 'string' || !/^cli_[A-Za-z0-9]+$/.test(appId)) {
+      throw new PlatformCommandError(
+        'lark_app_id_required',
+        '已有飞书应用必须通过 --app-id 提供有效 App ID；App Secret 随后从隐藏输入或 stdin 读取',
+      );
+    }
+    return [
+      {
+        command: 'lark',
+        args: ['config', 'init', '--app-id', appId, '--app-secret-stdin'],
+        capture: false,
+      },
+      {
+        command: 'lark',
+        args: ['auth', 'login', '--domain', larkReadDomains, '--recommend', '--json'],
+        capture: false,
+      },
+    ];
+  }
+  if (larkMode === 'configured') {
+    return [
+      {
+        command: 'lark',
+        args: ['auth', 'login', '--domain', larkReadDomains, '--recommend', '--json'],
+        capture: false,
+      },
+    ];
+  }
+  throw new PlatformCommandError(
+    'lark_initialization_choice_required',
+    '飞书尚未配置时必须明确选择 --new-app，或使用 --app-id <App ID> 绑定已有应用',
+  );
+}
+
+export function serviceUserInvocation(invocation) {
+  const environmentArguments = Object.entries(platformServiceEnvironment).map(
+    ([key, value]) => `${key}=${value}`,
+  );
+  return {
+    executable: 'runuser',
+    args: [
+      '--user',
+      'chat-hub',
+      '--',
+      'env',
+      ...environmentArguments,
+      invocation.executable,
+      ...invocation.prefixArgs,
+    ],
+  };
+}
+
+export function summarizePlatformStatus(platform, output) {
+  let value;
+  try {
+    value = JSON.parse(output);
+  } catch {
+    throw new PlatformCommandError(
+      'platform_status_invalid',
+      `${platform === 'lark' ? '飞书' : '钉钉'}状态输出无法识别`,
+    );
+  }
+  if (platform === 'lark') {
+    return {
+      platform,
+      configured: value.available !== false && Boolean(value.appId || value.profile),
+      authenticated: value.available === true && value.tokenStatus === 'ready',
+      displayName: cleanDisplayName(value.onBehalfOf?.userName),
+      status: value.tokenStatus ?? (value.available ? 'ready' : 'not_configured'),
+    };
+  }
+  return {
+    platform,
+    configured: true,
+    authenticated: value.authenticated === true && value.token_valid !== false,
+    displayName: cleanDisplayName(value.user_name),
+    status:
+      value.authenticated === true && value.token_valid !== false
+        ? 'ready'
+        : value.authenticated === false
+          ? 'not_authenticated'
+          : 'unknown',
+  };
+}
+
+export function runPlatformCommand({
+  platform,
+  action,
+  larkMode,
+  appId,
+  device,
+  resolveInvocation,
+  execute = execFileSync,
+}) {
+  const steps = platformCliSteps({ platform, action, larkMode, appId, device });
+  let captured = '';
+  for (const step of steps) {
+    const selected = resolveInvocation(step.command);
+    if (!selected) {
+      throw new PlatformCommandError(
+        'platform_cli_missing',
+        `缺少固定版本平台 CLI：${step.command}`,
+      );
+    }
+    const service = serviceUserInvocation(selected);
+    const options = step.capture
+      ? { encoding: 'utf8', timeout: 30_000, stdio: 'pipe' }
+      : { timeout: 10 * 60_000, stdio: 'inherit' };
+    const result = execute(service.executable, [...service.args, ...step.args], options);
+    if (step.capture) captured = String(result);
+  }
+  return action === 'status'
+    ? summarizePlatformStatus(platform, captured)
+    : { platform, authenticated: true, status: 'login_completed' };
+}
+
+function cleanDisplayName(value) {
+  if (typeof value !== 'string') return undefined;
+  const trimmed = value.trim();
+  return trimmed ? trimmed.slice(0, 80) : undefined;
+}

package/cli/runtime.mjs

@@ -0,0 +1,115 @@
+import { spawn } from 'node:child_process';
+import { existsSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { startGateway } from '../skills/chat-hub-setup/scripts/gateway.mjs';
+
+const configPath = process.argv[2];
+if (!configPath || !existsSync(configPath)) throw new Error('缺少运行配置');
+const config = JSON.parse(readFileSync(configPath, 'utf8'));
+const statePath = join(config.runtimeDirectory, 'state.json');
+let appProcess;
+let gateway;
+let closing = false;
+
+function writeState(status, code) {
+  const temporary = `${statePath}.tmp`;
+  writeFileSync(
+    temporary,
+    `${JSON.stringify(
+      {
+        id: config.id,
+        runId: config.runId,
+        pid: process.pid,
+        appPid: appProcess?.pid,
+        status,
+        code,
+        updatedAt: new Date().toISOString(),
+      },
+      null,
+      2,
+    )}\n`,
+    { encoding: 'utf8', mode: 0o600 },
+  );
+  renameSync(temporary, statePath);
+}
+
+async function close(code = 'stopped', failed = false) {
+  if (closing) return;
+  closing = true;
+  if (gateway) await gateway.close();
+  if (appProcess && appProcess.exitCode === null && appProcess.signalCode === null) {
+    await new Promise((resolvePromise) => {
+      const timer = setTimeout(() => {
+        appProcess.kill('SIGKILL');
+        resolvePromise();
+      }, 5_000);
+      appProcess.once('exit', () => {
+        clearTimeout(timer);
+        resolvePromise();
+      });
+      appProcess.kill('SIGTERM');
+    });
+  }
+  writeState(failed ? 'failed' : 'stopped', code);
+  process.exit(failed ? 1 : 0);
+}
+
+process.on('SIGTERM', () => void close());
+process.on('SIGINT', () => void close());
+function reportFailure(code, error) {
+  const message = error instanceof Error ? error.message : String(error ?? '未知错误');
+  console.error(`[chat-hub-runtime] ${code}: ${message}`);
+}
+
+process.on('uncaughtException', (error) => {
+  reportFailure('uncaught_exception', error);
+  void close('runtime_error', true);
+});
+process.on('unhandledRejection', (error) => {
+  reportFailure('unhandled_rejection', error);
+  void close('runtime_error', true);
+});
+
+async function waitForHealth() {
+  const deadline = Date.now() + 40_000;
+  while (Date.now() < deadline && !closing) {
+    try {
+      const response = await fetch(`http://127.0.0.1:${config.apiPort}/api/health`, {
+        signal: AbortSignal.timeout(1_000),
+      });
+      const body = await response.json();
+      if (response.ok && body.ok === true && body.data?.status === 'ready') return;
+    } catch {
+      // The application can still be opening SQLite or loading native modules.
+    }
+    await new Promise((resolvePromise) => setTimeout(resolvePromise, 250));
+  }
+  throw new Error('health_timeout');
+}
+
+try {
+  writeState('starting');
+  appProcess = spawn(process.execPath, [join(config.packageRoot, 'dist', 'server', 'index.js')], {
+    cwd: config.runtimeDirectory,
+    env: { ...process.env, ...config.environment },
+    stdio: 'inherit',
+    windowsHide: true,
+    shell: false,
+  });
+  appProcess.once('error', (error) => {
+    reportFailure('app_start_failed', error);
+    void close('app_start_failed', true);
+  });
+  appProcess.once('exit', (code, signal) => {
+    if (!closing) {
+      reportFailure('app_exited', `code=${code ?? 'null'}, signal=${signal ?? 'none'}`);
+      void close('app_exited', true);
+    }
+  });
+  await waitForHealth();
+  gateway = await startGateway(config);
+  writeState('ready');
+} catch (error) {
+  reportFailure('startup_failed', error);
+  await close('startup_failed', true);
+}

package/cli/server-maintenance.mjs

@@ -0,0 +1,207 @@
+import { randomBytes, timingSafeEqual } from 'node:crypto';
+import {
+  chmodSync,
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  statSync,
+  unlinkSync,
+  writeFileSync,
+} from 'node:fs';
+import { dirname, isAbsolute, relative, resolve } from 'node:path';
+import { deploymentPaths } from './deploy.mjs';
+import { ipCertificateAutomationPaths } from './ip-certificate.mjs';
+
+const caddyImport = 'import /etc/caddy/chat-hub.caddy';
+
+export const purgeConfirmationPath = '/etc/chat-hub/purge-confirmation.json';
+
+export function stageUninstall({ rootDirectory = '/' } = {}) {
+  const outputPath = (absolutePath) => rootedPath(rootDirectory, absolutePath);
+  const managedFiles = [
+    deploymentPaths.service,
+    deploymentPaths.caddySnippet,
+    deploymentPaths.runtimeConfig,
+    deploymentPaths.manifest,
+    ipCertificateAutomationPaths.service,
+    ipCertificateAutomationPaths.timer,
+    ipCertificateAutomationPaths.deployHook,
+    ipCertificateAutomationPaths.renewRunner,
+  ];
+  const managedDirectories = [ipCertificateAutomationPaths.publishedDirectory];
+  const previous = new Map();
+  for (const absolutePath of [...managedFiles, deploymentPaths.caddyfile]) {
+    const target = outputPath(absolutePath);
+    previous.set(
+      absolutePath,
+      existsSync(target)
+        ? { existed: true, content: readFileSync(target), mode: statSync(target).mode & 0o777 }
+        : { existed: false },
+    );
+  }
+  const quarantinedDirectories = new Map();
+
+  try {
+    for (const absolutePath of managedFiles) {
+      const target = outputPath(absolutePath);
+      if (existsSync(target)) unlinkSync(target);
+    }
+    for (const absolutePath of managedDirectories) {
+      const target = outputPath(absolutePath);
+      if (!existsSync(target)) continue;
+      const quarantine = `${target}.uninstall-${randomBytes(12).toString('hex')}`;
+      renameSync(target, quarantine);
+      quarantinedDirectories.set(target, quarantine);
+    }
+    const caddyfile = outputPath(deploymentPaths.caddyfile);
+    if (existsSync(caddyfile)) {
+      const filtered = readFileSync(caddyfile, 'utf8')
+        .split(/\r?\n/)
+        .filter((line) => line.trim() !== caddyImport)
+        .join('\n');
+      writeAtomic(caddyfile, filtered ? `${filtered.replace(/\n+$/, '')}\n` : '', 0o644);
+    }
+  } catch (error) {
+    restoreDirectories(quarantinedDirectories);
+    restoreFiles(previous, outputPath);
+    throw error;
+  }
+
+  let finalized = false;
+  return {
+    removedFiles: [...managedFiles, ...managedDirectories].map(outputPath),
+    preservedPaths: [
+      outputPath(deploymentPaths.data),
+      outputPath(deploymentPaths.credentials),
+      outputPath(deploymentPaths.backups),
+    ],
+    rollback() {
+      if (finalized) return;
+      restoreDirectories(quarantinedDirectories);
+      restoreFiles(previous, outputPath);
+      finalized = true;
+    },
+    commit() {
+      for (const quarantine of quarantinedDirectories.values()) {
+        if (existsSync(quarantine)) rmSync(quarantine, { recursive: true, force: true });
+      }
+      finalized = true;
+    },
+  };
+}
+
+function restoreDirectories(quarantinedDirectories) {
+  for (const [target, quarantine] of [...quarantinedDirectories.entries()].reverse()) {
+    if (existsSync(quarantine)) renameSync(quarantine, target);
+  }
+}
+
+export function createPurgeConfirmation({
+  rootDirectory = '/',
+  now = Date.now(),
+  token = randomBytes(24).toString('base64url'),
+} = {}) {
+  if (typeof token !== 'string' || token.length < 24 || /[\r\n\0]/.test(token)) {
+    throw new Error('purge 确认令牌强度不足');
+  }
+  const confirmation = rootedPath(rootDirectory, purgeConfirmationPath);
+  const configuration = rootedPath(rootDirectory, deploymentPaths.configuration);
+  mkdirSync(configuration, { recursive: true, mode: 0o700 });
+  chmodSync(configuration, 0o700);
+  const expiresAt = now + 10 * 60_000;
+  const paths = purgeTargets(rootDirectory);
+  writeAtomic(
+    confirmation,
+    `${JSON.stringify({ version: 1, token, createdAt: now, expiresAt, paths })}\n`,
+    0o600,
+  );
+  return { token, expiresAt, confirmationPath: confirmation, paths };
+}
+
+export function consumePurgeConfirmation({ token, rootDirectory = '/', now = Date.now() }) {
+  const validated = validatePurgeConfirmation({ token, rootDirectory, now });
+  const { confirmation, expectedPaths } = validated;
+  // Consume first so an interrupted command cannot be replayed. Every target is a fixed,
+  // validated Chat Hub path; no caller-controlled filesystem path reaches rmSync.
+  unlinkSync(confirmation);
+  for (const path of expectedPaths) {
+    if (existsSync(path)) rmSync(path, { recursive: true, force: true });
+  }
+  return { purged: true, removedPaths: expectedPaths };
+}
+
+export function validatePurgeConfirmation({ token, rootDirectory = '/', now = Date.now() }) {
+  const confirmation = rootedPath(rootDirectory, purgeConfirmationPath);
+  if (!existsSync(confirmation) || lstatSync(confirmation).isSymbolicLink()) {
+    throw new Error('没有待确认的 purge 请求，请先运行 chat-hub purge');
+  }
+  const value = JSON.parse(readFileSync(confirmation, 'utf8'));
+  const expectedPaths = purgeTargets(rootDirectory);
+  if (
+    !value ||
+    value.version !== 1 ||
+    typeof value.token !== 'string' ||
+    !Number.isFinite(value.expiresAt) ||
+    JSON.stringify(value.paths) !== JSON.stringify(expectedPaths)
+  ) {
+    throw new Error('purge 确认文件无效');
+  }
+  if (now > value.expiresAt) {
+    unlinkSync(confirmation);
+    throw new Error('purge 确认已过期，请重新运行 chat-hub purge');
+  }
+  if (!safeEqual(value.token, token)) throw new Error('purge 确认令牌不匹配');
+  return { confirmation, expectedPaths };
+}
+
+function purgeTargets(rootDirectory) {
+  return [
+    rootedPath(rootDirectory, deploymentPaths.data),
+    rootedPath(rootDirectory, deploymentPaths.backups),
+    rootedPath(rootDirectory, deploymentPaths.configuration),
+  ];
+}
+
+function safeEqual(left, right) {
+  if (typeof right !== 'string') return false;
+  const leftBuffer = Buffer.from(left);
+  const rightBuffer = Buffer.from(right);
+  return leftBuffer.length === rightBuffer.length && timingSafeEqual(leftBuffer, rightBuffer);
+}
+
+function writeAtomic(path, content, mode) {
+  const temporary = `${path}.${process.pid}.tmp`;
+  writeFileSync(temporary, content, { mode });
+  chmodSync(temporary, mode);
+  renameSync(temporary, path);
+}
+
+function restoreFiles(previous, outputPath) {
+  for (const [absolutePath, state] of [...previous.entries()].reverse()) {
+    const target = outputPath(absolutePath);
+    if (!state.existed) {
+      if (existsSync(target)) unlinkSync(target);
+      continue;
+    }
+    mkdirSync(dirname(target), { recursive: true });
+    writeFileSync(target, state.content, { mode: state.mode });
+    chmodSync(target, state.mode);
+  }
+}
+
+function rootedPath(rootDirectory, absolutePath) {
+  const root = resolve(rootDirectory);
+  if (!isAbsolute(rootDirectory) || !isAbsolute(absolutePath)) {
+    throw new Error('服务器维护路径必须是绝对路径');
+  }
+  if (root === resolve('/')) return absolutePath;
+  const target = resolve(root, absolutePath.replace(/^[/\\]+/, ''));
+  const pathFromRoot = relative(root, target);
+  if (pathFromRoot.startsWith('..') || isAbsolute(pathFromRoot)) {
+    throw new Error('服务器维护目标越出测试根目录');
+  }
+  return target;
+}