@vantran-se/openchamber-web 1.24.3 → 2.0.1

package/server/lib/scheduled-tasks/runtime.js

@@ -1,4 +1,4 @@
-import { createOpencodeClient } from '@opencode-ai/sdk/v2';
+import { OpenCode } from '@opencode/client';
 import { DateTime } from 'luxon';
 import { CronExpressionParser } from 'cron-parser';
 import { expandSnippets } from '../opencode/snippets.js';
@@ -255,12 +255,27 @@ export const createScheduledTasksRuntime = (deps) => {
     emitTaskRunEvent,
     setSessionAutoAccept,
     sessionKnowledgeRuntime = null,
+    // The goal record lives in OpenChamber's metadata store (OpenCode 2.x takes
+    // session metadata only at create time); without it goal mode cannot run.
+    persistSessionGoal = null,
     logger = console,
     maxGlobalConcurrency = DEFAULT_GLOBAL_CONCURRENCY,
     maxProjectConcurrency = DEFAULT_PROJECT_CONCURRENCY,
     maxRunDurationMs = DEFAULT_MAX_RUN_MS,
   } = deps;
 
+  // Every OpenCode route lives under /api in v2 and the client appends it, so
+  // the client only wants the origin. Directory scoping is a request header.
+  const openCodeOrigin = () => new URL(buildOpenCodeUrl('/api/info', '')).origin;
+  const createScopedClient = (directory) => OpenCode.make({
+    baseUrl: openCodeOrigin(),
+    headers: {
+      ...getOpenCodeAuthHeaders(),
+      ...(directory ? { 'x-opencode-directory': encodeURIComponent(directory) } : {}),
+    },
+    fetch,
+  });
+
   let started = false;
   const tasksByProject = new Map();
   const projectPathByID = new Map();
@@ -461,61 +476,45 @@ export const createScheduledTasksRuntime = (deps) => {
     return projectRunning < maxProjectConcurrency;
   };
 
