glad-web 1.0.45 → 2.0.1

package/lib/git/service.js

@@ -1,83 +0,0 @@
-const { execFile } = require('child_process');
-
-function execFilePromise(file, args, cwd) {
-  return new Promise((resolve) => {
-    execFile(file, args, { cwd, encoding: 'utf8', maxBuffer: 10 * 1024 * 1024 }, (error, stdout, stderr) => {
-      resolve({ success: !error, error: error?.message, stdout, stderr });
-    });
-  });
-}
-
-function parseGitStatusZ(stdout) {
-  if (!stdout) return [];
-
-  const entries = [];
-  const records = stdout.split('\0').filter(Boolean);
-
-  for (let i = 0; i < records.length; i++) {
-    const record = records[i];
-    if (record.length < 3) continue;
-
-    const status = record.substring(0, 2);
-    const path = record.substring(3);
-    const entry = { path, status };
-
-    if ((status.includes('R') || status.includes('C')) && i + 1 < records.length) {
-      entry.originalPath = records[++i];
-    }
-
-    entries.push(entry);
-  }
-
-  return entries;
-}
-
-class GitService {
-  async show(cwd, hash) {
-    return execFilePromise('git', ['show', '--format=fuller', '--stat', '-p', hash], cwd);
-  }
-
-  async log(cwd, maxCount = 100) {
-    const count = Number.parseInt(maxCount, 10) || 100;
-    const result = await execFilePromise(
-      'git',
-      ['log', '--all', '--date-order', `--max-count=${count}`, '--pretty=format:%h|%p|%d|%s|%an|%ar'],
-      cwd
-    );
-    if (!result.success) return result;
-
-    const commits = result.stdout.split('\n').filter(Boolean).map(line => {
-      const [hash, parents, refs, subject, author, time] = line.split('|');
-      return { hash, parents: parents ? parents.split(' ') : [], refs: refs ? refs.trim() : '', subject, author, time };
-    });
-    return { ...result, commits };
-  }
-
-  async status(cwd) {
-    const result = await execFilePromise('git', ['status', '--porcelain=v1', '-z', '--untracked-files=all'], cwd);
-    if (!result.success) return result;
-    return { ...result, files: parseGitStatusZ(result.stdout) };
-  }
-
-  diffNumstat(cwd, isStaged = false) {
-    const args = isStaged ? ['diff', '--cached', '--numstat'] : ['diff', '--numstat'];
-    return execFilePromise('git', args, cwd);
-  }
-
-  diffFile(cwd, filePath, isStaged = false) {
-    const args = isStaged
-      ? ['diff', '--cached', '--no-ext-diff', '--', filePath]
-      : ['diff', '--no-ext-diff', '--', filePath];
-    return execFilePromise('git', args, cwd);
-  }
-
-  async nameRev(cwd, hash) {
-    return execFilePromise('git', ['name-rev', '--name-only', '--exclude=tags/*', hash], cwd);
-  }
-}
-
-module.exports = {
-  GitService,
-  execFilePromise,
-  parseGitStatusZ
-};

package/lib/notifications/message-formatter.js

