@cydm/magic-shell-agent-node 0.1.0

package/dist/session-manager.js

@@ -0,0 +1,197 @@
+import { adapterRegistry } from "./adapters/registry.js";
+/**
+ * 会话管理器
+ * 管理所有终端会话的生命周期
+ */
+export class SessionManager {
+    registry;
+    sessions = new Map();
+    outputCallbacks = [];
+    exitCallbacks = [];
+    maxBufferedOutput = 200_000;
+    constructor(registry = adapterRegistry) {
+        this.registry = registry;
+    }
+    /**
+     * 创建或恢复会话
+     */
+    async createSession(sessionId, plugin) {
+        // 如果会话已存在，直接返回（支持重连恢复）
+        if (this.sessions.has(sessionId)) {
+            console.log(`[SessionManager] Session ${sessionId} already exists, reusing`);
+            return;
+        }
+        const adapter = this.registry.findAdapter(plugin);
+        const agentId = await adapter.start(plugin);
+        const session = {
+            id: sessionId,
+            agentId,
+            plugin,
+            createdAt: Date.now(),
+            lastActivity: Date.now(),
+            cols: 80,
+            rows: 24,
+            outputBuffer: "",
+        };
+        // 设置输出回调
+        adapter.onOutput((aid, output) => {
+            if (aid === agentId) {
+                session.lastActivity = Date.now();
+                session.outputBuffer = this.appendToBuffer(session.outputBuffer, output.content);
+                session.outputCallback?.(output);
+                this.emitOutput(sessionId, output);
+            }
+        });
+        // 设置退出回调
+        adapter.onExit((aid, code) => {
+            if (aid === agentId) {
+                console.log(`[SessionManager] Session ${sessionId} exited with code ${code}`);
+                const currentSession = this.sessions.get(sessionId);
+                if (currentSession?.agentId === aid) {
+                    this.sessions.delete(sessionId);
+                }
+                this.emitExit(sessionId, aid, code);
+            }
+        });
+        this.sessions.set(sessionId, session);
+        console.log(`[SessionManager] Created session ${sessionId} with agent ${agentId}`);
+    }
+    /**
+     * 销毁会话
+     */
+    async destroySession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            console.warn(`[SessionManager] Session not found: ${sessionId}`);
+            return;
+        }
+        const adapter = this.registry.findAdapter(session.plugin);
+        await adapter.stop(session.agentId);
+        this.sessions.delete(sessionId);
+        console.log(`[SessionManager] Destroyed session ${sessionId}`);
+    }
+    /**
+     * 发送输入到会话
+     */
+    sendInput(sessionId, data) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            console.warn(`[SessionManager] Cannot send input, session not found: ${sessionId}`);
+            return;
+        }
+        session.lastActivity = Date.now();
+        const adapter = this.registry.findAdapter(session.plugin);
+        // 检查是否有 sendRawInput 方法（PTY 模式）
+        if (adapter.sendRawInput) {
+            adapter.sendRawInput(session.agentId, data);
+        }
+        else {
+            adapter.sendInput(session.agentId, { text: data });
+        }
+    }
+    /**
+     * 调整终端尺寸
+     */
+    resize(sessionId, cols, rows) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            console.warn(`[SessionManager] Cannot resize, session not found: ${sessionId}`);
+            return;
+        }
+        session.cols = cols;
+        session.rows = rows;
+        const adapter = this.registry.findAdapter(session.plugin);
+        if (adapter.resize) {
+            adapter.resize(session.agentId, cols, rows);
+        }
+    }
+    /**
+     * 获取会话信息
+     */
+    getSession(sessionId) {
+        return this.sessions.get(sessionId);
+    }
+    /**
+     * 列出所有会话
+     */
+    listSessions() {
+        return Array.from(this.sessions.values());
+    }
+    getBufferedOutput(sessionId) {
+        return this.sessions.get(sessionId)?.outputBuffer || "";
+    }
+    appendOutput(sessionId, content) {
+        if (!content)
+            return;
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return;
+        session.lastActivity = Date.now();
+        session.outputBuffer = this.appendToBuffer(session.outputBuffer, content);
+        const output = {
+            timestamp: Date.now(),
+            type: "output",
+            content,
+        };
+        session.outputCallback?.(output);
+        this.emitOutput(sessionId, output);
+    }
+    /**
+     * 停止所有会话
+     */
+    async stopAll() {
+        console.log(`[SessionManager] Stopping ${this.sessions.size} sessions...`);
+        const promises = [];
+        for (const [sessionId, session] of this.sessions) {
+            const adapter = this.registry.findAdapter(session.plugin);
+            promises.push(adapter.stop(session.agentId).catch((err) => {
+                console.error(`[SessionManager] Error stopping session ${sessionId}:`, err);
+            }));
+        }
+        await Promise.all(promises);
+        this.sessions.clear();
+        console.log("[SessionManager] All sessions stopped");
+    }
+    /**
+     * 注册输出回调
+     */
+    onOutput(callback) {
+        this.outputCallbacks.push(callback);
+    }
+    onExit(callback) {
+        this.exitCallbacks.push(callback);
+    }
+    /**
+     * 触发输出事件
+     */
+    emitOutput(sessionId, output) {
+        console.log(`[SessionManager] emitOutput: ${sessionId}, ${output.content.length} chars, ${this.outputCallbacks.length} callbacks`);
+        for (const callback of this.outputCallbacks) {
+            try {
+                callback(sessionId, output);
+            }
+            catch (err) {
+                console.error("[SessionManager] Output callback error:", err);
+            }
+        }
+    }
+    emitExit(sessionId, agentId, code) {
+        for (const callback of this.exitCallbacks) {
+            try {
+                callback(sessionId, agentId, code);
+            }
+            catch (err) {
+                console.error("[SessionManager] Exit callback error:", err);
+            }
+        }
+    }
+    appendToBuffer(current, chunk) {
+        if (!chunk)
+            return current;
+        const next = current + chunk;
+        if (next.length <= this.maxBufferedOutput) {
+            return next;
+        }
+        return next.slice(next.length - this.maxBufferedOutput);
+    }
+}

