@jackle.dev/zalox-plugin 1.0.5 → 1.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jackle.dev/zalox-plugin",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "OpenClaw channel plugin for Zalo via zca-js (in-process, single login)",
   "type": "module",
   "main": "./src/index.ts",

package/src/core/templates.ts

@@ -0,0 +1,93 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { randomUUID } from 'crypto';
+import { getConfigDir, ensureConfigDir } from '../utils/config.js';
+
+export interface Template {
+  id: string;
+  name: string;
+  content: string;
+  variables: string[];
+  createdAt: string;
+  updatedAt: string;
+}
+
+function getTemplatesDir(): string {
+  const root = getConfigDir();
+  const dir = join(root, 'templates');
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+
+function getTemplatePath(id: string): string {
+  return join(getTemplatesDir(), `${id}.json`);
+}
+
+function extractVariables(content: string): string[] {
+  const matches = content.match(/\{\{(\w+)\}\}/g);
+  if (!matches) return [];
+  const vars = matches.map((m) => m.replace(/\{\{|\}\}/g, ''));
+  return [...new Set(vars)];
+}
+
+export function createTemplate(name: string, content: string): Template {
+  ensureConfigDir();
+  const dir = getTemplatesDir();
+  const existing = listTemplates();
+  if (existing.find((t) => t.name.toLowerCase() === name.toLowerCase())) {
+    throw new Error(`Template "${name}" already exists`);
+  }
+
+  const now = new Date().toISOString();
+  const template: Template = {
+    id: randomUUID().split('-')[0],
+    name,
+    content,
+    variables: extractVariables(content),
+    createdAt: now,
+    updatedAt: now,
+  };
+
+  writeFileSync(getTemplatePath(template.id), JSON.stringify(template, null, 2));
+  return template;
+}
+
+export function listTemplates(): Template[] {
+  const dir = getTemplatesDir();
+  if (!existsSync(dir)) return [];
+  const files = readdirSync(dir).filter((f) => f.endsWith('.json'));
+  const templates: Template[] = [];
+  for (const file of files) {
+    try {
+      const raw = readFileSync(join(dir, file), 'utf-8');
+      templates.push(JSON.parse(raw));
+    } catch {}
+  }
+  return templates.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+export function getTemplate(idOrName: string): Template | null {
+  const templates = listTemplates();
+  return templates.find((t) => t.id === idOrName || t.name.toLowerCase() === idOrName.toLowerCase()) || null;
+}
+
+export function deleteTemplate(idOrName: string): boolean {
+  const template = getTemplate(idOrName);
+  if (!template) return false;
+  const path = getTemplatePath(template.id);
+  if (existsSync(path)) {
+    unlinkSync(path);
+    return true;
+  }
+  return false;
+}
+
+export function renderTemplate(template: Template, vars: Record<string, string>): string {
+  let result = template.content;
+  for (const [key, value] of Object.entries(vars)) {
+    result = result.replace(new RegExp(`\\{\\{${key}\\}\\}`, 'g'), value);
+  }
+  return result;
+}

package/src/index.ts

@@ -6,21 +6,26 @@
  */
 
 import type { OpenClawPluginApi } from 'openclaw/plugin-sdk';
-import { emptyPluginConfigSchema } from 'openclaw/plugin-sdk';
 import { zaloxPlugin, zaloxDock } from './channel.js';
 import { setPluginRuntime } from './listener.js';
+import { zaloxGroupTool } from './tools.js';
+import { zaloxTemplateTool } from './tools-template.js';
 
 const plugin = {
   id: 'zalox',
   name: 'Zalo (ZaloX)',
   description: 'Zalo personal messaging — in-process, single login, no session conflicts',
-  configSchema: undefined, // Disabled to fix schema.toJSONSchema error
+  configSchema: undefined,
   register(api: OpenClawPluginApi) {
     // Store runtime for listener's message processing
     setPluginRuntime(api.runtime);
 
     // Register channel plugin
     api.registerChannel({ plugin: zaloxPlugin, dock: zaloxDock });
+
+    // Register admin tool
+    api.registerTool(zaloxGroupTool);
+    api.registerTool(zaloxTemplateTool);
   },
 };
 

package/src/tools-template.ts

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+import { createTemplate, listTemplates, getTemplate, renderTemplate, deleteTemplate } from './core/templates.js';
+
+export const zaloxTemplateTool = {
+  name: 'zalox_template',
+  description: 'Manage and use message templates.',
+  parameters: z.object({
+    action: z.enum(['list', 'get', 'create', 'delete', 'render']),
+    name: z.string().optional().describe('Template name or ID (required for get/create/delete/render)'),
+    content: z.string().optional().describe('Content for create (supports {{variable}})'),
+    vars: z.record(z.string()).optional().describe('Variables for render'),
+  }),
+  execute: async (args: any) => {
+    const { action, name, content, vars } = args;
+
+    try {
+      if (action === 'list') {
+        const templates = listTemplates();
+        if (templates.length === 0) return 'No templates found.';
+        return JSON.stringify(templates.map(t => ({ id: t.id, name: t.name, vars: t.variables })), null, 2);
+      }
+
+      if (action === 'get') {
+        if (!name) throw new Error('name required');
+        const t = getTemplate(name);
+        return t ? JSON.stringify(t, null, 2) : 'Template not found';
+      }
+
+      if (action === 'create') {
+        if (!name || !content) throw new Error('name and content required');
+        const t = createTemplate(name, content);
+        return `Created template "${t.name}" (vars: ${t.variables.join(', ')})`;
+      }
+
+      if (action === 'render') {
+        if (!name) throw new Error('name required');
+        const t = getTemplate(name);
+        if (!t) return 'Template not found';
+        const rendered = renderTemplate(t, vars || {});
+        return rendered;
+      }
+      
+      if (action === 'delete') {
+         if (!name) throw new Error('name required');
+         const ok = deleteTemplate(name);
+         return ok ? `Deleted template "${name}"` : 'Template not found';
+      }
+    } catch (e: any) {
+      return `Error: ${e.message}`;
+    }
+    
+    return 'Unknown action';
+  },
+};

package/src/tools.ts

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+import { getCachedApi } from './client.js';
+
+export const zaloxGroupTool = {
+  name: 'zalox_group',
+  description: 'Manage Zalo groups: kick members, add members, or get group info.',
+  parameters: z.object({
+    action: z.enum(['kick', 'add', 'info']),
+    groupId: z.string(),
+    userId: z.string().optional(),
+    profile: z.string().optional().default('default'),
+  }),
+  execute: async (args: any) => {
+    const { action, groupId, userId, profile } = args;
+    const cached = getCachedApi(profile);
+    if (!cached) throw new Error(`Profile ${profile} not connected`);
+    
+    const api = cached.api as any;
+
+    try {
+      if (action === 'kick') {
+        if (!userId) throw new Error('userId required for kick');
+        await api.removeUserFromGroup(userId, groupId);
+        return `Successfully kicked ${userId} from ${groupId}`;
+      }
+
+      if (action === 'add') {
+        if (!userId) throw new Error('userId required for add');
+        await api.addUserToGroup(userId, groupId);
+        return `Successfully added ${userId} to ${groupId}`;
+      }
+      
+      if (action === 'info') {
+         const info = await api.getGroupInfo(groupId);
+         // Simplify info to avoid huge context
+         const simple = {
+            id: info.id,
+            name: info.name,
+            topic: info.topic,
+            totalMember: info.totalMember,
+            admins: info.admins,
+         };
+         return JSON.stringify(simple, null, 2);
+      }
+    } catch (e: any) {
+      return `Action ${action} failed: ${e.message || e}`;
+    }
+
+    return 'Unknown action';
+  },
+};

package/src/utils/config.ts

@@ -0,0 +1,14 @@
+import { join } from 'path';
+import { homedir } from 'os';
+import { existsSync, mkdirSync } from 'fs';
+
+export function getConfigDir(): string {
+  return join(homedir(), '.openclaw', 'zalox');
+}
+
+export function ensureConfigDir(): void {
+  const dir = getConfigDir();
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}