@loggie-ai/openclaw-plugin 0.1.0

package/dist/src/monitor/transcript-dispatch.js

@@ -0,0 +1,124 @@
+import { fetchLoggieTranscriptDetail } from "../loggie-client.js";
+import { buildLoggieRouteSessionKey, buildLoggieSessionId, meetingConversationId } from "../routing.js";
+import { formatTranscriptReadyPrompt } from "./transcript-format.js";
+export function createOpenClawTranscriptDispatcher(params) {
+    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/dist/src/monitor/transcript-format.d.ts

@@ -0,0 +1,2 @@
+import type { LoggieTranscriptReadyEvent } from "../event-types.js";
+export declare function formatTranscriptReadyPrompt(event: LoggieTranscriptReadyEvent, detail?: unknown): string;

package/dist/src/monitor/transcript-format.js

@@ -0,0 +1,41 @@
+const MAX_DETAIL_CHARS = 60_000;
+export function formatTranscriptReadyPrompt(event, detail) {
+    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) {
+    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/dist/src/object.d.ts

@@ -0,0 +1,4 @@
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function readString(value: unknown): string | undefined;
+export declare function readBoolean(value: unknown, fallback: boolean): boolean;
+export declare function readInteger(value: unknown, fallback: number): number;

package/dist/src/object.js

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

package/dist/src/routing.d.ts

@@ -0,0 +1,11 @@
+import type { ResolvedLoggieAccount } from "./account.js";
+import type { LoggieEventEnvelope } from "./event-types.js";
+export declare function meetingConversationId(event: LoggieEventEnvelope): string;
+export declare function buildLoggieRouteSessionKey(params: {
+    account: Pick<ResolvedLoggieAccount, "accountId" | "agentId">;
+    event: LoggieEventEnvelope;
+}): string;
+export declare function buildLoggieSessionId(params: {
+    account: Pick<ResolvedLoggieAccount, "accountId">;
+    event: LoggieEventEnvelope;
+}): string;

package/dist/src/routing.js

@@ -0,0 +1,13 @@
+const UNSAFE_SESSION_CHARS_RE = /[^a-zA-Z0-9._-]+/g;
+export function meetingConversationId(event) {
+    return event.meetingScheduleId ?? event.meetingId ?? event.eventId;
+}
+export function buildLoggieRouteSessionKey(params) {
+    return `agent:${params.account.agentId}:loggie:${params.account.accountId}:meeting:${meetingConversationId(params.event)}`;
+}
+export function buildLoggieSessionId(params) {
+    return `loggie-${params.account.accountId}-${meetingConversationId(params.event)}`
+        .replace(UNSAFE_SESSION_CHARS_RE, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 128);
+}

package/dist/src/runtime.d.ts

@@ -0,0 +1,3 @@
+import type { PluginRuntime } from "openclaw/plugin-sdk/channel-core";
+declare const setLoggieRuntime: (runtime: PluginRuntime) => void, clearLoggieRuntime: () => void, getOptionalLoggieRuntime: () => PluginRuntime | undefined;
+export { clearLoggieRuntime, getOptionalLoggieRuntime, setLoggieRuntime };

package/dist/src/runtime.js

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

package/dist/src/status.d.ts

@@ -0,0 +1,45 @@
+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 declare const defaultLoggieRuntimeState: {
+    accountId: string;
+    running: false;
+    lastStartAt: null;
+    lastStopAt: null;
+    lastError: null;
+} & LoggieRuntimeExtra;
+export declare function buildLoggieAccountStatusSnapshot(params: {
+    account: ResolvedLoggieAccount;
+    runtime?: Record<string, unknown> | null;
+}): Record<string, unknown> & {
+    mode: string;
+    baseUrl: string;
+    agentId: string;
+    agentProfileId: string;
+    tokenStatus: "available" | "configured_unavailable" | "missing";
+    tokenSource: string;
+    connected: {};
+    authenticated: {};
+    caughtUp: {};
+    lastEventId: {} | null;
+    lastCursor: {} | null;
+    lastSequence: {} | null;
+    lastDispatchAt: {} | null;
+    lastDeadLetterAt: {} | null;
+    lastDeadLetteredEventId: {} | null;
+    lastDeadLetteredCursor: {} | null;
+    lastDeadLetterReason: {} | null;
+    lastDeadLetterAttempts: {} | null;
+};

package/dist/src/status.js

@@ -0,0 +1,45 @@
+import { buildBaseAccountStatusSnapshot, createDefaultChannelRuntimeState } from "openclaw/plugin-sdk/status-helpers";
+export const defaultLoggieRuntimeState = createDefaultChannelRuntimeState("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) {
+    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,
+    });
+}

package/index.ts

@@ -0,0 +1,13 @@
+import { defineChannelPluginEntry } from "openclaw/plugin-sdk/channel-core";
+import { loggiePlugin } from "./src/channel.js";
+import { loggieEntryConfigSchema } from "./src/config-schema.js";
+import { setLoggieRuntime } from "./src/runtime.js";
+
+export default defineChannelPluginEntry({
+  id: "loggie",
+  name: "Loggie",
+  description: "Receives durable Loggie meeting transcript events over WebSocket.",
+  plugin: loggiePlugin,
+  configSchema: loggieEntryConfigSchema,
+  setRuntime: setLoggieRuntime,
+});

package/openclaw.plugin.json

