@loggie-ai/openclaw-plugin 0.1.0

package/src/monitor/event-handler.ts

@@ -0,0 +1,133 @@
+import type { ResolvedLoggieAccount } from "../account.js";
+import {
+  advanceCursor,
+  deadLetterEvent,
+  decideCursor,
+  recordEventFailure,
+  type LoggieCursorStore,
+} from "../cursor-store.js";
+import {
+  isTranscriptReadyEvent,
+  parseLoggieEventEnvelope,
+  type LoggieEventEnvelope,
+} from "../event-types.js";
+import type { TranscriptDispatcher } from "./transcript-dispatch.js";
+
+export type LoggieEventHandleResult =
+  | { status: "dispatched"; event: LoggieEventEnvelope }
+  | {
+      status: "skipped";
+      reason: string;
+      event?: LoggieEventEnvelope;
+      deadLettered?: {
+        attempts: number;
+        reason: string;
+      };
+    }
+  | { status: "failed"; reason: string; retryable: boolean };
+
+const MAX_EVENT_DISPATCH_ATTEMPTS = 3;
+
+export async function handleLoggieEvent(params: {
+  raw: unknown;
+  account: ResolvedLoggieAccount;
+  cursorStore: LoggieCursorStore;
+  dispatcher: TranscriptDispatcher;
+  now?: Date;
+}): Promise<LoggieEventHandleResult> {
+  const parsed = parseLoggieEventEnvelope(params.raw);
+  if (!parsed.ok) {
+    return { status: "failed", reason: parsed.reason, retryable: false };
+  }
+  const event = parsed.event;
+  const cursor = await params.cursorStore.load(params.account.accountId, params.account.agentProfileId);
+  if (event.agentProfileId && event.agentProfileId !== params.account.agentProfileId) {
+    const reason = `event agentProfileId does not match configured account`;
+    await params.cursorStore.save(
+      deadLetterEvent({
+        record: cursor,
+        event,
+        accountId: params.account.accountId,
+        agentProfileId: params.account.agentProfileId,
+        reason,
+        attempts: 1,
+        now: params.now,
+      }),
+    );
+    return {
+      status: "skipped",
+      reason: `dead_lettered_non_retryable:${reason}`,
+      event,
+      deadLettered: {
+        attempts: 1,
+        reason,
+      },
+    };
+  }
+
+  const decision = decideCursor(cursor, event);
+  if (decision.action === "skip") {
+    return { status: "skipped", reason: decision.reason, event };
+  }
+
+  if (!isTranscriptReadyEvent(event)) {
+    await params.cursorStore.save(
+      advanceCursor({
+        record: cursor,
+        event,
+        accountId: params.account.accountId,
+        agentProfileId: params.account.agentProfileId,
+        now: params.now,
+      }),
+    );
+    return { status: "skipped", reason: `unsupported_event:${event.eventType}`, event };
+  }
+
+  try {
+    await params.dispatcher.dispatchTranscriptReady(event);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    const failure = recordEventFailure({
+      record: cursor,
+      event,
+      accountId: params.account.accountId,
+      agentProfileId: params.account.agentProfileId,
+      reason,
+      now: params.now,
+    });
+    if (failure.attempts < MAX_EVENT_DISPATCH_ATTEMPTS) {
+      await params.cursorStore.save(failure.record);
+      return { status: "failed", reason, retryable: true };
+    }
+    await params.cursorStore.save(
+      deadLetterEvent({
+        record: failure.record,
+        event,
+        accountId: params.account.accountId,
+        agentProfileId: params.account.agentProfileId,
+        reason,
+        attempts: failure.attempts,
+        now: params.now,
+      }),
+    );
+    return {
+      status: "skipped",
+      reason: `dead_lettered_after_${failure.attempts}_attempts:${reason}`,
+      event,
+      deadLettered: {
+        attempts: failure.attempts,
+        reason,
+      },
+    };
+  }
+  await params.cursorStore.save(
+    advanceCursor({
+      record: cursor,
+      event,
+      accountId: params.account.accountId,
+      agentProfileId: params.account.agentProfileId,
+      now: params.now,
+    }),
+  );
+  return { status: "dispatched", event };
+}

package/src/monitor/transcript-dispatch.ts

