foliko 1.0.87 → 1.1.1

package/.agent/data/ambient/goals.json

@@ -1,50 +0,0 @@
-[
-  {
-    "id": "041f34d6-8ada-4a0f-932d-147f8476a830",
-    "title": "邮箱监控与自动回复",
-    "description": "监控邮箱，收到新邮件时自动分析内容并回复，无需用户确认",
-    "priority": 8,
-    "state": "active",
-    "actions": [
-      {
-        "type": "tool",
-        "name": "email_auto_reply",
-        "args": {
-          "to": "${event.to}",
-          "subject": "${event.subject}",
-          "body": "${event.text}",
-          "from": "${event.from}",
-          "messageId": "${event.messageId}"
-        }
-      }
-    ],
-    "_originalActions": [
-      {
-        "type": "tool",
-        "name": "email_auto_reply",
-        "args": {
-          "to": "${event.to}",
-          "subject": "${event.subject}",
-          "body": "${event.text}",
-          "from": "${event.from}",
-          "messageId": "${event.messageId}"
-        }
-      }
-    ],
-    "conditions": {
-      "events": [
-        "email:received"
-      ]
-    },
-    "createdAt": "2026-03-29T18:15:42.180Z",
-    "updatedAt": "2026-03-29T19:00:39.406Z",
-    "activatedAt": "2026-03-29T18:15:44.186Z",
-    "completedAt": "2026-03-29T18:54:56.861Z",
-    "failedAt": null,
-    "attempts": 11,
-    "maxAttempts": 10,
-    "consecutiveSameActions": 0,
-    "lastActionId": null,
-    "eventsReceived": []
-  }
-]

package/.agent/data/ambient/memories.json

@@ -1,7 +0,0 @@
-[
-  {
-    "key": "test_memory",
-    "content": "Ambient Agent 测试记忆 - 创建时间: 2026-03-29，系统运行正常",
-    "timestamp": "2026-03-29T14:53:03.801Z"
-  }
-]

package/.agent/data/scheduler/tasks.json

@@ -1 +0,0 @@
-[]

package/.agent/package.json

@@ -1,8 +0,0 @@
-{
-  "dependencies": {
-    "imap": "^0.8.19",
-    "mailparser": "^3.9.4",
-    "node-telegram-bot-api": "^0.67.0",
-    "nodemailer": "^8.0.3"
-  }
-}

package/.agent/plugins/daytona/README.md

@@ -1,89 +0,0 @@
-# Daytona Plugin
-
-Daytona 云开发环境管理插件，用于在 Foliko 中创建和管理云开发环境（Sandbox）。
-
-## 功能特性
-
-- **沙箱管理**: 创建、启动、停止、删除沙箱环境
-- **代码执行**: 在沙箱中执行 JavaScript/TypeScript 代码
-- **文件操作**: 在沙箱中读写文件
-- **临时沙箱**: 支持创建临时沙箱（自动清理）
-- **多语言支持**: JavaScript、TypeScript、Python 等
-
-## 安装
-
-```bash
-cd .agent/plugins/daytona
-npm install
-```
-
-## 配置
-
-首次使用需要配置 API 密钥：
-
-```javascript
-daytona_configure({
-  apiKey: "your-daytona-api-key",
-  apiUrl: "https://app.daytona.io/api",
-  target: "default"
-})
-```
-
-## 工具列表
-
-### daytona_configure
-配置 Daytona API 密钥和连接信息。
-
-### daytona_create_sandbox
-创建新的沙箱环境。
-
-### daytona_get_sandbox
-获取指定沙箱信息。
-
-### daytona_list_sandboxes
-列出所有沙箱。
-
-### daytona_start_sandbox
-启动沙箱。
-
-### daytona_stop_sandbox
-停止沙箱。
-
-### daytona_delete_sandbox
-删除沙箱。
-
-### daytona_execute_code
-在沙箱中执行代码。
-
-### daytona_write_file
-在沙箱中写入文件。
-
-### daytona_read_file
-在沙箱中读取文件。
-
-### daytona_create_ephemeral_sandbox
-创建临时沙箱（5分钟后自动删除）。
-
-## 使用示例
-
-```javascript
-// 1. 配置 API
-daytona_configure({ apiKey: "your-key" })
-
-// 2. 创建沙箱
-daytona_create_sandbox({ language: "javascript" })
-
-// 3. 执行代码
-daytona_execute_code({ code: "console.log('Hello!')" })
-
-// 4. 读写文件
-daytona_write_file({ path: "/tmp/test.js", content: "..." })
-daytona_read_file({ path: "/tmp/test.js" })
-
-// 5. 清理
-daytona_delete_sandbox({ sandboxId: "sandbox-id" })
-```
-
-## 许可证
-
-Apache-2.0