@@ -1,94 +0,0 @@
-const path = require('path');
-
-const TITLE_LABELS = {
-  approval: '待审批',
-  completed: '已完成',
-  failed: '执行失败',
-  disconnected: '连接中断',
-  test: '通知测试'
-};
-
-function compactText(value, maxLength = 20) {
-  const text = String(value || '').replace(/[\r\n]+/g, ' ').trim();
-  if (text.length <= maxLength) return text;
-  return `${text.slice(0, Math.max(1, maxLength - 1))}…`;
-}
-
-function formatLocalDateTime(value) {
-  const date = new Date(Number(value) || Date.now());
-  const pad = number => String(number).padStart(2, '0');
-  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} `
-    + `${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
-}
-
-function formatDuration(durationMs) {
-  const totalSeconds = Math.max(0, Math.round(Number(durationMs) / 1000));
-  if (!Number.isFinite(totalSeconds) || totalSeconds <= 0) return '';
-  if (totalSeconds < 60) return `${totalSeconds}秒`;
-  const minutes = Math.floor(totalSeconds / 60);
-  const seconds = totalSeconds % 60;
-  return seconds ? `${minutes}分${seconds}秒` : `${minutes}分`;
-}
-
-function escapeMarkdown(value) {
-  return String(value || '').replace(/([\\`*_{}\[\]()#+\-.!|>])/g, '\\$1');
-}
-
-function providerName(provider, session) {
-  if (provider === 'claude') return 'Claude';
-  if (provider === 'codex') return 'Codex';
-  return session?.tool?.displayName || 'AI';
-}
-
-function sessionDirectory(session) {
-  return session?.workingDir || session?.workingDirectory || session?.ptyManager?.workingDir || process.cwd();
-}
-
-function formatNotification({ kind, provider, session, durationMs = null }, clientType = 'wechat') {
-  const name = String(session?.name || providerName(provider, session));
-  const directory = sessionDirectory(session);
-  const type = providerName(provider, session);
-  const title = `${TITLE_LABELS[kind] || '通知'}｜${compactText(name)}`;
-  const details = [
-    ['类型', type],
-    ['会话', name],
-    ['创建', formatLocalDateTime(session?.startTime)],
-    ['目录', directory]
-  ];
-  const duration = formatDuration(durationMs);
-  if (duration) details.push(['本轮耗时', duration]);
-
-  if (clientType === 'pushdeer') {
-    return {
-      title,
-      description: details
-        .map(([label, value]) => label === '目录'
-          ? `**${label}：** \`${escapeMarkdown(value)}\``
-          : `**${label}：** ${escapeMarkdown(value)}`)
-        .join('\n\n')
-    };
-  }
-
-  return {
-    title,
-    description: details.map(([label, value]) => `${label}：${value}`).join('\n\n')
-  };
-}
-
-function createTestSession(session = null) {
-  if (session) return session;
-  return {
-    name: 'Glad 测试会话',
-    startTime: Date.now(),
-    workingDir: path.resolve(process.cwd()),
-    tool: { displayName: 'Glad' }
-  };
-}
-
-module.exports = {
-  formatNotification,
-  createTestSession,
-  compactText,
-  formatLocalDateTime,
-  formatDuration
-};

package/lib/notifications/notification-service.js

