@clawchatsai/connector 0.0.86 → 0.0.88

package/server/util/helpers.js

@@ -0,0 +1,111 @@
+export function syncThreadUnreadCount(db, threadId) {
+  const count = db.prepare('SELECT COUNT(*) as c FROM unread_messages WHERE thread_id = ?').get(threadId).c;
+  db.prepare('UPDATE threads SET unread_count = ? WHERE id = ?').run(count, threadId);
+  return count;
+}
+
+export function parseSessionKey(sessionKey) {
+  if (!sessionKey) return null;
+  const match = sessionKey.match(/^agent:([^:]+):([^:]+):chat:([^:]+)$/);
+  if (!match) return null;
+  return { agent: match[1], workspace: match[2], threadId: match[3] };
+}
+
+export function extractContent(message) {
+  if (!message) return '';
+  if (typeof message.content === 'string') return message.content;
+  if (Array.isArray(message.content)) {
+    return message.content.filter(p => p.type === 'text').map(p => p.text).join('');
+  }
+  return '';
+}
+
+export function isSilentReplyExact(text, token = 'NO_REPLY') {
+  if (!text) return false;
+  const escaped = token.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return new RegExp(`^\\s*${escaped}\\s*$`).test(text);
+}
+
+export function isSilentReplyPrefix(text, token = 'NO_REPLY') {
+  if (!text) return false;
+  const trimmed = text.trimStart();
+  if (!trimmed) return false;
+  if (trimmed !== trimmed.toUpperCase()) return false;
+  const normalized = trimmed.toUpperCase();
+  if (normalized.length < 2 || /[^A-Z_]/.test(normalized)) return false;
+  const tokenUpper = token.toUpperCase();
+  if (!tokenUpper.startsWith(normalized)) return false;
+  if (normalized.includes('_')) return true;
+  return tokenUpper === 'NO_REPLY' && normalized === 'NO';
+}
+
+export function stripTrailingSentinel(text, token = 'NO_REPLY') {
+  if (!text) return text;
+  const escaped = token.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return text.replace(new RegExp(`(?:^|\\s+|\\*+)${escaped}\\s*$`), '').trim();
+}
+
+export function stripFinalTags(text) {
+  return text ? text.replace(/<\s*\/?\s*final\s*>/gi, '') : text;
+}
+
+export function sanitizeAssistantContent(text) {
+  if (!text) return text;
+  let out = stripFinalTags(text);
+  out = out.replace(/^(?:[ \t]*\r?\n)+/, '');
+  if (out.includes('NO_REPLY'))     out = stripTrailingSentinel(out, 'NO_REPLY');
+  if (out.includes('HEARTBEAT_OK')) out = stripTrailingSentinel(out, 'HEARTBEAT_OK');
+  return out;
+}
+
+export function generateActivitySummary(steps) {
+  const toolSteps = steps.filter(s => s.type === 'tool' && s.phase !== 'result' && s.phase !== 'update');
+  const hasThinking = steps.some(s => s.type === 'thinking' && s.text);
+  const hasNarration = steps.some(s => s.type === 'assistant' && s.text?.trim());
+  if (toolSteps.length === 0 && !hasThinking && !hasNarration) return null;
+  if (toolSteps.length === 0 && hasThinking) return 'Reasoned through the problem';
+  if (toolSteps.length === 0 && hasNarration) return 'Processed in multiple steps';
+  const counts = {};
+  for (const s of toolSteps) { const name = s.name || 'unknown'; counts[name] = (counts[name] || 0) + 1; }
+  const toolNames = { web_search: 'searched the web', web_fetch: 'fetched web pages', Read: 'read files', read: 'read files', Write: 'wrote files', write: 'wrote files', Edit: 'edited files', edit: 'edited files', exec: 'ran commands', Bash: 'ran commands', browser: 'browsed the web', memory_search: 'searched memory', memory_store: 'saved to memory', image: 'analyzed images', message: 'sent messages', sessions_spawn: 'spawned sub-agents', cron: 'managed cron jobs', Grep: 'searched code', grep: 'searched code', Glob: 'found files', glob: 'found files' };
+  const parts = [];
+  for (const [name, count] of Object.entries(counts)) {
+    const friendly = toolNames[name];
+    parts.push(friendly ? (count > 1 ? `${friendly} (${count}×)` : friendly) : (count > 1 ? `used ${name} (${count}×)` : `used ${name}`));
+  }
+  if (parts.length === 0) return null;
+  if (parts.length === 1) return parts[0].charAt(0).toUpperCase() + parts[0].slice(1);
+  const last = parts.pop();
+  return (parts.join(', ') + ' and ' + last).replace(/^./, c => c.toUpperCase());
+}
+
+export function writeActivityToDb(getDbFn, broadcastFn, runId, log) {
+  if (!log._parsed) log._parsed = parseSessionKey(log.sessionKey);
+  const parsed = log._parsed;
+  if (!parsed) return;
+  const db = getDbFn(parsed.workspace);
+  if (!db) return;
+  const cleanSteps = log.steps.map(s => { const c = { ...s }; delete c._sealed; return c; });
+  const summary = generateActivitySummary(log.steps);
+  const now = Date.now();
+  if (!log._messageId) {
+    const thread = db.prepare('SELECT id FROM threads WHERE id = ?').get(parsed.threadId);
+    if (!thread) return;
+    const messageId = `gw-activity-${runId}`;
+    const metadata = { activityLog: cleanSteps, activitySummary: summary, pending: true };
+    try {
+      db.prepare(`INSERT OR IGNORE INTO messages (id, thread_id, role, content, status, metadata, timestamp, created_at) VALUES (?, ?, 'assistant', '', 'sent', ?, ?, ?)`).run(messageId, parsed.threadId, JSON.stringify(metadata), now, now);
+      log._messageId = messageId;
+      broadcastFn(JSON.stringify({ type: 'clawchats', event: 'message-saved', threadId: parsed.threadId, workspace: parsed.workspace, messageId, timestamp: now }));
+    } catch (err) {
+      console.error(`[activity] Failed to write activity ${messageId}:`, err.message);
+    }
+  } else {
+    const existing = db.prepare('SELECT metadata FROM messages WHERE id = ?').get(log._messageId);
+    const metadata = existing?.metadata ? JSON.parse(existing.metadata) : {};
+    metadata.activityLog = cleanSteps;
+    metadata.activitySummary = summary;
+    metadata.pending = true;
+    db.prepare('UPDATE messages SET metadata = ? WHERE id = ?').run(JSON.stringify(metadata), log._messageId);
+  }
+}