@@ -0,0 +1,145 @@
+import type { OpenClawConfig, PluginRuntime } from "openclaw/plugin-sdk/channel-core";
+import type { ResolvedLoggieAccount } from "../account.js";
+import type { LoggieTranscriptReadyEvent } from "../event-types.js";
+import { fetchLoggieTranscriptDetail } from "../loggie-client.js";
+import { buildLoggieRouteSessionKey, buildLoggieSessionId, meetingConversationId } from "../routing.js";
+import { formatTranscriptReadyPrompt } from "./transcript-format.js";
+
+export type TranscriptDispatcher = {
+  dispatchTranscriptReady(event: LoggieTranscriptReadyEvent): Promise<void>;
+};
+
+type ChannelRuntime = PluginRuntime["channel"];
+
+export function createOpenClawTranscriptDispatcher(params: {
+  account: ResolvedLoggieAccount;
+  cfg: OpenClawConfig;
+  runtime: PluginRuntime;
+  channelRuntime: ChannelRuntime;
+  abortSignal?: AbortSignal;
+  fetchImpl?: typeof fetch;
+}): TranscriptDispatcher {
+  const agentRuntime = params.runtime.agent;
+  return {
+    async dispatchTranscriptReady(event) {
+      const routeSessionKey = buildLoggieRouteSessionKey({ account: params.account, event });
+      const conversationId = meetingConversationId(event);
+      const detail = event.payload.detailPath
+        ? await fetchLoggieTranscriptDetail({
+            account: params.account,
+            detailPath: event.payload.detailPath,
+            fetchImpl: params.fetchImpl,
+          })
+        : undefined;
+      const body = formatTranscriptReadyPrompt(event, detail);
+      const title = event.payload.title?.trim() || "Loggie meeting";
+      const timestamp = Date.parse(event.occurredAt);
+      const ctxPayload = await params.channelRuntime.inbound.buildContext({
+        channel: "loggie",
+        accountId: params.account.accountId,
+        provider: "loggie",
+        surface: "loggie",
+        messageId: event.eventId,
+        messageIdFull: `loggie:${event.eventId}`,
+        timestamp,
+        from: `loggie:${event.workspaceId}:${params.account.agentProfileId}`,
+        sender: {
+          id: params.account.agentProfileId,
+          name: "Loggie",
+          displayLabel: "Loggie",
+        },
+        conversation: {
+          kind: "group",
+          id: conversationId,
+          label: title,
+          nativeChannelId: conversationId,
+        },
+        route: {
+          routeSessionKey,
+          dispatchSessionKey: routeSessionKey,
+          accountId: params.account.accountId,
+          agentId: params.account.agentId,
+        },
+        reply: {
+          to: conversationId,
+          originatingTo: conversationId,
+          nativeChannelId: conversationId,
+        },
+        message: {
+          rawBody: body,
+          body,
+          bodyForAgent: body,
+          commandBody: body,
+          inboundEventKind: "user_request",
+          sourceModality: "text",
+        },
+        extra: {
+          LoggieEventId: event.eventId,
+          LoggieCursor: event.cursor,
+          LoggieSequence: event.sequence,
+          LoggieMeetingId: event.meetingId,
+          LoggieMeetingScheduleId: event.meetingScheduleId,
+          LoggieDetailPath: event.payload.detailPath,
+        },
+      });
+
+      const storePath = params.channelRuntime.session.resolveStorePath(undefined, {
+        agentId: params.account.agentId,
+      });
+      const sessionId = buildLoggieSessionId({ account: params.account, event });
+      await params.channelRuntime.inbound.runPreparedReply({
+        channel: "loggie",
+        accountId: params.account.accountId,
+        routeSessionKey,
+        storePath,
+        ctxPayload,
+        recordInboundSession: params.channelRuntime.session.recordInboundSession,
+        record: {
+          createIfMissing: true,
+          updateLastRoute: {
+            sessionKey: routeSessionKey,
+            channel: "loggie",
+            to: conversationId,
+            accountId: params.account.accountId,
+          },
+        },
+        runDispatch: async () => {
+          const workspaceDir = agentRuntime.resolveAgentWorkspaceDir(
+            params.cfg,
+            params.account.agentId,
+          );
+          await agentRuntime.ensureAgentWorkspace?.({ dir: workspaceDir });
+          return agentRuntime.runEmbeddedAgent({
+            sessionId,
+            sessionKey: routeSessionKey,
+            agentId: params.account.agentId,
+            messageChannel: "loggie",
+            messageProvider: "loggie",
+            chatType: "group",
+            agentAccountId: params.account.accountId,
+            trigger: "user",
+            messageTo: conversationId,
+            messageThreadId: conversationId,
+            groupId: conversationId,
+            groupChannel: title,
+            senderId: params.account.agentProfileId,
+            senderName: "Loggie",
+            currentChannelId: conversationId,
+            currentMessageId: event.eventId,
+            chatId: conversationId,
+            workspaceDir,
+            agentDir: agentRuntime.resolveAgentDir(params.cfg, params.account.agentId),
+            config: params.cfg,
+            prompt: body,
+            transcriptPrompt: body,
+            currentInboundEventKind: "user_request",
+            currentInboundContext: { text: body },
+            timeoutMs: agentRuntime.resolveAgentTimeoutMs({ cfg: params.cfg }),
+            runId: `loggie-${event.eventId}`,
+            abortSignal: params.abortSignal,
+          });
+        },
+      });
+    },
+  };
+}