@@ -0,0 +1,71 @@
+{
+  "id": "loggie",
+  "kind": "channel",
+  "name": "Loggie",
+  "version": "0.1.0",
+  "description": "OpenClaw channel plugin for durable Loggie meeting transcript events over WebSocket.",
+  "activation": {
+    "onStartup": false
+  },
+  "channels": ["loggie"],
+  "channelEnvVars": {
+    "loggie": ["LOGGIE_AGENT_TOKEN", "LOGGIE_BASE_URL"]
+  },
+  "channelConfigs": {
+    "loggie": {
+      "label": "Loggie",
+      "description": "Receives durable Loggie meeting transcript events over WebSocket.",
+      "schema": {
+        "type": "object",
+        "additionalProperties": true,
+        "properties": {
+          "enabled": { "type": "boolean", "default": true },
+          "baseUrl": { "type": "string" },
+          "socketPath": { "type": "string", "default": "/api/events/socket" },
+          "accountId": { "type": "string", "default": "default" },
+          "agentId": { "type": "string", "default": "main" },
+          "agentProfileId": { "type": "string" },
+          "credentialRef": {},
+          "token": { "type": "string" },
+          "authHeader": {
+            "type": "string",
+            "enum": ["authorization", "x-api-key"],
+            "default": "authorization"
+          },
+          "accounts": {
+            "type": "object",
+            "additionalProperties": { "type": "object" }
+          },
+          "reconnect": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+              "minMs": { "type": "integer", "minimum": 100, "default": 1000 },
+              "maxMs": { "type": "integer", "minimum": 1000, "default": 60000 }
+            }
+          },
+          "heartbeat": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+              "timeoutMs": { "type": "integer", "minimum": 1000, "default": 120000 }
+            }
+          },
+          "transcript": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+              "activation": { "type": "string", "enum": ["final-only"], "default": "final-only" },
+              "debounceMs": { "type": "integer", "minimum": 0, "default": 5000 }
+            }
+          }
+        }
+      }
+    }
+  },
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {}
+  }
+}

package/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "@loggie-ai/openclaw-plugin",
+  "version": "0.1.0",
+  "description": "OpenClaw channel plugin for Loggie meeting transcript events.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "README.md",
+    "index.ts",
+    "setup-entry.ts",
+    "src/",
+    "dist/",
+    "openclaw.plugin.json",
+    "plugin-inspector.config.json"
+  ],
+  "scripts": {
+    "clean": "node -e \"fs.rmSync('dist',{recursive:true,force:true})\"",
+    "build": "npm run clean && tsc -p tsconfig.build.json",
+    "check": "tsc -p tsconfig.json --noEmit",
+    "plugin:inspect": "plugin-inspector check --config plugin-inspector.config.json --no-openclaw",
+    "plugin:inspect:runtime": "plugin-inspector check --config plugin-inspector.config.json --no-openclaw --runtime --mock-sdk --allow-execute",
+    "test": "vitest run",
+    "preflight": "npm run check && npm test && npm run build && npm run plugin:inspect && npm run plugin:inspect:runtime"
+  },
+  "openclaw": {
+    "extensions": [
+      "./index.ts"
+    ],
+    "runtimeExtensions": [
+      "./dist/index.js"
+    ],
+    "setupEntry": "./setup-entry.ts",
+    "channel": {
+      "id": "loggie",
+      "label": "Loggie",
+      "selectionLabel": "Loggie",
+      "blurb": "Receives durable Loggie meeting transcript events over WebSocket.",
+      "docsPath": "/plugins/loggie"
+    },
+    "startup": {
+      "deferConfiguredChannelFullLoadUntilAfterListen": true
+    },
+    "install": {
+      "npmSpec": "@loggie-ai/openclaw-plugin",
+      "defaultChoice": "npm",
+      "minHostVersion": ">=2026.6.10"
+    },
+    "compat": {
+      "pluginApi": ">=2026.6.10",
+      "minGatewayVersion": ">=2026.6.10"
+    },
+    "build": {
+      "openclawVersion": "2026.6.10",
+      "pluginSdkVersion": "2026.6.10"
+    }
+  },
+  "keywords": [
+    "openclaw",
+    "openclaw-plugin",
+    "channel",
+    "loggie"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=22"
+  },
+  "peerDependencies": {
+    "openclaw": ">=2026.6.10"
+  },
+  "peerDependenciesMeta": {
+    "openclaw": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "ws": "^8.18.3",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "@openclaw/plugin-inspector": "^0.3.10",
+    "@types/node": "^22.15.29",
+    "@types/ws": "^8.18.1",
+    "typescript": "^5.9.2",
+    "vitest": "^3.2.4"
+  }
+}

package/plugin-inspector.config.json

@@ -0,0 +1,15 @@
+{
+  "version": 1,
+  "plugin": {
+    "id": "loggie",
+    "priority": "medium",
+    "seams": ["manifest-contract", "sdk-surface", "channel"],
+    "sourceRoot": ".",
+    "expect": {
+      "registrations": ["registerChannel"]
+    }
+  },
+  "capture": {
+    "mockSdk": true
+  }
+}

package/setup-entry.ts

@@ -0,0 +1,4 @@
+import { defineSetupPluginEntry } from "openclaw/plugin-sdk/channel-core";
+import { loggiePlugin } from "./src/channel.js";
+
+export default defineSetupPluginEntry(loggiePlugin);