agent-loft 0.2.30 → 0.2.32

package/src/core/task-prompt.ts

@@ -0,0 +1,38 @@
+// 定时任务每次运行时发给 agent 的话：用户写的提示词 + 一段 agent-loft 附上的说明（用户看不到）。
+//
+// 「只在需要时提醒」靠一个暗号：agent 判断这次没什么要说的，就在回复第一行只写 SILENT_MARK，
+// hub 看到它就把这一轮标成 silent，推送和飞书都不发。没写暗号一律当成要提醒 —— 宁可多提醒一次，
+// 也不能漏掉。
+import { wrapContext } from "./chat-mode.js";
+import { formatDateTime, serverTimeZone } from "./task-schedule.js";
+
+export const SILENT_MARK = "[[静默]]";
+
+export function isSilentReply(text: string): boolean {
+  return text.trimStart().startsWith(SILENT_MARK);
+}
+
+/** 去掉暗号，剩下的是 agent 顺手记的检查结果 */
+export function stripSilentMark(text: string): string {
+  return isSilentReply(text) ? text.trimStart().slice(SILENT_MARK.length).trim() : text;
+}
+
+export function taskMessage(
+  task: { title: string; prompt: string; notify: "smart" | "always" },
+  opts: { now?: number; manual?: boolean; version?: string } = {},
+): string {
+  const now = opts.now ?? Date.now();
+  const lines = [
+    `这条消息是定时任务「${task.title}」${opts.manual ? "（用户刚才手动点了「立即运行」）" : "到点自动发来的"}，现在是 ${formatDateTime(now)}（${serverTimeZone()}）。${opts.manual ? "" : "用户此刻多半不在屏幕前，不要向他提问、等他回答。"}`,
+    ...(opts.version ? [`agent-loft 服务端当前版本：${opts.version}。`] : []),
+    "按上面的要求做；这条对话里以前运行的结果可以拿来对比（比如「和上次比有没有变化」）。",
+  ];
+  if (task.notify === "smart") {
+    lines.push(
+      "",
+      `用户希望只在有需要时才被提醒：如果按上面的要求，这次没有需要告诉他的事（比如没有更新、没有变化、条件没满足），回复的第一行只写 ${SILENT_MARK}，后面用一两句话记下这次检查的结果（下次可以对比），他就不会收到通知。`,
+      `有需要告诉他的事时正常回复，开头直接说结论，不要写 ${SILENT_MARK}。`,
+    );
+  }
+  return `${task.prompt}\n\n${wrapContext(lines)}`;
+}

package/src/core/task-runner.ts