@@ -1,143 +0,0 @@
-const { formatNotification, createTestSession } = require('./message-formatter');
-
-class NotificationService {
-  constructor({ sessionManager, settingsStore, channel, logger = console }) {
-    this.sessionManager = sessionManager;
-    this.settingsStore = settingsStore;
-    this.channel = channel;
-    this.logger = logger;
-    this.seenEvents = new Map();
-    this.handlers = {
-      claude: payload => this.handleProviderEvent('claude', payload),
-      codex: payload => this.handleProviderEvent('codex', payload),
-      exit: payload => this.clearSession(payload.sessionId)
-    };
-    sessionManager.on('claude-event', this.handlers.claude);
-    sessionManager.on('codex-event', this.handlers.codex);
-    sessionManager.on('exit', this.handlers.exit);
-  }
-
-  stop() {
-    this.sessionManager.off('claude-event', this.handlers.claude);
-    this.sessionManager.off('codex-event', this.handlers.codex);
-    this.sessionManager.off('exit', this.handlers.exit);
-    this.seenEvents.clear();
-  }
-
-  getSessionState(sessionId) {
-    const session = this.sessionManager.get(sessionId);
-    if (!session) return null;
-    return {
-      enabled: Boolean(session.serverChanNotificationEnabled),
-      configured: this.settingsStore.getPublic().configured
-    };
-  }
-
-  async setSessionEnabled(sessionId, enabled) {
-    const session = this.sessionManager.get(sessionId);
-    if (!session) {
-      const error = new Error('Session not found');
-      error.statusCode = 404;
-      throw error;
-    }
-    if (enabled && !this.settingsStore.getPublic().configured) {
-      const error = new Error('请先配置 Server酱');
-      error.statusCode = 409;
-      error.code = 'SERVERCHAN_NOT_CONFIGURED';
-      throw error;
-    }
-    session.serverChanNotificationEnabled = Boolean(enabled);
-    if (enabled && session.pendingPermissions?.size > 0) {
-      await this.sendEvent({
-        kind: 'approval',
-        provider: session.kind === 'claude-structured' ? 'claude' : 'codex',
-        session
-      });
-    }
-    return this.getSessionState(sessionId);
-  }
-
-  disableAllSessions() {
-    for (const session of this.sessionManager.sessions.values()) {
-      session.serverChanNotificationEnabled = false;
-    }
-  }
-
-  async sendTest(input = {}) {
-    const settings = this.settingsStore.resolve(input);
-    const session = createTestSession(
-      input.sessionId ? this.sessionManager.get(input.sessionId) : null
-    );
-    const provider = session?.kind === 'claude-structured'
-      ? 'claude'
-      : session?.kind === 'codex-structured' ? 'codex' : null;
-    const message = formatNotification({ kind: 'test', provider, session }, settings.clientType);
-    await this.channel.send({ ...settings, ...message });
-    return { success: true };
-  }
-
-  handleProviderEvent(provider, payload = {}) {
-    const { session, event, sessionId } = payload;
-    if (!session || !event || !session.serverChanNotificationEnabled) return;
-
-    if (event.type === 'permission-request') {
-      const requestId = event.request?.id || event.request?.toolUseId || 'pending';
-      if (!this.markSeen(sessionId, `approval:${requestId}`)) return;
-      this.sendEvent({ kind: 'approval', provider, session });
-      return;
-    }
-
-    if (event.type === 'runtime-disconnected') {
-      if (!event.activeTurn || !this.markSeen(sessionId, `disconnected:${event.turnId || 'active'}`)) return;
-      this.sendEvent({ kind: 'disconnected', provider, session });
-      return;
-    }
-
-    if (event.type === 'turn-failed') {
-      if (!this.markSeen(sessionId, `failed:${event.turnId || event.createdAt || 'start'}`)) return;
-      this.sendEvent({ kind: 'failed', provider, session, durationMs: event.durationMs });
-      return;
-    }
-
-    const message = event.type === 'message' ? event.message : null;
-    if (!message || message.kind !== 'turn-end') return;
-    if (provider === 'codex' && message.threadId && session.threadId && message.threadId !== session.threadId) return;
-
-    const status = String(message.turnStatus || message.status || 'completed');
-    if (status === 'cancelled' || status === 'interrupted') return;
-    const turnId = message.turnId || message.id;
-    if (!this.markSeen(sessionId, `turn:${turnId}`)) return;
-    this.sendEvent({
-      kind: status === 'failed' ? 'failed' : 'completed',
-      provider,
-      session,
-      durationMs: message.durationMs
-    });
-  }
-
-  markSeen(sessionId, key) {
-    const seen = this.seenEvents.get(sessionId) || new Set();
-    if (seen.has(key)) return false;
-    seen.add(key);
-    if (seen.size > 100) seen.delete(seen.values().next().value);
-    this.seenEvents.set(sessionId, seen);
-    return true;
-  }
-
-  clearSession(sessionId) {
-    this.seenEvents.delete(sessionId);
-  }
-
-  async sendEvent(event) {
-    try {
-      const settings = this.settingsStore.get();
-      if (!settings.sendKey) return;
-      const message = formatNotification(event, settings.clientType);
-      await this.channel.send({ ...settings, ...message });
-    } catch (error) {
-      this.logger.error?.(`[serverchan] notification failed: ${error.message}`);
-    }
-  }
-}
-
-module.exports = NotificationService;

package/lib/notifications/serverchan-client.js

@@ -1,58 +0,0 @@
-const API_BASE = 'https://sctapi.ftqq.com';
-
-function sanitizeServerChanError(payload, fallback) {
-  const message = payload && typeof payload === 'object'
-    ? payload.message || payload.error || payload.data?.error
-    : '';
-  const text = String(message || fallback || 'Server酱发送失败').trim();
-  return text.slice(0, 300);
-}
-
-class ServerChanClient {
-  constructor({ fetchImpl = globalThis.fetch, timeoutMs = 10_000 } = {}) {
-    this.fetchImpl = fetchImpl;
-    this.timeoutMs = timeoutMs;
-  }
-
-  async send({ sendKey, title, description = '' }) {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
-    try {
-      const response = await this.fetchImpl(`${API_BASE}/${encodeURIComponent(sendKey)}.send`, {
-        method: 'POST',
-        headers: {
-          'content-type': 'application/x-www-form-urlencoded'
-        },
-        body: new URLSearchParams({
-          title: String(title || '').replace(/[\r\n]+/g, ' ').trim().slice(0, 64),
-          desp: String(description || '')
-        }),
-        signal: controller.signal
-      });
-      const text = await response.text();
-      let payload = null;
-      try {
-        payload = text ? JSON.parse(text) : null;
-      } catch (_) {
-        payload = null;
-      }
-      if (!response.ok || (payload && Number(payload.code) !== 0)) {
-        const error = new Error(sanitizeServerChanError(payload, `HTTP ${response.status}`));
-        error.statusCode = 502;
-        throw error;
-      }
-      return payload || { code: 0 };
-    } catch (error) {
-      if (error && error.name === 'AbortError') {
-        const timeoutError = new Error('Server酱请求超时');
-        timeoutError.statusCode = 504;
-        throw timeoutError;
-      }
-      throw error;
-    } finally {
-      clearTimeout(timeout);
-    }
-  }
-}
-
-module.exports = ServerChanClient;