package/src/monitor/transcript-format.ts

@@ -0,0 +1,49 @@
+import type { LoggieTranscriptReadyEvent } from "../event-types.js";
+
+const MAX_DETAIL_CHARS = 60_000;
+
+export function formatTranscriptReadyPrompt(
+  event: LoggieTranscriptReadyEvent,
+  detail?: unknown,
+): string {
+  const title = event.payload.title?.trim() || "Untitled meeting";
+  const meetingDate = event.payload.meetingDate ?? event.occurredAt;
+  const lines = [
+    `Loggie meeting transcript ready: ${title}`,
+    `Meeting ID: ${event.meetingScheduleId ?? event.meetingId}`,
+    `Workspace ID: ${event.workspaceId}`,
+    `Occurred At: ${event.occurredAt}`,
+    `Meeting Date: ${meetingDate}`,
+  ];
+  if (event.payload.source) {
+    lines.push(`Source: ${event.payload.source}`);
+  }
+  if (event.payload.externalId) {
+    lines.push(`External Transcript ID: ${event.payload.externalId}`);
+  }
+  if (event.payload.detailPath) {
+    lines.push(`Transcript Detail Path: ${event.payload.detailPath}`);
+  }
+  const formattedDetail = formatTranscriptDetail(detail);
+  if (formattedDetail) {
+    lines.push("", "Transcript Detail:", formattedDetail);
+  }
+  return lines.join("\n");
+}
+
+function formatTranscriptDetail(detail: unknown): string | undefined {
+  if (detail === undefined || detail === null) {
+    return undefined;
+  }
+  const text =
+    typeof detail === "string"
+      ? detail
+      : JSON.stringify(detail, null, 2);
+  const trimmed = text.trim();
+  if (!trimmed) {
+    return undefined;
+  }
+  return trimmed.length > MAX_DETAIL_CHARS
+    ? `${trimmed.slice(0, MAX_DETAIL_CHARS)}\n[truncated]`
+    : trimmed;
+}

package/src/object.ts