@@ -0,0 +1,232 @@
+// 定时任务的调度：每 30 秒看一眼哪些到点了，核对主人和对话，把提示词送进对话；一轮结束后记下结果。
+//
+// 到点时的核对（任何一条不满足都不跑）：
+//   - 主人还在、没被停用；
+//   - 回到的对话还在、没被删，而且还是他的（飞书私聊换绑了账号之类会让对话换主人）—— 不满足就暂停任务；
+//   - 对话没在忙、也没挂着授权 / 提问：忙的话等它（最多 WAIT_MAX_MS），不能插进别人正在进行的那一轮，
+//     更不能被当成对挂着的提问的回答。
+import crypto from "node:crypto";
+import { config, resolveWorkspacePath } from "./config.js";
+import { hub, type TaskTurnEnd } from "./hub.js";
+import { interactions } from "./interactions.js";
+import { memoryOwnerOf } from "./personal.js";
+import { getConversation, updateAgentBinding, updateConversation, type Conversation } from "./store.js";
+import { formatDateTime } from "./task-schedule.js";
+import { stripSilentMark, taskMessage } from "./task-prompt.js";
+import { advance, allTasks, finishRun, pauseTask, persistTask, pushRun, runId, type Task, type TaskRun } from "./tasks.js";
+import { RUNNING_VERSION } from "./upgrade.js";
+import { getUser } from "./users.js";
+
+const TICK_MS = 30_000;
+/** 服务停着的时候错过的：错过不到这么久的，启动后补跑一次；更早的记一笔「错过了」 */
+const CATCHUP_MS = 2 * 3600_000;
+/** 到点时对话在忙：最多等这么久，还忙就跳过这一次 */
+const WAIT_MAX_MS = 30 * 60_000;
+/** 送出去之后对话已经不忙了、却一直没等到结果（被别的操作吞掉了）：这么久之后按中断记 */
+const LOST_MS = 2 * 60_000;
+
+/** 到点了、在等对话空下来的 */
+const waiting = new Map<string, { since: number }>();
+/** 正在跑的：任务 id → 这次运行 */
+const running = new Map<string, { runId: string; key: string; at: number }>();
+let timer: NodeJS.Timeout | null = null;
+
+/** 这条对话现在归谁（和记忆同一个规则：飞书群聊、没绑定的私聊没有主人） */
+function ownerOf(conv: Conversation): string | undefined {
+  return memoryOwnerOf(conv);
+}
+
+function preview(text: string, max = 120): string {
+  const plain = text
+    .replace(/```[\s\S]*?```/g, " [代码] ")
+    .replace(/[`*_~#>|]/g, "")
+    .replace(/\s+/g, " ")
+    .trim();
+  return plain.length > max ? `${plain.slice(0, max - 1)}…` : plain;
+}
+
+type Resolved = { key: string } | { pause: string } | { error: string };
+
+/** 这次该发到哪条对话；专用对话还没有（或者被删了）就新建一条 */
+function resolveConv(task: Task): Resolved {
+  if (task.target.kind === "conv") {
+    const conv = getConversation(task.target.key);
+    if (!conv || conv.hidden) return { pause: "回复的那条对话已经被删除，任务已暂停。可以改成「专用对话」后再启用。" };
+    if (ownerOf(conv) !== task.owner) return { pause: "回复的那条对话已经不属于你了，任务已暂停。" };
+    return { key: conv.key };
+  }
+  const existing = task.target.key ? getConversation(task.target.key) : undefined;
+  if (existing && !existing.hidden && existing.taskId === task.id && ownerOf(existing) === task.owner) return { key: existing.key };
+
+  const enabled = hub.enabledAgents().map((d) => d.id);
+  if (!enabled.includes(task.agent)) return { error: `${hub.label(task.agent)} 没有启用` };
+  let cwd: string | null = null;
+  if (task.cwd) {
+    cwd = resolveWorkspacePath(task.cwd);
+    if (!cwd) return { error: `工作目录 ${task.cwd} 不存在了（或者不在工作区里），改一下任务的目录` };
+  }
+  const key = `web:${crypto.randomBytes(6).toString("hex")}`;
+  // 侧栏里专用对话前面有时钟图标（taskId），标题不用再加
+  hub.ensure({ key, channel: "web", channelId: "web", defaultAgent: task.agent, owner: task.owner, title: task.title.slice(0, 80) });
+  updateConversation(key, {
+    titleAuto: false,
+    taskId: task.id,
+    ...(task.mode === "chat" ? { mode: "chat" as const } : {}),
+    ...(cwd && cwd !== config().workspaceRoot ? { cwd, cwdExplicit: true } : {}),
+  });
+  if (task.model || task.effort) {
+    updateAgentBinding(key, task.agent, { ...(task.model ? { model: task.model } : {}), ...(task.effort ? { effort: task.effort } : {}) });
+  }
+  task.target = { kind: "dedicated", key };
+  persistTask(task);
+  hub.emitEvent(key, { type: "meta" });
+  return { key };
+}
+
+function record(task: Task, status: TaskRun["status"], note: string, now = Date.now()): void {
+  pushRun(task, { id: runId(), at: now, endedAt: now, status, note });
+}
+
+/**
+ * 试着跑一次。manual：用户点了「立即运行」—— 对话忙就直接报错，不排队。
+ * 返回给人看的错误；undefined 表示已经送出去了（或者在排队等）。
+ */
+function fire(task: Task, manual: boolean, now = Date.now()): string | undefined {
+  const user = getUser(task.owner);
+  if (!user || user.disabled) {
+    waiting.delete(task.id);
+    record(task, "skipped", "账号已停用", now);
+    return "账号已停用";
+  }
+  const where = resolveConv(task);
+  if ("pause" in where) {
+    waiting.delete(task.id);
+    pauseTask(task, where.pause, now);
+    return where.pause;
+  }
+  if ("error" in where) {
+    waiting.delete(task.id);
+    record(task, "error", where.error, now);
+    return where.error;
+  }
+  const key = where.key;
+  const conv = getConversation(key)!;
+  if (!hub.enabledAgents().some((d) => d.id === conv.agent)) {
+    waiting.delete(task.id);
+    record(task, "error", `${hub.label(conv.agent)} 没有启用`, now);
+    return `${hub.label(conv.agent)} 没有启用`;
+  }
+  // 刚点过停止的也当忙：被打断的那一轮可能还会晚到一个出错，别让它算到这次运行头上
+  if (hub.isBusy(key) || hub.recentlyStopped(key) || interactions.listPending(key).length > 0) {
+    if (manual) return "这条对话正在回复或者在等你处理授权，等它结束再试";
+    const since = waiting.get(task.id)?.since ?? now;
+    if (now - since > WAIT_MAX_MS) {
+      waiting.delete(task.id);
+      record(task, "skipped", `对话一直在忙（等了 ${WAIT_MAX_MS / 60_000} 分钟），跳过了这一次`, now);
+    } else {
+      waiting.set(task.id, { since });
+    }
+    return undefined;
+  }
+  waiting.delete(task.id);
+  const run = pushRun(task, { id: runId(), at: now, status: "running", convKey: key, ...(manual ? { note: "手动运行" } : {}) });
+  running.set(task.id, { runId: run.id, key, at: now });
+  console.log(`[定时任务] ${task.id}「${task.title}」${manual ? "手动运行" : "到点运行"}，发到 ${key}`);
+  hub.send(
+    key,
+    { text: taskMessage(task, { now, manual, version: RUNNING_VERSION }), attachments: [] },
+    { channel: "task", channelId: task.id, name: `定时任务「${task.title}」` },
+    undefined,
+    { task: { taskId: task.id, runId: run.id, title: task.title, smart: task.notify === "smart" } },
+  );
+  return undefined;
+}
+
+function onTurnEnd(e: TaskTurnEnd): void {
+  const cur = running.get(e.taskId);
+  if (cur?.runId === e.runId) running.delete(e.taskId);
+  const text = e.status === "notified" || e.status === "silent" ? preview(stripSilentMark(e.text)) : "";
+  finishRun(e.taskId, e.runId, {
+    status: e.status,
+    endedAt: Date.now(),
+    ...(text ? { preview: text } : {}),
+    ...(e.status === "error" || e.status === "interrupted" ? { note: preview(e.text) } : {}),
+  });
+}
+
+function tick(): void {
+  const now = Date.now();
+  for (const [taskId, cur] of running) {
+    // 送出去了，对话早就不忙了，却没等到结果：被吞掉了（比如期间切了会话），别让它永远「运行中」
+    if (now - cur.at > LOST_MS && !hub.isBusy(cur.key) && hub.currentTaskTurn(cur.key)?.runId !== cur.runId) {
+      running.delete(taskId);
+      finishRun(taskId, cur.runId, { status: "interrupted", endedAt: now, note: "没有拿到结果" });
+    }
+  }
+  for (const task of allTasks()) {
+    if (running.has(task.id)) continue;
+    if (waiting.has(task.id)) {
+      // 等着的时候被暂停了：这次就不跑了（「一次」的任务到点时已经自动停用，照样要跑完这一次）
+      if (!task.enabled && task.schedule.kind !== "once") waiting.delete(task.id);
+      else fire(task, false, now);
+      continue;
+    }
+    if (!task.enabled || task.nextRunAt === undefined || task.nextRunAt > now) continue;
+    // 先把下一次算好再跑：跑的过程中出了什么岔子，也不会在下一个 tick 又跑一遍
+    advance(task, now);
+    fire(task, false, now);
+  }
+}
+
+/** 网页上点「立即运行」 */
+export function runTaskNow(task: Task): string | undefined {
+  if (running.has(task.id)) return "这个任务正在运行";
+  return fire(task, true);
+}
+
+export function isTaskRunning(id: string): boolean {
+  return running.has(id) || waiting.has(id);
+}
+
+/** 任务删了：它的专用对话留着（里面有历史），只是不再是谁的专用对话 */
+export function forgetTask(task: Task): void {
+  waiting.delete(task.id);
+  running.delete(task.id);
+  if (task.target.kind === "dedicated" && task.target.key) {
+    const conv = getConversation(task.target.key);
+    if (conv?.taskId === task.id) {
+      updateConversation(conv.key, { taskId: undefined });
+      hub.emitEvent(conv.key, { type: "meta" });
+    }
+  }
+}
+
+export function startTaskRunner(): void {
+  if (timer) return;
+  const now = Date.now();
+  for (const task of allTasks()) {
+    // 上次进程退出时还在跑的：结果已经拿不到了
+    let dirty = false;
+    for (const run of task.runs) {
+      if (run.status !== "running") continue;
+      Object.assign(run, { status: "interrupted", endedAt: now, note: "服务重启，这次运行被打断了" });
+      dirty = true;
+    }
+    if (dirty) persistTask(task);
+    if (task.enabled && task.nextRunAt !== undefined && task.nextRunAt < now - CATCHUP_MS) {
+      record(task, "skipped", `服务没在运行，错过了 ${formatDateTime(task.nextRunAt)} 这一次`, now);
+      advance(task, now);
+    }
+  }
+  hub.on("task", onTurnEnd);
+  timer = setInterval(tick, TICK_MS);
+  timer.unref();
+  // 等 agent 起来了再补跑错过的
+  setTimeout(tick, 5_000).unref();
+}
+
+export function stopTaskRunner(): void {
+  if (timer) clearInterval(timer);
+  timer = null;
+  hub.off("task", onTurnEnd);
+}

package/src/core/task-schedule.ts

@@ -0,0 +1,250 @@
+// 定时任务的「什么时候跑」：几种常用的结构化写法 + 自定义 cron，一律按服务端所在时区解释。
+//
+// 存结构化的而不是一律存 cron：界面上的「每天 / 工作日 / 每周…」能原样回填，描述也好写；
+// 除「一次」以外都先换成 cron 再算下次时间，只有一条计算路径。
+
+export type TaskSchedule =
+  | { kind: "once"; at: number }
+  | { kind: "daily"; time: string }
+  | { kind: "weekdays"; time: string }
+  /** days：0 = 周日 … 6 = 周六 */
+  | { kind: "weekly"; days: number[]; time: string }
+  | { kind: "monthly"; day: number; time: string }
+  /** 每 every 小时一次，在第 minute 分（从 0 点起算：every=6 就是 0、6、12、18 点） */
+  | { kind: "hourly"; every: number; minute: number }
+  | { kind: "cron"; expr: string };
+
+/** 两次运行至少隔这么久：太密了会把额度跑光 */
+export const MIN_GAP_MS = 15 * 60_000;
+/** 「一次」最多排到多久以后 */
+export const ONCE_MAX_MS = 366 * 86400_000;
+
+export function serverTimeZone(): string {
+  return Intl.DateTimeFormat().resolvedOptions().timeZone || "本地时间";
+}
+
+// ---------- cron ----------
+
+type CronSpec = { minute: Set<number>; hour: Set<number>; dom: Set<number>; month: Set<number>; dow: Set<number>; domAny: boolean; dowAny: boolean };
+
+const RANGES: [number, number][] = [
+  [0, 59],
+  [0, 23],
+  [1, 31],
+  [1, 12],
+  [0, 7],
+];
+
+function parseField(raw: string, [min, max]: [number, number], name: string): Set<number> {
+  const out = new Set<number>();
+  for (const part of raw.split(",")) {
+    const m = /^(\*|(\d+)(?:-(\d+))?)(?:\/(\d+))?$/.exec(part.trim());
+    if (!m) throw new Error(`cron 的${name}字段写得不对：${raw}`);
+    const step = m[4] ? Number(m[4]) : 1;
+    let lo = min;
+    let hi = max;
+    if (m[1] !== "*") {
+      lo = Number(m[2]);
+      // 「5/15」= 从 5 起每 15
+      hi = m[3] !== undefined ? Number(m[3]) : m[4] ? max : lo;
+    }
+    if (step < 1 || lo < min || hi > max || lo > hi) throw new Error(`cron 的${name}字段超出范围：${raw}`);
+    for (let v = lo; v <= hi; v += step) out.add(v);
+  }
+  return out;
+}
+
+export function parseCron(expr: string): CronSpec {
+  const fields = expr.trim().split(/\s+/);
+  if (fields.length !== 5) throw new Error("cron 要写 5 段：分 时 日 月 周，比如「0 2 * * *」是每天 2 点");
+  const names = ["分钟", "小时", "日期", "月份", "星期"];
+  const [minute, hour, dom, month, dowRaw] = fields.map((f, i) => parseField(f, RANGES[i]!, names[i]!));
+  const dow = new Set([...dowRaw!].map((d) => d % 7));
+  return { minute: minute!, hour: hour!, dom: dom!, month: month!, dow, domAny: fields[2] === "*", dowAny: fields[4] === "*" };
+}
+
+function dayMatches(spec: CronSpec, d: Date): boolean {
+  const dom = spec.dom.has(d.getDate());
+  const dow = spec.dow.has(d.getDay());
+  // 和标准 cron 一样：日期、星期都限定了的时候，满足其一就算
+  if (spec.domAny && spec.dowAny) return true;
+  if (spec.domAny) return dow;
+  if (spec.dowAny) return dom;
+  return dom || dow;
+}
+
+/** from 之后（不含）最近一次匹配的时刻；一年内都没有就是 undefined */
+export function cronNext(spec: CronSpec, from: number): number | undefined {
+  const d = new Date(from);
+  d.setSeconds(0, 0);
+  d.setMinutes(d.getMinutes() + 1);
+  const limit = from + 400 * 86400_000;
+  while (d.getTime() <= limit) {
+    if (!spec.month.has(d.getMonth() + 1)) {
+      d.setMonth(d.getMonth() + 1, 1);
+      d.setHours(0, 0, 0, 0);
+      continue;
+    }
+    if (!dayMatches(spec, d)) {
+      d.setDate(d.getDate() + 1);
+      d.setHours(0, 0, 0, 0);
+      continue;
+    }
+    if (!spec.hour.has(d.getHours())) {
+      d.setHours(d.getHours() + 1, 0, 0, 0);
+      continue;
+    }
+    if (!spec.minute.has(d.getMinutes())) {
+      d.setMinutes(d.getMinutes() + 1, 0, 0);
+      continue;
+    }
+    return d.getTime();
+  }
+  return undefined;
+}
+
+// ---------- 结构化写法 ----------
+
+function parseTime(time: string): [number, number] {
+  const m = /^(\d{1,2}):(\d{2})$/.exec(String(time ?? "").trim());
+  if (!m || Number(m[1]) > 23 || Number(m[2]) > 59) throw new Error(`时间要写成 HH:MM，比如 02:00（收到的是「${time}」）`);
+  return [Number(m[1]), Number(m[2])];
+}
+
+export function toCron(s: Exclude<TaskSchedule, { kind: "once" }>): string {
+  switch (s.kind) {
+    case "daily": {
+      const [h, m] = parseTime(s.time);
+      return `${m} ${h} * * *`;
+    }
+    case "weekdays": {
+      const [h, m] = parseTime(s.time);
+      return `${m} ${h} * * 1-5`;
+    }
+    case "weekly": {
+      const [h, m] = parseTime(s.time);
+      return `${m} ${h} * * ${[...new Set(s.days)].sort((a, b) => a - b).join(",")}`;
+    }
+    case "monthly": {
+      const [h, m] = parseTime(s.time);
+      return `${m} ${h} ${s.day} * *`;
+    }
+    case "hourly":
+      return `${s.minute} ${s.every === 1 ? "*" : `*/${s.every}`} * * *`;
+    case "cron":
+      return s.expr.trim();
+  }
+}
+
+const int = (v: unknown, lo: number, hi: number, what: string): number => {
+  const n = Number(v);
+  if (!Number.isInteger(n) || n < lo || n > hi) throw new Error(`${what}要是 ${lo}-${hi} 之间的整数`);
+  return n;
+};
+
+/** 校验并规整（来自网页表单或 agent 的工具调用，都不可信）。不合规直接抛出给人看的错误 */
+export function normalizeSchedule(raw: unknown, now = Date.now()): TaskSchedule {
+  const r = (raw ?? {}) as Record<string, unknown>;
+  let s: Exclude<TaskSchedule, { kind: "once" }>;
+  switch (r.kind) {
+    case "once": {
+      const at = Number(r.at);
+      if (!Number.isFinite(at)) throw new Error("「一次」要给运行时间");
+      if (at < now - 60_000) throw new Error("运行时间要在现在之后");
+      if (at > now + ONCE_MAX_MS) throw new Error("最多只能排到一年以后");
+      return { kind: "once", at: Math.floor(at / 60_000) * 60_000 };
+    }
+    case "daily":
+    case "weekdays":
+      s = { kind: r.kind, time: String(r.time ?? "") };
+      break;
+    case "weekly": {
+      const days = Array.isArray(r.days) ? r.days.map((d) => int(d, 0, 7, "星期") % 7) : [];
+      if (days.length === 0) throw new Error("「每周」至少选一天");
+      s = { kind: "weekly", days: [...new Set(days)].sort((a, b) => a - b), time: String(r.time ?? "") };
+      break;
+    }
+    case "monthly":
+      s = { kind: "monthly", day: int(r.day, 1, 31, "日期"), time: String(r.time ?? "") };
+      break;
+    case "hourly":
+      s = { kind: "hourly", every: int(r.every, 1, 23, "间隔小时数"), minute: int(r.minute ?? 0, 0, 59, "分钟") };
+      break;
+    case "cron":
+      s = { kind: "cron", expr: String(r.expr ?? "").trim().replace(/\s+/g, " ") };
+      break;
+    default:
+      throw new Error("不认识的频率");
+  }
+  if ("time" in s) {
+    const [h, m] = parseTime(s.time);
+    s.time = `${String(h).padStart(2, "0")}:${String(m).padStart(2, "0")}`;
+  }
+  const spec = parseCron(toCron(s));
+  // 抽查接下来的几次，相邻两次不能太近
+  let prev = cronNext(spec, now);
+  if (prev === undefined) throw new Error("按这个写法一年内都不会运行");
+  for (let i = 0; i < 8; i++) {
+    const next = cronNext(spec, prev);
+    if (next === undefined) break;
+    if (next - prev < MIN_GAP_MS) throw new Error(`太频繁了：两次运行至少要隔 ${MIN_GAP_MS / 60_000} 分钟`);
+    prev = next;
+  }
+  return s;
+}
+
+/** from 之后下一次该跑的时刻；「一次」跑过了就没有 */
+export function nextRun(s: TaskSchedule, from: number): number | undefined {
+  if (s.kind === "once") return s.at > from ? s.at : undefined;
+  try {
+    return cronNext(parseCron(toCron(s)), from);
+  } catch {
+    return undefined;
+  }
+}
+
+// ---------- 描述 ----------
+
+const WEEK = ["日", "一", "二", "三", "四", "五", "六"];
+
+export function formatClock(ms: number): string {
+  const d = new Date(ms);
+  return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
+}
+
+export function formatDateTime(ms: number): string {
+  const d = new Date(ms);
+  const p = (n: number) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())} ${formatClock(ms)}`;
+}
+
+/** 给人看的一句话：「每天 02:00」「工作日 09:30」「每周一、三 08:00」 */
+export function describeSchedule(s: TaskSchedule): string {
+  switch (s.kind) {
+    case "once":
+      return `一次：${formatDateTime(s.at)}`;
+    case "daily":
+      return `每天 ${s.time}`;
+    case "weekdays":
+      return `工作日 ${s.time}`;
+    case "weekly":
+      return s.days.length === 7 ? `每天 ${s.time}` : `每周${s.days.map((d) => WEEK[d]).join("、")} ${s.time}`;
+    case "monthly":
+      return `每月 ${s.day} 日 ${s.time}`;
+    case "hourly":
+      return s.every === 1 ? `每小时第 ${s.minute} 分` : `每 ${s.every} 小时（第 ${s.minute} 分）`;
+    case "cron":
+      return `cron：${s.expr}`;
+  }
+}
+
+/**
+ * 「2026-10-23 15:00」这类本地时间（agent 给的），也认带时区的 ISO 写法。解析不了返回 NaN。
+ * 不带时区的一律按服务端时区解释 —— Date.parse 对「YYYY-MM-DDTHH:MM」本来就是按本地时间。
+ */
+export function parseLocalDateTime(text: string): number {
+  const t = String(text ?? "").trim();
+  const m = /^(\d{4})-(\d{1,2})-(\d{1,2})[ T](\d{1,2}):(\d{2})(?::\d{2})?$/.exec(t);
+  if (m) return new Date(Number(m[1]), Number(m[2]) - 1, Number(m[3]), Number(m[4]), Number(m[5])).getTime();
+  return Date.parse(t);
+}