package/lib/notifications/serverchan-settings-store.js

@@ -1,115 +0,0 @@
-const fs = require('fs');
-const {
-  getConfig,
-  setConfig,
-  getConfigPath
-} = require('../config/manager');
-
-const CLIENT_TYPES = new Set(['wechat', 'pushdeer']);
-
-function normalizeClientType(value) {
-  const clientType = String(value || 'wechat').trim().toLowerCase();
-  if (!CLIENT_TYPES.has(clientType)) {
-    const error = new Error('接收客户端必须是微信或 PushDeer');
-    error.statusCode = 400;
-    throw error;
-  }
-  return clientType;
-}
-
-function normalizeSendKey(value) {
-  const sendKey = String(value || '').trim();
-  if (!sendKey || sendKey.length < 8 || sendKey.length > 512 || /\s/.test(sendKey)) {
-    const error = new Error('请输入有效的 Server酱 SendKey');
-    error.statusCode = 400;
-    throw error;
-  }
-  return sendKey;
-}
-
-function maskSendKey(sendKey) {
-  if (!sendKey) return '';
-  return `${sendKey.slice(0, Math.min(3, sendKey.length))}${'•'.repeat(10)}`;
-}
-
-class ServerChanSettingsStore {
-  constructor({
-    readConfig = getConfig,
-    writeConfig = setConfig,
-    configPath = getConfigPath,
-    chmod = fs.chmodSync
-  } = {}) {
-    this.readConfig = readConfig;
-    this.writeConfig = writeConfig;
-    this.configPath = configPath;
-    this.chmod = chmod;
-  }
-
-  get() {
-    const stored = this.readConfig('serverChan') || {};
-    return {
-      sendKey: String(stored.sendKey || '').trim(),
-      clientType: CLIENT_TYPES.has(stored.clientType) ? stored.clientType : 'wechat'
-    };
-  }
-
-  getPublic() {
-    const settings = this.get();
-    return {
-      configured: Boolean(settings.sendKey),
-      maskedKey: maskSendKey(settings.sendKey),
-      clientType: settings.clientType
-    };
-  }
-
-  save(input = {}) {
-    const existing = this.get();
-    const sendKey = input.sendKey == null || String(input.sendKey).trim() === ''
-      ? existing.sendKey
-      : normalizeSendKey(input.sendKey);
-    if (!sendKey) {
-      const error = new Error('请先填写 Server酱 SendKey');
-      error.statusCode = 400;
-      throw error;
-    }
-    const settings = {
-      sendKey,
-      clientType: normalizeClientType(input.clientType ?? existing.clientType)
-    };
-    this.writeConfig('serverChan', settings);
-    this.restrictConfigFile();
-    return this.getPublic();
-  }
-
-  resolve(input = {}) {
-    const existing = this.get();
-    return {
-      sendKey: input.sendKey == null || String(input.sendKey).trim() === ''
-        ? normalizeSendKey(existing.sendKey)
-        : normalizeSendKey(input.sendKey),
-      clientType: normalizeClientType(input.clientType ?? existing.clientType)
-    };
-  }
-
-  clear() {
-    this.writeConfig('serverChan', { sendKey: '', clientType: 'wechat' });
-    this.restrictConfigFile();
-    return this.getPublic();
-  }
-
-  restrictConfigFile() {
-    try {
-      const configPath = typeof this.configPath === 'function' ? this.configPath() : this.configPath;
-      if (configPath && fs.existsSync(configPath)) this.chmod(configPath, 0o600);
-    } catch (_) {
-      // Best effort: configuration remains usable on filesystems without chmod support.
-    }
-  }
-}
-
-module.exports = {
-  ServerChanSettingsStore,
-  normalizeClientType,
-  normalizeSendKey,
-  maskSendKey
-};

package/lib/schedule/job-runner.js

