opencode-claude-code-ua 0.0.0-stage → 0.3.6

package/src/schedule.mjs

@@ -0,0 +1,88 @@
+const DEFAULTS = Object.freeze({ enabled: false, time: '09:00', timeZone: 'UTC' });
+const KEYS = new Set(['enabled', 'time', 'timeZone']);
+const formatters = new Map();
+const FORMATTER_LIMIT = 64;
+
+/** Validation messages never include supplied values or unknown property names. */
+export class ScheduleValidationError extends Error {
+  constructor(field = 'schedule') {
+    super('Invalid schedule.');
+    this.name = 'ScheduleValidationError';
+    this.fields = { [field]: 'Invalid value.' };
+  }
+}
+
+function formatterFor(timeZone) {
+  // Intl versions may accept numeric offsets. Only named zones are permitted here.
+  if (typeof timeZone !== 'string' || !/^[A-Za-z]/u.test(timeZone)
+    || /[^A-Za-z0-9._+\/-]/u.test(timeZone)) {
+    throw new ScheduleValidationError('schedule.timeZone');
+  }
+  if (formatters.has(timeZone)) return formatters.get(timeZone);
+  let formatter;
+  try {
+    formatter = new Intl.DateTimeFormat('en-US', {
+      timeZone,
+      calendar: 'iso8601',
+      numberingSystem: 'latn',
+      hourCycle: 'h23',
+      year: 'numeric',
+      month: '2-digit',
+      day: '2-digit',
+      hour: '2-digit',
+      minute: '2-digit',
+    });
+  } catch {
+    throw new ScheduleValidationError('schedule.timeZone');
+  }
+  const entry = { formatter, timeZone: formatter.resolvedOptions().timeZone };
+  if (formatters.size >= FORMATTER_LIMIT) formatters.delete(formatters.keys().next().value);
+  formatters.set(timeZone, entry);
+  return entry;
+}
+
+/** Return a new, canonical schedule. Missing or undefined properties use defaults. */
+export function normalizeSchedule(raw) {
+  if (raw === undefined) return { ...DEFAULTS };
+  if (raw === null || typeof raw !== 'object' || Array.isArray(raw)
+    || (Object.getPrototypeOf(raw) !== Object.prototype && Object.getPrototypeOf(raw) !== null)
+    || Reflect.ownKeys(raw).some((key) => !KEYS.has(key))) {
+    throw new ScheduleValidationError();
+  }
+  const { enabled = false, time = '09:00', timeZone = 'UTC' } = raw;
+  if (typeof enabled !== 'boolean') throw new ScheduleValidationError('schedule.enabled');
+  if (typeof time !== 'string' || time.length !== 5 || !/^(?:[01]\d|2[0-3]):[0-5]\d$/u.test(time)) {
+    throw new ScheduleValidationError('schedule.time');
+  }
+  return { enabled, time, timeZone: formatterFor(timeZone).timeZone };
+}
+
+function localParts(at, timeZone) {
+  const milliseconds = at instanceof Date ? Date.prototype.getTime.call(at) : at;
+  if (typeof milliseconds !== 'number' || !Number.isFinite(milliseconds)
+    || !Number.isFinite(new Date(milliseconds).getTime())) {
+    throw new ScheduleValidationError('schedule.at');
+  }
+  const entry = formatterFor(timeZone);
+  const parts = Object.fromEntries(entry.formatter.formatToParts(milliseconds)
+    .map(({ type, value }) => [type, value]));
+  return {
+    date: `${parts.year.padStart(4, '0')}-${parts.month}-${parts.day}`,
+    time: `${parts.hour}:${parts.minute}`,
+    timeZone: entry.timeZone,
+  };
+}
+
+/** Ledger date in the explicit zone; at must be a valid Date or epoch milliseconds. */
+export function scheduleDate(at, timeZone) {
+  return localParts(at, timeZone).date;
+}
+
+/** Exact local-minute matching only: no catch-up, timers, or DST repair heuristics. */
+export function scheduleOccurrence(schedule, at = Date.now()) {
+  if (schedule === null || schedule === undefined) return null;
+  const normalized = normalizeSchedule(schedule);
+  if (!normalized.enabled) return null;
+  const occurrence = localParts(at, normalized.timeZone);
+  return occurrence.time === normalized.time ? occurrence : null;
+}

package/src/scheduler.mjs

