@syengup/friday-channel-next 0.0.35 → 0.0.38

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { fridayNextChannelPlugin } from "./src/channel.js";
+export { setFridayNextRuntime } from "./src/runtime.js";
+declare const _default: any;
+export default _default;

package/dist/index.js

@@ -0,0 +1,182 @@
+import { defineChannelPluginEntry } from "openclaw/plugin-sdk/core";
+import { fridayNextChannelPlugin } from "./src/channel.js";
+import { setFridayNextRuntime } from "./src/runtime.js";
+import { resolveFridayNextConfig } from "./src/config.js";
+import { getHostOpenClawConfigSnapshot } from "./src/host-config.js";
+import { registerFridayNextHttpRoutes } from "./src/http/server.js";
+import { getFridayNextRuntime } from "./src/runtime.js";
+import { sseEmitter } from "./src/sse/emitter.js";
+import { forwardAgentEventRaw, getLastRegisteredFridayDeviceId, resolveFridayDeviceIdForSessionKey, } from "./src/friday-session.js";
+import { setFridayAgentForwardRuntime } from "./src/agent-forward-runtime.js";
+import { getOpenClawAgentRunContext } from "./src/agent-run-context-bridge.js";
+export { fridayNextChannelPlugin } from "./src/channel.js";
+export { setFridayNextRuntime } from "./src/runtime.js";
+/** `api.on` returns void — register tool hooks at most once per process. */
+let fridayNextToolHooksRegistered = false;
+let disposeAgentEventListener = null;
+/**
+ * Track the last `api` instance on which HTTP routes were registered.
+ * When the health-monitor restarts the plugin, `registerFull` receives a fresh `api` whose
+ * old routes are gone — we must re-register.  A WeakRef lets us distinguish "same api,
+ * re-entered" (skip) from "new api after restart" (re-register).
+ */
+let lastApiRoutesRegistered = null;
+function deviceIdFromToolContext(ctx) {
+    if (ctx.runId) {
+        const d = sseEmitter.getDeviceIdByRunId(ctx.runId);
+        if (d)
+            return d;
+    }
+    const sk = typeof ctx.sessionKey === "string" && ctx.sessionKey.trim()
+        ? ctx.sessionKey.trim()
+        : (ctx.runId ? getOpenClawAgentRunContext(ctx.runId)?.sessionKey?.trim() : undefined) ?? "";
+    if (sk) {
+        const d = resolveFridayDeviceIdForSessionKey(sk);
+        if (d)
+            return d;
+    }
+    const sole = sseEmitter.getSoleConnectedDeviceId();
+    if (sole)
+        return sole;
+    const last = getLastRegisteredFridayDeviceId();
+    if (last)
+        return last;
+    return null;
+}
+function isFridaySessionKey(sk) {
+    return /^friday-next-/i.test(sk) || /^agent:main:friday-next-/i.test(sk);
+}
+function shouldForwardToolEventToFriday(ctx) {
+    if (ctx.runId) {
+        if (sseEmitter.getDeviceIdByRunId(ctx.runId))
+            return true;
+        const runSk = getOpenClawAgentRunContext(ctx.runId)?.sessionKey?.trim() ?? "";
+        if (runSk) {
+            if (resolveFridayDeviceIdForSessionKey(runSk))
+                return true;
+            if (isFridaySessionKey(runSk))
+                return true;
+        }
+    }
+    const sk = typeof ctx.sessionKey === "string" ? ctx.sessionKey.trim() : "";
+    if (sk) {
+        if (resolveFridayDeviceIdForSessionKey(sk))
+            return true;
+        if (isFridaySessionKey(sk))
+            return true;
+    }
+    return false;
+}
+export default defineChannelPluginEntry({
+    id: "friday-next",
+    name: "Friday Next",
+    description: "Friday Next Apple 应用通道",
+    plugin: fridayNextChannelPlugin,
+    setRuntime: setFridayNextRuntime,
+    registerFull: (api) => {
+        setFridayAgentForwardRuntime(api);
+        const sameApi = lastApiRoutesRegistered?.deref() === api;
+        if (!sameApi) {
+            lastApiRoutesRegistered = new WeakRef(api);
+            registerFridayNextHttpRoutes(api);
+        }
+        else {
+            const cfg = resolveFridayNextConfig(getHostOpenClawConfigSnapshot(getFridayNextRuntime().config));
+            sseEmitter.setBacklogLimit(cfg.sseBacklogPerDevice);
+        }
+        disposeAgentEventListener?.();
+        disposeAgentEventListener = api.runtime.events.onAgentEvent((evt) => {
+            forwardAgentEventRaw({
+                runId: evt.runId,
+                seq: evt.seq,
+                ts: evt.ts,
+                stream: evt.stream,
+                data: evt.data,
+                sessionKey: evt.sessionKey,
+            });
+        });
+        if (fridayNextToolHooksRegistered) {
+            return;
+        }
+        fridayNextToolHooksRegistered = true;
+        api.on("subagent_delivery_target", (event) => {
+            if (!event.expectsCompletionMessage)
+                return;
+            const ch = event.requesterOrigin?.channel?.trim().toLowerCase();
+            if (ch !== "friday-next")
+                return;
+            const sk = event.requesterSessionKey?.trim();
+            if (!sk)
+                return;
+            const raw = resolveFridayDeviceIdForSessionKey(sk);
+            if (!raw)
+                return;
+            const to = raw.toUpperCase();
+            return {
+                origin: {
+                    channel: "friday-next",
+                    accountId: event.requesterOrigin?.accountId?.trim() || "default",
+                    to,
+                },
+            };
+        });
+        api.on("before_tool_call", (event, ctx) => {
+            if (!shouldForwardToolEventToFriday(ctx))
+                return;
+            const deviceId = deviceIdFromToolContext(ctx);
+            const runId = ctx.runId ?? "(unknown)";
+            const logLine = (detail) => {
+                const ts = new Date().toISOString();
+                console.error(`[Friday-HOOK] [${ts}] [TOOL_CALL] toolName=${event.toolName} runId=${runId} deviceId=${deviceId ?? "(unknown)"} detail=${detail}`);
+            };
+            if (!deviceId) {
+                logLine("SKIP_no_deviceId");
+                return;
+            }
+            logLine("START");
+            sseEmitter.broadcastToolEvent(deviceId.toUpperCase(), runId, {
+                type: "tool-hook",
+                data: {
+                    when: "before",
+                    runId,
+                    deviceId: deviceId.toUpperCase(),
+                    sessionKey: ctx.sessionKey,
+                    toolName: event.toolName,
+                    params: event.params,
+                    ts: Date.now(),
+                },
+            });
+        });
+        api.on("after_tool_call", (event, ctx) => {
+            if (!shouldForwardToolEventToFriday(ctx))
+                return;
+            const deviceId = deviceIdFromToolContext(ctx);
+            const runId = ctx.runId ?? "(unknown)";
+            const logLine = (detail) => {
+                const ts = new Date().toISOString();
+                console.error(`[Friday-HOOK] [${ts}] [TOOL_DONE] toolName=${event.toolName} runId=${runId} deviceId=${deviceId ?? "(unknown)"} detail=${detail}`);
+            };
+            if (!deviceId) {
+                logLine("SKIP_no_deviceId");
+                return;
+            }
+            logLine("END");
+            const normalizedDeviceId = deviceId.toUpperCase();
+            sseEmitter.broadcastToolEvent(normalizedDeviceId, runId, {
+                type: "tool-hook",
+                data: {
+                    when: "after",
+                    runId,
+                    deviceId: normalizedDeviceId,
+                    sessionKey: ctx.sessionKey,
+                    toolName: event.toolName,
+                    toolCallId: event.toolCallId,
+                    error: event.error ?? null,
+                    result: event.result,
+                    durationMs: event.durationMs ?? null,
+                    ts: Date.now(),
+                },
+            });
+        });
+    },
+});