package/server/util/http.js

@@ -0,0 +1,57 @@
+import crypto from 'node:crypto';
+
+export function parseBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on('data', c => chunks.push(c));
+    req.on('end', () => {
+      const raw = Buffer.concat(chunks).toString();
+      if (!raw) return resolve({});
+      try { resolve(JSON.parse(raw)); }
+      catch { reject(new Error('Invalid JSON')); }
+    });
+    req.on('error', reject);
+  });
+}
+
+export function send(res, status, data) {
+  const body = JSON.stringify(data);
+  res.writeHead(status, {
+    'Content-Type': 'application/json',
+    'Access-Control-Allow-Origin': '*',
+    'Access-Control-Allow-Methods': 'GET, POST, PATCH, DELETE, OPTIONS',
+    'Access-Control-Allow-Headers': 'Content-Type, Authorization',
+  });
+  res.end(body);
+}
+
+export function sendError(res, status, message) {
+  send(res, status, { error: message });
+}
+
+export function setCors(res) {
+  res.setHeader('Access-Control-Allow-Origin', '*');
+  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PATCH, DELETE, OPTIONS');
+  res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+}
+
+export function uuid() {
+  return crypto.randomUUID();
+}
+
+export function matchRoute(method, url, pattern) {
+  const [pMethod, pPath] = pattern.split(' ');
+  if (method !== pMethod) return null;
+  const pParts = pPath.split('/').filter(Boolean);
+  const uParts = url.split('/').filter(Boolean);
+  if (pParts.length !== uParts.length) return null;
+  const params = {};
+  for (let i = 0; i < pParts.length; i++) {
+    if (pParts[i].startsWith(':')) {
+      params[pParts[i].slice(1)] = decodeURIComponent(uParts[i]);
+    } else if (pParts[i] !== uParts[i]) {
+      return null;
+    }
+  }
+  return params;
+}

package/server/util/multipart.js

