scriptbook 1.0.0__py3-none-any.whl

scriptbook/__init__.py

@@ -0,0 +1,5 @@
+"""
+Markdown Script Runner - 执行Markdown中嵌入的脚本块
+"""
+
+__version__ = "1.0.0"

scriptbook/cli.py

@@ -0,0 +1,112 @@
+"""
+命令行入口
+"""
+import argparse
+import sys
+import uvicorn
+import os
+from pathlib import Path
+
+
+def create_app(content_dir: Path):
+    """创建FastAPI应用实例"""
+    from scriptbook.main import create_app as _create_app
+
+    # 设置环境变量传递content目录
+    import os
+    os.environ['CONTENT_DIR'] = str(content_dir)
+
+    return _create_app()
+
+
+def main():
+    """主函数"""
+    parser = argparse.ArgumentParser(
+        description='Scriptbook - 可执行脚本的 Markdown 服务器',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+示例:
+  %(prog)s content/                    # 使用content目录启动服务
+  %(prog)s /path/to/sop/documents      # 使用指定SOP目录
+  %(prog)s content/ --port 9000        # 指定端口
+  %(prog)s content/ --host 0.0.0.0     # 指定主机（允许外部访问）
+
+默认端口: 8000
+默认主机: 127.0.0.1
+
+功能特点:
+  - 在Markdown中嵌入可执行脚本
+  - 每个脚本块可独立执行
+  - 实时输出展示
+  - 类似Jupyter Notebook的交互体验
+        """
+    )
+
+    parser.add_argument(
+        'content_dir',
+        type=str,
+        help='Markdown文件目录路径'
+    )
+
+    parser.add_argument(
+        '--port',
+        type=int,
+        default=8000,
+        help='服务端口 (默认: 8000)'
+    )
+
+    parser.add_argument(
+        '--host',
+        type=str,
+        default='127.0.0.1',
+        help='服务主机 (默认: 127.0.0.1)'
+    )
+
+    parser.add_argument(
+        '--version',
+        action='version',
+        version='%(prog)s 1.0.0'
+    )
+
+    args = parser.parse_args()
+
+    # 验证content目录
+    content_path = Path(args.content_dir)
+    if not content_path.exists():
+        print(f"错误: 目录 '{args.content_dir}' 不存在", file=sys.stderr)
+        sys.exit(1)
+
+    if not content_path.is_dir():
+        print(f"错误: '{args.content_dir}' 不是一个目录", file=sys.stderr)
+        sys.exit(1)
+
+    # 创建应用
+    try:
+        app = create_app(content_path)
+    except Exception as e:
+        print(f"错误: 创建应用失败: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    # 启动服务
+    print(f"启动 Scriptbook - 可执行脚本的 Markdown 服务器")
+    print(f"文档目录: {content_path.absolute()}")
+    print(f"服务地址: http://{args.host}:{args.port}")
+    print(f"访问地址: http://localhost:{args.port}")
+    print(f"按 Ctrl+C 停止服务\n")
+
+    try:
+        uvicorn.run(
+            app,
+            host=args.host,
+            port=args.port,
+            log_level="info"
+        )
+    except KeyboardInterrupt:
+        print("\n服务已停止")
+    except Exception as e:
+        print(f"错误: 启动服务失败: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    main()

scriptbook/core/file_scanner.py

@@ -0,0 +1,99 @@
+import os
+import glob
+from datetime import datetime
+from typing import List, Dict, Any
+import time
+
+class FileScanner:
+    """文件扫描器，用于扫描markdown文件"""
+
+    def __init__(self, content_dir: str = "content"):
+        self.content_dir = content_dir
+        self._cache = None
+        self._cache_time = 0
+        self._cache_ttl = 10  # 缓存时间（秒）
+
+    def scan_files(self, force_refresh: bool = False) -> List[Dict[str, Any]]:
+        """
+        扫描content目录下的所有markdown文件
+
+        Args:
+            force_refresh: 是否强制刷新缓存
+
+        Returns:
+            文件信息列表，每个元素包含name, size, modified
+        """
+        # 检查缓存
+        current_time = time.time()
+        if (not force_refresh and self._cache is not None and
+            current_time - self._cache_time < self._cache_ttl):
+            return self._cache
+
+        files = []
+        try:
+            # 确保目录存在
+            if not os.path.exists(self.content_dir):
+                os.makedirs(self.content_dir, exist_ok=True)
+                return files
+
+            # 扫描.md文件
+            pattern = os.path.join(self.content_dir, "*.md")
+            for filepath in glob.glob(pattern):
+                try:
+                    stat = os.stat(filepath)
+                    filename = os.path.basename(filepath)
+
+                    files.append({
+                        "name": filename,
+                        "size": stat.st_size,
+                        "modified": datetime.fromtimestamp(stat.st_mtime)
+                    })
+                except Exception as e:
+                    print(f"读取文件信息失败 {filepath}: {e}")
+                    continue
+
+            # 按文件名排序
+            files.sort(key=lambda x: x["name"])
+
+            # 更新缓存和时间戳
+            self._cache = files
+            self._cache_time = current_time
+
+        except Exception as e:
+            print(f"扫描文件失败: {e}")
+            return []
+
+        return files
+
+    def get_file_content(self, filename: str) -> str:
+        """
+        获取指定文件的内容
+
+        Args:
+            filename: 文件名
+
+        Returns:
+            文件内容
+
+        Raises:
+            FileNotFoundError: 文件不存在
+            ValueError: 文件名不合法
+        """
+        # 安全检查
+        if not filename.endswith(".md"):
+            raise ValueError("文件必须是markdown文件 (.md)")
+
+        # 防止目录遍历攻击
+        if ".." in filename or "/" in filename or "\\" in filename:
+            raise ValueError("文件名不合法")
+
+        filepath = os.path.join(self.content_dir, filename)
+        if not os.path.exists(filepath):
+            raise FileNotFoundError(f"文件不存在: {filename}")
+
+        with open(filepath, "r", encoding="utf-8") as f:
+            return f.read()
+
+
+# 创建全局文件扫描器实例
+file_scanner = FileScanner()

scriptbook/core/markdown_parser.py

@@ -0,0 +1,160 @@
+import re
+import json
+from typing import List, Dict, Any, Tuple
+from scriptbook.models.schemas import ScriptBlock
+
+class MarkdownParser:
+    """Markdown解析器，支持特殊脚本语法"""
+
+    def __init__(self):
+        self.script_pattern = re.compile(
+            r'```(bash|sh|shell)\s*(\{[^}]*\})?\s*\n(.*?)\n\s*```',
+            re.DOTALL
+        )
+
+    def extract_scripts(self, markdown_text: str) -> Tuple[str, List[ScriptBlock]]:
+        """
+        从markdown文本中提取脚本块
+
+        返回:
+            - 清理后的markdown文本（脚本块被替换为占位符）
+            - 脚本块列表
+        """
+        scripts = []
+        cleaned_text = markdown_text
+        offset = 0
+
+        for match in self.script_pattern.finditer(markdown_text):
+            language = match.group(1)
+            metadata_str = match.group(2)
+            code = match.group(3).strip()
+
+            # 处理language为None的情况
+            if language is None:
+                language = "text"
+
+            script_id = f'script_{len(scripts)}'
+            title = f'{language}脚本'  # 默认title
+
+            # 如果有metadata字符串，尝试解析
+            if metadata_str and metadata_str.strip():
+                try:
+                    metadata = json.loads(metadata_str)
+                    # 如果解析成功，使用metadata中的值
+                    if 'id' in metadata:
+                        script_id = metadata['id']
+                    if 'title' in metadata:
+                        title = metadata['title']
+                    else:
+                        # 有metadata但没有title，使用智能生成
+                        title = self._generate_title(code, language)
+                except json.JSONDecodeError:
+                    # JSON解析失败，使用默认title
+                    pass
+            else:
+                # 没有metadata，使用智能生成title
+                title = self._generate_title(code, language)
+
+            script_block = ScriptBlock(
+                id=script_id,
+                title=title,
+                language=language,
+                code=code,
+                line_start=match.start() - offset,
+                line_end=match.end() - offset
+            )
+            scripts.append(script_block)
+
+            # 用占位符替换脚本块
+            placeholder = f'\n\n[脚本块: {script_id} - {title}]\n\n'
+            cleaned_text = (
+                cleaned_text[:match.start() - offset] +
+                placeholder +
+                cleaned_text[match.end() - offset:]
+            )
+            offset += len(match.group(0)) - len(placeholder)
+
+        return cleaned_text, scripts
+
+    def _generate_title(self, code: str, language: str) -> str:
+        """
+        从代码中智能生成title
+        """
+        lines = code.strip().split('\n')
+        first_line = lines[0].strip() if lines else ''
+
+        # 尝试从echo命令提取引号内的内容
+        echo_match = re.search(r'echo\s+["\']([^"\']+)["\']', first_line, re.IGNORECASE)
+        if echo_match:
+            return echo_match.group(1)
+
+        # 尝试从printf命令提取引号内的内容
+        printf_match = re.search(r'printf\s+["\']([^"\']+)["\']', first_line, re.IGNORECASE)
+        if printf_match:
+            return printf_match.group(1)
+
+        # 如果是cat命令，尝试获取文件名
+        cat_match = re.search(r'cat\s+(\S+)', first_line)
+        if cat_match:
+            return f"读取文件: {cat_match.group(1)}"
+
+        # 如果是ls命令，生成描述
+        if re.match(r'^\s*ls\b', first_line, re.IGNORECASE):
+            if '-l' in first_line or '-la' in first_line:
+                return "列出文件详情"
+            return "列出文件"
+
+        # 如果是cd命令，生成描述
+        cd_match = re.search(r'cd\s+(\S+)', first_line)
+        if cd_match:
+            return f"切换目录: {cd_match.group(1)}"
+
+        # 如果是git命令，生成描述
+        git_match = re.search(r'git\s+(\w+)', first_line)
+        if git_match:
+            git_actions = {
+                'clone': '克隆仓库',
+                'pull': '更新代码',
+                'push': '推送代码',
+                'commit': '提交代码',
+                'status': '查看状态',
+                'checkout': '切换分支',
+            }
+            action = git_match.group(1)
+            return git_actions.get(action, f'Git操作: {action}')
+
+        # 如果第一行不超过30个字符，直接使用
+        if len(first_line) <= 30:
+            # 清理引号
+            first_line = first_line.strip('"').strip("'")
+            return first_line
+
+        # 否则取前几个词作为title
+        words = first_line.split()[:4]
+        return ' '.join(words) + ('...' if len(first_line.split()) > 4 else '')
+
+    def parse(self, markdown_text: str) -> Dict[str, Any]:
+        """
+        解析markdown文本，返回解析结果
+
+        返回:
+            {
+                "html": "渲染后的HTML",
+                "scripts": [脚本块列表]
+            }
+        """
+        # 提取脚本块
+        cleaned_text, scripts = self.extract_scripts(markdown_text)
+
+        # 这里应该使用markdown库渲染cleaned_text
+        # 暂时返回原始文本
+        html = cleaned_text
+
+        return {
+            "html": html,
+            "scripts": scripts
+        }
+
+
+# 创建全局解析器实例
+parser = MarkdownParser()

scriptbook/core/plugin_manager.py

@@ -0,0 +1,109 @@
+import os
+import json
+import copy
+from typing import List, Dict, Any, Optional
+from scriptbook.models.schemas import PluginInfo
+
+class PluginManager:
+    """插件管理器"""
+
+    def __init__(self, plugins_dir: str = "app/plugins"):
+        self.plugins_dir = plugins_dir
+        self._plugins_cache = None
+        self._active_plugins = []
+
+    def scan_plugins(self, force_refresh: bool = False) -> List[PluginInfo]:
+        """扫描插件目录，返回所有可用插件"""
+        # 如果有缓存且不强制刷新，返回缓存的副本
+        if not force_refresh and self._plugins_cache is not None:
+            return copy.deepcopy(self._plugins_cache)
+
+        plugins = []
+
+        if not os.path.exists(self.plugins_dir):
+            os.makedirs(self.plugins_dir, exist_ok=True)
+            return plugins
+
+        for plugin_name in os.listdir(self.plugins_dir):
+            plugin_path = os.path.join(self.plugins_dir, plugin_name)
+
+            # 必须是目录
+            if not os.path.isdir(plugin_path):
+                continue
+
+            manifest_path = os.path.join(plugin_path, "manifest.json")
+
+            # 必须有manifest.json文件
+            if not os.path.exists(manifest_path):
+                continue
+
+            try:
+                with open(manifest_path, "r", encoding="utf-8") as f:
+                    manifest = json.load(f)
+
+                # 验证必要字段
+                if "name" not in manifest:
+                    manifest["name"] = plugin_name
+
+                plugin_info = PluginInfo(
+                    name=manifest.get("name", plugin_name),
+                    version=manifest.get("version", "1.0.0"),
+                    description=manifest.get("description", ""),
+                    type=manifest.get("type", "theme"),
+                    css=manifest.get("css"),
+                    js=manifest.get("js")
+                )
+
+                plugins.append(plugin_info)
+
+            except (json.JSONDecodeError, IOError) as e:
+                print(f"加载插件 {plugin_name} 失败: {e}")
+                continue
+
+        # 更新缓存
+        self._plugins_cache = plugins
+        return copy.deepcopy(plugins)
+
+    def get_plugin(self, plugin_name: str) -> Optional[PluginInfo]:
+        """获取指定插件信息"""
+        plugins = self.scan_plugins(force_refresh=True)
+        for plugin in plugins:
+            if plugin.name == plugin_name:
+                return plugin
+        return None
+
+    def activate_plugin(self, plugin_name: str) -> bool:
+        """激活插件"""
+        plugin = self.get_plugin(plugin_name)
+        if not plugin:
+            return False
+
+        # 避免重复激活
+        if plugin_name not in self._active_plugins:
+            self._active_plugins.append(plugin_name)
+
+        return True
+
+    def deactivate_plugin(self, plugin_name: str) -> bool:
+        """停用插件"""
+        if plugin_name in self._active_plugins:
+            self._active_plugins.remove(plugin_name)
+            return True
+        return False
+
+    def get_active_plugins(self) -> List[str]:
+        """获取当前激活的插件列表"""
+        return self._active_plugins.copy()
+
+    def get_active_plugins_info(self) -> List[PluginInfo]:
+        """获取当前激活插件的详细信息"""
+        active_plugins = []
+        for plugin_name in self._active_plugins:
+            plugin = self.get_plugin(plugin_name)
+            if plugin:
+                active_plugins.append(plugin)
+        return active_plugins
+
+
+# 创建全局插件管理器实例
+plugin_manager = PluginManager()

scriptbook/core/script_executor.py

@@ -0,0 +1,116 @@
+import asyncio
+import subprocess
+from typing import AsyncGenerator, Dict, Any
+from datetime import datetime
+
+class ScriptExecutor:
+    """脚本执行器，用于执行bash脚本"""
+
+    def __init__(self):
+        self._processes: Dict[str, asyncio.subprocess.Process] = {}
+
+    async def execute(
+        self,
+        script_id: str,
+        code: str,
+        timeout: int = 30
+    ) -> AsyncGenerator[Dict[str, Any], None]:
+        """
+        异步执行bash脚本
+
+        Args:
+            script_id: 脚本ID
+            code: 脚本代码
+            timeout: 超时时间（秒）
+
+        Yields:
+            输出消息字典，包含type, content, timestamp
+        """
+        process = None
+        terminated = False
+        try:
+            # 创建子进程
+            process = await asyncio.create_subprocess_shell(
+                code,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                shell=True
+            )
+
+            # 存储进程引用
+            self._processes[script_id] = process
+
+            # 读取输出的协程
+            async def read_output(stream, output_type):
+                while True:
+                    line = await stream.readline()
+                    if not line:
+                        break
+                    yield {
+                        "type": output_type,
+                        "content": line.decode("utf-8", errors="replace").rstrip(),
+                        "timestamp": datetime.now().isoformat()
+                    }
+
+            # 同时读取stdout和stderr
+            stdout_reader = read_output(process.stdout, "stdout")
+            stderr_reader = read_output(process.stderr, "stderr")
+
+            # 合并输出流
+            async for output in self._merge_outputs(stdout_reader, stderr_reader):
+                yield output
+
+            # 使用wait_for设置超时
+            try:
+                returncode = await asyncio.wait_for(process.wait(), timeout=timeout)
+                yield {
+                    "type": "exit",
+                    "content": f"进程退出，返回码: {returncode}",
+                    "timestamp": datetime.now().isoformat()
+                }
+            except asyncio.TimeoutError:
+                # 超时，终止进程
+                terminated = True
+                process.terminate()
+                yield {
+                    "type": "error",
+                    "content": f"脚本执行超时 ({timeout}秒)，进程已终止",
+                    "timestamp": datetime.now().isoformat()
+                }
+
+        except Exception as e:
+            yield {
+                "type": "error",
+                "content": f"执行错误: {str(e)}",
+                "timestamp": datetime.now().isoformat()
+            }
+        finally:
+            # 清理进程引用
+            if script_id in self._processes:
+                del self._processes[script_id]
+            # 只在未终止且进程仍在运行时才终止
+            if process and not terminated and process.returncode is None:
+                try:
+                    process.terminate()
+                except:
+                    pass
+
+    async def _merge_outputs(self, *generators):
+        """合并多个异步生成器的输出"""
+        # 简化实现：按顺序读取
+        # 实际应该使用asyncio.Queue
+        for gen in generators:
+            async for item in gen:
+                yield item
+
+    def kill_process(self, script_id: str):
+        """终止指定脚本的进程"""
+        if script_id in self._processes:
+            process = self._processes[script_id]
+            if process.returncode is None:
+                process.terminate()
+            del self._processes[script_id]
+
+
+# 创建全局脚本执行器实例
+executor = ScriptExecutor()

scriptbook/main.py

@@ -0,0 +1,70 @@
+"""
+FastAPI应用入口
+"""
+from fastapi import FastAPI
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import FileResponse
+from pathlib import Path
+import os
+
+
+def create_app(content_dir: Path = None) -> FastAPI:
+    """
+    创建FastAPI应用实例
+
+    Args:
+        content_dir: Markdown文件目录，如果为None则使用环境变量CONTENT_DIR或默认content目录
+
+    Returns:
+        FastAPI应用实例
+    """
+    # 确定content目录
+    if content_dir is None:
+        content_dir = os.environ.get('CONTENT_DIR', 'content')
+    content_dir = Path(content_dir)
+
+    # 创建FastAPI应用
+    app = FastAPI(
+        title="Scriptbook - 可执行脚本的 Markdown 服务器",
+        description="支持脚本执行的在线 Markdown 服务器，可用于SOP自动化和交互式文档",
+        version="1.0.0"
+    )
+
+    # 设置content目录到应用状态
+    app.state.content_dir = str(content_dir)
+
+    # 设置插件目录到应用状态
+    # 优先使用环境变量，否则使用相对于当前模块目录的路径
+    base_dir = Path(__file__).parent
+    plugins_dir = base_dir / "static" / "plugins"
+    app.state.plugins_dir = str(plugins_dir)
+
+    # 导入路由
+    from scriptbook.routers import markdown, scripts, plugins
+
+    # 包含路由
+    app.include_router(markdown.router, prefix="/api/markdown")
+    app.include_router(scripts.router, prefix="/api")
+    app.include_router(plugins.router, prefix="/api/plugins")
+
+    # 静态文件目录
+    static_dir = base_dir / "static"
+    app.mount("/static", StaticFiles(directory=str(static_dir)), name="static")
+
+    # 根路由 - 返回主页面
+    @app.get("/")
+    async def read_root():
+        return FileResponse(str(static_dir / "index.html"))
+
+    # 健康检查端点
+    @app.get("/health")
+    async def health_check():
+        return {
+            "status": "healthy",
+            "service": "scriptbook",
+            "version": "1.0.0",
+            "description": "Scriptbook - 可执行脚本的 Markdown 服务器"
+        }
+
+    return app
+