package/dist/terminal-metadata.d.ts

@@ -0,0 +1,7 @@
+export interface TerminalMetadata {
+    title?: string;
+    activityState?: "ready" | "busy";
+    agentSessionId?: string;
+}
+export declare function normalizeWorkerTitleCandidate(raw: string): string | null;
+export declare function extractTerminalMetadata(output: string, agentType: string): TerminalMetadata | null;

package/dist/terminal-metadata.js

@@ -0,0 +1,52 @@
+export function normalizeWorkerTitleCandidate(raw) {
+    const cleaned = raw
+        .split(/\n{2,}/)[0]
+        .split("\n")[0]
+        .replace(/Work in your own session.*$/i, "")
+        .replace(/Reply to the primary agent now.*$/i, "")
+        .replace(/\s+/g, " ")
+        .trim();
+    const title = cleaned.slice(0, 48);
+    if (!title)
+        return null;
+    if (title.startsWith("/"))
+        return null;
+    return title;
+}
+export function extractTerminalMetadata(output, agentType) {
+    const matches = Array.from(output.matchAll(/\x1b\](?:0|2);([^\x07\x1b]*)(?:\x07|\x1b\\)/g));
+    if (!matches.length) {
+        return null;
+    }
+    const rawTitle = matches[matches.length - 1]?.[1]?.trim();
+    if (!rawTitle) {
+        return null;
+    }
+    let visibleTitle = rawTitle;
+    const metadata = {};
+    const metadataMatch = rawTitle.match(/\s+\[ms:([^\]]+)\]\s*$/);
+    if (metadataMatch) {
+        visibleTitle = rawTitle.slice(0, metadataMatch.index).trim();
+        for (const part of metadataMatch[1].split(";")) {
+            const [rawKey, ...rawValueParts] = part.split("=");
+            const key = rawKey?.trim();
+            const value = rawValueParts.join("=").trim();
+            if (!key || !value)
+                continue;
+            if (key === "state" && (value === "ready" || value === "busy")) {
+                metadata.activityState = value;
+            }
+            if (key === "session") {
+                metadata.agentSessionId = value;
+            }
+        }
+    }
+    const normalized = agentType === "pie"
+        ? visibleTitle.replace(/^Pie\s*[·-]\s*/i, "")
+        : visibleTitle;
+    const title = normalized.trim().replace(/\s+/g, " ").slice(0, 60);
+    if (title) {
+        metadata.title = title;
+    }
+    return Object.keys(metadata).length > 0 ? metadata : null;
+}