package/dist/src/agent/abort-run.d.ts

@@ -0,0 +1 @@
+export declare function abortRun(runId: string): Promise<void>;

package/dist/src/agent/abort-run.js

@@ -0,0 +1,11 @@
+export async function abortRun(runId) {
+    if (process.env.VITEST !== "true") {
+        try {
+            const { abortAgentHarnessRun } = await import("openclaw/plugin-sdk/agent-harness");
+            abortAgentHarnessRun(runId);
+        }
+        catch {
+            // optional at runtime
+        }
+    }
+}

package/dist/src/agent/active-runs.d.ts

@@ -0,0 +1,9 @@
+/** Tracks agent runs that have emitted lifecycle `phase: start` without matching `end`/`error`. */
+export declare function observeAgentEventForActiveRuns(evt: {
+    stream: string;
+    runId: string;
+    data: Record<string, unknown>;
+}): void;
+export declare function getActiveRunIds(): string[];
+export declare function getActiveRunCount(): number;
+export declare function resetActiveRunsForTest(): void;

package/dist/src/agent/active-runs.js

@@ -0,0 +1,20 @@
+/** Tracks agent runs that have emitted lifecycle `phase: start` without matching `end`/`error`. */
+const active = new Set();
+export function observeAgentEventForActiveRuns(evt) {
+    if (evt.stream !== "lifecycle")
+        return;
+    const phase = evt.data.phase;
+    if (phase === "start")
+        active.add(evt.runId);
+    if (phase === "end" || phase === "error")
+        active.delete(evt.runId);
+}
+export function getActiveRunIds() {
+    return [...active];
+}
+export function getActiveRunCount() {
+    return active.size;
+}
+export function resetActiveRunsForTest() {
+    active.clear();
+}