@@ -1,162 +0,0 @@
-const { sequenceForKey } = require('./key-sequences');
-
-function sleep(ms) {
-  return new Promise(resolve => setTimeout(resolve, ms));
-}
-
-class SessionEndedError extends Error {
-  constructor() {
-    super('Session ended');
-    this.code = 'SESSION_ENDED';
-  }
-}
-
-class JobRunner {
-  constructor({ createSession, getJob, updateJob, logger }) {
-    this.createSession = createSession;
-    this.getJob = getJob;
-    this.updateJob = updateJob;
-    this.logger = logger;
-    this.running = new Set();
-  }
-
-  async run(jobId, options = {}) {
-    const job = this.getJob(jobId);
-    if (!job) throw new Error('Scheduled task not found');
-    if (this.running.has(job.id)) {
-      this.updateJob(job.id, {
-        lastRunAt: Date.now(),
-        lastRunStatus: 'skipped',
-        lastRunMessage: 'Previous run is still active'
-      });
-      return { skipped: true, reason: 'Previous run is still active' };
-    }
-
-    this.running.add(job.id);
-    this.updateJob(job.id, {
-      running: true,
-      lastRunAt: Date.now(),
-      lastRunStatus: options.manual ? 'manual-running' : 'running',
-      lastRunMessage: ''
-    });
-
-    let session = null;
-    try {
-      session = this.createSession({
-        toolKey: job.target.toolKey,
-        workingDirectory: job.target.workingDirectory,
-        name: `${job.name}${options.manual ? ' (Test)' : ''}`
-      });
-
-      this.updateJob(job.id, {
-        lastSessionId: session.id,
-        lastRunMessage: `Started session ${session.id}`
-      });
-
-      const execute = async () => {
-        try {
-          await sleep(1000);
-          await this.executeSteps(job, session);
-          this.updateJob(job.id, {
-            running: false,
-            lastRunStatus: options.manual ? 'manual-success' : 'success',
-            lastRunMessage: `Started session ${session.id}`,
-            lastSessionId: session.id
-          });
-        } catch (error) {
-          const ended = error && error.code === 'SESSION_ENDED';
-          if (!ended) this.logger?.error?.(`Scheduled task failed: ${error.message}`);
-          this.updateJob(job.id, {
-            running: false,
-            lastRunStatus: ended ? 'cancelled' : 'failed',
-            lastRunMessage: ended ? 'Session ended' : error.message,
-            lastSessionId: session?.id || null
-          });
-          if (!options.background) throw error;
-        } finally {
-          this.running.delete(job.id);
-          this.updateJob(job.id, { running: false });
-        }
-      };
-
-      if (options.background) {
-        execute();
-        return { success: true, sessionId: session.id };
-      }
-
-      await execute();
-      return { success: true, sessionId: session.id };
-    } catch (error) {
-      if (!session) {
-        this.running.delete(job.id);
-        this.updateJob(job.id, { running: false });
-      }
-      this.logger?.error?.(`Scheduled task failed: ${error.message}`);
-      this.updateJob(job.id, {
-        running: false,
-        lastRunStatus: 'failed',
-        lastRunMessage: error.message,
-        lastSessionId: session?.id || null
-      });
-      throw error;
-    }
-  }
-
-  async executeSteps(job, session) {
-    const modifiers = { ctrl: false, alt: false };
-
-    for (const step of job.steps || []) {
-      this.assertSessionRunning(session);
-      if (step.type === 'sleep') {
-        await this.sleepWhileRunning(session, Math.max(0, Number(step.seconds) || 0) * 1000);
-        continue;
-      }
-
-      if (step.type === 'sendText') {
-        if (!session.write(String(step.text || ''))) throw new SessionEndedError();
-        continue;
-      }
-
-      if (step.type === 'sendKey') {
-        if (!session.write(sequenceForKey(step.key, modifiers))) throw new SessionEndedError();
-        continue;
-      }
-
-      if (step.type === 'keyDown') {
-        const key = String(step.key || '').toLowerCase();
-        if (key === 'ctrl' || key === 'alt') modifiers[key] = true;
-        continue;
-      }
-
-      if (step.type === 'keyUp') {
-        const key = String(step.key || '').toLowerCase();
-        if (key === 'ctrl' || key === 'alt') modifiers[key] = false;
-        continue;
-      }
-
-      if (step.type === 'stop') break;
-
-      if (step.type === 'closeSession') {
-        session.kill?.();
-        break;
-      }
-    }
-  }
-
-  assertSessionRunning(session) {
-    if (session && typeof session.isRunning === 'function' && !session.isRunning()) {
-      throw new SessionEndedError();
-    }
-  }
-
-  async sleepWhileRunning(session, ms) {
-    const end = Date.now() + ms;
-    while (Date.now() < end) {
-      this.assertSessionRunning(session);
-      await sleep(Math.min(500, end - Date.now()));
-    }
-    this.assertSessionRunning(session);
-  }
-}
-
-module.exports = JobRunner;