@@ -0,0 +1,15 @@
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+export function readString(value: unknown): string | undefined {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+
+export function readBoolean(value: unknown, fallback: boolean): boolean {
+  return typeof value === "boolean" ? value : fallback;
+}
+
+export function readInteger(value: unknown, fallback: number): number {
+  return Number.isInteger(value) ? (value as number) : fallback;
+}

package/src/routing.ts

@@ -0,0 +1,27 @@
+import type { ResolvedLoggieAccount } from "./account.js";
+import type { LoggieEventEnvelope } from "./event-types.js";
+
+const UNSAFE_SESSION_CHARS_RE = /[^a-zA-Z0-9._-]+/g;
+
+export function meetingConversationId(event: LoggieEventEnvelope): string {
+  return event.meetingScheduleId ?? event.meetingId ?? event.eventId;
+}
+
+export function buildLoggieRouteSessionKey(params: {
+  account: Pick<ResolvedLoggieAccount, "accountId" | "agentId">;
+  event: LoggieEventEnvelope;
+}): string {
+  return `agent:${params.account.agentId}:loggie:${params.account.accountId}:meeting:${meetingConversationId(
+    params.event,
+  )}`;
+}
+
+export function buildLoggieSessionId(params: {
+  account: Pick<ResolvedLoggieAccount, "accountId">;
+  event: LoggieEventEnvelope;
+}): string {
+  return `loggie-${params.account.accountId}-${meetingConversationId(params.event)}`
+    .replace(UNSAFE_SESSION_CHARS_RE, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 128);
+}

package/src/runtime.ts

@@ -0,0 +1,13 @@
+import type { PluginRuntime } from "openclaw/plugin-sdk/channel-core";
+import { createPluginRuntimeStore } from "openclaw/plugin-sdk/runtime-store";
+
+const {
+  setRuntime: setLoggieRuntime,
+  clearRuntime: clearLoggieRuntime,
+  tryGetRuntime: getOptionalLoggieRuntime,
+} = createPluginRuntimeStore<PluginRuntime>({
+  pluginId: "loggie",
+  errorMessage: "Loggie runtime not initialized",
+});
+
+export { clearLoggieRuntime, getOptionalLoggieRuntime, setLoggieRuntime };

package/src/status.ts

@@ -0,0 +1,72 @@
+import { buildBaseAccountStatusSnapshot, createDefaultChannelRuntimeState } from "openclaw/plugin-sdk/status-helpers";
+import type { ResolvedLoggieAccount } from "./account.js";
+
+export type LoggieRuntimeExtra = {
+  connected?: boolean;
+  authenticated?: boolean;
+  caughtUp?: boolean;
+  lastEventId?: string | null;
+  lastCursor?: string | null;
+  lastSequence?: number | null;
+  lastDispatchAt?: number | null;
+  lastDeadLetterAt?: number | null;
+  lastDeadLetteredEventId?: string | null;
+  lastDeadLetteredCursor?: string | null;
+  lastDeadLetterReason?: string | null;
+  lastDeadLetterAttempts?: number | null;
+};
+
+export const defaultLoggieRuntimeState = createDefaultChannelRuntimeState<LoggieRuntimeExtra>(
+  "default",
+  {
+    connected: false,
+    authenticated: false,
+    caughtUp: false,
+    lastEventId: null,
+    lastCursor: null,
+    lastSequence: null,
+    lastDispatchAt: null,
+    lastDeadLetterAt: null,
+    lastDeadLetteredEventId: null,
+    lastDeadLetteredCursor: null,
+    lastDeadLetterReason: null,
+    lastDeadLetterAttempts: null,
+  },
+);
+
+export function buildLoggieAccountStatusSnapshot(params: {
+  account: ResolvedLoggieAccount;
+  runtime?: Record<string, unknown> | null;
+}) {
+  return buildBaseAccountStatusSnapshot(
+    {
+      account: {
+        accountId: params.account.accountId,
+        name: params.account.name,
+        enabled: params.account.enabled,
+        configured: params.account.configured,
+      },
+      runtime: params.runtime,
+    },
+    {
+      mode: "websocket",
+      baseUrl: params.account.baseUrl,
+      agentId: params.account.agentId,
+      agentProfileId: params.account.agentProfileId,
+      tokenStatus: params.account.tokenStatus.status,
+      tokenSource: params.account.tokenStatus.source,
+      connected: params.runtime?.connected ?? false,
+      authenticated: params.runtime?.authenticated ?? false,
+      caughtUp: params.runtime?.caughtUp ?? false,
+      lastEventId: params.runtime?.lastEventId ?? null,
+      lastCursor: params.runtime?.lastCursor ?? null,
+      lastSequence: params.runtime?.lastSequence ?? null,
+      lastDispatchAt: params.runtime?.lastDispatchAt ?? null,
+      lastDeadLetterAt: params.runtime?.lastDeadLetterAt ?? null,
+      lastDeadLetteredEventId: params.runtime?.lastDeadLetteredEventId ?? null,
+      lastDeadLetteredCursor: params.runtime?.lastDeadLetteredCursor ?? null,
+      lastDeadLetterReason: params.runtime?.lastDeadLetterReason ?? null,
+      lastDeadLetterAttempts: params.runtime?.lastDeadLetterAttempts ?? null,
+    },
+  );
+}