@lightcone-ai/daemon 0.11.0 → 0.13.0

package/mcp-servers/publisher/precheck.js

@@ -0,0 +1,240 @@
+function pickField(source, keys = []) {
+  for (const key of keys) {
+    const value = source?.[key];
+    if (value === undefined || value === null) continue;
+    const asText = typeof value === 'string' ? value.trim() : value;
+    if (asText === '') continue;
+    return value;
+  }
+  return null;
+}
+
+export function normalizeBoolean(value, fallback = false) {
+  if (value === undefined || value === null) return fallback;
+  if (typeof value === 'boolean') return value;
+  const normalized = String(value).trim().toLowerCase();
+  if (!normalized) return fallback;
+  if (['1', 'true', 'yes', 'y', 'on'].includes(normalized)) return true;
+  if (['0', 'false', 'no', 'n', 'off'].includes(normalized)) return false;
+  return fallback;
+}
+
+function normalizeRole(value) {
+  return String(value ?? '').trim().toLowerCase();
+}
+
+function normalizeStringArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value
+    .map(item => String(item ?? '').trim())
+    .filter(Boolean);
+}
+
+export function composeDraftText({ title, text, tags = [] } = {}) {
+  const lines = [];
+  if (title && String(title).trim()) lines.push(String(title).trim());
+  if (text && String(text).trim()) lines.push(String(text).trim());
+  const normalizedTags = normalizeStringArray(tags);
+  if (normalizedTags.length > 0) {
+    lines.push(normalizedTags.map(tag => (tag.startsWith('#') ? tag : `#${tag}`)).join(' '));
+  }
+  return lines.join('\n').trim();
+}
+
+function collectPayloadFlags(payload = {}) {
+  const accountId = pickField(payload, [
+    'account_id',
+    'accountId',
+    'target_account_id',
+    'targetAccountId',
+  ]);
+  const accountRole = pickField(payload, [
+    'account_role',
+    'accountRole',
+    'target_account_role',
+    'targetAccountRole',
+  ]);
+
+  const autoPublishViaDelegation = normalizeBoolean(
+    pickField(payload, [
+      'auto_publish_via_delegation',
+      'autoPublishViaDelegation',
+      'auto_publish',
+      'autoPublish',
+    ]),
+    false
+  );
+
+  const contentIndicatesCollaboration = normalizeBoolean(
+    pickField(payload, [
+      'content_indicates_collaboration',
+      'contentIndicatesCollaboration',
+      'is_ad_content',
+      'isAdContent',
+      'ad_content',
+      'adContent',
+    ]),
+    false
+  );
+
+  const hasAdDisclosure = normalizeBoolean(
+    pickField(payload, [
+      'has_ad_disclosure',
+      'hasAdDisclosure',
+      'ad_disclosure',
+      'adDisclosure',
+    ]),
+    false
+  );
+
+  const contentContainsAiGenerated = normalizeBoolean(
+    pickField(payload, [
+      'content_contains_ai_generated',
+      'contentContainsAiGenerated',
+      'ai_generated',
+      'aiGenerated',
+    ]),
+    false
+  );
+
+  const hasAiLabel = normalizeBoolean(
+    pickField(payload, [
+      'has_ai_label',
+      'hasAiLabel',
+      'ai_labeled',
+      'aiLabeled',
+    ]),
+    false
+  );
+
+  const publishHistory = Array.isArray(payload?.publish_history)
+    ? payload.publish_history
+    : (Array.isArray(payload?.publishHistory) ? payload.publishHistory : []);
+
+  return {
+    accountId: accountId ? String(accountId).trim() : null,
+    accountRole: normalizeRole(accountRole),
+    autoPublishViaDelegation,
+    contentIndicatesCollaboration,
+    hasAdDisclosure,
+    contentContainsAiGenerated,
+    hasAiLabel,
+    publishHistory,
+  };
+}
+
+function summarizePolicyViolations(policyScan = {}) {
+  const violations = Array.isArray(policyScan.violations) ? policyScan.violations : [];
+  const blockers = [];
+  const warnings = [];
+  for (const violation of violations) {
+    const severity = String(violation?.severity ?? '').trim().toLowerCase();
+    const item = {
+      code: String(violation?.rule_id ?? 'policy_violation'),
+      message: String(violation?.reason ?? violation?.term ?? 'policy violation').trim(),
+      snippet: violation?.snippet ?? null,
+      action: violation?.action ?? null,
+      term: violation?.term ?? null,
+    };
+    if (severity === 'blocker') blockers.push(item);
+    else warnings.push(item);
+  }
+  return { blockers, warnings };
+}
+
+function evaluatePrimaryAccountProtection(flags) {
+  if (flags.accountRole !== 'primary') return null;
+  if (!flags.autoPublishViaDelegation) return null;
+  return {
+    code: 'primary_account_protection',
+    message: 'primary account cannot use auto-publish via delegation; manual confirmation is required',
+  };
+}
+
+function evaluateLabelBlockers(flags, policyScan = {}) {
+  const blockers = [];
+  if (policyScan.ai_label_required && flags.contentContainsAiGenerated && !flags.hasAiLabel) {
+    blockers.push({
+      code: 'policy_ai_label_required',
+      message: 'AI-generated content is detected but AI label is missing',
+    });
+  }
+  if (policyScan.ad_disclosure_required && flags.contentIndicatesCollaboration && !flags.hasAdDisclosure) {
+    blockers.push({
+      code: 'policy_ad_disclosure_required',
+      message: 'ad/collaboration content requires platform disclosure label',
+    });
+  }
+  return blockers;
+}
+
+export async function runPublishPrecheck({
+  platform,
+  title,
+  text,
+  tags = [],
+  payload = {},
+  callTool,
+}) {
+  if (typeof callTool !== 'function') {
+    throw new Error('callTool function is required');
+  }
+
+  const draftText = composeDraftText({ title, text, tags });
+  const flags = collectPayloadFlags(payload ?? {});
+  const blockers = [];
+  const warnings = [];
+
+  const policyScan = await callTool({
+    serverId: 'platform-policy-db',
+    toolName: 'platform_policy_db',
+    argumentsPayload: {
+      operation: 'scan_text',
+      platform,
+      text: draftText,
+      max_matches: 20,
+    },
+  });
+  const policySummary = summarizePolicyViolations(policyScan);
+  blockers.push(...policySummary.blockers);
+  warnings.push(...policySummary.warnings);
+
+  const primaryProtection = evaluatePrimaryAccountProtection(flags);
+  if (primaryProtection) blockers.push(primaryProtection);
+
+  blockers.push(...evaluateLabelBlockers(flags, policyScan));
+
+  let advisory = null;
+  try {
+    advisory = await callTool({
+      serverId: 'publish-window-optimizer',
+      toolName: 'publish_window_optimizer',
+      argumentsPayload: {
+        platform,
+        account_id: flags.accountId ?? undefined,
+        history: flags.publishHistory,
+        limit: 3,
+      },
+    });
+    if (advisory?.advisory?.level === 'suggest_delay') {
+      warnings.push({
+        code: 'publish_window_suggest_delay',
+        message: String(advisory?.advisory?.message ?? 'recommended publish window suggests delay').trim(),
+      });
+    }
+  } catch (error) {
+    warnings.push({
+      code: 'publish_window_optimizer_unavailable',
+      message: `publish-window-optimizer unavailable: ${error.message}`,
+    });
+  }
+
+  return {
+    ok: blockers.length === 0,
+    blockers,
+    warnings,
+    policyScan,
+    advisory,
+    payloadFlags: flags,
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lightcone-ai/daemon",
-  "version": "0.11.0",
+  "version": "0.13.0",
   "type": "module",
   "main": "src/index.js",
   "bin": {