package/dist/src/agent/dispatch-bridge.d.ts

@@ -0,0 +1,5 @@
+type DispatchFn = (args: unknown) => Promise<unknown> | unknown;
+export declare function runFridayDispatch(args: Parameters<DispatchFn>[0]): ReturnType<DispatchFn>;
+export declare function __setMockFridayDispatchForTests(fn: DispatchFn): void;
+export declare function __resetMockFridayDispatchForTests(): void;
+export {};

package/dist/src/agent/dispatch-bridge.js

@@ -0,0 +1,12 @@
+let overrideDispatch = null;
+export function runFridayDispatch(args) {
+    if (overrideDispatch)
+        return overrideDispatch(args);
+    return import("openclaw/plugin-sdk/reply-dispatch-runtime").then((m) => m.dispatchReplyWithDispatcher(args));
+}
+export function __setMockFridayDispatchForTests(fn) {
+    overrideDispatch = fn;
+}
+export function __resetMockFridayDispatchForTests() {
+    overrideDispatch = null;
+}

package/dist/src/agent/media-bridge.d.ts

@@ -0,0 +1,4 @@
+export declare function saveInboundMediaBuffer(buffer: Buffer, mimeType: string): Promise<{
+    id: string;
+    path: string;
+}>;

package/dist/src/agent/media-bridge.js

@@ -0,0 +1,21 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import crypto from "node:crypto";
+export async function saveInboundMediaBuffer(buffer, mimeType) {
+    try {
+        const sdk = await import("openclaw/plugin-sdk/media-store");
+        const saved = await sdk.saveMediaBuffer(buffer, mimeType, "inbound");
+        if (saved?.id && saved?.path)
+            return { id: saved.id, path: saved.path };
+    }
+    catch {
+        // fallback for tests or stripped runtime
+    }
+    const id = crypto.randomUUID();
+    const dir = path.join(os.tmpdir(), "friday-next-media");
+    fs.mkdirSync(dir, { recursive: true });
+    const p = path.join(dir, id);
+    fs.writeFileSync(p, buffer);
+    return { id, path: p };
+}

package/dist/src/agent/subagent-registry.d.ts