package/.agent/plugins/daytona/index.js

@@ -1,377 +0,0 @@
-const { z } = require('zod');
-
-module.exports = function (Plugin) {
-  return class DaytonaPlugin extends Plugin {
-    constructor(config = {}) {
-      super();
-      this.name = 'daytona';
-      this.version = '1.0.0';
-      this.description = 'Daytona 云开发环境管理插件';
-      this.priority = 10;
-      this.daytona = null;
-      this.currentSandbox = null;
-      this.config = {};
-    }
-
-    start(framework) {
-      this._framework = framework;
-      this._loadConfig();
-      return this;
-    }
-
-    _loadConfig() {
-      try {
-        const storage = this._framework.pluginManager.get('storage');
-        if (storage) {
-          const store = storage.getStore();
-          const entry = store.get('daytona:config');
-          if (entry && entry.value) {
-            this.config = entry.value;
-            if (this.config.apiKey) {
-              const { Daytona } = require('@daytonaio/sdk');
-              this.daytona = new Daytona(this.config);
-            }
-          }
-        }
-      } catch (error) {
-        // 配置加载失败，忽略
-      }
-    }
-
-    tools = {
-      daytona_configure: {
-        description: '配置 Daytona API 密钥和连接信息（配置会持久化保存）',
-        inputSchema: z.object({
-          apiKey: z.string().describe('Daytona API Key'),
-          apiUrl: z.string().optional().describe('Daytona API URL，默认为 https://app.daytona.io/api'),
-          target: z.string().optional().describe('目标区域，如 us, eu 等'),
-          organizationId: z.string().optional().describe('组织 ID（JWT 认证时需要）'),
-        }),
-        execute: async (args, framework) => {
-          try {
-            const { Daytona } = require('@daytonaio/sdk');
-            this.config = {
-              apiKey: args.apiKey,
-            };
-            if (args.apiUrl) this.config.apiUrl = args.apiUrl;
-            if (args.target) this.config.target = args.target;
-            if (args.organizationId) this.config.organizationId = args.organizationId;
-
-            this.daytona = new Daytona(this.config);
-
-            const storage = framework.pluginManager.get('storage');
-            if (storage) {
-              storage.setDirect('daytona:config', {
-                value: this.config,
-                updatedAt: new Date()
-              });
-            }
-
-            return {
-              success: true,
-              message: 'Daytona 配置已保存',
-              config: {
-                apiUrl: this.config.apiUrl || 'https://app.daytona.io/api',
-                target: this.config.target || 'default',
-                hasApiKey: true
-              },
-            };
-          } catch (error) {
-            return { success: false, error: error.message };
-          }
-        },
-      },
-
-      daytona_create_sandbox: {
-        description: '创建 Daytona 沙箱环境',
-        inputSchema: z.object({
-          language: z.string().optional().describe('编程语言：javascript, typescript, python（默认 javascript）'),
-          name: z.string().optional().describe('沙箱名称'),
-          resources: z.object({
-            cpu: z.number().optional().describe('CPU 核心数'),
-            memory: z.number().optional().describe('内存大小（GiB）'),
-            disk: z.number().optional().describe('磁盘大小（GiB）'),
-          }).optional().describe('资源配置'),
-          envVars: z.record(z.string()).optional().describe('环境变量'),
-          ephemeral: z.boolean().optional().describe('是否临时沙箱（停止后自动删除）'),
-          autoStopInterval: z.number().optional().describe('自动停止间隔（分钟，0 禁用）'),
-        }),
-        execute: async (args) => {
-          try {
-            if (!this.daytona) {
-              return { success: false, error: '请先调用 daytona_configure 配置 API' };
-            }
-            const params = {
-              language: args.language || 'javascript',
-            };
-            if (args.name) params.name = args.name;
-            if (args.resources) params.resources = args.resources;
-            if (args.envVars) params.envVars = args.envVars;
-            if (args.ephemeral !== undefined) params.ephemeral = args.ephemeral;
-            if (args.autoStopInterval !== undefined) params.autoStopInterval = args.autoStopInterval;
-            const sandbox = await this.daytona.create(params);
-            this.currentSandbox = sandbox;
-            return {
-              success: true,
-              sandbox: {
-                id: sandbox.id,
-                name: sandbox.name,
-                state: sandbox.state,
-                language: sandbox.language,
-              },
-            };
-          } catch (error) {
-            return { success: false, error: error.message };
-          }
-        },
-      },
-
-      daytona_get_sandbox: {
-        description: '获取指定沙箱信息',
-        inputSchema: z.object({
-          sandboxId: z.string().describe('沙箱 ID 或名称'),
-        }),
-        execute: async (args) => {
-          try {
-            if (!this.daytona) {
-              return { success: false, error: '请先调用 daytona_configure 配置 API' };
-            }
-            const sandbox = await this.daytona.get(args.sandboxId);
-            return {
-              success: true,
-              sandbox: {
-                id: sandbox.id,
-                name: sandbox.name,
-                state: sandbox.state,
-                language: sandbox.language,
-                createdAt: sandbox.createdAt,
-              },
-            };
-          } catch (error) {
-            return { success: false, error: error.message };
-          }
-        },
-      },
-
-      daytona_list_sandboxes: {
-        description: '列出所有沙箱',
-        inputSchema: z.object({
-          labels: z.record(z.string()).optional().describe('标签过滤'),
-          page: z.number().optional().describe('页码'),
-          limit: z.number().optional().describe('每页数量'),
-        }),
-        execute: async (args) => {
-          try {
-            if (!this.daytona) {
-              return { success: false, error: '请先调用 daytona_configure 配置 API' };
-            }
-            const result = await this.daytona.list(args.labels, args.page, args.limit);
-            return {
-              success: true,
-              total: result.total,
-              page: result.page,
-              sandboxes: result.items.map((s) => ({
-                id: s.id,
-                name: s.name,
-                state: s.state,
-                language: s.language,
-              })),
-            };
-          } catch (error) {
-            return { success: false, error: error.message };
-          }
-        },
-      },
-
-      daytona_start_sandbox: {
-        description: '启动沙箱',
-        inputSchema: z.object({
-          sandboxId: z.string().describe('沙箱 ID 或名称'),
-          timeout: z.number().optional().describe('超时时间（秒）'),
-        }),
-        execute: async (args) => {
-          try {
-            if (!this.daytona) {
-              return { success: false, error: '请先调用 daytona_configure 配置 API' };
-            }
-            const sandbox = await this.daytona.get(args.sandboxId);
-            await this.daytona.start(sandbox, args.timeout || 60);
-            return { success: true, message: `沙箱 ${args.sandboxId} 启动成功` };
-          } catch (error) {
-            return { success: false, error: error.message };
-          }
-        },
-      },
-
-      daytona_stop_sandbox: {
-        description: '停止沙箱',
-        inputSchema: z.object({
-          sandboxId: z.string().describe('沙箱 ID 或名称'),
-        }),
-        execute: async (args) => {
-          try {
-            if (!this.daytona) {
-              return { success: false, error: '请先调用 daytona_configure 配置 API' };
-            }
-            const sandbox = await this.daytona.get(args.sandboxId);
-            await this.daytona.stop(sandbox);
-            return { success: true, message: `沙箱 ${args.sandboxId} 已停止` };
-          } catch (error) {
-            return { success: false, error: error.message };
-          }
-        },
-      },
-
-      daytona_delete_sandbox: {
-        description: '删除沙箱',
-        inputSchema: z.object({
-          sandboxId: z.string().describe('沙箱 ID 或名称'),
-          timeout: z.number().optional().describe('超时时间（秒）'),
-        }),
-        execute: async (args) => {
-          try {
-            if (!this.daytona) {
-              return { success: false, error: '请先调用 daytona_configure 配置 API' };
-            }
-            const sandbox = await this.daytona.get(args.sandboxId);
-            await this.daytona.delete(sandbox, args.timeout || 60);
-            if (this.currentSandbox?.id === sandbox.id) {
-              this.currentSandbox = null;
-            }
-            return { success: true, message: `沙箱 ${args.sandboxId} 已删除` };
-          } catch (error) {
-            return { success: false, error: error.message };
-          }
-        },
-      },
-
-      daytona_execute_code: {
-        description: '在沙箱中执行代码',
-        inputSchema: z.object({
-          code: z.string().describe('要执行的代码'),
-          sandboxId: z.string().optional().describe('沙箱 ID（不填使用当前沙箱）'),
-        }),
-        execute: async (args) => {
-          try {
-            if (!this.daytona) {
-              return { success: false, error: '请先调用 daytona_configure 配置 API' };
-            }
-            let sandbox = this.currentSandbox;
-            if (args.sandboxId) {
-              sandbox = await this.daytona.get(args.sandboxId);
-            }
-            if (!sandbox) {
-              return { success: false, error: '没有活动的沙箱，请先创建或指定沙箱' };
-            }
-            const result = await sandbox.process.executeCommand(args.code);
-            return {
-              success: true,
-              stdout: result.result,
-              stderr: result.stderr,
-              exitCode: result.exitCode,
-            };
-          } catch (error) {
-            return { success: false, error: error.message };
-          }
-        },
-      },
-
-      daytona_write_file: {
-        description: '在沙箱中写入文件',
-        inputSchema: z.object({
-          path: z.string().describe('文件路径'),
-          content: z.string().describe('文件内容'),
-          sandboxId: z.string().optional().describe('沙箱 ID（不填使用当前沙箱）'),
-        }),
-        execute: async (args) => {
-          try {
-            if (!this.daytona) {
-              return { success: false, error: '请先调用 daytona_configure 配置 API' };
-            }
-            let sandbox = this.currentSandbox;
-            if (args.sandboxId) {
-              sandbox = await this.daytona.get(args.sandboxId);
-            }
-            if (!sandbox) {
-              return { success: false, error: '没有活动的沙箱，请先创建或指定沙箱' };
-            }
-            await sandbox.fs.uploadFiles([{ source: Buffer.from(args.content), destination: args.path }]);
-            return { success: true, message: `文件 ${args.path} 写入成功` };
-          } catch (error) {
-            return { success: false, error: error.message };
-          }
-        },
-      },
-
-      daytona_read_file: {
-        description: '在沙箱中读取文件',
-        inputSchema: z.object({
-          path: z.string().describe('文件路径'),
-          sandboxId: z.string().optional().describe('沙箱 ID（不填使用当前沙箱）'),
-        }),
-        execute: async (args) => {
-          try {
-            if (!this.daytona) {
-              return { success: false, error: '请先调用 daytona_configure 配置 API' };
-            }
-            let sandbox = this.currentSandbox;
-            if (args.sandboxId) {
-              sandbox = await this.daytona.get(args.sandboxId);
-            }
-            if (!sandbox) {
-              return { success: false, error: '没有活动的沙箱，请先创建或指定沙箱' };
-            }
-            const result = await sandbox.process.executeCommand(`cat "${args.path}"`);
-            return { success: true, path: args.path, content: result.result || '' };
-          } catch (error) {
-            return { success: false, error: error.message };
-          }
-        },
-      },
-
-      daytona_create_ephemeral_sandbox: {
-        description: '创建临时沙箱（停止后自动删除）',
-        inputSchema: z.object({
-          language: z.string().optional().describe('编程语言（默认 javascript）'),
-          timeout: z.number().optional().describe('创建超时时间（秒，默认 60）'),
-        }),
-        execute: async (args) => {
-          try {
-            if (!this.daytona) {
-              return { success: false, error: '请先调用 daytona_configure 配置 API' };
-            }
-            const params = {
-              language: args.language || 'javascript',
-              ephemeral: true,
-              autoStopInterval: 5,
-            };
-            const sandbox = await this.daytona.create(params, { timeout: args.timeout || 60 });
-            this.currentSandbox = sandbox;
-            return {
-              success: true,
-              message: '临时沙箱创建成功（5分钟后自动停止并删除）',
-              sandbox: {
-                id: sandbox.id,
-                name: sandbox.name,
-                state: sandbox.state,
-                language: sandbox.language,
-              },
-            };
-          } catch (error) {
-            return { success: false, error: error.message };
-          }
-        },
-      },
-    };
-
-    install(framework) {
-      return this;
-    }
-
-    uninstall(framework) {
-      if (this.currentSandbox && this.daytona) {
-        this.daytona.delete(this.currentSandbox).catch(() => {});
-      }
-    }
-  };
-};