-  const buildPromptAsyncPayload = (task, projectPath, knowledgeText = '') => ({
-    model: {
-      providerID: task.execution.providerID,
-      modelID: task.execution.modelID,
-    },
-    ...(task.execution.agent ? { agent: task.execution.agent } : {}),
-    ...(task.execution.variant ? { variant: task.execution.variant } : {}),
-    parts: [
-      // Standing project context first, so the prompt reads against it. A
-      // scheduled run has no UI to attach this, which is why it is asked for
-      // here rather than assembled by whoever is sending.
-      ...(knowledgeText ? [{ type: 'text', text: knowledgeText, synthetic: true }] : []),
-      {
-        type: 'text',
-        text: expandSnippets(task.execution.prompt, projectPath),
-      },
-      ...(task.execution.goalEnabled
-        ? [{ type: 'text', text: buildGoalIntroText(task.execution.goalTokenBudget), synthetic: true }]
-        : []),
-    ],
-  });
-
-  const runPromptAsync = async ({ baseUrl, authHeaders, sessionID, projectPath, task }) => {
-    // Never allowed to fail the run: a task that executes without its
-    // background is a lesser loss than a task that does not execute.
-    const knowledge = sessionKnowledgeRuntime
-      ? await sessionKnowledgeRuntime.resolvePendingForSession(sessionID, projectPath)
-        .catch(() => ({ text: '', signature: '' }))
-      : { text: '', signature: '' };
-
-    const promptUrl = new URL(`${baseUrl}/session/${encodeURIComponent(sessionID)}/prompt_async`);
-    promptUrl.searchParams.set('directory', projectPath);
-    const response = await fetch(promptUrl.toString(), {
-      method: 'POST',
-      headers: {
-        ...authHeaders,
-        'content-type': 'application/json',
-        accept: 'application/json',
-      },
-      body: JSON.stringify(buildPromptAsyncPayload(task, projectPath, knowledge.text)),
-    });
-
-    if (!response.ok) {
-      const body = await response.text().catch(() => '');
-      throw new Error(`prompt_async failed (${response.status})${body ? `: ${body}` : ''}`);
-    }
+  // Never allowed to fail the run: a task that executes without its
+  // background is a lesser loss than a task that does not execute.
+  const resolveKnowledge = (sessionID, projectPath) => (sessionKnowledgeRuntime
+    ? sessionKnowledgeRuntime.resolvePendingForSession(sessionID, projectPath)
+      .catch(() => ({ text: '', signature: '' }))
+    : Promise.resolve({ text: '', signature: '' }));
 
-    // Recorded only after the prompt is accepted, so a failed dispatch carries
-    // the context again on the next run.
+  // Recorded only after the send is accepted, so a failed dispatch carries
+  // the context again on the next run.
+  const recordKnowledge = async (sessionID, projectPath, knowledge) => {
     if (knowledge.text && sessionKnowledgeRuntime) {
       await sessionKnowledgeRuntime.recordDelivered(sessionID, projectPath, knowledge.signature)
         .catch(() => undefined);
     }
   };
 
+  const runPrompt = async ({ client, sessionID, projectPath, task }) => {
+    const knowledge = await resolveKnowledge(sessionID, projectPath);
+
+    // A v2 prompt carries a single authored text. Standing project context and
+    // the goal briefing therefore travel as synthetic messages sent first, so
+    // the model still reads the prompt against them exactly as before. A
+    // synthetic message schedules execution unless `resume: false`: without
+    // it the model would start on the briefing alone, before the task arrived.
+    if (knowledge.text) {
+      await client.session.synthetic({ sessionID, text: knowledge.text, resume: false });
+    }
+    if (task.execution.goalEnabled) {
+      await client.session.synthetic({ sessionID, text: buildGoalIntroText(task.execution.goalTokenBudget), resume: false });
+    }
+
+    await client.session.prompt({
+      sessionID,
+      text: expandSnippets(task.execution.prompt, projectPath),
+    });
+
+    await recordKnowledge(sessionID, projectPath, knowledge);
+  };
+
   const resolveScheduledCommand = async ({ client, projectPath, task }) => {
     const parsed = parseScheduledCommandPrompt(task?.execution?.prompt);
     if (!parsed) {
@@ -524,27 +523,35 @@ export const createScheduledTasksRuntime = (deps) => {
 
     let commands = [];
     try {
-      const response = await client.command.list({ directory: projectPath });
+      const response = await client.command.list({ location: { directory: projectPath } });
       commands = Array.isArray(response?.data) ? response.data : [];
     } catch {
       return null;
     }
 
+    // v2 CommandInfo carries no template, so a goal objective distilled from
+    // the command body is no longer available; the goal falls back to the
+    // prompt text, which expandCommandGoalObjective already handles.
     const command = commands.find((candidate) => candidate?.name === parsed.command);
     return command ? { ...parsed, template: command.template } : null;
   };
 
-  const runScheduledCommand = async ({ client, projectPath, sessionID, task, command }) => {
+  const runScheduledCommand = async ({ client, sessionID, projectPath, command }) => {
+    // The command route takes no extra parts, so standing context goes in
+    // first as a synthetic message that does not start execution.
+    const knowledge = await resolveKnowledge(sessionID, projectPath);
+    if (knowledge.text) {
+      await client.session.synthetic({ sessionID, text: knowledge.text, resume: false });
+    }
+    // Agent, model and variant are session properties in v2 and were already
+    // set when the run created the session; the command body only carries text.
     await client.session.command({
       sessionID,
-      directory: projectPath,
-      command: command.command,
-      arguments: command.arguments,
-      ...(task.execution.agent ? { agent: task.execution.agent } : {}),
-      model: `${task.execution.providerID}/${task.execution.modelID}`,
-      ...(task.execution.variant ? { variant: task.execution.variant } : {}),
+      // OpenCode 2.0.8 renamed the command body field `command` to `name`.
+      name: command.command,
+      text: command.arguments,
     });
-
+    await recordKnowledge(sessionID, projectPath, knowledge);
   };
 
   const runTaskWithWatchdog = async (projectID, task, reason) => {
@@ -559,18 +566,23 @@ export const createScheduledTasksRuntime = (deps) => {
       await waitForOpenCodeReady(10_000, 250);
     }
 
-    const baseUrl = buildOpenCodeUrl('/', '').replace(/\/$/, '');
+    const baseUrl = openCodeOrigin();
     const authHeaders = getOpenCodeAuthHeaders();
-    const client = createOpencodeClient({
-      baseUrl,
-      headers: authHeaders,
-    });
+    const client = createScopedClient(projectPath);
 
-    const sessionResponse = await client.session.create({
-      directory: projectPath,
+    // Agent, model and variant belong to the session in v2: a scheduled run
+    // fixes them here instead of repeating them on every prompt.
+    const session = await client.session.create({
       title,
+      location: { directory: projectPath },
+      model: {
+        providerID: task.execution.providerID,
+        id: task.execution.modelID,
+        ...(task.execution.variant ? { variant: task.execution.variant } : {}),
+      },
+      ...(task.execution.agent ? { agent: task.execution.agent } : {}),
     });
-    const sessionID = sessionResponse?.data?.id;
+    const sessionID = session?.id;
     if (!sessionID) {
       throw new Error('failed to create session');
     }
@@ -606,6 +618,7 @@ export const createScheduledTasksRuntime = (deps) => {
       await createSessionGoal({
         baseUrl,
         authHeaders,
+        persistSessionGoal,
         sessionID,
         directory: projectPath,
         objective: commandObjective ?? expandSnippets(task.execution.prompt, projectPath),
@@ -617,15 +630,9 @@ export const createScheduledTasksRuntime = (deps) => {
     }
 
     if (scheduledCommand) {
-      await runScheduledCommand({ client, projectPath, sessionID, task, command: scheduledCommand });
+      await runScheduledCommand({ client, sessionID, projectPath, command: scheduledCommand });
     } else {
-      await runPromptAsync({
-        baseUrl,
-        authHeaders,
-        sessionID,
-        projectPath,
-        task,
-      });
+      await runPrompt({ client, sessionID, projectPath, task });
     }
 
     const finishedAt = Date.now();

package/server/lib/scheduled-tasks/runtime.test.js

@@ -1,4 +1,4 @@
-import { describe, expect, it, vi } from 'vitest';
+import { afterEach, describe, expect, it, vi } from 'vitest';
 import os from 'os';
 import path from 'path';
 import { mkdtemp, rm, mkdir, writeFile } from 'fs/promises';
@@ -273,3 +273,55 @@ Run daily.
     }
   });
 });
+
+describe('scheduled-tasks runtime prompt dispatch', () => {
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it('parks the briefing with resume: false so execution starts on the task prompt', async () => {
+    const posts = [];
+    vi.stubGlobal('fetch', vi.fn(async (input, init = {}) => {
+      const { pathname } = new URL(String(input));
+      if (init.method === 'POST') posts.push({ pathname, body: JSON.parse(init.body) });
+      const data = pathname === '/api/session' ? { id: 'ses_run' } : pathname === '/api/command' ? [] : {};
+      return new Response(JSON.stringify({ location: { directory: '/repo' }, data }), { status: 200, headers: { 'content-type': 'application/json' } });
+    }));
+    const task = {
+      id: 'task-1',
+      name: 'Nightly',
+      enabled: true,
+      schedule: { kind: 'daily', times: ['03:00'], timezone: 'UTC' },
+      execution: { prompt: 'Review open issues', providerID: 'openai', modelID: 'gpt-5', goalEnabled: true, goalTokenBudget: 50_000 },
+      state: { createdAt: 1, updatedAt: 1 },
+    };
+    const runtime = createScheduledTasksRuntime({
+      projectConfigRuntime: {
+        listScheduledTasks: async () => [task],
+        reconcileLoopTasks: async () => [task],
+        updateScheduledTaskState: async () => ({ task, updated: true }),
+        updateScheduledTaskStateIf: async () => ({ task, updated: true }),
+      },
+      listProjects: async () => [{ id: 'proj', path: '/repo' }],
+      buildOpenCodeUrl: () => 'http://127.0.0.1:1/',
+      getOpenCodeAuthHeaders: () => ({}),
+      waitForOpenCodeReady: async () => {},
+      persistSessionGoal: async () => undefined,
+      sessionKnowledgeRuntime: {
+        resolvePendingForSession: async () => ({ text: 'Project background', signature: 'sig' }),
+        recordDelivered: async () => undefined,
+      },
+      logger: { info: () => {}, warn: () => {}, error: () => {} },
+    });
+    await runtime.start();
+    await runtime.runNow('proj', 'task-1');
+    runtime.stop();
+
+    const dispatch = posts.filter((post) => post.pathname.startsWith('/api/session/ses_run/'));
+    expect(dispatch.map((post) => post.pathname.split('/').at(-1))).toEqual(['synthetic', 'synthetic', 'prompt']);
+    expect(dispatch[0].body).toMatchObject({ text: 'Project background', resume: false });
+    expect(dispatch[1].body.resume).toBe(false);
+    expect(dispatch[2].body).toMatchObject({ text: 'Review open issues' });
+    expect(dispatch[2].body.resume).toBeUndefined();
+  });
+});

package/server/lib/session-assist/DOCUMENTATION.md

@@ -28,9 +28,14 @@ bringing an entire old task back into the prompt. This was compared against
 one, five, ten, and full-history contexts on long maintainer sessions. There
 is no full-history cache and no assumed provider prefix-cache behavior.
 
-The latest record must be a completed, successful, non-summary assistant answer
-with visible text. Child, archived, and reverted sessions are skipped. A new
-prompt clears the revert boundary before its next idle event.
+The latest content record must be a completed, successful, non-summary
+assistant answer with visible text. OpenCode closes every turn with an `idle`
+record and appends agent/model/location switches as records of their own;
+`newestContentId` looks past those, both here and in the re-check before the
+write, so an ordinary v2 transcript still ends in its answer. An `idle` whose
+outcome is `failed` or `interrupted` is not skipped: it disqualifies the turn.
+Child, archived, and reverted sessions are skipped. A new prompt clears the
+revert boundary before its next idle event.
 
 Human turns follow chronological message intervals. OpenCode can insert
 synthetic continuation users during compaction, so a final answer's `parentID`

package/server/lib/session-assist/context.js

@@ -23,8 +23,8 @@ export function excerpt(text, limit) {
   return text.slice(0, head) + marker + (tail > 0 ? text.slice(-tail) : '');
 }
 
-function attachedText(part) {
-  const context = part.metadata?.openchamberContext;
+function attachedText(message) {
+  const context = message.metadata?.openchamberContext;
   if (QUOTE_FIELDS.has(context?.kind)) {
     const source = (context[QUOTE_FIELDS.get(context.kind)] ?? '').trim();
     const authored = (context.text ?? '').trim();
@@ -33,8 +33,8 @@ function attachedText(part) {
     const quote = excerpt(source, 4_000).split('\n').map((line) => `> ${line}`).join('\n');
     return { text: `Attached ${context.kind}${label ? ` (${label}${location})` : ''}:\n${quote}\n\nUser comment:\n${excerpt(authored, USER_CHAR_LIMIT)}`, authored };
   }
-  if (LINK_KINDS.has(context?.kind)) return { text: excerpt(part.text, USER_CHAR_LIMIT), authored: '' };
-  const comment = part.metadata?.opencodeComment;
+  if (LINK_KINDS.has(context?.kind)) return { text: excerpt(message.text ?? '', USER_CHAR_LIMIT), authored: '' };
+  const comment = message.metadata?.opencodeComment;
   if (comment) {
     const authored = comment.comment.trim();
     const source = (comment.preview ?? '').trim();
@@ -44,51 +44,119 @@ function attachedText(part) {
   return null;
 }
 
-/** SDK message records are chronological; tool payloads never enter this view. */
-function readMessage({ info, parts }) {
+// Records OpenCode appends around a turn that carry no conversation content:
+// the `idle` marker that closes every turn and the agent/model/location
+// switches. They are invisible to turn boundaries and to "what is the newest
+// message". An `idle` whose outcome is not `succeeded` is not transparent: it
+// is the evidence that the turn failed or was interrupted.
+const TRANSPARENT_TYPES = new Set(['agent-switched', 'model-switched', 'location-switched']);
+
+function isTransparent(record) {
+  if (record?.type === 'idle') return record.outcome === 'succeeded';
+  return TRANSPARENT_TYPES.has(record?.type);
+}
+
+/**
+ * The id of the newest record that is conversation content, given a page in
+ * v2's newest-first order; null when the page holds only service records.
+ * Both the assist reader and the pre-write re-check use it so they agree on
+ * what "the last message" is.
+ */
+export function newestContentId(records) {
+  for (const record of Array.isArray(records) ? records : []) {
+    if (!record?.id || isTransparent(record)) continue;
+    return record.id;
+  }
+  return null;
+}
+
+/**
+ * v2 message records are flat: an assistant message carries `content[]`, a user
+ * message a single `text` plus its attachments, and context items that used to
+ * ride along as `synthetic` text parts are their own `synthetic` messages now.
+ * Tool payloads never enter this view.
+ */
+function readMessage(message) {
+  const role = message.type;
   const blocks = [];
   const authored = [];
-  for (const part of parts) {
-    if (part.type !== 'text' || part.ignored) continue;
-    const attached = info.role === 'user' ? attachedText(part) : null;
+
+  if (role === 'user') {
+    const attached = attachedText(message);
     if (attached) {
       blocks.push(attached.text);
       authored.push(attached.authored);
-    } else if (!part.synthetic) {
-      blocks.push(part.text);
-      if (info.role === 'user') {
-        // Legacy terminal selections are source material, not a language sample.
-        authored.push(part.text.replace(/\n*<terminal_context>\n[\s\S]*?\n<\/terminal_context>\s*$/, ''));
-      }
+    } else if (typeof message.text === 'string') {
+      blocks.push(message.text);
+      // Legacy terminal selections are source material, not a language sample.
+      authored.push(message.text.replace(/\n*<terminal_context>\n[\s\S]*?\n<\/terminal_context>\s*$/, ''));
+    }
+  } else if (role === 'assistant') {
+    for (const part of Array.isArray(message.content) ? message.content : []) {
+      if (part?.type === 'text' && typeof part.text === 'string') blocks.push(part.text);
+    }
+  } else if (role === 'synthetic') {
+    // Context the user attached to the message that follows: in v1 it was a
+    // `synthetic` text part inside the user message, in v2 it is its own turn.
+    const attached = attachedText(message);
+    if (attached) {
+      blocks.push(attached.text);
+      authored.push(attached.authored);
+    } else if (typeof message.text === 'string') {
+      blocks.push(message.text);
     }
   }
+
   return {
-    id: info.id, role: info.role, parentID: info.parentID,
-    providerID: info.providerID, modelID: info.modelID,
-    complete: info.role === 'assistant' && info.finish === 'stop' && Boolean(info.time?.completed) && !info.error && !info.summary,
-    summary: Boolean(info.summary),
-    text: excerpt(blocks.join('\n\n').trim(), info.role === 'user' ? USER_CHAR_LIMIT : ANSWER_CHAR_LIMIT),
+    id: message.id,
+    role,
+    transparent: isTransparent(message),
+    // v2 has no `parentID` on a message: a turn is the run of messages between
+    // one user message and the assistant reply that follows it, which is what
+    // `collectTurns` walks.
+    providerID: message.model?.providerID,
+    modelID: message.model?.id,
+    complete: role === 'assistant'
+      && message.finish === 'stop'
+      && Boolean(message.time?.completed)
+      && !message.error,
+    text: excerpt(blocks.join('\n\n').trim(), role === 'user' ? USER_CHAR_LIMIT : ANSWER_CHAR_LIMIT),
     authored: excerpt(authored.filter(Boolean).join('\n\n').trim(), USER_CHAR_LIMIT),
   };
 }
 
+/**
+ * A turn is one user message and the assistant reply that closes it. v2 dropped
+ * `parentID`, so the boundary is positional: everything between two user
+ * messages belongs to the turn the earlier one opened.
+ *
+ * Synthetic messages are the context the user attached to the message they are
+ * about to send — v1 carried them as parts of that user message — so they are
+ * folded into the next user message instead of opening a turn of their own.
+ */
 function collectTurns(messages) {
   const turns = [];
   let active = null;
-  let parents = new Set();
+  let attached = [];
   for (const message of messages) {
-    if (message.role === 'user' && message.text) {
-      active = { user: message, assistant: null, complete: false };
-      parents = new Set([message.id]);
+    if (message.transparent) continue;
+    if (message.role === 'synthetic') {
+      if (message.text) attached.push(message);
+      continue;
+    }
+    if (message.role === 'user') {
+      const text = [...attached.map((entry) => entry.text), message.text].filter(Boolean).join('\n\n');
+      const authored = [...attached.map((entry) => entry.authored), message.authored].filter(Boolean).join('\n\n');
+      attached = [];
+      if (!text) continue;
+      active = { user: { ...message, text, authored }, assistant: null, complete: false };
       turns.push(active);
-    } else if (active && message.role === 'user') {
-      parents.add(message.id);
-    } else if (active && message.role === 'assistant' && parents.has(message.parentID) && !message.summary) {
-      // Compaction's synthetic continuation users belong to the same human
-      // turn. Parent IDs alone would lose its eventual final answer.
-      if (message.text) active.assistant = message;
-      active.complete = message.complete && Boolean(message.text);
+      continue;
     }
+    attached = [];
+    if (!active || message.role !== 'assistant') continue;
+    if (message.text) active.assistant = message;
+    active.complete = message.complete && Boolean(message.text);
   }
   return turns.slice(-TURN_LIMIT);
 }
@@ -96,32 +164,40 @@ function collectTurns(messages) {
 /** Failure is thrown; null means no eligible final answer within bounded history. */
 export async function loadAssistContext({ readPage, signal }) {
   let messages = [];
-  let before;
+  let cursor;
   const cursors = new Set();
   const ids = new Set();
   for (let pageNumber = 0; pageNumber < MAX_PAGES; pageNumber++) {
     signal.throwIfAborted();
-    const page = await readPage({ limit: PAGE_SIZE, before });
+    // v2 pages messages newest first and returns `{ data, cursor }`.
+    const page = await readPage({ limit: PAGE_SIZE, cursor });
     signal.throwIfAborted();
-    if (!Array.isArray(page.data)) throw new Error('Session message page is unavailable');
+    if (!Array.isArray(page?.data)) throw new Error('Session message page is unavailable');
     const older = [];
     for (const record of page.data) {
-      if (ids.has(record.info.id)) continue;
-      ids.add(record.info.id);
+      if (!record?.id || ids.has(record.id)) continue;
+      ids.add(record.id);
       older.push(readMessage(record));
     }
+    older.reverse();
     messages = older.concat(messages);
-    const last = messages.at(-1);
-    if (!last?.complete || !last.text) return null;
-    const turns = collectTurns(messages);
-    const cursor = page.response.headers.get('x-next-cursor');
-    if (turns.length === TURN_LIMIT || !cursor || pageNumber === MAX_PAGES - 1) {
-      if (!turns.at(-1)?.complete || turns.at(-1).assistant.id !== last.id) return null;
-      return { turns, last };
+    const next = typeof page.cursor?.next === 'string' ? page.cursor.next : null;
+    // A successful turn ends with an `idle` marker after the answer; look past
+    // it and its siblings to the newest content record.
+    const last = messages.findLast((message) => !message.transparent);
+    if (!last) {
+      if (!next || pageNumber === MAX_PAGES - 1) return null;
+    } else {
+      if (!last.complete || !last.text) return null;
+      const turns = collectTurns(messages);
+      if (turns.length === TURN_LIMIT || !next || pageNumber === MAX_PAGES - 1) {
+        if (!turns.at(-1)?.complete || turns.at(-1).assistant.id !== last.id) return null;
+        return { turns, last };
+      }
     }
-    if (cursors.has(cursor)) throw new Error('Session message pagination made no progress');
-    cursors.add(cursor);
-    before = cursor;
+    if (cursors.has(next)) throw new Error('Session message pagination made no progress');
+    cursors.add(next);
+    cursor = next;
   }
   return null;
 }