@@ -0,0 +1,68 @@
+export type SubagentStatus = "spawning" | "running" | "ended";
+export type SubagentOutcome = "ok" | "error" | "timeout" | "killed" | "reset" | "deleted";
+export type SubagentEntry = {
+    childSessionKey: string;
+    runId?: string;
+    parentRunId?: string;
+    deviceId: string;
+    label?: string;
+    depth: number;
+    status: SubagentStatus;
+    outcome?: SubagentOutcome;
+    error?: string;
+};
+export type SubagentMeta = {
+    label?: string;
+    parentRunId?: string;
+    depth: number;
+};
+type SpawnIntent = {
+    label?: string;
+    parentRunId: string;
+    deviceId: string;
+    depth: number;
+    requesterSessionKey?: string;
+};
+/** Called by forwardAgentEventRaw on lifecycle start so we can resolve parentRunId. */
+export declare function registerSessionKeyForRun(sessionKey: string, runId: string): void;
+/** Look up subagent entry by any runId form (announce compound or bare). */
+export declare function lookupByRunId(runId: string): SubagentEntry | undefined;
+/** Look up subagent entry by childSessionKey. */
+export declare function lookupByChildSessionKey(key: string): SubagentEntry | undefined;
+/**
+ * Called on sessions_spawn item.start (before tool execution).
+ * Stores the spawn intent so spawning SSE can be emitted immediately.
+ */
+export declare function registerSpawnIntent(params: {
+    toolCallId: string;
+    label?: string;
+    deviceId: string;
+    parentRunId: string;
+    requesterSessionKey?: string;
+}): SpawnIntent;
+/** Consume a previously registered spawn intent. Returns undefined if none. */
+export declare function consumeSpawnIntent(toolCallId: string): SpawnIntent | undefined;
+/**
+ * Called when forwardAgentEventRaw sees a sessions_spawn tool result.
+ * Extracts childSessionKey, runId, taskName and registers the subagent.
+ */
+export declare function ensureSubagentFromSpawnTool(params: {
+    childSessionKey: string;
+    bareRunId?: string;
+    label?: string;
+    deviceId: string;
+    parentRunId: string;
+    requesterSessionKey?: string;
+    depth?: number;
+}): SubagentEntry;
+/** Mark subagent as ended. Resolves by bare/compound runId or childSessionKey. */
+export declare function registerEnded(params: {
+    runId?: string;
+    childSessionKey?: string;
+    outcome?: SubagentOutcome;
+    error?: string;
+}): SubagentEntry | undefined;
+/** Extract subagent metadata for SSE annotation. */
+export declare function subagentMeta(entry: SubagentEntry): SubagentMeta;
+export declare function resetForTest(): void;
+export {};

package/dist/src/agent/subagent-registry.js

