@lightcone-ai/daemon 0.14.1 → 0.14.3

package/mcp-servers/publisher/index.js

@@ -115,6 +115,9 @@ async function validateApproval(actionId, platform) {
     throw new Error('approval_action_id is required. Request human approval first, then pass the approved action_id to publish_content.');
   }
   const data = await api('POST', `/actions/${encodeURIComponent(actionId)}/execute`, {});
+  if (data?.execution?.mode === 'user_daemon_job') {
+    throw new Error(`APPROVAL_DISPATCHED_TO_DAEMON_JOB:${data?.execution?.publish_job_id ?? ''}`);
+  }
   if (data.platform && data.platform !== platform) {
     throw new Error(`Approval platform mismatch: approved for "${data.platform}", requested "${platform}"`);
   }
@@ -387,6 +390,12 @@ images/video 字段填写本地绝对路径（在 agent workspace 目录下）
         content: [{ type: 'text', text: `✓ 已成功发布到${label}。${postUrl}${advisoryMessage}${healthMessage}` }],
       };
     } catch (err) {
+      if (err.message?.startsWith('APPROVAL_DISPATCHED_TO_DAEMON_JOB:')) {
+        return {
+          content: [{ type: 'text', text: '该审批动作已派发到用户侧 daemon job，请等待任务结果，不要直接调用 publish_content。' }],
+          isError: true,
+        };
+      }
       if (err.message?.startsWith('LOGIN_EXPIRED')) {
         closeSession(platform);
         await completeApproval(approval_action_id, false, null, err.message);

package/mcp-servers/publisher/official-tool-client.js

@@ -1,5 +1,5 @@
 import { spawn } from 'child_process';
-import { resolveMcpServerEntrypoint } from '../../../src/mcp/registry.js';
+import { resolveMcpServerEntrypoint } from '../../src/_vendor/mcp/registry.js';
 
 function extractErrorText(result) {
   const chunks = Array.isArray(result?.content) ? result.content : [];

package/package.json

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

package/src/agent-manager.js

@@ -16,6 +16,7 @@ import { injectWorkspaceContext } from './drivers/claude.js';
 import { parseKimiLine, encodeKimiStdin } from './drivers/kimi.js';
 import { startSession, stopSession, stopAllSessions } from './browser-login.js';
 import { markInvalidatedLeases } from './governance-state.js';
+import { runPublishJob } from './publish-job-runner.js';
 
 const KIMI_SYSTEM_PROMPT_FILE = '.lightcone-kimi-system.md';
 const KIMI_AGENT_FILE = '.lightcone-kimi-agent.yaml';
@@ -156,6 +157,7 @@ export class AgentManager {
       case 'agent:start':       return this._startAgent(msg, connection);
       case 'agent:stop':        return this._stopAgent(msg.agentId, msg.workspaceId, connection);
       case 'agent:deliver':     return this._deliverMessage(msg, connection);
+      case 'publish:job':       return this._handlePublishJob(msg, connection);
       case 'browser:start_login': return this._startBrowserLogin(msg, connection);
       case 'browser:stop_login':  return this._stopBrowserLogin(msg);
       case 'policy_invalidate':   return this._handlePolicyInvalidate(msg, connection);
@@ -1005,6 +1007,96 @@ export class AgentManager {
     }
   }
 
+  async _postInternalActionComplete({ agentId, actionId, ok, result, error }) {
+    const url = `${this.serverUrl.replace(/\/$/, '')}/internal/agent/${encodeURIComponent(agentId)}/actions/${encodeURIComponent(actionId)}/complete`;
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${this.machineApiKey}`,
+      },
+      body: JSON.stringify({ ok, result, error }),
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`action complete failed (${res.status}): ${text}`);
+    }
+    return res.json();
+  }
+
+  async _handlePublishJob(msg, connection) {
+    const job = normalizeObject(msg.job);
+    const jobId = String(job.id ?? '').trim();
+    const actionId = String(job.approval_action_id ?? '').trim();
+    const agentId = String(job.agent_id ?? '').trim();
+    const workspaceId = String(job.workspace_id ?? '').trim() || null;
+
+    if (!jobId || !actionId || !agentId) {
+      console.warn('[AgentManager] publish:job missing required fields (id, approval_action_id, agent_id)');
+      return;
+    }
+
+    connection.send({
+      type: 'publish:job_status',
+      job_id: jobId,
+      action_id: actionId,
+      status: 'running',
+      started_at: new Date().toISOString(),
+    });
+
+    try {
+      const workspaceDir = this._workspaceDir(agentId, workspaceId);
+      const publishResult = await runPublishJob({
+        serverUrl: this.serverUrl,
+        machineApiKey: this.machineApiKey,
+        agentId,
+        workspaceDir,
+        job,
+      });
+
+      await this._postInternalActionComplete({
+        agentId,
+        actionId,
+        ok: true,
+        result: publishResult.completionResult,
+        error: null,
+      });
+
+      connection.send({
+        type: 'publish:job_status',
+        job_id: jobId,
+        action_id: actionId,
+        status: 'succeeded',
+        completed_at: new Date().toISOString(),
+        result: publishResult.completionResult,
+      });
+    } catch (err) {
+      const errorMessage = err?.message ?? String(err);
+      try {
+        await this._postInternalActionComplete({
+          agentId,
+          actionId,
+          ok: false,
+          result: null,
+          error: errorMessage,
+        });
+      } catch (completeErr) {
+        console.error(
+          `[AgentManager] Failed to report publish job completion for action=${actionId}: ${completeErr.message}`
+        );
+      }
+
+      connection.send({
+        type: 'publish:job_status',
+        job_id: jobId,
+        action_id: actionId,
+        status: 'failed',
+        completed_at: new Date().toISOString(),
+        error: errorMessage,
+      });
+    }
+  }
+
   _stopAgent(agentId, workspaceId, connection) {
     const key = this._key(agentId, workspaceId);
     const agent = this.agents.get(key);

package/src/chat-bridge.js

@@ -1580,6 +1580,15 @@ server.tool('execute_approved_action',
     try {
       const data = await api('POST', `/actions/${action_id}/execute`, {});
       if (data.error) return { isError: true, content: [{ type: 'text', text: `Failed: ${data.error}` }] };
+      if (data?.execution?.mode === 'user_daemon_job') {
+        return { content: [{ type: 'text', text:
+          `Action approved. Publish has been routed to a user-side daemon job.\n` +
+          `actionType=${data.actionType} platform=${data.platform}\n` +
+          `publish_job_id=${data.execution.publish_job_id} target_machine_id=${data.execution.target_machine_id}\n` +
+          `status=${data.execution.status}\n` +
+          `Do not call publish_content for this action_id again; wait for the daemon job result.`
+        }]};
+      }
       return { content: [{ type: 'text', text:
         `Action approved. Now call the appropriate platform tool with approval_action_id="${action_id}" to actually perform the operation.\n` +
         `actionType=${data.actionType} platform=${data.platform}\n` +

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;
+  }
+}