package/dist/types.d.ts

@@ -0,0 +1 @@
+export * from "@cydm/magic-shell-protocol";

package/dist/types.js

@@ -0,0 +1 @@
+export * from "@cydm/magic-shell-protocol";

package/dist/worker-control.d.ts

@@ -0,0 +1,15 @@
+import type { ServerMessage } from "./types.js";
+import type { WorkerRegistry } from "./worker-registry.js";
+import type { SessionManager } from "./session-manager.js";
+import type { SpawnWorkerOptions } from "./node.js";
+export interface WorkerControlDeps {
+    workerRegistry: WorkerRegistry;
+    sessionManager: SessionManager;
+    clearSessionTitle(sessionId: string): void;
+    broadcastWorkerList(): void;
+    spawnWorker(options: SpawnWorkerOptions): Promise<void>;
+}
+export declare function attachWorkerSession(sessionId: string, deps: Pick<WorkerControlDeps, "workerRegistry" | "sessionManager">): ServerMessage[];
+export declare function stopWorkerSession(sessionId: string, deps: WorkerControlDeps): Promise<void>;
+export declare function restartWorkerSession(sessionId: string, deps: WorkerControlDeps): Promise<string | null>;
+export declare function inspectWorkerSession(sessionId: string, deps: Pick<WorkerControlDeps, "workerRegistry" | "sessionManager">): ServerMessage | null;

package/dist/worker-control.js

@@ -0,0 +1,89 @@
+export function attachWorkerSession(sessionId, deps) {
+    const worker = deps.workerRegistry.getWorkerBySessionId(sessionId);
+    if (!worker) {
+        return [];
+    }
+    deps.workerRegistry.recordEvent(worker.agentId, {
+        type: "attached",
+        timestamp: Date.now(),
+        message: "attached from browser",
+    });
+    const messages = [
+        {
+            type: "session",
+            sessionId: worker.sessionId,
+            agentType: worker.agentType,
+            capabilities: worker.capabilities,
+        },
+    ];
+    const bufferedOutput = deps.sessionManager.getBufferedOutput(sessionId);
+    if (bufferedOutput) {
+        messages.push({
+            type: "output",
+            sessionId: worker.sessionId,
+            data: bufferedOutput,
+        });
+    }
+    return messages;
+}
+export async function stopWorkerSession(sessionId, deps) {
+    const worker = deps.workerRegistry.getWorkerBySessionId(sessionId);
+    if (!worker) {
+        return;
+    }
+    deps.workerRegistry.updateWorkerStatus(worker.agentId, "stopping");
+    deps.clearSessionTitle(sessionId);
+    await deps.sessionManager.destroySession(sessionId);
+    deps.broadcastWorkerList();
+}
+export async function restartWorkerSession(sessionId, deps) {
+    const worker = deps.workerRegistry.getWorkerBySessionId(sessionId);
+    if (!worker) {
+        return null;
+    }
+    try {
+        deps.workerRegistry.recordEvent(worker.agentId, {
+            type: "restarted",
+            timestamp: Date.now(),
+            message: "restart requested",
+        });
+        deps.workerRegistry.updateWorkerStatus(worker.agentId, "stopping");
+        deps.clearSessionTitle(sessionId);
+        await deps.sessionManager.destroySession(sessionId);
+        await deps.spawnWorker({
+            sessionId: worker.sessionId,
+            pluginName: worker.agentType,
+            cwd: worker.cwd,
+            parentAgentId: worker.parentAgentId,
+        });
+        return null;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        deps.workerRegistry.recordEvent(worker.agentId, {
+            type: "error",
+            timestamp: Date.now(),
+            message,
+        });
+        deps.workerRegistry.updateWorkerStatus(worker.agentId, "failed", {
+            lastError: message,
+        });
+        deps.broadcastWorkerList();
+        return message;
+    }
+}
+export function inspectWorkerSession(sessionId, deps) {
+    const worker = deps.workerRegistry.getWorkerBySessionId(sessionId);
+    if (!worker) {
+        return null;
+    }
+    deps.workerRegistry.recordEvent(worker.agentId, {
+        type: "inspected",
+        timestamp: Date.now(),
+        message: "detail requested",
+    });
+    return {
+        type: "worker_detail",
+        worker: deps.workerRegistry.getWorkerDetail(worker.agentId, deps.sessionManager.getBufferedOutput(worker.sessionId)),
+    };
+}