@@ -0,0 +1,142 @@
+const byChildSessionKey = new Map();
+const byRunId = new Map();
+const byToolCallId = new Map();
+const sessionKeyToRunId = new Map();
+/** Called by forwardAgentEventRaw on lifecycle start so we can resolve parentRunId. */
+export function registerSessionKeyForRun(sessionKey, runId) {
+    if (!sessionKey || !runId)
+        return;
+    sessionKeyToRunId.set(sessionKey, runId);
+}
+function resolveRunIdForSessionKey(sessionKey) {
+    return sessionKeyToRunId.get(sessionKey);
+}
+/**
+ * Parse OpenClaw announce compound runId:
+ *   announce:v<version>:<sessionKey>:<bareRunId>
+ * Example:
+ *   announce:v1:agent:main:subagent:uuid:runId
+ *   → { childSessionKey: "agent:main:subagent:uuid", bareRunId: "runId" }
+ */
+const ANNOUNCE_RUN_ID_RE = /^announce:v\d+:(agent:.+?):([^:]+)$/;
+function parseAnnounceRunId(runId) {
+    const m = runId.match(ANNOUNCE_RUN_ID_RE);
+    if (!m)
+        return null;
+    return { childSessionKey: m[1] ?? "", bareRunId: m[2] ?? "" };
+}
+/** Look up subagent entry by any runId form (announce compound or bare). */
+export function lookupByRunId(runId) {
+    const direct = byRunId.get(runId);
+    if (direct)
+        return direct;
+    const parsed = parseAnnounceRunId(runId);
+    if (parsed) {
+        const byChild = byChildSessionKey.get(parsed.childSessionKey);
+        if (byChild) {
+            // Also register the compound runId for future fast lookup
+            byRunId.set(runId, byChild);
+            return byChild;
+        }
+        return byRunId.get(parsed.bareRunId);
+    }
+    return undefined;
+}
+/** Look up subagent entry by childSessionKey. */
+export function lookupByChildSessionKey(key) {
+    return byChildSessionKey.get(key);
+}
+/**
+ * Called on sessions_spawn item.start (before tool execution).
+ * Stores the spawn intent so spawning SSE can be emitted immediately.
+ */
+export function registerSpawnIntent(params) {
+    let depth = 1;
+    if (params.requesterSessionKey) {
+        const parent = byChildSessionKey.get(params.requesterSessionKey);
+        if (parent)
+            depth = parent.depth + 1;
+    }
+    const intent = {
+        label: params.label,
+        parentRunId: params.parentRunId,
+        deviceId: params.deviceId.toUpperCase(),
+        depth,
+        requesterSessionKey: params.requesterSessionKey,
+    };
+    byToolCallId.set(params.toolCallId, intent);
+    return intent;
+}
+/** Consume a previously registered spawn intent. Returns undefined if none. */
+export function consumeSpawnIntent(toolCallId) {
+    const intent = byToolCallId.get(toolCallId);
+    byToolCallId.delete(toolCallId);
+    return intent;
+}
+/**
+ * Called when forwardAgentEventRaw sees a sessions_spawn tool result.
+ * Extracts childSessionKey, runId, taskName and registers the subagent.
+ */
+export function ensureSubagentFromSpawnTool(params) {
+    const existing = byChildSessionKey.get(params.childSessionKey);
+    if (existing) {
+        if (params.bareRunId && !existing.runId) {
+            existing.runId = params.bareRunId;
+            byRunId.set(params.bareRunId, existing);
+            sessionKeyToRunId.set(params.childSessionKey, params.bareRunId);
+        }
+        existing.status = "running";
+        return existing;
+    }
+    let depth = params.depth ?? 1;
+    if (depth <= 1 && params.requesterSessionKey) {
+        const parent = byChildSessionKey.get(params.requesterSessionKey);
+        if (parent)
+            depth = parent.depth + 1;
+    }
+    const entry = {
+        childSessionKey: params.childSessionKey,
+        runId: params.bareRunId,
+        parentRunId: params.parentRunId,
+        deviceId: params.deviceId.toUpperCase(),
+        label: params.label || undefined,
+        depth,
+        status: "running",
+    };
+    byChildSessionKey.set(params.childSessionKey, entry);
+    if (params.bareRunId) {
+        byRunId.set(params.bareRunId, entry);
+        sessionKeyToRunId.set(params.childSessionKey, params.bareRunId);
+    }
+    return entry;
+}
+/** Mark subagent as ended. Resolves by bare/compound runId or childSessionKey. */
+export function registerEnded(params) {
+    let entry;
+    if (params.runId)
+        entry = lookupByRunId(params.runId);
+    if (!entry && params.childSessionKey)
+        entry = byChildSessionKey.get(params.childSessionKey);
+    if (!entry)
+        return undefined;
+    entry.status = "ended";
+    if (params.outcome)
+        entry.outcome = params.outcome;
+    if (params.error)
+        entry.error = params.error;
+    return entry;
+}
+/** Extract subagent metadata for SSE annotation. */
+export function subagentMeta(entry) {
+    return {
+        label: entry.label,
+        parentRunId: entry.parentRunId,
+        depth: entry.depth,
+    };
+}
+export function resetForTest() {
+    byChildSessionKey.clear();
+    byRunId.clear();
+    byToolCallId.clear();
+    sessionKeyToRunId.clear();
+}

package/dist/src/agent-forward-runtime.d.ts

