@lightcone-ai/daemon 0.14.0 → 0.14.2

package/src/publish-job-runner.js

@@ -0,0 +1,438 @@
+import { existsSync, statSync, realpathSync, mkdirSync, writeFileSync } from 'fs';
+import path from 'path';
+import { getSession, closeSession } from '../mcp-servers/publisher/chrome-pool.js';
+import { XhsAdapter } from '../mcp-servers/publisher/adapters/xhs.js';
+import { DouyinAdapter } from '../mcp-servers/publisher/adapters/douyin.js';
+import { KuaishouAdapter } from '../mcp-servers/publisher/adapters/kuaishou.js';
+import { callOfficialTool } from '../mcp-servers/publisher/official-tool-client.js';
+import { runPublishPrecheck } from '../mcp-servers/publisher/precheck.js';
+import { withProfileLock } from './profile-lock.js';
+
+const PLATFORM_ENV_KEYS = {
+  xhs: 'XHS_PROFILE_DIR',
+  douyin: 'DOUYIN_PROFILE_DIR',
+  kuaishou: 'KUAISHOU_PROFILE_DIR',
+};
+
+const ADAPTER_REGISTRY = Object.freeze({
+  xhs: XhsAdapter,
+  douyin: DouyinAdapter,
+  kuaishou: KuaishouAdapter,
+});
+
+const DEFAULT_MEDIA_LIMITS = {
+  xhs: { maxImages: 9, imageExts: ['.jpg', '.jpeg', '.png', '.webp'], videoExts: ['.mp4', '.mov'] },
+  douyin: { maxImages: 35, imageExts: ['.jpg', '.jpeg', '.png', '.webp'], videoExts: ['.mp4', '.mov', '.webm'] },
+  kuaishou: { maxImages: 12, imageExts: ['.jpg', '.jpeg', '.png'], videoExts: ['.mp4', '.mov'] },
+};
+
+function normalizeText(value) {
+  const normalized = String(value ?? '').trim();
+  return normalized || null;
+}
+
+function asObject(value) {
+  if (value && typeof value === 'object' && !Array.isArray(value)) return value;
+  return {};
+}
+
+function getProfileDir(platform) {
+  const key = PLATFORM_ENV_KEYS[platform];
+  if (!key) return null;
+  return process.env[key] ?? null;
+}
+
+function getAdapterClass(platform) {
+  const AdapterClass = ADAPTER_REGISTRY[platform];
+  if (!AdapterClass) throw new Error(`Unknown platform: ${platform}`);
+  return AdapterClass;
+}
+
+function createStaticAdapter(platform) {
+  const AdapterClass = getAdapterClass(platform);
+  return new AdapterClass(null);
+}
+
+async function getAdapter(platform) {
+  const profileDir = getProfileDir(platform);
+  if (!profileDir) {
+    throw new Error(`No profile dir for platform="${platform}". Has the user logged in and authorized this machine?`);
+  }
+  const cdp = await getSession(platform, profileDir);
+  const AdapterClass = getAdapterClass(platform);
+  return new AdapterClass(cdp);
+}
+
+async function withPublisherProfile(platform, fn) {
+  const profileDir = getProfileDir(platform);
+  if (!profileDir) {
+    throw new Error(`No profile dir for platform="${platform}". Has the user logged in and authorized this machine?`);
+  }
+  return withProfileLock(platform, profileDir, {
+    owner: `publisher:${platform}`,
+    timeoutMs: 30_000,
+    staleMs: 20 * 60 * 1000,
+  }, fn);
+}
+
+function isInsideDir(filePath, dir) {
+  const rel = path.relative(dir, filePath);
+  return rel === '' || (!!rel && !rel.startsWith('..') && !path.isAbsolute(rel));
+}
+
+function decodeWorkspaceContent(content) {
+  if (typeof content !== 'string') throw new Error('workspace file content is not a string');
+  if (!content.startsWith('data:')) return Buffer.from(content, 'utf8');
+
+  const commaIdx = content.indexOf(',');
+  if (commaIdx === -1) throw new Error('invalid data URL in workspace file');
+  const header = content.slice(5, commaIdx);
+  const body = content.slice(commaIdx + 1);
+  if (header.split(';').includes('base64')) return Buffer.from(body, 'base64');
+  return Buffer.from(decodeURIComponent(body), 'utf8');
+}
+
+async function internalApi({ serverUrl, machineApiKey, agentId, method, endpoint, body }) {
+  const url = `${String(serverUrl).replace(/\/$/, '')}/internal/agent/${encodeURIComponent(agentId)}${endpoint}`;
+  const res = await fetch(url, {
+    method,
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${machineApiKey}`,
+    },
+    body: body != null ? JSON.stringify(body) : undefined,
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`internal API ${method} ${endpoint} failed (${res.status}): ${text}`);
+  }
+  return res.json();
+}
+
+function workspacePathFromMediaPath(filePath, workspaceId) {
+  if (!filePath) return null;
+
+  const normalized = filePath.replaceAll('\\', '/');
+  const virtualMatch = normalized.match(/^\/agent-workspace\/([^/]+)\/workspace\/(.+)$/);
+  if (virtualMatch) return { workspaceId: virtualMatch[1], relPath: virtualMatch[2] };
+
+  const workspaceSegmentMatch = normalized.match(/\/workspace\/((?:artifacts|notes|tmp)\/.+)$/);
+  if (workspaceSegmentMatch) {
+    return { workspaceId, relPath: workspaceSegmentMatch[1] };
+  }
+
+  if (!path.isAbsolute(filePath) && /^(artifacts|notes|tmp)\//.test(normalized)) {
+    return { workspaceId, relPath: normalized };
+  }
+
+  return null;
+}
+
+async function materializeWorkspaceMedia({ filePath, workspaceId, workspaceRootDir, serverUrl, machineApiKey, agentId }) {
+  if (!filePath || existsSync(filePath)) return filePath;
+
+  const workspacePath = workspacePathFromMediaPath(filePath, workspaceId);
+  if (!workspacePath?.workspaceId || !workspacePath.relPath) return filePath;
+
+  const localPath = path.resolve(workspaceRootDir, workspacePath.relPath);
+  const allowedRoots = ['artifacts', 'notes', 'tmp'].map(dir => path.join(workspaceRootDir, dir));
+  if (!allowedRoots.some(root => isInsideDir(localPath, root))) {
+    throw new Error(`workspace media path is outside allowed workspace directories: ${filePath}`);
+  }
+
+  if (existsSync(localPath)) return localPath;
+
+  const data = await internalApi({
+    serverUrl,
+    machineApiKey,
+    agentId,
+    method: 'GET',
+    endpoint: `/workspace-memory?path=${encodeURIComponent(workspacePath.relPath)}&workspaceId=${encodeURIComponent(workspacePath.workspaceId)}`,
+  });
+  mkdirSync(path.dirname(localPath), { recursive: true });
+  writeFileSync(localPath, decodeWorkspaceContent(data.content));
+  return localPath;
+}
+
+async function materializeMedia({
+  images = [],
+  video,
+  cover,
+  workspaceId,
+  workspaceRootDir,
+  serverUrl,
+  machineApiKey,
+  agentId,
+}) {
+  return {
+    images: await Promise.all(images.map(filePath => materializeWorkspaceMedia({
+      filePath,
+      workspaceId,
+      workspaceRootDir,
+      serverUrl,
+      machineApiKey,
+      agentId,
+    }))),
+    video: video ? await materializeWorkspaceMedia({
+      filePath: video,
+      workspaceId,
+      workspaceRootDir,
+      serverUrl,
+      machineApiKey,
+      agentId,
+    }) : video,
+    cover: cover ? await materializeWorkspaceMedia({
+      filePath: cover,
+      workspaceId,
+      workspaceRootDir,
+      serverUrl,
+      machineApiKey,
+      agentId,
+    }) : cover,
+  };
+}
+
+function validateLocalFile(filePath, { kind, required = false, allowedExts = [], workspaceDir, workspaceRootDir }) {
+  if (!filePath) {
+    if (required) throw new Error(`${kind} file path is required`);
+    return null;
+  }
+  if (!path.isAbsolute(filePath)) {
+    throw new Error(`${kind} path must be absolute: ${filePath}`);
+  }
+  if (!existsSync(filePath)) {
+    throw new Error(`${kind} file does not exist: ${filePath}`);
+  }
+
+  const realFile = realpathSync(filePath);
+  const allowedRoots = [
+    realpathSync(workspaceDir),
+    ...['artifacts', 'notes', 'tmp']
+      .map(dir => path.join(workspaceRootDir, dir))
+      .filter(existsSync)
+      .map(dir => realpathSync(dir)),
+  ];
+  if (!allowedRoots.some(root => isInsideDir(realFile, root))) {
+    throw new Error(`${kind} file must be inside the daemon workspace or shared artifacts/notes/tmp directories: ${filePath}`);
+  }
+
+  const stat = statSync(realFile);
+  if (!stat.isFile()) throw new Error(`${kind} path is not a file: ${filePath}`);
+  const ext = path.extname(realFile).toLowerCase();
+  if (allowedExts.length > 0 && !allowedExts.includes(ext)) {
+    throw new Error(`${kind} file has unsupported extension "${ext}". Allowed: ${allowedExts.join(', ')}`);
+  }
+  return realFile;
+}
+
+function normalizeFormatExts(formats = [], fallback = []) {
+  if (!Array.isArray(formats) || formats.length === 0) return fallback;
+  return formats
+    .map(item => String(item ?? '').trim().toLowerCase())
+    .filter(Boolean)
+    .map(item => (item.startsWith('.') ? item : `.${item}`));
+}
+
+function resolveMediaLimits(platform, contentType) {
+  const fallback = DEFAULT_MEDIA_LIMITS[platform] ?? DEFAULT_MEDIA_LIMITS.xhs;
+  const adapter = createStaticAdapter(platform);
+  const requirements = adapter.getRequirements(contentType) ?? {};
+  const capabilities = typeof adapter.getCapabilities === 'function'
+    ? (adapter.getCapabilities() ?? {})
+    : {};
+
+  return {
+    maxImages: Number(requirements.max_images ?? capabilities.max_image ?? fallback.maxImages),
+    imageExts: normalizeFormatExts(requirements.image_formats ?? capabilities.image_formats, fallback.imageExts),
+    videoExts: normalizeFormatExts(requirements.video_formats ?? capabilities.video_formats, fallback.videoExts),
+  };
+}
+
+function validateMedia({ platform, contentType, images = [], video, cover, workspaceDir, workspaceRootDir }) {
+  const limits = resolveMediaLimits(platform, contentType);
+  if (contentType === 'image_text') {
+    if (images.length === 0) {
+      throw new Error(`image_text requires at least 1 image on ${platform}.`);
+    }
+    if (images.length > limits.maxImages) {
+      throw new Error(`image_text supports at most ${limits.maxImages} images on ${platform}`);
+    }
+    return {
+      images: images.map(filePath => validateLocalFile(filePath, {
+        kind: 'image',
+        required: true,
+        allowedExts: limits.imageExts,
+        workspaceDir,
+        workspaceRootDir,
+      })),
+      video: null,
+      cover: null,
+    };
+  }
+
+  return {
+    images: [],
+    video: validateLocalFile(video, {
+      kind: 'video',
+      required: true,
+      allowedExts: limits.videoExts,
+      workspaceDir,
+      workspaceRootDir,
+    }),
+    cover: cover ? validateLocalFile(cover, {
+      kind: 'cover',
+      allowedExts: limits.imageExts,
+      workspaceDir,
+      workspaceRootDir,
+    }) : null,
+  };
+}
+
+function normalizeContentType(value) {
+  const normalized = String(value ?? '').trim().toLowerCase();
+  if (normalized === 'image_text' || normalized === 'short_video') return normalized;
+  return null;
+}
+
+function ensureStringArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value.map(item => String(item ?? '')).filter(Boolean);
+}
+
+function buildJobInput(job = {}) {
+  const payload = asObject(job.payload);
+  const platform = String(job.platform ?? payload.platform ?? '').trim().toLowerCase();
+  const contentType = normalizeContentType(
+    payload.content_type ?? payload.contentType ?? job.content_type ?? job.contentType
+  );
+  const workspaceId = normalizeText(job.workspace_id ?? job.workspaceId ?? payload.workspace_id ?? payload.workspaceId);
+  const title = payload.title;
+  const text = payload.text;
+  const tags = ensureStringArray(payload.tags);
+  const images = ensureStringArray(payload.images);
+  const video = normalizeText(payload.video);
+  const cover = normalizeText(payload.cover);
+
+  return {
+    payload,
+    platform,
+    contentType,
+    workspaceId,
+    title,
+    text,
+    tags,
+    images,
+    video,
+    cover,
+  };
+}
+
+export async function runPublishJob({ serverUrl, machineApiKey, agentId, workspaceDir, job }) {
+  if (!serverUrl || !machineApiKey || !agentId) {
+    throw new Error('runPublishJob requires serverUrl, machineApiKey, and agentId');
+  }
+
+  const {
+    payload,
+    platform,
+    contentType,
+    workspaceId,
+    title,
+    text,
+    tags,
+    images,
+    video,
+    cover,
+  } = buildJobInput(job);
+
+  if (!platform) throw new Error('publish job missing platform');
+  if (!contentType) throw new Error('publish job missing content_type');
+  if (typeof text !== 'string' || !text.trim()) throw new Error('publish job missing text');
+
+  const resolvedWorkspaceDir = workspaceDir ?? process.cwd();
+  const workspaceRootDir = path.dirname(resolvedWorkspaceDir);
+
+  const precheck = await runPublishPrecheck({
+    platform,
+    title,
+    text,
+    tags,
+    payload,
+    callTool: callOfficialTool,
+  });
+  if (!precheck.ok) {
+    const blockerSummary = precheck.blockers.map(item => `${item.code}: ${item.message}`).join(' | ');
+    throw new Error(`PUBLISH_PRECHECK_BLOCKED:${blockerSummary || 'precheck failed'}`);
+  }
+
+  const localMedia = await materializeMedia({
+    images,
+    video,
+    cover,
+    workspaceId,
+    workspaceRootDir,
+    serverUrl,
+    machineApiKey,
+    agentId,
+  });
+  const staticAdapter = createStaticAdapter(platform);
+  const req = staticAdapter.getRequirements(contentType);
+  if (!req) throw new Error(`INPUT_UNSUPPORTED_CONTENT_TYPE: ${platform} does not support ${contentType}`);
+
+  const media = validateMedia({
+    platform,
+    contentType,
+    ...localMedia,
+    workspaceDir: resolvedWorkspaceDir,
+    workspaceRootDir,
+  });
+
+  try {
+    const { publishResult, healthCheck } = await withPublisherProfile(platform, async () => {
+      const adapter = await getAdapter(platform);
+      const prePublishLogin = await adapter.checkLoginStatus();
+      if (prePublishLogin?.loggedIn === false) {
+        throw new Error(`LOGIN_EXPIRED:${platform}`);
+      }
+      let publishResult = null;
+      if (contentType === 'image_text') {
+        publishResult = await adapter.publishImageText({ title, text, tags, images: media.images });
+      } else {
+        publishResult = await adapter.publishShortVideo({ title, text, tags, video: media.video, cover: media.cover });
+      }
+
+      let healthCheck = null;
+      try {
+        healthCheck = await adapter.checkLoginStatus();
+      } catch (error) {
+        healthCheck = {
+          loggedIn: null,
+          error: error.message,
+        };
+      }
+      return { publishResult, healthCheck };
+    });
+
+    return {
+      completionResult: {
+        precheck: {
+          blockers: precheck.blockers,
+          warnings: precheck.warnings,
+          policy_version: precheck?.policyScan?.policy_version ?? null,
+          advisory: precheck?.advisory?.advisory ?? null,
+        },
+        pre_publish_login: true,
+        publish_result: publishResult,
+        post_publish_health: healthCheck,
+      },
+      publishResult,
+      precheck,
+      healthCheck,
+    };
+  } catch (err) {
+    if (err.message?.startsWith('LOGIN_EXPIRED')) {
+      closeSession(platform);
+    }
+    throw err;
+  }
+}

package/src/workspace-file-upload.js

@@ -0,0 +1,71 @@
+import path, { extname } from 'node:path';
+import { readFileSync } from 'node:fs';
+
+export const WORKSPACE_BINARY_MIME = {
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.webp': 'image/webp',
+  '.gif': 'image/gif',
+  '.pdf': 'application/pdf',
+};
+
+export const VIDEO_EXT = '.mp4';
+export const VIDEO_MIME = 'video/mp4';
+
+export function resolveWorkspaceFileUploadPlan({ localPath, workspacePath }) {
+  const target = String(workspacePath ?? '').trim() || String(localPath ?? '').trim();
+  const ext = extname(target).toLowerCase();
+  const filename = path.basename(target || localPath);
+  if (ext === VIDEO_EXT) {
+    return {
+      mode: 'upload-video',
+      ext,
+      filename,
+      mime: VIDEO_MIME,
+    };
+  }
+  return {
+    mode: 'workspace-memory',
+    ext,
+    filename,
+    mime: WORKSPACE_BINARY_MIME[ext] ?? 'application/octet-stream',
+  };
+}
+
+export async function writeLocalFileToWorkspace({
+  localPath,
+  workspacePath,
+  workspaceId,
+  readFileSyncFn = readFileSync,
+  uploadWorkspaceMemory,
+  uploadVideo,
+}) {
+  const plan = resolveWorkspaceFileUploadPlan({ localPath, workspacePath });
+  if (plan.mode === 'upload-video') {
+    return uploadVideo({
+      localPath,
+      workspacePath,
+      workspaceId,
+      filename: plan.filename,
+      mime: plan.mime,
+      mode: plan.mode,
+    });
+  }
+
+  const buf = readFileSyncFn(localPath);
+  const content = `data:${plan.mime};base64,${buf.toString('base64')}`;
+  await uploadWorkspaceMemory({
+    workspacePath,
+    workspaceId,
+    content,
+    mime: plan.mime,
+    bytes: buf.length,
+    mode: plan.mode,
+  });
+  return {
+    mode: plan.mode,
+    mime: plan.mime,
+    bytes: buf.length,
+  };
+}