@@ -0,0 +1,141 @@
+import * as fs from 'node:fs/promises';
+import { createHash, randomUUID } from 'node:crypto';
+import { isAbsolute, join, resolve } from 'node:path';
+import { scheduleOccurrence, scheduleDate } from './schedule.mjs';
+
+const schedulers = new Map();
+
+function identityOf(account) {
+  const url = new URL(account.siteUrl);
+  return `${url.origin}${url.pathname.replace(/\/+$/, '')}\n${account.userId}`;
+}
+
+export function createCheckinScheduler({
+  accountManager,
+  stateDirectory,
+  now = Date.now,
+  setIntervalImpl = setInterval,
+  clearIntervalImpl = clearInterval,
+  onError = () => {},
+  io = fs,
+} = {}) {
+  if (typeof stateDirectory !== 'string' || !isAbsolute(stateDirectory)) throw new Error('签到调度记录必须使用绝对路径');
+  let timer;
+  let active;
+
+  async function claim(identity, occurrence, at) {
+    await io.mkdir(stateDirectory, { recursive: true, mode: 0o700 });
+    const info = await io.lstat(stateDirectory);
+    if (!info.isDirectory() || info.isSymbolicLink()) throw new Error('签到调度目录无效');
+    const digest = createHash('sha256').update(identity).digest('hex');
+    const path = join(stateDirectory, `${occurrence.date}-${digest}.json`);
+    const lockPath = join(stateDirectory, `${digest}.lock`);
+    const lastPath = join(stateDirectory, `${digest}.last.json`);
+    const temporary = join(stateDirectory, `${digest}-${randomUUID()}.tmp`);
+    let lock, file;
+    try {
+      lock = await io.open(lockPath, 'wx', 0o600);
+      try {
+        const stat = await io.lstat(lastPath);
+        if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 2048) throw new Error('调度状态无效');
+        const last = JSON.parse(await io.readFile(lastPath, 'utf8'));
+        const previousAt = Date.parse(last.at);
+        if (!Number.isFinite(previousAt) || typeof last.timeZone !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(last.date) || scheduleDate(previousAt, last.timeZone) !== last.date) throw new Error('调度状态无效');
+        if (previousAt > at || scheduleDate(previousAt, occurrence.timeZone) === occurrence.date ||
+          scheduleDate(at, last.timeZone) === last.date) return false;
+      } catch (error) { if (error.code !== 'ENOENT') throw error; }
+      file = await io.open(path, 'wx', 0o600);
+      const content = JSON.stringify({ at: new Date(at).toISOString(), ...occurrence });
+      await file.writeFile(content, 'utf8');
+      await file.sync();
+      await file.close(); file = undefined;
+      await io.writeFile(temporary, content, { flag: 'wx', mode: 0o600 });
+      await io.rename(temporary, lastPath);
+      return true;
+    } catch (error) {
+      if (error.code === 'EEXIST') return false;
+      throw error;
+    } finally {
+      await file?.close();
+      if (lock) {
+        await lock.close();
+        await io.unlink(lockPath);
+        await io.unlink(temporary).catch(() => {});
+      }
+    }
+  }
+
+  async function run() {
+    const attempted = [], errors = [];
+    let accounts;
+    try { ({ accounts } = await accountManager.list()); }
+    catch { return { attempted, error: '无法读取账号，未执行定时签到' }; }
+    const identities = new Set();
+    const due = accounts.filter((account) => {
+      if (!account.enabled || !account.checkinEnabled || !account.schedule?.enabled) return false;
+      try {
+        const occurrence = scheduleOccurrence(account.schedule, Number(now()));
+        if (!occurrence) return false;
+        const identity = identityOf(account);
+        if (accounts.some((other) => {
+          const checkedAt = Date.parse(other.checkin?.checkedAt);
+          return Number.isFinite(checkedAt) && identityOf(other) === identity && scheduleDate(checkedAt, occurrence.timeZone) === occurrence.date;
+        })) return false;
+        if (identities.has(identity)) return false;
+        identities.add(identity);
+        return true;
+      } catch { errors.push(account.id); return false; }
+    });
+    let next = 0;
+    async function worker() {
+      while (next < due.length) {
+        const account = due[next++];
+        const at = Number(now());
+        try {
+          const occurrence = scheduleOccurrence(account.schedule, at);
+          if (!occurrence || !await claim(identityOf(account), occurrence, at)) continue;
+          attempted.push(account.id);
+          const result = await accountManager.checkin(account.id, { expectedRevision: account.revision });
+          if (['error', 'failed'].includes(result?.checkin?.state)) errors.push(account.id);
+        } catch { errors.push(account.id); }
+      }
+    }
+    await Promise.all(Array.from({ length: Math.min(4, due.length) }, worker));
+    return { attempted, ...(errors.length ? { error: '部分自动签到未执行或未完成，请检查账号记录与调度目录权限；不会自动重试', accounts: errors } : {}) };
+  }
+
+  function tick() {
+    if (active) return active;
+    active = run().finally(() => { active = undefined; });
+    return active;
+  }
+
+  function start() {
+    if (timer !== undefined) return;
+    timer = setIntervalImpl(async () => {
+      try {
+        const result = await tick();
+        if (result.error) await onError(result.error);
+      } catch { /* A reporting failure must not repeat a check-in. */ }
+    }, 15000);
+    timer.unref?.();
+  }
+
+  function stop() {
+    if (timer !== undefined) clearIntervalImpl(timer);
+    timer = undefined;
+  }
+
+  return { start, stop, tick };
+}
+
+export function ensureCheckinScheduler(options) {
+  const path = resolve(options.stateDirectory);
+  const key = process.platform === 'win32' ? path.toLowerCase() : path;
+  if (!schedulers.has(key)) {
+    const scheduler = createCheckinScheduler(options);
+    schedulers.set(key, scheduler);
+    scheduler.start();
+  }
+  return schedulers.get(key);
+}