@cydm/magic-shell-agent-node 0.1.0

package/dist/pie-session-control.d.ts

@@ -0,0 +1,21 @@
+export interface PieSessionControlCommand {
+    requestId: string;
+    message: string;
+    mode: "steer" | "follow_up";
+    createdAt: number;
+    status?: "pending" | "running" | "completed" | "failed";
+}
+export interface PieSessionControlState {
+    sessionId: string;
+    updatedAt: number;
+    activeRequestId?: string | null;
+    lastCompletedRequestId?: string | null;
+    lastTurnIndex?: number | null;
+    lastAssistantText?: string | null;
+    lastError?: string | null;
+    status?: "idle" | "busy";
+}
+export declare function getPieSessionControlInboxPath(sessionId: string): string;
+export declare function getPieSessionControlStatePath(sessionId: string): string;
+export declare function writePieSessionControlCommand(sessionId: string, command: PieSessionControlCommand): void;
+export declare function readPieSessionControlState(sessionId: string): PieSessionControlState | null;

package/dist/pie-session-control.js

@@ -0,0 +1,28 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+function getSessionsDir() {
+    return path.join(os.homedir(), ".pie", "sessions");
+}
+export function getPieSessionControlInboxPath(sessionId) {
+    return path.join(getSessionsDir(), `${sessionId}.magic-shell-inbox.json`);
+}
+export function getPieSessionControlStatePath(sessionId) {
+    return path.join(getSessionsDir(), `${sessionId}.magic-shell-state.json`);
+}
+export function writePieSessionControlCommand(sessionId, command) {
+    fs.mkdirSync(getSessionsDir(), { recursive: true });
+    fs.writeFileSync(getPieSessionControlInboxPath(sessionId), JSON.stringify(command, null, 2));
+}
+export function readPieSessionControlState(sessionId) {
+    const statePath = getPieSessionControlStatePath(sessionId);
+    if (!fs.existsSync(statePath)) {
+        return null;
+    }
+    try {
+        return JSON.parse(fs.readFileSync(statePath, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}

package/dist/plugin-loader.d.ts

@@ -0,0 +1,19 @@
+import type { PluginConfig } from "./adapters/types.js";
+export interface LoadOptions {
+    /** 插件目录路径 */
+    dir: string;
+    /** 是否递归搜索 */
+    recursive?: boolean;
+}
+/**
+ * 加载单个插件配置
+ */
+export declare function loadPlugin(path: string): PluginConfig;
+/**
+ * 扫描目录加载所有插件
+ */
+export declare function loadPlugins(options: LoadOptions): Map<string, PluginConfig>;
+/**
+ * 获取默认插件目录
+ */
+export declare function getDefaultPluginDir(): string;

package/dist/plugin-loader.js

@@ -0,0 +1,144 @@
+import { readFileSync, readdirSync, existsSync } from "fs";
+import { join, extname, dirname, isAbsolute, resolve } from "path";
+import { fileURLToPath } from "url";
+/**
+ * 加载单个插件配置
+ */
+export function loadPlugin(path) {
+    if (!existsSync(path)) {
+        throw new Error(`Plugin file not found: ${path}`);
+    }
+    const content = readFileSync(path, "utf-8");
+    const config = JSON.parse(content);
+    const configDir = dirname(path);
+    const repoRoot = dirname(configDir);
+    // 基础验证
+    if (!config.name) {
+        throw new Error(`Plugin ${path} missing required field: name`);
+    }
+    if (!config.type) {
+        throw new Error(`Plugin ${path} missing required field: type`);
+    }
+    if (!config.command) {
+        throw new Error(`Plugin ${path} missing required field: command`);
+    }
+    if (!config.capabilities || !Array.isArray(config.capabilities)) {
+        throw new Error(`Plugin ${path} missing or invalid field: capabilities`);
+    }
+    // 验证 type 值
+    if (!["stdio", "pty", "rpc"].includes(config.type)) {
+        throw new Error(`Plugin ${path} invalid type: ${config.type}`);
+    }
+    return {
+        ...config,
+        command: resolveCommandPath(config.command, configDir, repoRoot),
+        args: resolveArgPaths(config.args, configDir, repoRoot),
+        cwd: resolveOptionalPath(config.cwd, configDir, repoRoot),
+    };
+}
+function resolveOptionalPath(value, configDir, repoRoot) {
+    if (!value)
+        return value;
+    if (isAbsolute(value))
+        return value;
+    const repoCandidate = resolve(repoRoot, value);
+    if (existsSync(repoCandidate))
+        return repoCandidate;
+    const configCandidate = resolve(configDir, value);
+    if (existsSync(configCandidate))
+        return configCandidate;
+    return value;
+}
+function resolveCommandPath(command, configDir, repoRoot) {
+    if (!command || isAbsolute(command))
+        return command;
+    if (!command.includes("/") && !command.includes("\\"))
+        return command;
+    const repoCandidate = resolve(repoRoot, command);
+    if (existsSync(repoCandidate))
+        return repoCandidate;
+    const configCandidate = resolve(configDir, command);
+    if (existsSync(configCandidate))
+        return configCandidate;
+    return command;
+}
+function resolveArgPaths(args, configDir, repoRoot) {
+    if (!args)
+        return args;
+    return args.map((arg) => {
+        if (!arg || isAbsolute(arg))
+            return arg;
+        if (arg.startsWith("-"))
+            return arg;
+        const looksLikePath = arg.includes("/") || arg.includes("\\") || /\.[a-z0-9]+$/i.test(arg);
+        if (!looksLikePath)
+            return arg;
+        const repoCandidate = resolve(repoRoot, arg);
+        if (existsSync(repoCandidate))
+            return repoCandidate;
+        const configCandidate = resolve(configDir, arg);
+        if (existsSync(configCandidate))
+            return configCandidate;
+        return arg;
+    });
+}
+/**
+ * 扫描目录加载所有插件
+ */
+export function loadPlugins(options) {
+    const { dir, recursive = false } = options;
+    if (!existsSync(dir)) {
+        console.warn(`[PluginLoader] Directory not found: ${dir}`);
+        return new Map();
+    }
+    const plugins = new Map();
+    function scanDirectory(currentDir) {
+        const entries = readdirSync(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = join(currentDir, entry.name);
+            if (entry.isDirectory() && recursive) {
+                scanDirectory(fullPath);
+            }
+            else if (entry.isFile() && extname(entry.name) === ".json") {
+                try {
+                    // 跳过 schema.json
+                    if (entry.name === "schema.json")
+                        continue;
+                    const config = loadPlugin(fullPath);
+                    // 检查重复
+                    if (plugins.has(config.name)) {
+                        console.warn(`[PluginLoader] Duplicate plugin name: ${config.name}, skipping ${fullPath}`);
+                        continue;
+                    }
+                    plugins.set(config.name, config);
+                    console.log(`[PluginLoader] Loaded: ${config.name} (${config.type})`);
+                }
+                catch (error) {
+                    console.error(`[PluginLoader] Failed to load ${fullPath}:`, error);
+                }
+            }
+        }
+    }
+    scanDirectory(dir);
+    console.log(`[PluginLoader] Total plugins loaded: ${plugins.size}`);
+    return plugins;
+}
+/**
+ * 获取默认插件目录
+ */
+export function getDefaultPluginDir() {
+    // 优先使用环境变量
+    if (process.env.MAGIC_SHELL_PLUGINS_DIR) {
+        return process.env.MAGIC_SHELL_PLUGINS_DIR;
+    }
+    const packagePluginDir = resolve(dirname(fileURLToPath(import.meta.url)), "..", "plugins");
+    if (existsSync(packagePluginDir)) {
+        return packagePluginDir;
+    }
+    const distPluginDir = resolve(dirname(fileURLToPath(import.meta.url)), "plugins");
+    if (existsSync(distPluginDir)) {
+        return distPluginDir;
+    }
+    // 回退到当前工作目录的 plugins，兼容仓库内开发
+    return join(process.cwd(), "plugins");
+}

package/dist/plugins/pie.json

@@ -0,0 +1,7 @@
+{
+	"name": "pie",
+	"type": "pty",
+	"command": "pie",
+	"args": [],
+	"capabilities": ["terminal", "file-edit", "web-search", "bash", "ansi256", "interactive"]
+}

package/dist/primary-agent-bridge.d.ts

@@ -0,0 +1,69 @@
+import type { PluginConfig, AgentRecord } from "./types.js";
+import type { NodeReply } from "./node-reply.js";
+export interface PrimaryCliResponse {
+    ok: boolean;
+    text?: string;
+    error?: string;
+    sessionId?: string;
+    provider?: string;
+    modelId?: string;
+}
+export interface PrimaryAgentPromptContext {
+    pluginName: string;
+    preferredWorkerPluginName?: string;
+    status: "starting" | "running" | "stopped" | "failed" | "disabled" | "missing";
+    lastTaskSummary?: string;
+    lastWorkerSessionId?: string;
+    history: Array<{
+        role: "user" | "assistant";
+        text: string;
+        timestamp: number;
+        actionType?: "spawn" | "attach";
+        actionLabel?: string;
+        actionTaskSummary?: string;
+        actionSessionId?: string;
+    }>;
+    liveWorkers: AgentRecord[];
+}
+export interface QueryPrimaryAgentOptions {
+    text: string;
+    plugin: PluginConfig;
+    primarySessionId?: string;
+    context: PrimaryAgentPromptContext;
+    isSessionAttachable?: (sessionId: string) => boolean;
+}
+export interface PrimarySessionPromptContext {
+    pluginName: string;
+    preferredWorkerPluginName?: string;
+    lastTaskSummary?: string;
+    lastWorkerSessionId?: string;
+    history: Array<{
+        role: "user" | "assistant";
+        text: string;
+        timestamp: number;
+        actionType?: "spawn" | "attach";
+        actionLabel?: string;
+        actionTaskSummary?: string;
+        actionSessionId?: string;
+    }>;
+    liveWorkers: AgentRecord[];
+}
+export interface PrimarySessionSnapshot {
+    messageCount: number;
+    lastAssistantText: string;
+    updatedAt: number;
+    lastMessageRole?: string;
+    lastAssistantHasToolCall?: boolean;
+}
+export declare function getPrimaryPieExtensionDistDir(): string;
+export declare function withPrimaryPieExtensionPath(plugin: PluginConfig): PluginConfig;
+export declare function buildPrimaryPrompt(text: string, context: PrimaryAgentPromptContext): string;
+export declare function buildPrimarySessionPrompt(text: string, context: PrimarySessionPromptContext): string;
+export declare function runPrimaryCli(plugin: PluginConfig, prompt: string, options?: {
+    sessionId?: string;
+    timeoutMs?: number;
+}): Promise<PrimaryCliResponse>;
+export declare function parsePrimaryReply(response: PrimaryCliResponse): NodeReply | null;
+export declare function queryPrimaryAgentReply(options: QueryPrimaryAgentOptions): Promise<NodeReply | null>;
+export declare function readPieSessionSnapshot(sessionId: string): PrimarySessionSnapshot | null;
+export declare const readPrimarySessionSnapshot: typeof readPieSessionSnapshot;

package/dist/primary-agent-bridge.js

@@ -0,0 +1,282 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+export function getPrimaryPieExtensionDistDir() {
+    const currentDir = path.dirname(fileURLToPath(import.meta.url));
+    const repoRoot = path.resolve(currentDir, "..", "..", "..");
+    return path.join(repoRoot, "packages", "primary-pie-extension", "dist");
+}
+export function withPrimaryPieExtensionPath(plugin) {
+    if (plugin.name !== "pie") {
+        return plugin;
+    }
+    const extensionDir = getPrimaryPieExtensionDistDir();
+    return {
+        ...plugin,
+        args: [...(plugin.args || []), "--extension-path", extensionDir],
+    };
+}
+export function buildPrimaryPrompt(text, context) {
+    const liveWorkers = context.liveWorkers.map((worker) => ({
+        sessionId: worker.sessionId,
+        displayName: worker.displayName,
+        title: worker.displayName || worker.taskSummary || worker.agentSessionId || `S:${worker.sessionId.slice(-6)}`,
+        status: worker.status,
+        phase: worker.phase,
+        activityState: worker.activityState,
+        cwd: worker.cwd,
+    }));
+    const recentHistory = context.history.slice(-6);
+    return [
+        "You are the primary agent inside Magic Shell.",
+        "You are deciding how AgentNode should respond to the user.",
+        "You are the node's main conversational brain, not a thin status bot.",
+        "Reply with JSON only.",
+        'Use this schema: {"reply":"string","actionType":"none|spawn|attach","actionLabel":"string","actionTaskSummary":"string","actionSessionId":"string"}',
+        "Rules:",
+        "- If the user is asking about capabilities or status, answer directly and set actionType to none.",
+        "- If the user is asking to do work and no existing worker should continue it, set actionType to spawn and fill actionTaskSummary.",
+        "- When spawning a new worker, prefer the configured preferred worker plugin unless the user explicitly asks for another worker type.",
+        "- If the user is following up on an existing worker, set actionType to attach, fill actionSessionId, and put the short follow-up instruction in actionTaskSummary.",
+        "- Do not spawn a worker just because the user greeted you or asked what you can do.",
+        "- If there is already a relevant live worker, prefer attach over spawn.",
+        "- If the user says things like continue, keep going, start working, or why are you not doing it, treat that as follow-up on the most relevant live worker when possible.",
+        "- Keep reply concise and useful.",
+        "- Be explicit about what you are about to do or already did.",
+        "Examples:",
+        '- User: "你能做什么" -> {"reply":"...","actionType":"none"}',
+        '- User: "帮我看看这个目录里有什么" with no relevant worker -> {"reply":"I will start a worker to inspect the directory.","actionType":"spawn","actionLabel":"ATTACH WORKER","actionTaskSummary":"Inspect the current directory and summarize what is here."}',
+        '- User: "继续" with a live worker -> {"reply":"I will push the current worker to keep going.","actionType":"attach","actionLabel":"ATTACH WORKER","actionSessionId":"...","actionTaskSummary":"Continue the current task and make visible progress. Summarize what you are doing."}',
+        "",
+        `Primary plugin: ${context.pluginName}`,
+        `Preferred worker plugin: ${context.preferredWorkerPluginName || "pie"}`,
+        `Primary status: ${context.status}`,
+        `Recent task summary: ${context.lastTaskSummary || ""}`,
+        `Recent worker session: ${context.lastWorkerSessionId || ""}`,
+        `Live workers: ${JSON.stringify(liveWorkers)}`,
+        `Recent conversation: ${JSON.stringify(recentHistory)}`,
+        `User message: ${text}`,
+    ].join("\n");
+}
+export function buildPrimarySessionPrompt(text, context) {
+    const liveWorkers = context.liveWorkers.map((worker) => ({
+        sessionId: worker.sessionId,
+        displayName: worker.displayName,
+        title: worker.displayName || worker.taskSummary || worker.agentSessionId || `S:${worker.sessionId.slice(-6)}`,
+        status: worker.status,
+        activityState: worker.activityState,
+        cwd: worker.cwd,
+    }));
+    const recentHistory = context.history.slice(-6);
+    const recommendedWorkerSessionId = context.lastWorkerSessionId || "";
+    return [
+        "You are the protected primary agent inside Magic Shell.",
+        "You are the only chat speaker. AgentNode should not narrate worker progress for you.",
+        "For any execution, inspection, file-system, shell, directory, repository, path, or follow-up task, use the tool `magic_shell_delegate_worker_turn` instead of answering from memory.",
+        "When the task touches a path or repository that may be outside the current cwd, still use the tool and ask the worker to inspect the concrete location before concluding that it is missing.",
+        "When the user points to a specific directory or says a target directory lives under a known parent, pass that directory as the tool's cwd when you can infer it.",
+        "If a delegated tool call returns a recoverable failure, do not stop. Use that failure result to continue reasoning, correct the path or arguments, and try again when appropriate.",
+        "Prefer one clean delegated worker turn that waits for the worker's answer instead of sending multiple retries or asking the user to attach a worker.",
+        "Prefer reusing the current worker when it is relevant.",
+        "If you are continuing, clarifying, or following up on the most recent worker task, pass `sessionId` explicitly to the tool instead of selecting a random live worker.",
+        "If you are not confident which existing worker is intended, do not guess. Start a fresh worker instead.",
+        "When multiple workers exist, only reuse one if you can name the intended session confidently; otherwise start a fresh worker.",
+        "If the user gives a worker a name, preserve that name by passing `workerName` to the tool.",
+        "If the user explicitly asks multiple named workers to do distinct work in one reply, you may call the tool multiple times in the same turn and then summarize all results together.",
+        "If you are spawning a new worker instead of reusing an existing session, pass pluginName set to the preferred worker plugin unless the user explicitly requests another worker type.",
+        "Do not ask the user to manually attach a worker unless inspection is explicitly requested.",
+        "Do not narrate intermediate runtime states back to the user unless they explicitly ask for them.",
+        "If you use the worker tool, produce one final user-facing answer that integrates the worker result.",
+        "Keep the final answer concise, concrete, and user-facing.",
+        "",
+        `Primary plugin: ${context.pluginName}`,
+        `Preferred worker plugin: ${context.preferredWorkerPluginName || "pie"}`,
+        `Current working context should be discovered through the worker tool when needed.`,
+        `Recommended current worker sessionId: ${recommendedWorkerSessionId}`,
+        `Recent task summary: ${context.lastTaskSummary || ""}`,
+        `Live workers: ${JSON.stringify(liveWorkers)}`,
+        `Recent conversation: ${JSON.stringify(recentHistory)}`,
+        "",
+        `User message: ${text}`,
+    ].join("\n");
+}
+export function runPrimaryCli(plugin, prompt, options = {}) {
+    return new Promise((resolve, reject) => {
+        const runtimePlugin = withPrimaryPieExtensionPath(plugin);
+        const args = [
+            ...(runtimePlugin.args || []),
+            "--json-output",
+        ];
+        if (options.sessionId) {
+            args.push("--session-id", options.sessionId);
+        }
+        args.push(prompt);
+        const child = spawn(runtimePlugin.command, args, {
+            cwd: runtimePlugin.cwd || process.cwd(),
+            env: { ...process.env, ...(runtimePlugin.env || {}) },
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        const timeoutMs = options.timeoutMs ?? 45_000;
+        const timeout = setTimeout(() => {
+            child.kill("SIGTERM");
+            reject(new Error("Primary agent CLI timed out"));
+        }, timeoutMs);
+        child.stdout.on("data", (chunk) => {
+            stdout += String(chunk);
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += String(chunk);
+        });
+        child.on("error", (err) => {
+            clearTimeout(timeout);
+            reject(err);
+        });
+        child.on("close", (code) => {
+            clearTimeout(timeout);
+            const output = stdout.trim();
+            let parsed = null;
+            try {
+                parsed = output ? JSON.parse(output) : null;
+            }
+            catch {
+                parsed = null;
+            }
+            if (code !== 0) {
+                reject(new Error(parsed?.error || stderr.trim() || `Primary agent CLI exited with code ${code}`));
+                return;
+            }
+            if (!parsed || typeof parsed.ok !== "boolean") {
+                reject(new Error("Primary agent CLI returned invalid JSON"));
+                return;
+            }
+            if (!parsed.ok) {
+                reject(new Error(parsed.error || "Primary agent CLI returned an error"));
+                return;
+            }
+            resolve(parsed);
+        });
+    });
+}
+export function parsePrimaryReply(response) {
+    const candidate = (response.text || "").trim();
+    const fenced = candidate.match(/```(?:json)?\s*([\s\S]*?)```/i);
+    const payload = (fenced?.[1] || candidate).trim();
+    const start = payload.indexOf("{");
+    const end = payload.lastIndexOf("}");
+    if (start < 0 || end <= start) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(payload.slice(start, end + 1));
+        if (!parsed.reply) {
+            return null;
+        }
+        return {
+            text: parsed.reply,
+            actionType: parsed.actionType && parsed.actionType !== "none" ? parsed.actionType : undefined,
+            actionLabel: parsed.actionLabel,
+            actionTaskSummary: parsed.actionTaskSummary,
+            actionSessionId: parsed.actionSessionId,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export async function queryPrimaryAgentReply(options) {
+    const prompt = buildPrimaryPrompt(options.text, options.context);
+    const raw = await runPrimaryCli(options.plugin, prompt, {
+        sessionId: options.primarySessionId,
+        timeoutMs: 8_000,
+    });
+    const parsed = parsePrimaryReply(raw);
+    if (!parsed) {
+        return null;
+    }
+    if (parsed.actionType === "attach"
+        && parsed.actionSessionId
+        && options.isSessionAttachable
+        && !options.isSessionAttachable(parsed.actionSessionId)) {
+        delete parsed.actionType;
+        delete parsed.actionLabel;
+        delete parsed.actionSessionId;
+    }
+    return parsed;
+}
+function collectSessionMessages(raw) {
+    if (Array.isArray(raw.messages) && raw.messages.length > 0) {
+        return raw.messages;
+    }
+    if (Array.isArray(raw.entries) && raw.entries.length > 0) {
+        return raw.entries
+            .filter((entry) => entry?.type === "message" && entry.message)
+            .map((entry) => ({
+            role: entry.message?.role,
+            content: entry.message?.content,
+            timestamp: entry.message?.timestamp || entry.timestamp,
+        }));
+    }
+    return [];
+}
+function readLastMessageMeta(messages) {
+    const lastMessage = messages.length ? messages[messages.length - 1] : undefined;
+    if (!lastMessage) {
+        return {};
+    }
+    return {
+        role: lastMessage.role,
+        hasToolCall: Array.isArray(lastMessage.content)
+            && lastMessage.content.some((item) => item?.type === "toolCall"),
+    };
+}
+export function readPieSessionSnapshot(sessionId) {
+    if (!sessionId) {
+        return null;
+    }
+    const sessionPath = path.join(os.homedir(), ".pie", "sessions", `${sessionId}.json`);
+    if (!fs.existsSync(sessionPath)) {
+        return null;
+    }
+    try {
+        const raw = JSON.parse(fs.readFileSync(sessionPath, "utf8"));
+        const messages = collectSessionMessages(raw);
+        for (let index = messages.length - 1; index >= 0; index -= 1) {
+            const message = messages[index];
+            if (message?.role !== "assistant" || !Array.isArray(message.content)) {
+                continue;
+            }
+            const text = message.content
+                .filter((item) => item?.type === "text" && typeof item.text === "string")
+                .map((item) => item.text?.trim() || "")
+                .filter(Boolean)
+                .join("\n\n")
+                .trim();
+            if (!text) {
+                continue;
+            }
+            return {
+                messageCount: raw.metadata?.messageCount || messages.length,
+                lastAssistantText: text,
+                updatedAt: raw.metadata?.updatedAt || message.timestamp || Date.now(),
+                lastMessageRole: readLastMessageMeta(messages).role,
+                lastAssistantHasToolCall: readLastMessageMeta(messages).hasToolCall,
+            };
+        }
+        const meta = readLastMessageMeta(messages);
+        return {
+            messageCount: raw.metadata?.messageCount || messages.length,
+            lastAssistantText: "",
+            updatedAt: raw.metadata?.updatedAt || Date.now(),
+            lastMessageRole: meta.role,
+            lastAssistantHasToolCall: meta.hasToolCall,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export const readPrimarySessionSnapshot = readPieSessionSnapshot;

package/dist/session-manager.d.ts

@@ -0,0 +1,66 @@
+import { type AdapterRegistry } from "./adapters/registry.js";
+import type { PluginConfig, AdapterOutput } from "./adapters/types.js";
+export interface Session {
+    id: string;
+    agentId: string;
+    plugin: PluginConfig;
+    createdAt: number;
+    lastActivity: number;
+    cols: number;
+    rows: number;
+    outputBuffer: string;
+    outputCallback?: (output: AdapterOutput) => void;
+}
+/**
+ * 会话管理器
+ * 管理所有终端会话的生命周期
+ */
+export declare class SessionManager {
+    private registry;
+    private sessions;
+    private outputCallbacks;
+    private exitCallbacks;
+    private readonly maxBufferedOutput;
+    constructor(registry?: AdapterRegistry);
+    /**
+     * 创建或恢复会话
+     */
+    createSession(sessionId: string, plugin: PluginConfig): Promise<void>;
+    /**
+     * 销毁会话
+     */
+    destroySession(sessionId: string): Promise<void>;
+    /**
+     * 发送输入到会话
+     */
+    sendInput(sessionId: string, data: string): void;
+    /**
+     * 调整终端尺寸
+     */
+    resize(sessionId: string, cols: number, rows: number): void;
+    /**
+     * 获取会话信息
+     */
+    getSession(sessionId: string): Session | undefined;
+    /**
+     * 列出所有会话
+     */
+    listSessions(): Session[];
+    getBufferedOutput(sessionId: string): string;
+    appendOutput(sessionId: string, content: string): void;
+    /**
+     * 停止所有会话
+     */
+    stopAll(): Promise<void>;
+    /**
+     * 注册输出回调
+     */
+    onOutput(callback: (sessionId: string, output: AdapterOutput) => void): void;
+    onExit(callback: (sessionId: string, agentId: string, code: number | null) => void): void;
+    /**
+     * 触发输出事件
+     */
+    private emitOutput;
+    private emitExit;
+    private appendToBuffer;
+}