package/dist/worker-narration.d.ts

@@ -0,0 +1,25 @@
+import type { AgentRecord } from "./types.js";
+export type WorkerMilestoneReason = "ready" | "attention" | "failed" | "stopped";
+export interface WorkerMilestonePromptContext {
+    lastTaskSummary?: string;
+    lastUserMessage?: string;
+    outputSummary: string;
+}
+export type WorkerNarrationDecision = {
+    kind: "none";
+} | {
+    kind: "node_update";
+    text: string;
+    actionLabel: string;
+    actionSessionId: string;
+} | {
+    kind: "milestone";
+    reason: WorkerMilestoneReason;
+    fallback: string;
+    actionLabel: string;
+    actionSessionId: string;
+    stateKey: string;
+};
+export declare function buildWorkerMilestonePrompt(worker: AgentRecord, reason: WorkerMilestoneReason, context: WorkerMilestonePromptContext): string;
+export declare function describeCurrentWorkerForNode(worker: AgentRecord, recentOutput: string): string;
+export declare function decideWorkerNarration(previous: AgentRecord | undefined, next: AgentRecord): WorkerNarrationDecision;

package/dist/worker-narration.js

@@ -0,0 +1,90 @@
+export function buildWorkerMilestonePrompt(worker, reason, context) {
+    return [
+        "You are AgentNode, a personal agent coordinator.",
+        "Summarize the worker's latest milestone for the user.",
+        "Write 1-2 short sentences only.",
+        "Match the user's language when it is obvious from the recent message.",
+        "Do not mention ANSI, terminals, logs, JSON, or raw control output.",
+        "Speak like a calm secretary giving a progress update.",
+        "",
+        `Reason: ${reason}`,
+        `Worker title: ${worker.taskSummary || worker.agentSessionId || `S:${worker.sessionId.slice(-6)}`}`,
+        `Worker state: ${[worker.status, worker.phase, worker.activityState].filter(Boolean).join(" · ")}`,
+        `Task summary: ${worker.taskSummary || context.lastTaskSummary || ""}`,
+        `Attention reason: ${worker.attentionReason || worker.interventionReason || worker.recommendedActionReason || ""}`,
+        `Recent user message: ${context.lastUserMessage || ""}`,
+        `Recent meaningful output:\n${context.outputSummary}`,
+        "",
+        "Return only the short update text.",
+    ].join("\n");
+}
+export function describeCurrentWorkerForNode(worker, recentOutput) {
+    const label = worker.taskSummary || worker.agentSessionId || `S:${worker.sessionId.slice(-6)}`;
+    const parts = [`Current task worker: ${label}.`];
+    if (worker.phase || worker.activityState) {
+        parts.push(`State: ${[worker.status, worker.phase, worker.activityState].filter(Boolean).join(" · ")}.`);
+    }
+    if (worker.attentionReason) {
+        parts.push(`Attention: ${worker.attentionReason}.`);
+    }
+    else if (worker.recommendedActionReason) {
+        parts.push(`Hint: ${worker.recommendedActionReason}.`);
+    }
+    if (recentOutput) {
+        parts.push(`Recent output:\n${recentOutput}`);
+    }
+    return parts.join("\n");
+}
+export function decideWorkerNarration(previous, next) {
+    const label = next.taskSummary || next.agentSessionId || `S:${next.sessionId.slice(-6)}`;
+    const stateKey = `${next.status}:${next.phase || ""}:${next.activityState || ""}`;
+    if (next.status === "failed") {
+        return {
+            kind: "milestone",
+            reason: "failed",
+            fallback: `Worker ${label} failed${next.lastError ? `: ${next.lastError}` : "."}`,
+            actionLabel: "ATTACH WORKER",
+            actionSessionId: next.sessionId,
+            stateKey,
+        };
+    }
+    if (next.status === "stopped") {
+        return {
+            kind: "milestone",
+            reason: "stopped",
+            fallback: `Worker ${label} stopped.`,
+            actionLabel: "VIEW LAST OUTPUT",
+            actionSessionId: next.sessionId,
+            stateKey,
+        };
+    }
+    if (previous?.activityState !== "busy" && next.activityState === "busy") {
+        return {
+            kind: "node_update",
+            text: `Worker ${label} is actively working now.`,
+            actionLabel: "ATTACH WORKER",
+            actionSessionId: next.sessionId,
+        };
+    }
+    if (previous?.activityState === "busy" && next.activityState === "ready") {
+        return {
+            kind: "milestone",
+            reason: "ready",
+            fallback: `Worker ${label} looks ready for input or review.`,
+            actionLabel: "ATTACH WORKER",
+            actionSessionId: next.sessionId,
+            stateKey,
+        };
+    }
+    if (previous?.phase !== "attention" && next.phase === "attention") {
+        return {
+            kind: "milestone",
+            reason: "attention",
+            fallback: `Worker ${label} may need intervention${next.attentionReason ? `: ${next.attentionReason}` : "."}`,
+            actionLabel: "ATTACH WORKER",
+            actionSessionId: next.sessionId,
+            stateKey,
+        };
+    }
+    return { kind: "none" };
+}

