chrome-openclaw-sider 1.0.2 → 1.0.26

package/{src/auth.ts → dist/src/auth.js}

@@ -1,70 +1,36 @@
-import { type OpenClawConfig, type PluginRuntime } from "openclaw/plugin-sdk";
 import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
-import { type OpenClawPluginService } from "openclaw/plugin-sdk/plugin-entry";
 import {
   SIDER_CHANNEL_ID,
   SIDER_DEFAULT_BASE_URL,
+  SIDER_SERVICE_ID,
   readDefaultSiderSetupTokenEnv,
-  readSiderBaseUrlEnv,
+  readSiderBaseUrlEnv
 } from "./config.js";
 import { SIDER_USER_AGENT } from "./user-agent.js";
-
-export const SIDER_AUTH_EXCHANGE_API_PATH = "/v1/claws/register";
-export type SiderSetupConfigSnapshot = {
-  enabled?: boolean;
-  setupToken?: string;
-  token?: string;
-};
-
-type SiderRegisterResponse = {
-  claw_id: string;
-  token: string;
-};
-
-type SiderResolvedCredentials = {
-  token: string;
-};
-
-type SiderAuthSetupServiceParams = {
-  listAccountIds: (cfg: OpenClawConfig) => string[];
-  getAccountSetupConfig: (
-    cfg: OpenClawConfig,
-    accountId: string,
-  ) => SiderSetupConfigSnapshot;
-};
-
-let runtimeRef: PluginRuntime | null = null;
-const pendingAccountOperations = new Map<string, Promise<OpenClawConfig>>();
-
-function getSiderAuthRuntime(): PluginRuntime {
+const SIDER_AUTH_EXCHANGE_API_PATH = "/v1/claws/register";
+let runtimeRef = null;
+const pendingAccountOperations = /* @__PURE__ */ new Map();
+function getSiderAuthRuntime() {
   if (!runtimeRef) {
     throw new Error("sider auth runtime not initialized");
   }
   return runtimeRef;
 }
-
-function trimMaybe(value: string | undefined): string | undefined {
+function trimMaybe(value) {
   const trimmed = value?.trim();
-  return trimmed || undefined;
+  return trimmed || void 0;
 }
-
-function normalizeGatewayUrl(raw?: string): string | undefined {
+function normalizeGatewayUrl(raw) {
   const trimmed = trimMaybe(raw);
-  return trimmed ? trimmed.replace(/\/+$/, "") : undefined;
+  return trimmed ? trimmed.replace(/\/+$/, "") : void 0;
 }
-
-export function resolveSiderBaseUrl(): string {
+function resolveSiderBaseUrl() {
   return normalizeGatewayUrl(readSiderBaseUrlEnv()) ?? SIDER_DEFAULT_BASE_URL;
 }
-
-function getPendingOperation(accountId: string): Promise<OpenClawConfig> | undefined {
+function getPendingOperation(accountId) {
   return pendingAccountOperations.get(accountId);
 }
-
-async function withPendingOperation(
-  accountId: string,
-  run: () => Promise<OpenClawConfig>,
-): Promise<OpenClawConfig> {
+async function withPendingOperation(accountId, run) {
   const existing = getPendingOperation(accountId);
   if (existing) {
     return await existing;
@@ -79,8 +45,7 @@ async function withPendingOperation(
   pendingAccountOperations.set(accountId, pending);
   return await pending;
 }
-
-function buildSiderApiUrl(pathname: string): string {
+function buildSiderApiUrl(pathname) {
   const url = new URL(resolveSiderBaseUrl());
   const basePath = url.pathname.replace(/\/+$/, "");
   const suffix = pathname.startsWith("/") ? pathname : `/${pathname}`;
@@ -89,20 +54,17 @@ function buildSiderApiUrl(pathname: string): string {
   url.hash = "";
   return url.toString();
 }
-
-export function resolveSiderApiUrl(pathname: string): string {
+function resolveSiderApiUrl(pathname) {
   return buildSiderApiUrl(pathname);
 }
-
-export function formatAuthorizationHeader(token: string): string {
+function formatAuthorizationHeader(token) {
   const trimmed = token.trim();
   if (!trimmed) {
     return trimmed;
   }
   return /^Bearer\s+/i.test(trimmed) ? trimmed : `Bearer ${trimmed}`;
 }
-
-export function appendTokenQuery(url: string, token?: string): string {
+function appendTokenQuery(url, token) {
   const trimmed = token?.trim();
   if (!trimmed) {
     return url;
@@ -111,41 +73,32 @@ export function appendTokenQuery(url: string, token?: string): string {
   next.searchParams.set("token", trimmed);
   return next.toString();
 }
-
-function parseRegisterResponse(payload: unknown): SiderRegisterResponse {
+function parseRegisterResponse(payload) {
   if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
     throw new Error("selfclaw register response is not a JSON object");
   }
   const clawId = trimMaybe(
-    typeof (payload as Record<string, unknown>).claw_id === "string"
-      ? ((payload as Record<string, unknown>).claw_id as string)
-      : undefined,
+    typeof payload.claw_id === "string" ? payload.claw_id : void 0
   );
   const token = trimMaybe(
-    typeof (payload as Record<string, unknown>).token === "string"
-      ? ((payload as Record<string, unknown>).token as string)
-      : undefined,
+    typeof payload.token === "string" ? payload.token : void 0
   );
   if (!clawId || !token) {
     throw new Error("selfclaw register response missing claw_id/token");
   }
   return {
     claw_id: clawId,
-    token,
+    token
   };
 }
-
-async function exchangeSetupToken(params: {
-  pathname: string;
-  authorization: string;
-}): Promise<SiderResolvedCredentials> {
+async function exchangeSetupToken(params) {
   const url = buildSiderApiUrl(params.pathname);
   const response = await fetch(url, {
     method: "POST",
     headers: {
       Authorization: formatAuthorizationHeader(params.authorization),
-      "User-Agent": SIDER_USER_AGENT,
-    },
+      "User-Agent": SIDER_USER_AGENT
+    }
   });
   if (!response.ok) {
     let detail = "";
@@ -155,11 +108,10 @@ async function exchangeSetupToken(params: {
         detail = `: ${text}`;
       }
     } catch {
-      // Ignore body read failures and keep the status-only error.
     }
     throw new Error(`selfclaw request failed (${response.status} ${response.statusText})${detail}`);
   }
-  let payload: unknown = null;
+  let payload = null;
   try {
     payload = await response.json();
   } catch {
@@ -168,86 +120,56 @@ async function exchangeSetupToken(params: {
   const parsed = parseRegisterResponse(payload);
   return { token: parsed.token };
 }
-
-export function cloneOpenClawConfig(cfg: OpenClawConfig): OpenClawConfig {
+function cloneOpenClawConfig(cfg) {
   return structuredClone(cfg);
 }
-
-function ensureChannelConfig(cfg: OpenClawConfig): Record<string, unknown> {
-  const next = cfg as OpenClawConfig & {
-    channels?: Record<string, Record<string, unknown>>;
-  };
+function ensureChannelConfig(cfg) {
+  const next = cfg;
   next.channels ??= {};
   next.channels[SIDER_CHANNEL_ID] ??= {};
-  return next.channels[SIDER_CHANNEL_ID]!;
+  return next.channels[SIDER_CHANNEL_ID];
 }
-
-export function resolveWritableSiderAccountConfig(
-  cfg: OpenClawConfig,
-  accountId: string,
-): Record<string, unknown> {
+function resolveWritableSiderAccountConfig(cfg, accountId) {
   const channelCfg = ensureChannelConfig(cfg);
   if (accountId === DEFAULT_ACCOUNT_ID) {
     return channelCfg;
   }
-  const accounts =
-    typeof channelCfg.accounts === "object" && channelCfg.accounts && !Array.isArray(channelCfg.accounts)
-      ? (channelCfg.accounts as Record<string, Record<string, unknown>>)
-      : ((channelCfg.accounts = {}) as Record<string, Record<string, unknown>>);
+  const accounts = typeof channelCfg.accounts === "object" && channelCfg.accounts && !Array.isArray(channelCfg.accounts) ? channelCfg.accounts : channelCfg.accounts = {};
   accounts[accountId] ??= {};
-  return accounts[accountId]!;
+  return accounts[accountId];
 }
-
-async function persistSiderCredentials(params: {
-  accountId: string;
-  credentials: SiderResolvedCredentials;
-}): Promise<OpenClawConfig> {
+async function persistSiderCredentials(params) {
   const runtime = getSiderAuthRuntime();
   const latestCfg = cloneOpenClawConfig(runtime.config.loadConfig());
   const accountCfg = resolveWritableSiderAccountConfig(latestCfg, params.accountId);
   accountCfg.token = params.credentials.token;
   delete accountCfg.setupToken;
-  if (accountCfg.enabled === undefined) {
+  if (accountCfg.enabled === void 0) {
     accountCfg.enabled = true;
   }
   await runtime.config.writeConfigFile(latestCfg);
   return latestCfg;
 }
-
-function resolveConfiguredSetupToken(snapshot: SiderSetupConfigSnapshot): string | undefined {
+function resolveConfiguredSetupToken(snapshot) {
   return trimMaybe(snapshot.setupToken);
 }
-
-export function setSiderAuthRuntime(runtime: PluginRuntime): void {
+function setSiderAuthRuntime(runtime) {
   runtimeRef = runtime;
 }
-
-export function resolveSiderSetupToken(
-  accountId: string,
-  snapshot?: SiderSetupConfigSnapshot,
-): string | undefined {
-  const configuredToken = snapshot ? resolveConfiguredSetupToken(snapshot) : undefined;
+function resolveSiderSetupToken(accountId, snapshot) {
+  const configuredToken = snapshot ? resolveConfiguredSetupToken(snapshot) : void 0;
   if (configuredToken) {
     return configuredToken;
   }
   if (accountId === DEFAULT_ACCOUNT_ID) {
     return trimMaybe(readDefaultSiderSetupTokenEnv());
   }
-  return undefined;
+  return void 0;
 }
-
-export function isSiderAccountSetupPending(accountId: string): boolean {
+function isSiderAccountSetupPending(accountId) {
   return pendingAccountOperations.has(accountId);
 }
-
-export async function ensureSiderAccountSetup(params: {
-  cfg: OpenClawConfig;
-  accountId: string;
-  getAccountSetupConfig: (
-    cfg: OpenClawConfig,
-    accountId: string,
-  ) => SiderSetupConfigSnapshot;
-}): Promise<OpenClawConfig> {
+async function ensureSiderAccountSetup(params) {
   const snapshot = params.getAccountSetupConfig(params.cfg, params.accountId);
   if (snapshot.enabled === false) {
     return params.cfg;
@@ -259,20 +181,17 @@ export async function ensureSiderAccountSetup(params: {
   return await withPendingOperation(params.accountId, async () => {
     const credentials = await exchangeSetupToken({
       pathname: SIDER_AUTH_EXCHANGE_API_PATH,
-      authorization: setupToken,
+      authorization: setupToken
     });
     return await persistSiderCredentials({
       accountId: params.accountId,
-      credentials,
+      credentials
     });
   });
 }
-
-export function createSiderAuthSetupService(
-  params: SiderAuthSetupServiceParams,
-): OpenClawPluginService {
+function createSiderAuthSetupService(params) {
   return {
-    id: "sider-auth-setup",
+    id: SIDER_SERVICE_ID,
     start: async (ctx) => {
       const accountIds = params.listAccountIds(ctx.config);
       for (const accountId of accountIds) {
@@ -280,13 +199,27 @@ export function createSiderAuthSetupService(
           await ensureSiderAccountSetup({
             cfg: ctx.config,
             accountId,
-            getAccountSetupConfig: params.getAccountSetupConfig,
+            getAccountSetupConfig: params.getAccountSetupConfig
           });
         } catch (error) {
           const message = error instanceof Error ? error.message : String(error);
           ctx.logger.warn(`sider setup failed for "${accountId}": ${message}`);
         }
       }
-    },
+    }
   };
 }
+export {
+  SIDER_AUTH_EXCHANGE_API_PATH,
+  appendTokenQuery,
+  cloneOpenClawConfig,
+  createSiderAuthSetupService,
+  ensureSiderAccountSetup,
+  formatAuthorizationHeader,
+  isSiderAccountSetupPending,
+  resolveSiderApiUrl,
+  resolveSiderBaseUrl,
+  resolveSiderSetupToken,
+  resolveWritableSiderAccountConfig,
+  setSiderAuthRuntime
+};

package/dist/src/auto-title.d.ts

@@ -0,0 +1,20 @@
+import { OpenClawConfig } from 'openclaw/plugin-sdk';
+
+type SiderAutoTitleConfig = boolean | {
+    enabled?: boolean;
+    prompt?: string;
+};
+declare const AUTO_SIDER_TITLE_DEFAULT_PROMPT = "Generate a very short chat title (2-4 words, max 25 chars) for a conversation based on the user's first message below. No emoji. Use the same language as the message. Be concise and descriptive. Return ONLY the title, nothing else.";
+declare function resolveAutoTitleConfig(config?: SiderAutoTitleConfig): {
+    enabled: true;
+    prompt: string;
+} | null;
+declare function generateSiderSessionTitle(params: {
+    userMessage: string;
+    prompt: string;
+    cfg: OpenClawConfig;
+    agentId?: string;
+    agentDir?: string;
+}): Promise<string | null>;
+
+export { AUTO_SIDER_TITLE_DEFAULT_PROMPT, type SiderAutoTitleConfig, generateSiderSessionTitle, resolveAutoTitleConfig };

package/dist/src/auto-title.js

@@ -0,0 +1,22 @@
+import { generateTopicLabel } from "openclaw/plugin-sdk/reply-runtime";
+const AUTO_SIDER_TITLE_DEFAULT_PROMPT = "Generate a very short chat title (2-4 words, max 25 chars) for a conversation based on the user's first message below. No emoji. Use the same language as the message. Be concise and descriptive. Return ONLY the title, nothing else.";
+function resolveAutoTitleConfig(config) {
+  if (config === void 0 || config === true) {
+    return { enabled: true, prompt: AUTO_SIDER_TITLE_DEFAULT_PROMPT };
+  }
+  if (config === false || config.enabled === false) {
+    return null;
+  }
+  return {
+    enabled: true,
+    prompt: config.prompt?.trim() || AUTO_SIDER_TITLE_DEFAULT_PROMPT
+  };
+}
+async function generateSiderSessionTitle(params) {
+  return await generateTopicLabel(params);
+}
+export {
+  AUTO_SIDER_TITLE_DEFAULT_PROMPT,
+  generateSiderSessionTitle,
+  resolveAutoTitleConfig
+};

package/dist/src/channel-auto-title.d.ts

@@ -0,0 +1,23 @@
+import { OpenClawConfig } from 'openclaw/plugin-sdk/config-runtime';
+import { ResolvedSiderAccount } from './account.js';
+import 'openclaw/plugin-sdk/setup';
+import './auth.js';
+import 'openclaw/plugin-sdk';
+import 'openclaw/plugin-sdk/plugin-entry';
+import './auto-title.js';
+
+declare function isFirstTurnInSiderSession(params: {
+    cfg: OpenClawConfig;
+    agentId: string;
+    sessionKey?: string;
+}): boolean;
+declare function scheduleSiderAutoTitleUpdate(params: {
+    cfg: OpenClawConfig;
+    account: ResolvedSiderAccount;
+    sessionId: string;
+    userMessage: string;
+    prompt: string;
+    agentId: string;
+}): void;
+
+export { isFirstTurnInSiderSession, scheduleSiderAutoTitleUpdate };

package/dist/src/channel-auto-title.js

@@ -0,0 +1,77 @@
+import {
+  loadSessionStore,
+  resolveSessionStoreEntry
+} from "openclaw/plugin-sdk/config-runtime";
+import { resolveAgentDir } from "openclaw/plugin-sdk/agent-runtime";
+import { generateSiderSessionTitle } from "./auto-title.js";
+import { getSiderRuntime, logDebug, logWarn } from "./channel-runtime.js";
+import { updateSiderSessionTitle } from "./channel-util.js";
+function isFirstTurnInSiderSession(params) {
+  if (!params.sessionKey) {
+    return false;
+  }
+  const storePath = getSiderRuntime().channel.session.resolveStorePath(params.cfg.session?.store, {
+    agentId: params.agentId
+  });
+  const store = loadSessionStore(storePath, {
+    skipCache: true
+  });
+  const entry = resolveSessionStoreEntry({
+    store,
+    sessionKey: params.sessionKey
+  }).existing;
+  return !entry?.systemSent;
+}
+function scheduleSiderAutoTitleUpdate(params) {
+  const userMessage = params.userMessage.trim();
+  if (!userMessage) {
+    return;
+  }
+  const authorization = params.account.token?.trim();
+  if (!authorization) {
+    logWarn("sider auto-title skipped: missing auth token", {
+      accountId: params.account.accountId,
+      sessionId: params.sessionId
+    });
+    return;
+  }
+  const agentDir = resolveAgentDir(params.cfg, params.agentId);
+  void (async () => {
+    try {
+      const title = await generateSiderSessionTitle({
+        userMessage,
+        prompt: params.prompt,
+        cfg: params.cfg,
+        agentId: params.agentId,
+        agentDir
+      });
+      if (!title) {
+        logDebug("sider auto-title generator returned empty title", {
+          accountId: params.account.accountId,
+          sessionId: params.sessionId
+        });
+        return;
+      }
+      await updateSiderSessionTitle({
+        sessionId: params.sessionId,
+        title,
+        authorization
+      });
+      logDebug("sider auto-title updated session title", {
+        accountId: params.account.accountId,
+        sessionId: params.sessionId,
+        titleLength: title.length
+      });
+    } catch (error) {
+      logWarn("sider auto-title update failed", {
+        accountId: params.account.accountId,
+        sessionId: params.sessionId,
+        error: String(error)
+      });
+    }
+  })();
+}
+export {
+  isFirstTurnInSiderSession,
+  scheduleSiderAutoTitleUpdate
+};

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

@@ -0,0 +1,105 @@
+import { SiderSampleEvent, SiderPart } from './channel-types.js';
+import 'openclaw/plugin-sdk';
+import './account.js';
+import 'openclaw/plugin-sdk/setup';
+import './auth.js';
+import 'openclaw/plugin-sdk/plugin-entry';
+import './auto-title.js';
+import 'ws';
+
+declare function isPathLikeSource(value: string): boolean;
+declare function buildSourceFields(source?: string): Record<string, unknown>;
+declare function buildThinkingPart(text: string): SiderPart;
+declare function buildTextPart(text: string): SiderPart;
+declare function buildToolCallPart(params: {
+    callId: string;
+    toolName?: string;
+    toolCallId?: string;
+    runId?: string;
+    toolArgs?: unknown;
+}): SiderPart;
+declare function buildToolResultPart(params: {
+    callId: string;
+    toolName?: string;
+    toolCallId?: string;
+    runId?: string;
+    toolArgs?: unknown;
+    result?: unknown;
+    error?: string;
+    durationMs?: number;
+}): SiderPart;
+declare function buildTypingEvent(params: {
+    state: "typing" | "idle";
+    sessionId: string;
+    accountId: string;
+}): SiderSampleEvent;
+declare function buildStreamingStartEvent(params: {
+    sessionId: string;
+    streamId: string;
+    accountId: string;
+}): SiderSampleEvent;
+declare function buildStreamingDeltaEvent(params: {
+    sessionId: string;
+    streamId: string;
+    seq: number;
+    delta: string;
+    text: string;
+    accountId: string;
+}): SiderSampleEvent;
+declare function buildStreamingDoneEvent(params: {
+    sessionId: string;
+    streamId: string;
+    seq: number;
+    accountId: string;
+    reason: "final" | "interrupted";
+}): SiderSampleEvent;
+declare function buildReasoningStartEvent(params: {
+    sessionId: string;
+    streamId: string;
+    accountId: string;
+}): SiderSampleEvent;
+declare function buildReasoningDeltaEvent(params: {
+    sessionId: string;
+    streamId: string;
+    seq: number;
+    delta: string;
+    text: string;
+    accountId: string;
+}): SiderSampleEvent;
+declare function buildReasoningDoneEvent(params: {
+    sessionId: string;
+    streamId: string;
+    seq: number;
+    accountId: string;
+    reason: "final" | "interrupted";
+}): SiderSampleEvent;
+declare function buildToolCallEvent(params: {
+    sessionId: string;
+    accountId: string;
+    seq: number;
+    callId: string;
+    phase: "start";
+    toolName?: string;
+    toolCallId?: string;
+    runId?: string;
+    sessionKey?: string;
+    toolArgs?: Record<string, unknown>;
+    error?: string;
+    durationMs?: number;
+}): SiderSampleEvent;
+declare function buildToolResultEvent(params: {
+    sessionId: string;
+    accountId: string;
+    seq: number;
+    callId: string;
+    toolName?: string;
+    toolCallId?: string;
+    runId?: string;
+    sessionKey?: string;
+    toolArgs?: Record<string, unknown>;
+    result?: unknown;
+    error?: string;
+    durationMs?: number;
+}): SiderSampleEvent;
+
+export { buildReasoningDeltaEvent, buildReasoningDoneEvent, buildReasoningStartEvent, buildSourceFields, buildStreamingDeltaEvent, buildStreamingDoneEvent, buildStreamingStartEvent, buildTextPart, buildThinkingPart, buildToolCallEvent, buildToolCallPart, buildToolResultEvent, buildToolResultPart, buildTypingEvent, isPathLikeSource };