@@ -0,0 +1,46 @@
+export function parseMultipart(req) {
+  return new Promise((resolve, reject) => {
+    const contentType = req.headers['content-type'] || '';
+    const boundaryMatch = contentType.match(/boundary=(?:"([^"]+)"|([^\s;]+))/);
+    if (!boundaryMatch) return reject(new Error('No boundary in content-type'));
+    const boundary = boundaryMatch[1] || boundaryMatch[2];
+    const chunks = [];
+    req.on('data', c => chunks.push(c));
+    req.on('end', () => {
+      const buf = Buffer.concat(chunks);
+      const files = [];
+      const delimiter = Buffer.from(`--${boundary}`);
+
+      let pos = 0;
+      while (pos < buf.length) {
+        const start = buf.indexOf(delimiter, pos);
+        if (start === -1) break;
+        const nextStart = buf.indexOf(delimiter, start + delimiter.length);
+        if (nextStart === -1) break;
+
+        const part = buf.subarray(start + delimiter.length, nextStart);
+        const headerEnd = part.indexOf('\r\n\r\n');
+        if (headerEnd === -1) { pos = nextStart; continue; }
+
+        const headerStr = part.subarray(0, headerEnd).toString();
+        let body = part.subarray(headerEnd + 4);
+        if (body.length >= 2 && body[body.length - 2] === 0x0d && body[body.length - 1] === 0x0a) {
+          body = body.subarray(0, body.length - 2);
+        }
+
+        const filenameMatch = headerStr.match(/filename="([^"]+)"/);
+        const ctMatch = headerStr.match(/Content-Type:\s*(\S+)/i);
+        if (filenameMatch) {
+          files.push({
+            filename: filenameMatch[1],
+            mimeType: ctMatch ? ctMatch[1] : 'application/octet-stream',
+            data: body,
+          });
+        }
+        pos = nextStart;
+      }
+      resolve(files);
+    });
+    req.on('error', reject);
+  });
+}

package/dist/migrate.d.ts

@@ -1,16 +0,0 @@
-/**
- * Schema migration runner for the ClawChats plugin SQLite database.
- *
- * - Tracks schema version in a `_schema_version` table
- * - Runs migrations sequentially from current version to target
- * - Creates a backup before migrating (if not `:memory:` and currentVersion > 0)
- * - Wraps all migrations in a transaction with rollback on error
- */
-import type Database from 'better-sqlite3';
-export declare const SCHEMA_VERSION = 1;
-/**
- * Run all pending migrations against the given database.
- *
- * Safe to call on every startup — exits early if already up to date.
- */
-export declare function runMigrations(db: Database): void;

package/dist/migrate.js

@@ -1,114 +0,0 @@
-/**
- * Schema migration runner for the ClawChats plugin SQLite database.
- *
- * - Tracks schema version in a `_schema_version` table
- * - Runs migrations sequentially from current version to target
- * - Creates a backup before migrating (if not `:memory:` and currentVersion > 0)
- * - Wraps all migrations in a transaction with rollback on error
- */
-import * as fs from 'node:fs';
-export const SCHEMA_VERSION = 1;
-const migrations = [
-    {
-        version: 1,
-        up: (db) => {
-            db.exec(`
-        CREATE TABLE IF NOT EXISTS threads (
-          id TEXT PRIMARY KEY,
-          session_key TEXT UNIQUE NOT NULL,
-          title TEXT DEFAULT 'New chat',
-          pinned INTEGER DEFAULT 0,
-          pin_order INTEGER DEFAULT 0,
-          model TEXT,
-          last_session_id TEXT,
-          sort_order INTEGER DEFAULT 0,
-          unread_count INTEGER DEFAULT 0,
-          created_at INTEGER NOT NULL,
-          updated_at INTEGER NOT NULL
-        );
-
-        CREATE TABLE IF NOT EXISTS messages (
-          id TEXT PRIMARY KEY,
-          thread_id TEXT NOT NULL,
-          role TEXT NOT NULL,
-          content TEXT NOT NULL,
-          status TEXT DEFAULT 'sent',
-          metadata TEXT,
-          seq INTEGER,
-          timestamp INTEGER NOT NULL,
-          created_at INTEGER NOT NULL,
-          FOREIGN KEY (thread_id) REFERENCES threads(id) ON DELETE CASCADE
-        );
-
-        CREATE INDEX IF NOT EXISTS idx_messages_thread ON messages(thread_id, timestamp);
-        CREATE INDEX IF NOT EXISTS idx_messages_dedup ON messages(thread_id, role, timestamp);
-
-        CREATE TABLE IF NOT EXISTS unread_messages (
-          thread_id TEXT NOT NULL,
-          message_id TEXT NOT NULL,
-          created_at INTEGER NOT NULL,
-          PRIMARY KEY (thread_id, message_id),
-          FOREIGN KEY (thread_id) REFERENCES threads(id) ON DELETE CASCADE
-        );
-
-        CREATE INDEX IF NOT EXISTS idx_unread_thread ON unread_messages(thread_id);
-
-        CREATE VIRTUAL TABLE messages_fts USING fts5(
-          content, content=messages, content_rowid=rowid,
-          tokenize='porter unicode61'
-        );
-
-        CREATE TRIGGER messages_ai AFTER INSERT ON messages BEGIN
-          INSERT INTO messages_fts(rowid, content) VALUES (new.rowid, new.content);
-        END;
-      `);
-        },
-    },
-];
-/**
- * Run all pending migrations against the given database.
- *
- * Safe to call on every startup — exits early if already up to date.
- */
-export function runMigrations(db) {
-    // Ensure the version-tracking table exists
-    db.exec(`
-    CREATE TABLE IF NOT EXISTS _schema_version (
-      version INTEGER NOT NULL
-    );
-  `);
-    // Read the current schema version (0 = fresh database)
-    const row = db.prepare('SELECT version FROM _schema_version LIMIT 1').get();
-    const currentVersion = row?.version ?? 0;
-    if (currentVersion >= SCHEMA_VERSION) {
-        return;
-    }
-    // Create a backup before migrating an existing database
-    const dbPath = db.name;
-    if (currentVersion > 0 && dbPath !== ':memory:') {
-        const backupPath = `${dbPath}.backup-v${currentVersion}`;
-        fs.copyFileSync(dbPath, backupPath);
-    }
-    // Run all pending migrations inside a single transaction
-    const migrate = db.transaction(() => {
-        for (const migration of migrations) {
-            if (migration.version > currentVersion) {
-                migration.up(db);
-            }
-        }
-        // Record the new schema version
-        if (row === undefined) {
-            db.prepare('INSERT INTO _schema_version (version) VALUES (?)').run(SCHEMA_VERSION);
-        }
-        else {
-            db.prepare('UPDATE _schema_version SET version = ?').run(SCHEMA_VERSION);
-        }
-    });
-    try {
-        migrate();
-    }
-    catch (err) {
-        // better-sqlite3 transactions automatically roll back on throw
-        throw err;
-    }
-}

