@deployxai/dxc 0.1.0

package/dist/chunks/monitor-VPRVRQIS.js

@@ -0,0 +1,694 @@
+import { createRequire as __dxcCreateRequire } from "node:module"; const require = __dxcCreateRequire(import.meta.url);
+import {
+  SourceCli,
+  SourceCliError
+} from "./chunk-I6VZLNRZ.js";
+import {
+  CONTENT_MONITOR_SCHEMA_VERSION,
+  LocalStateError,
+  contentMonitorAddResultSchema,
+  contentMonitorListResultSchema,
+  contentMonitorRemoveResultSchema,
+  contentMonitorRunResultSchema,
+  contentMonitorSourceSchema,
+  contentMonitorStatusResultSchema,
+  ensurePrivateRegularFile,
+  sourceFetchKindSchema
+} from "./chunk-XIHX5YAF.js";
+
+// apps/cli/src/monitor.ts
+import { createHash, randomUUID as systemRandomUUID } from "node:crypto";
+import { lstat } from "node:fs/promises";
+import path from "node:path";
+import { DatabaseSync } from "node:sqlite";
+var DATABASE_DISPLAY_PATH = "~/.dxc/source-monitor.sqlite";
+var LEASE_DURATION_MILLISECONDS = 2 * 60 * 1e3;
+var MAXIMUM_HEADER_BINDINGS = 12;
+var MAXIMUM_RSS_ITEMS = 100;
+var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
+var MonitorCliError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "MonitorCliError";
+  }
+  code;
+};
+function asRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new MonitorCliError("DXC_MONITOR_STATE_INVALID", "\u672C\u5730\u76D1\u63A7\u72B6\u6001\u65E0\u6548\u3002");
+  }
+  return value;
+}
+function stringColumn(row, name) {
+  const value = row[name];
+  if (typeof value !== "string") {
+    throw new MonitorCliError("DXC_MONITOR_STATE_INVALID", "\u672C\u5730\u76D1\u63A7\u72B6\u6001\u65E0\u6548\u3002");
+  }
+  return value;
+}
+function nullableStringColumn(row, name) {
+  const value = row[name];
+  if (value === null) {
+    return null;
+  }
+  if (typeof value !== "string") {
+    throw new MonitorCliError("DXC_MONITOR_STATE_INVALID", "\u672C\u5730\u76D1\u63A7\u72B6\u6001\u65E0\u6548\u3002");
+  }
+  return value;
+}
+function numberColumn(row, name) {
+  const value = row[name];
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new MonitorCliError("DXC_MONITOR_STATE_INVALID", "\u672C\u5730\u76D1\u63A7\u72B6\u6001\u65E0\u6548\u3002");
+  }
+  return value;
+}
+function errorCode(error) {
+  return typeof error === "object" && error !== null && "code" in error ? String(error.code) : void 0;
+}
+function bounded(value, maximum) {
+  return value.trim().replaceAll(/\s+/gu, " ").slice(0, maximum).trim();
+}
+function sha256(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function validUuid(value) {
+  return UUID_PATTERN.test(value);
+}
+function validUrl(value) {
+  let parsed;
+  try {
+    parsed = new URL(value);
+  } catch {
+    throw new MonitorCliError("DXC_MONITOR_SOURCE_INVALID", "\u6765\u6E90\u5730\u5740\u5FC5\u987B\u662F\u6709\u6548\u7684 HTTP(S) URL\u3002");
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:" || parsed.username.length > 0 || parsed.password.length > 0 || parsed.hostname.length === 0) {
+    throw new MonitorCliError("DXC_MONITOR_SOURCE_INVALID", "\u6765\u6E90\u5730\u5740\u53EA\u80FD\u662F\u65E0\u51ED\u636E\u7684 HTTP(S) URL\u3002");
+  }
+  return parsed.toString();
+}
+function parseHeaderBindings(values) {
+  if (values.length > MAXIMUM_HEADER_BINDINGS) {
+    throw new MonitorCliError("DXC_MONITOR_SOURCE_INVALID", "\u6700\u591A\u7ED1\u5B9A 12 \u4E2A API \u8BF7\u6C42\u5934\u3002");
+  }
+  return values.map((value) => {
+    const [header, environment, ...rest] = value.split("=");
+    if (header === void 0 || environment === void 0 || rest.length > 0 || !/^[A-Za-z0-9-]+$/u.test(header) || !/^[A-Za-z_][A-Za-z0-9_]*$/u.test(environment)) {
+      throw new MonitorCliError(
+        "DXC_MONITOR_SOURCE_INVALID",
+        "--header-env \u5FC5\u987B\u4F7F\u7528 Header=\u73AF\u5883\u53D8\u91CF\u540D \u7684\u5F62\u5F0F\u3002"
+      );
+    }
+    return { environment, header };
+  });
+}
+function sourceRow(value) {
+  const row = asRecord(value);
+  let headerEnvironments;
+  try {
+    headerEnvironments = JSON.parse(stringColumn(row, "header_environments"));
+  } catch {
+    throw new MonitorCliError("DXC_MONITOR_STATE_INVALID", "\u672C\u5730\u76D1\u63A7\u72B6\u6001\u65E0\u6548\u3002");
+  }
+  const source = contentMonitorSourceSchema.safeParse({
+    bearerEnvironment: nullableStringColumn(row, "bearer_environment"),
+    createdAt: stringColumn(row, "created_at"),
+    enabled: numberColumn(row, "enabled") === 1,
+    headerEnvironments,
+    id: stringColumn(row, "id"),
+    kind: stringColumn(row, "kind"),
+    name: stringColumn(row, "name"),
+    rssLimit: nullableNumberColumn(row, "rss_limit"),
+    url: stringColumn(row, "url")
+  });
+  if (!source.success) {
+    throw new MonitorCliError("DXC_MONITOR_STATE_INVALID", "\u672C\u5730\u76D1\u63A7\u72B6\u6001\u65E0\u6548\u3002");
+  }
+  return {
+    ...source.data,
+    lastRunAt: nullableStringColumn(row, "last_run_at"),
+    lastRunSummary: nullableStringColumn(row, "last_run_summary"),
+    latestItemAt: nullableStringColumn(row, "latest_item_at"),
+    observedItemCount: numberColumn(row, "observed_item_count")
+  };
+}
+function nullableNumberColumn(row, name) {
+  const value = row[name];
+  if (value === null) {
+    return null;
+  }
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new MonitorCliError("DXC_MONITOR_STATE_INVALID", "\u672C\u5730\u76D1\u63A7\u72B6\u6001\u65E0\u6548\u3002");
+  }
+  return value;
+}
+function monitorSchema(database) {
+  const version = numberColumn(
+    asRecord(database.prepare("PRAGMA user_version").get()),
+    "user_version"
+  );
+  if (version !== 0 && version !== Number(CONTENT_MONITOR_SCHEMA_VERSION)) {
+    throw new MonitorCliError("DXC_MONITOR_SCHEMA_UNSUPPORTED", "\u672C\u5730\u76D1\u63A7\u6570\u636E\u5E93\u7248\u672C\u4E0D\u53D7\u652F\u6301\u3002");
+  }
+  database.exec(`
+    PRAGMA foreign_keys = ON;
+    PRAGMA busy_timeout = 5000;
+    PRAGMA journal_mode = DELETE;
+    PRAGMA synchronous = FULL;
+
+    CREATE TABLE IF NOT EXISTS monitor_sources (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      kind TEXT NOT NULL CHECK (kind IN ('rss', 'api', 'html')),
+      url TEXT NOT NULL,
+      bearer_environment TEXT,
+      header_environments TEXT NOT NULL,
+      rss_limit INTEGER,
+      enabled INTEGER NOT NULL CHECK (enabled IN (0, 1)),
+      created_at TEXT NOT NULL,
+      UNIQUE(kind, url)
+    );
+
+    CREATE TABLE IF NOT EXISTS monitor_runs (
+      id TEXT PRIMARY KEY,
+      started_at TEXT NOT NULL,
+      finished_at TEXT,
+      summary TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS monitor_run_sources (
+      run_id TEXT NOT NULL REFERENCES monitor_runs(id) ON DELETE CASCADE,
+      source_id TEXT NOT NULL,
+      source_name TEXT NOT NULL,
+      summary TEXT NOT NULL,
+      failure_message TEXT,
+      monitored_item_count INTEGER NOT NULL CHECK (monitored_item_count >= 0),
+      new_item_count INTEGER NOT NULL CHECK (new_item_count >= 0),
+      updated_item_count INTEGER NOT NULL CHECK (updated_item_count >= 0),
+      unchanged_item_count INTEGER NOT NULL CHECK (unchanged_item_count >= 0)
+    );
+
+    CREATE TABLE IF NOT EXISTS monitor_items (
+      source_id TEXT NOT NULL REFERENCES monitor_sources(id) ON DELETE CASCADE,
+      identity TEXT NOT NULL,
+      title TEXT NOT NULL,
+      canonical_url TEXT,
+      published_at TEXT,
+      content_hash TEXT NOT NULL,
+      first_seen_at TEXT NOT NULL,
+      last_seen_at TEXT NOT NULL,
+      sightings INTEGER NOT NULL CHECK (sightings > 0),
+      PRIMARY KEY (source_id, identity)
+    );
+
+    CREATE TABLE IF NOT EXISTS monitor_leases (
+      source_id TEXT PRIMARY KEY REFERENCES monitor_sources(id) ON DELETE CASCADE,
+      holder TEXT NOT NULL,
+      expires_at TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS monitor_items_source_seen_idx
+      ON monitor_items(source_id, last_seen_at DESC);
+    CREATE INDEX IF NOT EXISTS monitor_runs_finished_idx
+      ON monitor_runs(finished_at DESC);
+
+    PRAGMA user_version = 1;
+  `);
+}
+async function openDatabase(target) {
+  try {
+    await ensurePrivateRegularFile(target);
+    const database = new DatabaseSync(target);
+    try {
+      monitorSchema(database);
+      return database;
+    } catch (error) {
+      database.close();
+      throw error;
+    }
+  } catch (error) {
+    if (error instanceof MonitorCliError) {
+      throw error;
+    }
+    if (error instanceof LocalStateError) {
+      throw new MonitorCliError("DXC_MONITOR_STATE_INVALID", "\u672C\u5730\u76D1\u63A7\u72B6\u6001\u65E0\u6CD5\u5B89\u5168\u8BFB\u53D6\u3002");
+    }
+    throw new MonitorCliError("DXC_MONITOR_IO_FAILED", "\u65E0\u6CD5\u6253\u5F00\u672C\u5730\u76D1\u63A7\u6570\u636E\u5E93\u3002");
+  }
+}
+async function databaseExists(target) {
+  try {
+    const metadata = await lstat(target);
+    if (!metadata.isFile() || metadata.isSymbolicLink()) {
+      throw new MonitorCliError("DXC_MONITOR_STATE_INVALID", "\u672C\u5730\u76D1\u63A7\u72B6\u6001\u65E0\u6548\u3002");
+    }
+    return true;
+  } catch (error) {
+    if (error instanceof MonitorCliError) {
+      throw error;
+    }
+    if (errorCode(error) === "ENOENT") {
+      return false;
+    }
+    throw new MonitorCliError("DXC_MONITOR_IO_FAILED", "\u65E0\u6CD5\u8BFB\u53D6\u672C\u5730\u76D1\u63A7\u72B6\u6001\u3002");
+  }
+}
+function sourceRows(database, sourceId) {
+  const rows = database.prepare(
+    `
+      SELECT
+        source.id, source.name, source.kind, source.url, source.bearer_environment,
+        source.header_environments, source.rss_limit, source.enabled, source.created_at,
+        latest.finished_at AS last_run_at, latest_source.summary AS last_run_summary,
+        (SELECT MAX(item.last_seen_at) FROM monitor_items item WHERE item.source_id = source.id)
+          AS latest_item_at,
+        (SELECT COUNT(*) FROM monitor_items item WHERE item.source_id = source.id)
+          AS observed_item_count
+      FROM monitor_sources source
+      LEFT JOIN monitor_runs latest ON latest.id = (
+        SELECT run.id
+        FROM monitor_runs run
+        INNER JOIN monitor_run_sources run_source ON run_source.run_id = run.id
+        WHERE run_source.source_id = source.id AND run.finished_at IS NOT NULL
+        ORDER BY run.finished_at DESC
+        LIMIT 1
+      )
+      LEFT JOIN monitor_run_sources latest_source
+        ON latest_source.run_id = latest.id AND latest_source.source_id = source.id
+      WHERE (? IS NULL OR source.id = ?)
+      ORDER BY source.created_at ASC, source.id ASC
+    `
+  ).all(sourceId ?? null, sourceId ?? null);
+  return rows.map(sourceRow);
+}
+function observedItems(data, source) {
+  if (data.kind === "rss") {
+    return data.items.map((item) => ({
+      contentHash: sha256(JSON.stringify(item)),
+      identity: item.url ?? item.id,
+      publishedAt: item.publishedAt ?? null,
+      title: item.title,
+      url: item.url ?? null
+    }));
+  }
+  if (data.kind === "html") {
+    return [
+      {
+        contentHash: data.capture.contentHash,
+        identity: data.document.canonicalUrl ?? data.capture.finalUrl,
+        publishedAt: null,
+        title: data.document.title,
+        url: data.document.canonicalUrl ?? data.capture.finalUrl
+      }
+    ];
+  }
+  return [
+    {
+      contentHash: data.capture.contentHash,
+      identity: data.capture.finalUrl,
+      publishedAt: null,
+      title: source.name,
+      url: data.capture.finalUrl
+    }
+  ];
+}
+function sourceResultSummary(source, counts) {
+  return `${source.name}\uFF1A\u53D1\u73B0 ${counts.created} \u6761\u65B0\u5185\u5BB9\uFF0C\u66F4\u65B0 ${counts.updated} \u6761\uFF0C\u5DF2\u6709 ${counts.unchanged} \u6761\u4FDD\u6301\u4E0D\u53D8\u3002`;
+}
+function persistObservedItems(database, source, items, timestamp) {
+  let created = 0;
+  let unchanged = 0;
+  let updated = 0;
+  database.exec("BEGIN IMMEDIATE");
+  try {
+    const select = database.prepare(
+      "SELECT content_hash FROM monitor_items WHERE source_id = ? AND identity = ? LIMIT 1"
+    );
+    const insert = database.prepare(`
+      INSERT INTO monitor_items (
+        source_id, identity, title, canonical_url, published_at, content_hash,
+        first_seen_at, last_seen_at, sightings
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, 1)
+    `);
+    const update = database.prepare(`
+      UPDATE monitor_items
+      SET title = ?, canonical_url = ?, published_at = ?, content_hash = ?,
+          last_seen_at = ?, sightings = sightings + 1
+      WHERE source_id = ? AND identity = ?
+    `);
+    for (const item of items) {
+      const existing = select.get(source.id, item.identity);
+      if (existing === void 0) {
+        insert.run(
+          source.id,
+          item.identity,
+          item.title,
+          item.url,
+          item.publishedAt,
+          item.contentHash,
+          timestamp,
+          timestamp
+        );
+        created += 1;
+        continue;
+      }
+      const existingHash = stringColumn(asRecord(existing), "content_hash");
+      update.run(
+        item.title,
+        item.url,
+        item.publishedAt,
+        item.contentHash,
+        timestamp,
+        source.id,
+        item.identity
+      );
+      if (existingHash === item.contentHash) {
+        unchanged += 1;
+      } else {
+        updated += 1;
+      }
+    }
+    database.exec("COMMIT");
+  } catch (error) {
+    try {
+      database.exec("ROLLBACK");
+    } catch {
+    }
+    if (error instanceof MonitorCliError) {
+      throw error;
+    }
+    throw new MonitorCliError("DXC_MONITOR_IO_FAILED", "\u65E0\u6CD5\u4FDD\u5B58\u672C\u6B21\u76D1\u63A7\u7ED3\u679C\u3002");
+  }
+  return { created, unchanged, updated };
+}
+function acquireLease(database, sourceId, holder, now) {
+  const expiresAt = new Date(now.getTime() + LEASE_DURATION_MILLISECONDS).toISOString();
+  const result = database.prepare(
+    `
+      INSERT INTO monitor_leases (source_id, holder, expires_at)
+      VALUES (?, ?, ?)
+      ON CONFLICT(source_id) DO UPDATE SET holder = excluded.holder, expires_at = excluded.expires_at
+      WHERE monitor_leases.expires_at <= ?
+    `
+  ).run(sourceId, holder, expiresAt, now.toISOString());
+  return result.changes > 0;
+}
+function releaseLease(database, sourceId, holder) {
+  database.prepare("DELETE FROM monitor_leases WHERE source_id = ? AND holder = ?").run(sourceId, holder);
+}
+var MonitorCli = class {
+  #databasePath;
+  #now;
+  #randomUUID;
+  #sourceCli;
+  constructor(dependencies) {
+    this.#databasePath = dependencies.databasePath ?? path.join(dependencies.homeDirectory, ".dxc", "source-monitor.sqlite");
+    this.#now = dependencies.now ?? (() => /* @__PURE__ */ new Date());
+    this.#randomUUID = dependencies.randomUUID ?? systemRandomUUID;
+    this.#sourceCli = dependencies.sourceCli ?? new SourceCli(dependencies.sourceDependencies);
+  }
+  async add(options) {
+    const kind = sourceFetchKindSchema.safeParse(options.kind);
+    const name = bounded(options.name ?? "", 120);
+    const bearerEnvironment = options.bearerEnvironment?.trim() || null;
+    if (!kind.success || bearerEnvironment !== null && !/^[A-Za-z_][A-Za-z0-9_]*$/u.test(bearerEnvironment) || kind.data !== "api" && (bearerEnvironment !== null || options.headerEnvironments.length > 0) || options.rssLimit !== void 0 && (!Number.isSafeInteger(options.rssLimit) || options.rssLimit < 1 || options.rssLimit > MAXIMUM_RSS_ITEMS) || kind.data !== "rss" && options.rssLimit !== void 0) {
+      throw new MonitorCliError("DXC_MONITOR_SOURCE_INVALID", "\u76D1\u63A7\u6765\u6E90\u914D\u7F6E\u65E0\u6548\u3002");
+    }
+    const url = validUrl(options.url);
+    const source = {
+      bearerEnvironment,
+      createdAt: this.#now().toISOString(),
+      enabled: true,
+      headerEnvironments: [...parseHeaderBindings(options.headerEnvironments)],
+      id: this.#randomUUID(),
+      kind: kind.data,
+      name: name || new URL(url).hostname,
+      rssLimit: kind.data === "rss" ? options.rssLimit ?? 20 : null,
+      url
+    };
+    const database = await openDatabase(this.#databasePath);
+    try {
+      const duplicate = database.prepare("SELECT id FROM monitor_sources WHERE kind = ? AND url = ? LIMIT 1").get(source.kind, source.url);
+      if (duplicate !== void 0) {
+        throw new MonitorCliError("DXC_MONITOR_SOURCE_INVALID", "\u8BE5\u6765\u6E90\u5DF2\u7ECF\u5728\u672C\u5730\u76D1\u63A7\u5217\u8868\u4E2D\u3002");
+      }
+      database.prepare(
+        `
+          INSERT INTO monitor_sources (
+            id, name, kind, url, bearer_environment, header_environments, rss_limit, enabled, created_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `
+      ).run(
+        source.id,
+        source.name,
+        source.kind,
+        source.url,
+        source.bearerEnvironment,
+        JSON.stringify(source.headerEnvironments),
+        source.rssLimit,
+        source.enabled ? 1 : 0,
+        source.createdAt
+      );
+      return contentMonitorAddResultSchema.parse({
+        command: "monitor.add",
+        data: { source, summary: `\u5DF2\u6DFB\u52A0\u201C${source.name}\u201D\uFF1B\u53EF\u8FD0\u884C monitor run \u8FDB\u884C\u9996\u6B21\u68C0\u67E5\u3002` },
+        ok: true
+      });
+    } catch (error) {
+      if (error instanceof MonitorCliError) {
+        throw error;
+      }
+      throw new MonitorCliError("DXC_MONITOR_IO_FAILED", "\u65E0\u6CD5\u4FDD\u5B58\u672C\u5730\u76D1\u63A7\u6765\u6E90\u3002");
+    } finally {
+      database.close();
+    }
+  }
+  async list() {
+    if (!await databaseExists(this.#databasePath)) {
+      return contentMonitorListResultSchema.parse({
+        command: "monitor.list",
+        data: { sources: [], summary: "\u672C\u5730\u5C1A\u672A\u6DFB\u52A0\u76D1\u63A7\u6765\u6E90\u3002" },
+        ok: true
+      });
+    }
+    const database = await openDatabase(this.#databasePath);
+    try {
+      const sources = sourceRows(database);
+      return contentMonitorListResultSchema.parse({
+        command: "monitor.list",
+        data: {
+          sources,
+          summary: sources.length === 0 ? "\u672C\u5730\u5C1A\u672A\u6DFB\u52A0\u76D1\u63A7\u6765\u6E90\u3002" : `\u5F53\u524D\u6709 ${sources.length} \u4E2A\u672C\u5730\u76D1\u63A7\u6765\u6E90\u3002`
+        },
+        ok: true
+      });
+    } finally {
+      database.close();
+    }
+  }
+  async remove(sourceId) {
+    if (!validUuid(sourceId)) {
+      throw new MonitorCliError("DXC_MONITOR_SOURCE_INVALID", "\u76D1\u63A7\u6765\u6E90 ID \u65E0\u6548\u3002");
+    }
+    if (!await databaseExists(this.#databasePath)) {
+      return contentMonitorRemoveResultSchema.parse({
+        command: "monitor.remove",
+        data: { removed: false, sourceId, summary: "\u672A\u627E\u5230\u8981\u79FB\u9664\u7684\u672C\u5730\u76D1\u63A7\u6765\u6E90\u3002" },
+        ok: true
+      });
+    }
+    const database = await openDatabase(this.#databasePath);
+    try {
+      database.exec("BEGIN IMMEDIATE");
+      try {
+        const removed = database.prepare("DELETE FROM monitor_sources WHERE id = ?").run(sourceId).changes > 0;
+        database.exec("COMMIT");
+        return contentMonitorRemoveResultSchema.parse({
+          command: "monitor.remove",
+          data: {
+            removed,
+            sourceId,
+            summary: removed ? "\u5DF2\u79FB\u9664\u672C\u5730\u76D1\u63A7\u6765\u6E90\u53CA\u5176\u53BB\u91CD\u8BB0\u5F55\u3002" : "\u672A\u627E\u5230\u8981\u79FB\u9664\u7684\u672C\u5730\u76D1\u63A7\u6765\u6E90\u3002"
+          },
+          ok: true
+        });
+      } catch {
+        database.exec("ROLLBACK");
+        throw new MonitorCliError("DXC_MONITOR_IO_FAILED", "\u65E0\u6CD5\u79FB\u9664\u672C\u5730\u76D1\u63A7\u6765\u6E90\u3002");
+      }
+    } finally {
+      database.close();
+    }
+  }
+  async run(sourceId) {
+    if (sourceId !== void 0 && !validUuid(sourceId)) {
+      throw new MonitorCliError("DXC_MONITOR_SOURCE_INVALID", "\u76D1\u63A7\u6765\u6E90 ID \u65E0\u6548\u3002");
+    }
+    const database = await openDatabase(this.#databasePath);
+    const startedAt = this.#now().toISOString();
+    const runId = this.#randomUUID();
+    try {
+      const sources = sourceRows(database, sourceId).filter((source) => source.enabled);
+      if (sourceId !== void 0 && sources.length === 0) {
+        throw new MonitorCliError("DXC_MONITOR_SOURCE_NOT_FOUND", "\u672A\u627E\u5230\u5DF2\u542F\u7528\u7684\u672C\u5730\u76D1\u63A7\u6765\u6E90\u3002");
+      }
+      database.prepare("INSERT INTO monitor_runs (id, started_at) VALUES (?, ?)").run(runId, startedAt);
+      const results = [];
+      for (const source of sources) {
+        const holder = this.#randomUUID();
+        const now = this.#now();
+        if (!acquireLease(database, source.id, holder, now)) {
+          results.push({
+            failureMessage: "\u53E6\u4E00\u4E2A\u672C\u5730\u8FD0\u884C\u4ECD\u5728\u8FDB\u884C\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5\u3002",
+            monitoredItemCount: 0,
+            newItemCount: 0,
+            sourceId: source.id,
+            sourceName: source.name,
+            summary: `${source.name}\uFF1A\u672C\u6B21\u672A\u6267\u884C\uFF0C\u56E0\u4E3A\u5DF2\u6709\u672C\u5730\u8FD0\u884C\u6B63\u5728\u5904\u7406\u3002`,
+            unchangedItemCount: 0,
+            updatedItemCount: 0
+          });
+          continue;
+        }
+        try {
+          const capture = await this.#capture(source);
+          const items = observedItems(capture.data, source);
+          const counts = persistObservedItems(database, source, items, this.#now().toISOString());
+          results.push({
+            failureMessage: null,
+            monitoredItemCount: items.length,
+            newItemCount: counts.created,
+            sourceId: source.id,
+            sourceName: source.name,
+            summary: sourceResultSummary(source, { monitored: items.length, ...counts }),
+            unchangedItemCount: counts.unchanged,
+            updatedItemCount: counts.updated
+          });
+        } catch (error) {
+          const message = error instanceof SourceCliError || error instanceof MonitorCliError ? bounded(error.message, 500) : "\u6765\u6E90\u6682\u65F6\u65E0\u6CD5\u8BFB\u53D6\uFF0C\u8BF7\u68C0\u67E5\u5730\u5740\u6216\u7A0D\u540E\u518D\u8BD5\u3002";
+          results.push({
+            failureMessage: message,
+            monitoredItemCount: 0,
+            newItemCount: 0,
+            sourceId: source.id,
+            sourceName: source.name,
+            summary: `${source.name}\uFF1A\u672C\u6B21\u672A\u5B8C\u6210\u68C0\u67E5\u3002${message}`,
+            unchangedItemCount: 0,
+            updatedItemCount: 0
+          });
+        } finally {
+          releaseLease(database, source.id, holder);
+        }
+      }
+      const finishedAt = this.#now().toISOString();
+      const failedSourceCount = results.filter((result) => result.failureMessage !== null).length;
+      const summary = results.length === 0 ? "\u6CA1\u6709\u5DF2\u542F\u7528\u7684\u672C\u5730\u76D1\u63A7\u6765\u6E90\u3002" : failedSourceCount === 0 ? `\u672C\u6B21\u5DF2\u5B8C\u6210 ${results.length} \u4E2A\u6765\u6E90\u7684\u672C\u5730\u68C0\u67E5\u3002` : `\u672C\u6B21\u5B8C\u6210 ${results.length} \u4E2A\u6765\u6E90\u68C0\u67E5\uFF0C\u5176\u4E2D ${failedSourceCount} \u4E2A\u9700\u8981\u7A0D\u540E\u91CD\u8BD5\u3002`;
+      this.#saveRun(database, runId, finishedAt, summary, results);
+      return contentMonitorRunResultSchema.parse({
+        command: "monitor.run",
+        data: { failedSourceCount, finishedAt, results, startedAt, summary },
+        ok: true
+      });
+    } finally {
+      database.close();
+    }
+  }
+  async status() {
+    if (!await databaseExists(this.#databasePath)) {
+      return contentMonitorStatusResultSchema.parse({
+        command: "monitor.status",
+        data: {
+          databasePath: DATABASE_DISPLAY_PATH,
+          enabledSourceCount: 0,
+          latestRunAt: null,
+          latestRunSummary: null,
+          sourceCount: 0,
+          summary: "\u672C\u5730\u76D1\u63A7\u5C1A\u672A\u521D\u59CB\u5316\uFF1B\u5148\u6DFB\u52A0\u4E00\u4E2A\u516C\u5F00\u6765\u6E90\u3002"
+        },
+        ok: true
+      });
+    }
+    const database = await openDatabase(this.#databasePath);
+    try {
+      const counts = asRecord(
+        database.prepare(
+          "SELECT COUNT(*) AS source_count, COALESCE(SUM(enabled), 0) AS enabled_source_count FROM monitor_sources"
+        ).get()
+      );
+      const latest = database.prepare(
+        "SELECT finished_at, summary FROM monitor_runs WHERE finished_at IS NOT NULL ORDER BY finished_at DESC LIMIT 1"
+      ).get();
+      const sourceCount = numberColumn(counts, "source_count");
+      const enabledSourceCount = numberColumn(counts, "enabled_source_count");
+      const latestRow = latest === void 0 ? void 0 : asRecord(latest);
+      const latestRunAt = latestRow === void 0 ? null : nullableStringColumn(latestRow, "finished_at");
+      const latestRunSummary = latestRow === void 0 ? null : nullableStringColumn(latestRow, "summary");
+      return contentMonitorStatusResultSchema.parse({
+        command: "monitor.status",
+        data: {
+          databasePath: DATABASE_DISPLAY_PATH,
+          enabledSourceCount,
+          latestRunAt,
+          latestRunSummary,
+          sourceCount,
+          summary: sourceCount === 0 ? "\u672C\u5730\u5C1A\u672A\u6DFB\u52A0\u76D1\u63A7\u6765\u6E90\u3002" : latestRunAt === null ? `\u5DF2\u6709 ${sourceCount} \u4E2A\u6765\u6E90\uFF0C\u5C1A\u672A\u8FDB\u884C\u9996\u6B21\u68C0\u67E5\u3002` : `\u5DF2\u6709 ${enabledSourceCount} \u4E2A\u5DF2\u542F\u7528\u6765\u6E90\uFF1B${latestRunSummary ?? "\u6700\u8FD1\u68C0\u67E5\u5DF2\u5B8C\u6210\u3002"}`
+        },
+        ok: true
+      });
+    } finally {
+      database.close();
+    }
+  }
+  async #capture(source) {
+    if (source.kind === "rss") {
+      return this.#sourceCli.fetchRss(source.url, source.rssLimit ?? 20);
+    }
+    if (source.kind === "html") {
+      return this.#sourceCli.fetchHtml(source.url);
+    }
+    return this.#sourceCli.fetchApi({
+      ...source.bearerEnvironment === null ? {} : { bearerEnvironment: source.bearerEnvironment },
+      headerEnvironments: source.headerEnvironments.map(
+        (binding) => `${binding.header}=${binding.environment}`
+      ),
+      url: source.url
+    });
+  }
+  #saveRun(database, runId, finishedAt, summary, results) {
+    database.exec("BEGIN IMMEDIATE");
+    try {
+      const insert = database.prepare(`
+        INSERT INTO monitor_run_sources (
+          run_id, source_id, source_name, summary, failure_message, monitored_item_count,
+          new_item_count, updated_item_count, unchanged_item_count
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `);
+      for (const result of results) {
+        insert.run(
+          runId,
+          result.sourceId,
+          result.sourceName,
+          result.summary,
+          result.failureMessage,
+          result.monitoredItemCount,
+          result.newItemCount,
+          result.updatedItemCount,
+          result.unchangedItemCount
+        );
+      }
+      database.prepare("UPDATE monitor_runs SET finished_at = ?, summary = ? WHERE id = ?").run(finishedAt, summary, runId);
+      database.exec("COMMIT");
+    } catch {
+      try {
+        database.exec("ROLLBACK");
+      } catch {
+      }
+      throw new MonitorCliError("DXC_MONITOR_IO_FAILED", "\u65E0\u6CD5\u8BB0\u5F55\u672C\u6B21\u672C\u5730\u76D1\u63A7\u8FD0\u884C\u3002 ");
+    }
+  }
+};
+export {
+  MonitorCli,
+  MonitorCliError
+};