@@ -0,0 +1,17 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk/plugin-entry";
+export type FridayAgentForwardRuntime = {
+    resolveStorePath: (store?: string, opts?: {
+        agentId?: string;
+    }) => string;
+    loadSessionStore: (path: string, options?: {
+        skipCache?: boolean;
+        maintenanceConfig?: unknown;
+        clone?: boolean;
+    }) => Record<string, unknown>;
+    getConfig: () => unknown;
+};
+/** Called from `registerFull` so terminal lifecycle forwards can read `sessions.json` after persist. */
+export declare function setFridayAgentForwardRuntime(api: OpenClawPluginApi): void;
+export declare function getFridayAgentForwardRuntime(): FridayAgentForwardRuntime | null;
+/** Vitest-only */
+export declare function resetFridayAgentForwardRuntimeForTest(): void;

package/dist/src/agent-forward-runtime.js

@@ -0,0 +1,16 @@
+let forwardRuntime = null;
+/** Called from `registerFull` so terminal lifecycle forwards can read `sessions.json` after persist. */
+export function setFridayAgentForwardRuntime(api) {
+    forwardRuntime = {
+        resolveStorePath: api.runtime.agent.session.resolveStorePath,
+        loadSessionStore: api.runtime.agent.session.loadSessionStore,
+        getConfig: () => api.runtime.config.current(),
+    };
+}
+export function getFridayAgentForwardRuntime() {
+    return forwardRuntime;
+}
+/** Vitest-only */
+export function resetFridayAgentForwardRuntimeForTest() {
+    forwardRuntime = null;
+}

package/dist/src/agent-run-context-bridge.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Read OpenClaw agent run context (sessionKey, …) from the same global singleton
+ * as `src/infra/agent-events.ts` (`Symbol.for("openclaw.agentEvents.state")`).
+ *
+ * When a run is hidden from Control UI, `emitAgentEvent` strips `sessionKey` from
+ * the listener payload, but `runContextById` still holds it — we need that for
+ * Friday SSE and tool hooks without importing the `openclaw` package from this folder.
+ */
+export type OpenClawAgentRunContextBridge = {
+    sessionKey?: string;
+    isControlUiVisible?: boolean;
+};
+export declare function getOpenClawAgentRunContext(runId: string): OpenClawAgentRunContextBridge | undefined;

package/dist/src/agent-run-context-bridge.js

@@ -0,0 +1,23 @@
+/**
+ * Read OpenClaw agent run context (sessionKey, …) from the same global singleton
+ * as `src/infra/agent-events.ts` (`Symbol.for("openclaw.agentEvents.state")`).
+ *
+ * When a run is hidden from Control UI, `emitAgentEvent` strips `sessionKey` from
+ * the listener payload, but `runContextById` still holds it — we need that for
+ * Friday SSE and tool hooks without importing the `openclaw` package from this folder.
+ */
+const AGENT_EVENT_STATE_KEY = Symbol.for("openclaw.agentEvents.state");
+function getAgentEventState() {
+    const raw = globalThis[AGENT_EVENT_STATE_KEY];
+    if (!raw || typeof raw !== "object")
+        return undefined;
+    const runContextById = raw.runContextById;
+    if (!(runContextById instanceof Map))
+        return undefined;
+    return { runContextById };
+}
+export function getOpenClawAgentRunContext(runId) {
+    if (!runId)
+        return undefined;
+    return getAgentEventState()?.runContextById.get(runId);
+}

package/dist/src/channel-actions.d.ts

@@ -0,0 +1,13 @@
+type MessageActionCtx = {
+    action: string;
+    params: Record<string, unknown>;
+    mediaReadFile?: (filePath: string) => Promise<Buffer>;
+    sessionKey?: string | null;
+    requesterSenderId?: string | null;
+};
+export declare function describeMessageActions(): {
+    actions: readonly ["send", "channel-info", "channel-list"];
+    capabilities: readonly ["text", "media"];
+};
+export declare function handleMessageAction(ctx: MessageActionCtx): Promise<unknown>;
+export {};