package/dist/worker-output.d.ts

@@ -0,0 +1,6 @@
+export declare function stripAnsi(value: string): string;
+export declare function normalizePrimarySummaryText(value: string): string;
+export declare function isMeaningfulWorkerOutputLine(line: string): boolean;
+export declare function summarizeRecentWorkerOutput(bufferedOutput: string): string;
+export declare function getLastMeaningfulWorkerMessage(bufferedOutput: string): string;
+export declare function getFreshWorkerOutputSummary(agentId: string, bufferedOutput: string, seenSummaries: Map<string, string>): string;

package/dist/worker-output.js

@@ -0,0 +1,72 @@
+export function stripAnsi(value) {
+    return String(value || "")
+        .replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, "")
+        .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")
+        .replace(/\x1b[@-_]/g, "");
+}
+export function normalizePrimarySummaryText(value) {
+    return String(value || "")
+        .replace(/^```(?:json|text)?/i, "")
+        .replace(/```$/i, "")
+        .trim();
+}
+export function isMeaningfulWorkerOutputLine(line) {
+    const normalized = String(line || "").trim();
+    if (!normalized || normalized.length < 4)
+        return false;
+    if (/^(thinking|ready|booting|working|waiting)$/i.test(normalized))
+        return false;
+    if (/extension loaded/i.test(normalized))
+        return false;
+    if (/^\d+(\.\d+)?%\/\d+/i.test(normalized))
+        return false;
+    if (/^(local-|company-|kimi-|gpt-|claude-|qwen-)/i.test(normalized))
+        return false;
+    if (/^\/Users\/|^~\//.test(normalized))
+        return false;
+    if (/^[\u2500-\u257f\s]+$/u.test(normalized))
+        return false;
+    if (/^[\[\](){}<>\-_=.:;|\\/+*#\s]+$/.test(normalized))
+        return false;
+    return true;
+}
+export function summarizeRecentWorkerOutput(bufferedOutput) {
+    const cleaned = stripAnsi(bufferedOutput)
+        .replace(/\r/g, "\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+    if (!cleaned)
+        return "";
+    const lines = cleaned
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => isMeaningfulWorkerOutputLine(line));
+    if (!lines.length)
+        return "";
+    const uniqueTail = Array.from(new Set(lines)).slice(-4);
+    const tail = uniqueTail.join("\n");
+    return tail.slice(-280);
+}
+export function getLastMeaningfulWorkerMessage(bufferedOutput) {
+    const cleaned = stripAnsi(bufferedOutput)
+        .replace(/\r/g, "\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+    if (!cleaned)
+        return "";
+    const lines = cleaned
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => isMeaningfulWorkerOutputLine(line));
+    return lines.length ? lines[lines.length - 1].slice(-400) : "";
+}
+export function getFreshWorkerOutputSummary(agentId, bufferedOutput, seenSummaries) {
+    const summary = summarizeRecentWorkerOutput(bufferedOutput);
+    if (!summary)
+        return "";
+    if (seenSummaries.get(agentId) === summary) {
+        return "";
+    }
+    seenSummaries.set(agentId, summary);
+    return summary;
+}

package/dist/worker-registry.d.ts

@@ -0,0 +1,45 @@
+import type { AgentRecord, AgentStatus, PluginConfig, RuntimeFocusItem, RuntimeSummary, WorkerDetail, WorkerEvent } from "./types.js";
+export interface CreateWorkerRecordOptions {
+    agentId: string;
+    sessionId: string;
+    nodeId: string;
+    plugin: PluginConfig;
+    cwd?: string;
+    displayName?: string;
+    taskSummary?: string;
+    parentAgentId?: string;
+}
+export declare class WorkerRegistry {
+    private workers;
+    private sessionToAgent;
+    private recentEvents;
+    private snapshots;
+    private readonly maxRecentEvents;
+    private readonly maxSnapshots;
+    private allocateDisplayName;
+    createWorkerRecord(options: CreateWorkerRecordOptions): AgentRecord;
+    rebindWorkerSession(existingAgentId: string, options: CreateWorkerRecordOptions): AgentRecord | undefined;
+    getWorkerByAgentId(agentId: string): AgentRecord | undefined;
+    getWorkerBySessionId(sessionId: string): AgentRecord | undefined;
+    listWorkers(): AgentRecord[];
+    updateWorker(agentId: string, updates: Partial<AgentRecord>): AgentRecord | undefined;
+    getWorkerDetail(agentId: string, lastBufferedOutput?: string): WorkerDetail | undefined;
+    getRuntimeSummary(): RuntimeSummary;
+    getRuntimeFocus(limit?: number): RuntimeFocusItem[];
+    updateWorkerStatus(agentId: string, status: AgentStatus, details?: Partial<AgentRecord>): AgentRecord | undefined;
+    removeWorker(agentId: string): boolean;
+    recordOutput(sessionId: string): AgentRecord | undefined;
+    recordOutputActivity(agentId: string, charCount: number): AgentRecord | undefined;
+    recordEvent(agentId: string, event: WorkerEvent): void;
+    private appendEvent;
+    private summarizeEvent;
+    private normalizeEvent;
+    private inferEventLevel;
+    private captureSnapshot;
+    private summarizeSnapshot;
+    private workerNeedsAttention;
+    private deriveWorkerState;
+    private refreshAllWorkerStates;
+    private refreshWorkerState;
+    private hasDerivedStateChanged;
+}