orca/src/main/opencode/status-plugin-factory-source.ts

import {
  getOpenCode2ModuleSource,
  getOpenCode2EventNormalizationSource
} from '../opencode2/status-plugin-setup-source'

export function getStatusPluginFactorySource(options: {
  emitSessionStart: boolean
  emitNextEvents?: boolean
  expectedAgent?: 'opencode' | 'opencode2'
}): string[] {
  const expectedAgent = options.expectedAgent ?? (options.emitNextEvents ? 'opencode2' : 'opencode')
  // Both variants share a config directory; duplicate plugin IDs would disable one.
  const pluginID = expectedAgent === 'opencode2' ? 'orca-opencode2-status' : 'orca-opencode-status'
  return [
    ...(options.emitNextEvents ? getOpenCode2EventNormalizationSource() : []),
    '// OpenCode may call the factory without context; destructuring would crash startup.',
    'export const OrcaOpenCodeStatusPlugin = async (_ctx) => {',
    `  if (process.env.ORCA_OPENCODE_AGENT && process.env.ORCA_OPENCODE_AGENT !== '${expectedAgent}') return {};`,
    '  const client = _ctx?.client;',
    '  const sessionsOutliveDispose = _ctx?.sessionsOutliveDispose === true;',
    '  const factoryID = ++nextFactoryID;',
    '  activeFactoryIDs.add(factoryID);',
    '  let disposed = false;',
    ...(options.emitNextEvents ? ['  const nextTextByMessageID = new Map();'] : []),
    '  return {',
    '  event: async ({ event }) => {',
    '    if (disposed || !event?.type) return;',
    '    const authorityRevision = stateArrivalRevision;',
    '    const statusType = getStatusType(event);',
    '',
    '    // Cache roles before awaiting lineage: back-to-back part events otherwise see no role.',
    '    if (event.type === "message.updated") {',
    '      const info = event.properties && event.properties.info;',
    '      rememberMessageRole(info && info.id, info && info.role);',
    '    }',
    '',
    '    const sessionID = event.properties?.sessionID;',
    '    const updatedPart = event.properties?.part;',
    ...(options.emitNextEvents
      ? [
          '',
          '    if (event.type === "session.next.prompt.admitted") {',
          '      if (!sessionID) return;',
          '      if ((await isChildSession(client, sessionID)) !== false) return;',
          '      if (disposed || authorityRevision !== stateArrivalRevision || desiredStatus === "waiting") return;',
          '      const prompt = event.properties?.prompt?.text;',
          '      if (typeof prompt !== "string" || !prompt) return;',
          '      await postMessagePart({',
          '        role: "user",',
          '        text: capMessagePartText(prompt),',
          '        messageID: event.properties?.messageID,',
          '        sessionID,',
          '      }, factoryID);',
          '      return;',
          '    }',
          '    if (event.type === "session.next.text.started") {',
          '      if (event.properties?.assistantMessageID) {',
          '        if (nextTextByMessageID.size >= 128) nextTextByMessageID.delete(nextTextByMessageID.keys().next().value);',
          '        nextTextByMessageID.set(event.properties.assistantMessageID, "");',
          '      }',
          '      return;',
          '    }',
          '    if (event.type === "session.next.text.delta") {',
          '      const messageID = event.properties?.assistantMessageID;',
          '      const delta = event.properties?.delta;',
          '      if (typeof messageID !== "string" || typeof delta !== "string") return;',
          '      nextTextByMessageID.set(messageID, capMessagePartText((nextTextByMessageID.get(messageID) || "") + delta));',
          '      if (nextTextByMessageID.size > 128) nextTextByMessageID.delete(nextTextByMessageID.keys().next().value);',
          '      return;',
          '    }',
          '    if (event.type === "session.next.text.ended") {',
          '      if (!sessionID) return;',
          '      if ((await isChildSession(client, sessionID)) !== false) return;',
          '      const messageID = event.properties?.assistantMessageID;',
          '      const text = typeof event.properties?.text === "string"',
          '        ? event.properties.text',
          '        : (typeof messageID === "string" ? nextTextByMessageID.get(messageID) : "");',
          '      if (typeof messageID !== "string" || !text) return;',
          '      nextTextByMessageID.delete(messageID);',
          '      queueAssistantPart({ role: "assistant", text, messageID, sessionID, authorityRevision, factoryID });',
          '      return;',
          '    }'
        ]
      : []),
    ...(options.emitSessionStart
      ? [
          '    if (event.type === "session.created") {',
          '      const info = event.properties?.info;',
          '      if (!info?.id || info.parentID) return;',
          '      rememberSessionRoot(info.id, info.id);',
          '      if (isOpenCodeRunProcess()) return; // a `run` goes Busy at once; its start row only blinks idle',
          '      await enqueueLifecycle(() =>',
          '        disposed ? undefined : post("SessionStart", { sessionID: info.id })',
          '      );',
          '      return;',
          '    }',
          ''
        ]
      : []),
    '    if (',
    '      event.type === "message.part.updated" &&',
    '      updatedPart?.type === "tool" &&',
    '      updatedPart.tool === "question" &&',
    '      (updatedPart.state?.status === "completed" || updatedPart.state?.status === "error")',
    '    ) {',
    '      await enqueueLifecycle(async () => {',
    '        if (disposed) return;',
    '        // Stored ownership retires child questions even when ancestry lookup is unavailable.',
    '        const rootSessionID = clearQuestionForToolPart(updatedPart, sessionID, factoryID);',
    '        if (!rootSessionID) return;',
    '        await publishOwnershipChange(factoryID, rootSessionID);',
    '      });',
    '      return;',
    '    }',
    '',
    '    if (',
    '      event.type === "session.status" ||',
    '      event.type === "session.idle" ||',
    '      event.type === "session.error" ||',
    '      event.type === "permission.asked" ||',
    '      event.type === "question.asked" ||',
    '      event.type === "permission.replied" ||',
    '      event.type === "question.replied" ||',
    `      event.type === "question.rejected"${
      options.emitNextEvents
        ? ' || event.type === "permission.v2.asked" || event.type === "permission.v2.replied" || event.type === "question.v2.asked" || event.type === "question.v2.replied" || event.type === "question.v2.rejected" || event.type === "session.next.step.started" || event.type === "session.next.tool.called" || event.type === "session.next.tool.progress" || event.type === "session.next.retried"'
        : ''
    }`,
    '    ) {',
    '      await enqueueLifecycle(() =>',
    `        disposed ? undefined : handleLifecycleEvent(client, ${options.emitNextEvents ? 'normalizeNextLifecycleEvent(event)' : 'event'}, factoryID)`,
    '      );',
    '      return;',
    '    }',
    '',
    '    if (event.type === "message.part.delta") {',
    '      const properties = event.properties || {};',
    '      if (',
    '        properties.field === "text" &&',
    '        typeof properties.delta === "string" &&',
    '        properties.delta.length > 0',
    '      ) {',
    '        await recoverBusyFromDelta(client, sessionID, factoryID);',
    '      }',
    '      return;',
    '    }',
    '',
    '    if (sessionID && (await isChildSession(client, sessionID)) !== false) {',
    '      return;',
    '    }',
    '    if (disposed) return;',
    '    if (authorityRevision !== stateArrivalRevision) return;',
    '    if (desiredStatus === "waiting") return;',
    '',
    '    if (event.type === "message.updated") {',
    '      return;',
    '    }',
    '',
    '    if (event.type === "message.part.updated") {',
    '      // Unknown roles can mislabel user prompts as replies; skip until message.updated seeds the cache.',
    '      const part = event.properties && event.properties.part;',
    '      if (!part || part.type !== "text" || !part.text) return;',
    '      // OpenCode hides synthetic background-task text; it must not replace human/assistant previews.',
    '      if (part.synthetic === true) return;',
    '      const role = messageRoleById.get(part.messageID);',
    '      if (!role) return;',
    '      if (role === "user") {',
    '        // User prompts are single events; post immediately without consuming the assistant throttle slot.',
    '        await postMessagePart(',
    '          { role, text: capMessagePartText(part.text), messageID: part.messageID, sessionID },',
    '          factoryID',
    '        );',
    '        return;',
    '      }',
    '      queueAssistantPart({',
    '        role,',
    '        text: part.text,',
    '        messageID: part.messageID,',
    '        sessionID,',
    '        authorityRevision,',
    '        factoryID,',
    '      });',
    '      return;',
    '    }',
    '',
    '  },',
    '  dispose: async () => {',
    '    if (disposed) return;',
    '    disposed = true;',
    ...(options.emitNextEvents ? ['    nextTextByMessageID.clear();'] : []),
    '    disposingFactoryIDs.add(factoryID);',
    '    await enqueueLifecycle(async () => {',
    '      // Drain old previews before disposal so late Working updates cannot overwrite its verdict.',
    '      while (messagePartPostInFlight) await messagePartPostInFlight;',
    '      for (const [sessionID, ownerID] of busyRootOwnerBySessionID) {',
    '        if (ownerID === factoryID) busyRootOwnerBySessionID.delete(sessionID);',
    '      }',
    '      for (const [key, provisional] of provisionalBusyByKey) {',
    '        if (provisional.factoryID === factoryID) provisionalBusyByKey.delete(key);',
    '      }',
    '      for (const [key, busyChild] of busyChildRootByKey) {',
    '        if (busyChild.factoryID === factoryID) busyChildRootByKey.delete(key);',
    '      }',
    '      for (const [key, attention] of pendingAttentionByKey) {',
    '        if (attention.factoryID === factoryID) pendingAttentionByKey.delete(key);',
    '      }',
    '      if (pendingAssistantPart?.factoryID === factoryID) {',
    '        if (assistantPartFlushTimer) clearTimeout(assistantPartFlushTimer);',
    '        assistantPartFlushTimer = null;',
    '        pendingAssistantPart = null;',
    '      }',
    '      const ownsDeliveredMessagePart = deliveredMessagePartFactoryID === factoryID;',
    '      // OpenCode 1 teardown cancels all runs; OpenCode 2 hot reloads preserve runs and publish no Idle.',
    '      if (sessionsOutliveDispose) {',
    '        if (desiredFactoryID === factoryID) {',
    '          clearStatusRetry();',
    '          statusRevision += 1;',
    '        }',
    '      } else if (desiredFactoryID === factoryID || ownsDeliveredMessagePart) {',
    '        clearStatusRetry();',
    '        statusRevision += 1;',
    '        // Reassert status after MessagePart may have changed the listener to Working.',
    '        statusDeliveryDirty = ownsDeliveredMessagePart;',
    '        busyRecoveryUsed = false;',
    '        busyRecoveryEndpointKey = "";',
    '        const fallbackFactoryID = Array.from(activeFactoryIDs).find((id) => id !== factoryID);',
    '        if (fallbackFactoryID !== undefined) {',
    '          await publishAggregateStatus(',
    '            fallbackFactoryID,',
    '            desiredStatusProperties?.sessionID',
    '          );',
    '        } else {',
    '          if (!deliveredStatusKey.startsWith("idle:") || ownsDeliveredMessagePart) {',
    '            await setStatus(',
    '              "idle",',
    '              { sessionID: desiredStatusProperties?.sessionID },',
    '              factoryID',
    '            );',
    '          }',
    '          clearStatusRetry();',
    '          desiredStatus = "idle";',
    '          desiredHookEventName = "SessionIdle";',
    '          desiredStatusKey = "idle:";',
    '          desiredStatusProperties = {};',
    '          desiredFactoryID = null;',
    '        }',
    '      }',
    '      activeFactoryIDs.delete(factoryID);',
    '      disposingFactoryIDs.delete(factoryID);',
    '    });',
    '  },',
    '  };',
    '};',
    ...(options.emitNextEvents ? getOpenCode2ModuleSource(pluginID, expectedAgent) : []),
    '',
    'export default process.env.ORCA_OPENCODE_PLUGIN_API === "v1" ? OrcaOpenCodeStatusPlugin : {',
    `  id: "${pluginID}",`,
    '  server: OrcaOpenCodeStatusPlugin,',
    ...(options.emitNextEvents ? ['  setup: setupOpenCode2Status,'] : []),
    '};',
    ''
  ]
}