package/.agent/plugins/daytona/package.json

@@ -1,12 +0,0 @@
-{
-  "name": "daytona-plugin",
-  "version": "1.0.0",
-  "description": "Daytona 云开发环境管理插件",
-  "main": "index.js",
-  "keywords": ["daytona", "sandbox", "cloud", "foliko", "plugin"],
-  "author": "",
-  "license": "Apache-2.0",
-  "dependencies": {
-    "@daytonaio/sdk": "^0.161.0"
-  }
-}

package/.agent/plugins/marknative/README.md

@@ -1,134 +0,0 @@
-# MarkNative Plugin
-
-将 Markdown 转换为 PNG/SVG 图片的 Foliko 插件。基于 [marknative](https://github.com/liyown/marknative) 项目。
-
-## 特性
-
-- **原生渲染**: 不需要浏览器，使用原生 2D canvas API
-- **多种格式**: 支持 PNG 和 SVG 输出
-- **丰富主题**: 10 种内置主题（浅色/深色）
-- **代码高亮**: 支持代码块语法高亮
-- **分页支持**: 自动分页处理长文档
-- **双重模式**: 支持本地运行和 Daytona 沙箱运行
-
-## 安装依赖
-
-### 方式一：本地安装
-```bash
-cd .agent/plugins/marknative
-npm install
-```
-
-### 方式二：使用 Daytona 沙箱
-确保已配置 Daytona 插件，插件将自动在沙箱中运行。
-
-## 工具列表
-
-### marknative_render
-将 Markdown 渲染为图片（Base64 编码返回）
-
-参数:
-- `markdown`: Markdown 内容（必填）
-- `format`: 输出格式 (png/svg)
-- `theme`: 主题名称
-- `singlePage`: 是否单页输出
-- `codeTheme`: 代码高亮主题
-- `useSandbox`: 是否强制使用沙箱执行
-
-### marknative_render_to_file
-将 Markdown 渲染为图片并保存到文件
-
-参数:
-- `markdown`: Markdown 内容（必填）
-- `outputPath`: 输出文件路径（必填）
-- `format`: 输出格式
-- `theme`: 主题名称
-- `codeTheme`: 代码高亮主题
-
-### marknative_preview
-预览渲染效果（返回第一页 Base64）
-
-参数:
-- `markdown`: Markdown 内容（必填）
-- `theme`: 主题名称
-- `codeTheme`: 代码高亮主题
-
-### marknative_get_themes
-获取所有可用主题和代码高亮主题列表
-
-### marknative_status
-检查插件状态
-
-## 可用主题
-
-| 主题 | 描述 |
-|------|------|
-| default | 默认主题（浅色） |
-| github | GitHub 风格 |
-| solarized | Solarized 风格 |
-| sepia | 复古纸张风格 |
-| rose | 玫瑰粉风格 |
-| dark | 深色主题 |
-| nord | Nord 风格 |
-| dracula | Dracula 风格 |
-| ocean | 海洋风格 |
-| forest | 森林风格 |
-
-## 代码高亮主题
-
-支持 Shiki 主题：`github-light`, `github-dark`, `nord`, `dracula`, `solarized-light`, `solarized-dark`, `monokai` 等。
-
-## 使用示例
-
-```javascript
-// 1. 检查状态
-marknative_status({})
-
-// 2. 渲染为 Base64 图片
-marknative_render({
-  markdown: '# Hello\n\nThis is **markdown** to image!',
-  format: 'png',
-  theme: 'github'
-})
-
-// 3. 保存为文件
-marknative_render_to_file({
-  markdown: '# Document\n\nContent here...',
-  outputPath: './output.png',
-  theme: 'dark'
-})
-
-// 4. 预览
-marknative_preview({
-  markdown: '# Preview\n\nTest content',
-  theme: 'nord'
-})
-
-// 5. 获取主题列表
-marknative_get_themes({})
-```
-
-## 完整示例
-
-```javascript
-// 渲染带有代码高亮的文档
-marknative_render({
-  markdown: `# 示例代码
-
-\`\`\`javascript
-function hello() {
-  console.log('Hello, World!');
-}
-\`\`\`
-
-**支持语法高亮！**
-`,
-  format: 'png',
-  theme: 'dark',
-  codeTheme: 'github-dark'
-})
-```
-
-## 许可证
-
-MIT