@jackle.dev/zalox-plugin 1.0.6 → 1.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jackle.dev/zalox-plugin",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "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

@@ -9,6 +9,8 @@ import type { OpenClawPluginApi } 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';
+import { zaloxScenarioTool } from './tools-scenario.js';
 
 const plugin = {
   id: 'zalox',
@@ -24,6 +26,8 @@ const plugin = {
 
     // Register admin tool
     api.registerTool(zaloxGroupTool);
+    api.registerTool(zaloxTemplateTool);
+    api.registerTool(zaloxScenarioTool);
   },
 };
 

package/src/tools-scenario.ts

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+import { createTemplate } from './core/templates.js';
+
+export const zaloxScenarioTool = {
+  name: 'zalox_scenario',
+  description: 'Import scenario templates from a URL or Registry ID.',
+  parameters: z.object({
+    action: z.enum(['import']),
+    url: z.string().optional().describe('Direct URL to scenario JSON'),
+    registryId: z.string().optional().describe('Registry ID (e.g., "appointment-booking")'),
+  }),
+  execute: async (args: any) => {
+    const { action, url, registryId } = args;
+    if (action !== 'import') return 'Only import action supported';
+    
+    let targetUrl = url;
+    if (!targetUrl && registryId) {
+        // Default to jackle.dev registry
+        targetUrl = `https://zalox.jackle.dev/registry/${registryId}.json`;
+    }
+    if (!targetUrl) throw new Error('url or registryId required');
+
+    try {
+        const res = await fetch(targetUrl);
+        if (!res.ok) throw new Error(`Fetch failed: ${res.statusText}`);
+        const data = await res.json();
+        
+        const results = [];
+        if (Array.isArray(data.templates)) {
+            for (const t of data.templates) {
+                try {
+                    createTemplate(t.name, t.content);
+                    results.push(`✅ Created "${t.name}"`);
+                } catch (e: any) {
+                    if (e.message.includes('exists')) {
+                       results.push(`⚠️ Skipped "${t.name}" (already exists)`);
+                    } else {
+                       results.push(`❌ Failed "${t.name}": ${e.message}`);
+                    }
+                }
+            }
+        }
+        return `Imported scenario "${data.name || 'Unknown'}":\n${results.join('\n')}`;
+    } catch (e: any) {
+        return `Scenario import failed: ${e.message}`;
+    }
+  },
+};

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/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 });
+  }
+}