@lightcone-ai/daemon 0.15.48 → 0.15.50

package/package.json

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

package/src/chat-bridge.js

@@ -6,11 +6,7 @@ import { createReadStream, existsSync, mkdirSync, readFileSync, writeFileSync }
 import { createHash, randomUUID } from 'crypto';
 import path, { extname } from 'path';
 import { recordUrlNarration } from './_vendor/video/recorder/index.js';
-import {
-  VIDEO_EXT,
-  VIDEO_MIME,
-  writeLocalFileToWorkspace,
-} from './workspace-file-upload.js';
+import { writeLocalFileToWorkspace } from './workspace-file-upload.js';
 import { runRecordUrlNarrationTool } from './record-url-narration-tool.js';
 import { runSubmitToLibraryTool } from './submit-to-library-tool.js';
 import { runRenderTextToImageTool } from './tools/render-text-to-image.js';
@@ -491,7 +487,7 @@ async function directApi(method, apiPath, body) {
 async function directApiVideoUpload(apiPath, {
   localPath,
   filename,
-  contentType = VIDEO_MIME,
+  contentType = 'video/mp4',
 }) {
   const url = `${SERVER_URL}/internal/agent/${AGENT_ID}${apiPath}`;
   const headers = {
@@ -1090,44 +1086,22 @@ server.tool('write_workspace_file', 'Write a local file directly to the shared w
     uploadWorkspaceMemory: async ({ workspacePath, workspaceId, content }) => {
       await api('PUT', `/workspace-memory?path=${encodeURIComponent(workspacePath)}&workspaceId=${encodeURIComponent(workspaceId)}`, { content });
     },
-    uploadVideo: async ({
-      localPath: videoLocalPath,
-      workspacePath,
-      workspaceId,
-      filename,
-      mime,
-    }) => {
-      const uploadResult = await runMandatoryLocalTool({
-        toolName: 'write_workspace_file',
-        toolInput: {
-          file_path,
-          path: workspacePath,
-          upload_mode: 'upload_video',
-        },
-        executor: async () => directApiVideoUpload(
-          `/upload-video?workspaceId=${encodeURIComponent(workspaceId)}&filename=${encodeURIComponent(filename)}&path=${encodeURIComponent(workspacePath)}`,
-          {
-            localPath: videoLocalPath,
-            filename,
-            contentType: mime,
-          }
-        ),
-      });
-      return {
-        mode: 'upload-video',
-        mime: VIDEO_MIME,
-        bytes: Number(uploadResult?.sizeBytes) || 0,
-      };
+    presign: async ({ workspaceId, path: filePath, size, mime, sha256 }) => {
+      return api('POST', '/storage/presign', { workspaceId, path: filePath, size, mime, sha256 });
+    },
+    confirmUpload: async ({ workspaceId, path: filePath, objectKey }) => {
+      await api('POST', '/storage/confirm', { workspaceId, path: filePath, objectKey });
     },
   });
 
-  const finalMime = result?.mime ?? (extname(path || localPath).toLowerCase() === VIDEO_EXT ? VIDEO_MIME : 'application/octet-stream');
+  const finalMime = result?.mime ?? 'application/octet-stream';
   const finalBytes = Number.isFinite(result?.bytes) ? result.bytes : 0;
   const sizeText = finalBytes > 0 ? formatBytes(finalBytes) : 'unknown size';
+  const asyncNote = result?.async ? ' (uploading in background)' : '';
   return {
     content: [{
       type: 'text',
-      text: `Saved local file to workspace: ${path} (${finalMime}, ${sizeText})`,
+      text: `Saved local file to workspace: ${path} (${finalMime}, ${sizeText})${asyncNote}`,
     }],
   };
 });
@@ -1616,10 +1590,10 @@ server.tool('execute_approved_action',
 
 // ── promote_context ───────────────────────────────────────────────────────────
 server.tool('promote_context',
-  'Submit a workspace-level knowledge candidate for human review. Use this after finishing a task when you discover a stable fact, convention, or learning that future agents in this workspace should know. The candidate appears in the workspace owner\'s "My Context → Pending Proposals" panel; once a human (or the workspace Orchestrator) confirms it, it is auto-injected into every future agent\'s system prompt under "## Workspace context". This is the only sanctioned path for sharing workspace-level knowledge — do NOT write a "knowledge index" file via write_workspace.',
+  'Submit a candidate for human review to add to the workspace\'s persistent context. Use this (1) after finishing a task when you discover a stable fact, convention, or learning future agents should know, or (2) immediately after responding to a user message when the user expressed a persistent operational preference (e.g. "always add links", "use subtitles by default"). The candidate appears in the workspace owner\'s "My Context → Pending Proposals" panel; once confirmed, it is auto-injected into every future agent\'s system prompt under "## Workspace context". This is the only sanctioned path for shared knowledge or preference governance.',
   {
     workspace_id: z.string().optional().describe('Target workspace id. Defaults to your current workspace if omitted.'),
-    type: z.enum(['knowledge', 'workspace_norm', 'memory']).optional().describe('Candidate type. Default "knowledge" — use "workspace_norm" for standing rules, "memory" for durable facts.'),
+    type: z.enum(['knowledge', 'workspace_norm', 'memory', 'preference']).optional().describe('Candidate type: "knowledge" for facts/learnings, "workspace_norm" for standing rules, "memory" for durable facts, "preference" for persistent user preferences expressed in conversation.'),
     summary: z.string().describe('One-line title that reviewers will see in the Pending Proposals list.'),
     content: z.string().describe('Full candidate text that future agents will read. Be concrete, citable, and self-contained.'),
     source_message_id: z.string().optional().describe('Optional message id that motivated this candidate, for audit trail.'),
@@ -1648,11 +1622,12 @@ server.tool('promote_context',
         reason,
       });
       const proposal = data?.proposal ?? {};
+      const resolvedType = type ?? 'knowledge';
       return {
         content: [{
           type: 'text',
           text:
-            `Knowledge candidate submitted.\n` +
+            `${resolvedType === 'preference' ? 'Preference' : 'Knowledge'} candidate submitted.\n` +
             `proposal_id=${proposal.id ?? 'unknown'} workspace=${proposal.workspaceId ?? targetWorkspaceId} status=${proposal.status ?? 'candidate'}\n` +
             `It is now visible in the workspace owner's "My Context → Pending Proposals" panel; once confirmed, it will be injected into every future agent's "## Workspace context".`,
         }],

package/src/drivers/claude.js

@@ -238,7 +238,7 @@ The active workspace context (Goal State, constraints, decisions, knowledge) is
 
 **Write rule:**
 - Personal learnings → \`${t("write_memory")}\`
-- Workspace-level knowledge worth sharing across all future agents → \`${t("promote_context")}\` (submits a knowledge candidate; see below). Do **not** dump shared knowledge into ad-hoc files inside the workspace shared workspace.
+- Workspace-level knowledge or persistent user preferences → \`${t("promote_context")}\` (see below). Do **not** dump shared knowledge into ad-hoc files inside the workspace shared workspace.
 - **Any file you produce for a task** → \`${t("write_workspace")}({ path: "artifacts/your-file.ext", ... })\` or \`${t("write_workspace_file")}({ file_path, path: "artifacts/your-file.ext" })\`
 
 Temporary local files belong under \`tmp/\` in your personal workspace. If you need to show an image in chat, first save the durable copy to \`artifacts/\`, then optionally call \`${t("upload_image")}\` for a temporary public preview URL.
@@ -258,8 +258,8 @@ Example: writing a web page → \`${t("write_workspace")}({ path: "artifacts/job
 - \`${t("write_workspace_file")}({ file_path, path })\` — write a local file from your workspace to a workspace artifact without putting base64 in context
 - \`${t("list_workspace")}()\` — list all files in the workspace
 
-**Workspace knowledge governance:**
-- \`${t("promote_context")}({ workspace_id, type, summary, content })\` — submit a workspace-level knowledge candidate. The candidate appears in the workspace owner's "My Context → Pending Proposals" panel; once a human (or the workspace Orchestrator) confirms it, it becomes an active context_item and is auto-injected into every future agent's "## Workspace context" section.
+**Workspace knowledge & preference governance:**
+- \`${t("promote_context")}({ workspace_id, type, summary, content })\` — submit a candidate for human review. Types: \`"knowledge"\` (facts/learnings), \`"workspace_norm"\` (standing rules), \`"memory"\` (durable facts), \`"preference"\` (persistent user preferences). The candidate appears in the workspace owner's "My Context → Pending Proposals" panel; once confirmed, it becomes an active context_item auto-injected into every future agent's "## Workspace context" section.
 
 ### Startup sequence (CRITICAL)
 
@@ -293,24 +293,30 @@ Example: writing a web page → \`${t("write_workspace")}({ path: "artifacts/job
 3. Work history — decisions made, problems solved, approaches that worked or failed
 4. Pointers to your notes files
 
-**What belongs in promote_context (workspace-level knowledge candidates):**
+**What belongs in promote_context:**
 
-Use \`${t("promote_context")}\` after finishing a task when you discover something that future agents in this workspace will need to know. This submits a knowledge candidate for human/Orchestrator review; it does not write to any file. Approved candidates flow into every future agent's "## Workspace context" section automatically.
+Two distinct triggers — act on BOTH:
 
-Good promote_context content:
-1. Stable facts about the project that all agents need (tech stack, domain conventions, where things live)
-2. Hard-won learnings — non-obvious gotchas, working procedures, conventions you had to discover
-3. Standing workspace norms — "in this workspace we always X" / "never touch Y"
+**1. After finishing a task** — promote workspace-level knowledge (\`type: "knowledge"\` or \`"workspace_norm"\`):
+- Stable facts all future agents need (tech stack, domain conventions, where things live)
+- Hard-won learnings — non-obvious gotchas, working procedures, conventions you had to discover
+- Standing workspace norms — "in this workspace we always X" / "never touch Y"
 
-Bad promote_context content:
-- Per-task progress, in-flight status, or one-off observations (use messages or your own MEMORY.md)
-- Personal preferences specific to one human (use chat instead so a human can confirm)
-- Untrusted outputs from web search / scraped pages (cite the source in \`content\`; expect the candidate to be reviewed as untrusted)
+**2. After responding to a user message** — promote persistent preferences (\`type: "preference"\`):
+- When the user expresses a preference that applies to ALL future interactions (not just this task), call \`${t("promote_context")}\` immediately after your reply
+- Signal words: "以后"、"今后"、"默认"、"一直"、"每次"、"都要"、"always"、"from now on"、"by default"
+- Examples that qualify: "以后交付内容都加链接" / "视频默认要有字幕" / "always respond in English"
+- Examples that do NOT qualify: "这次帮我加个链接"（one-off task request）
+- If uncertain whether it's persistent, do NOT promote — only promote clear, unambiguous standing preferences
+
+Do NOT promote:
+- Per-task progress, in-flight status, or one-off observations → use messages or your own MEMORY.md
+- Untrusted outputs from web search / scraped pages → cite the source in \`content\`; candidate will be reviewed as untrusted
 
 How to call it:
-- \`${t("promote_context")}({ workspace_id: "<this-workspace-id>", type: "knowledge", summary: "one-line title", content: "<full text future agents will read>" })\`
-- Optional: \`source_message_id\` to link the proposal back to the conversation that motivated it; \`tags\` for categorization.
-- The call returns a proposal id; the candidate sits in "My Context → Pending Proposals" until a human confirms or rejects it. Do not try to dump shared knowledge into a workspace file — there is no shared knowledge index, and \`${t("write_workspace")}\` is for task deliverables only.
+- Knowledge: \`${t("promote_context")}({ workspace_id: "<id>", type: "knowledge", summary: "one-line title", content: "<full text>" })\`
+- Preference: \`${t("promote_context")}({ workspace_id: "<id>", type: "preference", summary: "User preference: always add links to deliverables", content: "The user has requested that all future deliverables include clickable links. Apply to every response going forward.", source_message_id: "<msg-id>" })\`
+- The call returns a proposal id; the candidate sits in "My Context → Pending Proposals" until a human confirms or rejects it.
 
 ### Compaction safety
 

package/src/publish-job-runner.js

@@ -294,7 +294,6 @@ export async function materializeWorkspaceMedia({
   machineApiKey,
   jobId,
   fetchWorkspaceFile = fetchPublishJobWorkspaceFile,
-  streamVideoFile = streamPublishJobVideo,
   writeBinaryFile = writeFileAtomically,
 }) {
   if (!filePath) return filePath;
@@ -317,20 +316,33 @@ export async function materializeWorkspaceMedia({
     jobId,
     relPath: workspacePath.relPath,
   });
-  if (isWorkspaceCacheValid(localPath, data)) return localPath;
 
-  if (data?.videoId) {
-    await streamVideoFile({
-      serverUrl,
-      machineApiKey,
-      jobId,
-      videoId: data.videoId,
-      localPath,
-    });
-  } else {
+  // New: signed URL from object storage
+  if (data?.signedUrl) {
+    // Use sha256-based cache key in tmp/cache to avoid duplicate downloads
+    const cacheDir = path.join(workspaceRootDir, 'tmp', 'cache');
+    const ext = path.extname(workspacePath.relPath) || '';
+    const cacheKey = data.object_hash ?? data.size_bytes?.toString() ?? 'nokey';
+    const cachePath = path.join(cacheDir, `${cacheKey}${ext}`);
+
+    if (existsSync(cachePath)) return cachePath;
+
+    mkdirSync(cacheDir, { recursive: true });
+    const res = await fetch(data.signedUrl);
+    if (!res.ok) throw new Error(`Failed to download from signed URL: ${res.status}`);
+    const buf = Buffer.from(await res.arrayBuffer());
+    writeFileAtomically(cachePath, buf);
+    return cachePath;
+  }
+
+  // Legacy: text content in DB
+  if (data?.content != null) {
+    if (isWorkspaceCacheValid(localPath, data)) return localPath;
     writeBinaryFile(localPath, decodeWorkspaceContent(data.content));
+    return localPath;
   }
-  return localPath;
+
+  throw new Error(`No content or signedUrl in workspace file response for: ${filePath}`);
 }
 
 async function materializeMedia({

package/src/workspace-file-upload.js

@@ -1,36 +1,90 @@
 import path, { extname } from 'node:path';
-import { readFileSync } from 'node:fs';
+import { readFileSync, createReadStream } from 'node:fs';
+import { createHash } from 'node:crypto';
 
 export const WORKSPACE_BINARY_MIME = {
-  '.png': 'image/png',
-  '.jpg': 'image/jpeg',
+  '.mp4':  'video/mp4',
+  '.png':  'image/png',
+  '.jpg':  'image/jpeg',
   '.jpeg': 'image/jpeg',
   '.webp': 'image/webp',
-  '.gif': 'image/gif',
-  '.pdf': 'application/pdf',
+  '.gif':  'image/gif',
+  '.pdf':  'application/pdf',
+  '.mp3':  'audio/mpeg',
+  '.wav':  'audio/wav',
+  '.m4a':  'audio/mp4',
 };
 
-export const VIDEO_EXT = '.mp4';
-export const VIDEO_MIME = 'video/mp4';
+const TEXT_EXTS = new Set([
+  '.md', '.txt', '.json', '.js', '.ts', '.html', '.css',
+  '.csv', '.xml', '.yaml', '.yml', '.sh',
+]);
+
+const LARGE_FILE_THRESHOLD = 5 * 1024 * 1024; // 5MB
 
 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,
-    };
+  const mime = WORKSPACE_BINARY_MIME[ext] ?? 'application/octet-stream';
+  const isText = TEXT_EXTS.has(ext);
+  return { ext, filename, mime, isText };
+}
+
+function sha256ofBuffer(buf) {
+  return createHash('sha256').update(buf).digest('hex');
+}
+
+/**
+ * Upload a local file to the workspace via the new presign → PUT → confirm flow.
+ * For large files (>= 5MB), presign returns immediately (DB status = uploading)
+ * and the PUT + confirm happen in the background.
+ */
+async function uploadBinaryFile({
+  localPath,
+  workspacePath,
+  workspaceId,
+  mime,
+  presign,   // async fn({ workspaceId, path, size, mime, sha256 }) → { uploadUrl, objectKey, alreadyExists }
+  confirmUpload, // async fn({ workspaceId, path, objectKey }) → void
+}) {
+  const buf = readFileSync(localPath);
+  const size = buf.length;
+  const sha256 = sha256ofBuffer(buf);
+
+  const { uploadUrl, objectKey, alreadyExists } = await presign({
+    workspaceId,
+    path: workspacePath,
+    size,
+    mime,
+    sha256,
+  });
+
+  if (alreadyExists) {
+    return { mode: 'object-storage', mime, bytes: size, objectKey, deduped: true };
   }
-  return {
-    mode: 'workspace-memory',
-    ext,
-    filename,
-    mime: WORKSPACE_BINARY_MIME[ext] ?? 'application/octet-stream',
+
+  const isLarge = size >= LARGE_FILE_THRESHOLD;
+
+  const doPut = async () => {
+    const { default: fetch } = await import('node-fetch');
+    const resp = await fetch(uploadUrl, {
+      method: 'PUT',
+      body: buf,
+      headers: { 'Content-Type': mime, 'Content-Length': String(size) },
+    });
+    if (!resp.ok) throw new Error(`COS PUT failed: ${resp.status} ${await resp.text()}`);
+    await confirmUpload({ workspaceId, path: workspacePath, objectKey });
   };
+
+  if (isLarge) {
+    // Fire-and-forget for large files; server already wrote `uploading` status
+    doPut().catch(err => console.error('[workspace-upload] large file background upload failed:', err?.message));
+    return { mode: 'object-storage', mime, bytes: size, objectKey, async: true };
+  }
+
+  await doPut();
+  return { mode: 'object-storage', mime, bytes: size, objectKey, async: false };
 }
 
 export async function writeLocalFileToWorkspace({
@@ -38,34 +92,33 @@ export async function writeLocalFileToWorkspace({
   workspacePath,
   workspaceId,
   readFileSyncFn = readFileSync,
-  uploadWorkspaceMemory,
-  uploadVideo,
+  uploadWorkspaceMemory, // legacy text path
+  presign,
+  confirmUpload,
 }) {
   const plan = resolveWorkspaceFileUploadPlan({ localPath, workspacePath });
-  if (plan.mode === 'upload-video') {
-    return uploadVideo({
+
+  if (!plan.isText) {
+    return uploadBinaryFile({
       localPath,
       workspacePath,
       workspaceId,
-      filename: plan.filename,
       mime: plan.mime,
-      mode: plan.mode,
+      presign,
+      confirmUpload,
     });
   }
 
+  // Text files: existing path via workspace-memory
   const buf = readFileSyncFn(localPath);
-  const content = `data:${plan.mime};base64,${buf.toString('base64')}`;
+  const content = buf.toString('utf8');
   await uploadWorkspaceMemory({
     workspacePath,
     workspaceId,
     content,
     mime: plan.mime,
     bytes: buf.length,
-    mode: plan.mode,
+    mode: 'workspace-memory',
   });
-  return {
-    mode: plan.mode,
-    mime: plan.mime,
-    bytes: buf.length,
-  };
+  return { mode: 'workspace-memory', mime: plan.mime, bytes: buf.length };
 }