package/dist/updater.d.ts

@@ -1,21 +0,0 @@
-/**
- * Auto-update checker for the @clawchatsai/connector plugin.
- *
- * Checks the npm registry for newer versions and can trigger
- * an in-place update via the OpenClaw plugin CLI.
- */
-export interface UpdateInfo {
-    current: string;
-    latest: string;
-}
-/**
- * Check npm registry for updates.
- * Returns UpdateInfo if a newer version is available, null otherwise.
- * Silently returns null on any network or parse error.
- */
-export declare function checkForUpdates(): Promise<UpdateInfo | null>;
-/**
- * Run the OpenClaw plugin update command.
- * Throws an Error if the command exits with a non-zero code or times out.
- */
-export declare function performUpdate(): Promise<void>;

package/dist/updater.js

@@ -1,64 +0,0 @@
-/**
- * Auto-update checker for the @clawchatsai/connector plugin.
- *
- * Checks the npm registry for newer versions and can trigger
- * an in-place update via the OpenClaw plugin CLI.
- */
-import { execFile } from 'node:child_process';
-import { PLUGIN_VERSION } from './index.js';
-/**
- * Compare two semver strings. Returns true if `a` is greater than `b`.
- * Handles major.minor.patch only — no pre-release suffixes.
- */
-function semverGt(a, b) {
-    const parse = (v) => {
-        const parts = v.split('.').map(Number);
-        return [parts[0] ?? 0, parts[1] ?? 0, parts[2] ?? 0];
-    };
-    const [aMaj, aMin, aPat] = parse(a);
-    const [bMaj, bMin, bPat] = parse(b);
-    if (aMaj !== bMaj)
-        return aMaj > bMaj;
-    if (aMin !== bMin)
-        return aMin > bMin;
-    return aPat > bPat;
-}
-/**
- * Check npm registry for updates.
- * Returns UpdateInfo if a newer version is available, null otherwise.
- * Silently returns null on any network or parse error.
- */
-export async function checkForUpdates() {
-    try {
-        const res = await fetch('https://registry.npmjs.org/@clawchatsai%2Fconnector/latest');
-        if (!res.ok)
-            return null;
-        const data = await res.json();
-        const latest = data.version;
-        if (typeof latest !== 'string')
-            return null;
-        if (!semverGt(latest, PLUGIN_VERSION))
-            return null;
-        return { current: PLUGIN_VERSION, latest };
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Run the OpenClaw plugin update command.
- * Throws an Error if the command exits with a non-zero code or times out.
- */
-export async function performUpdate() {
-    return new Promise((resolve, reject) => {
-        const child = execFile('openclaw', ['plugins', 'update', '@clawchatsai/connector'], { timeout: 120_000 }, (error) => {
-            if (error) {
-                reject(new Error(`Plugin update failed: ${error.message}`));
-            }
-            else {
-                resolve();
-            }
-        });
-        child; // reference kept to satisfy linter — callback handles lifecycle
-    });
-}