@cydm/magic-shell-agent-node 0.1.0

package/dist/local-direct-server.js

@@ -0,0 +1,266 @@
+import { createServer } from "node:http";
+import { existsSync, createReadStream } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { WebSocketServer, WebSocket } from "ws";
+function createConnectionId() {
+    return `local-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function guessContentType(filePath) {
+    if (filePath.endsWith(".html"))
+        return "text/html; charset=utf-8";
+    if (filePath.endsWith(".js"))
+        return "application/javascript; charset=utf-8";
+    if (filePath.endsWith(".css"))
+        return "text/css; charset=utf-8";
+    if (filePath.endsWith(".json"))
+        return "application/json; charset=utf-8";
+    if (filePath.endsWith(".svg"))
+        return "image/svg+xml";
+    if (filePath.endsWith(".png"))
+        return "image/png";
+    return "text/plain; charset=utf-8";
+}
+function findWorkbenchRoot() {
+    const currentDir = path.dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        path.resolve(currentDir, "../../../apps/web/src"),
+        path.resolve(currentDir, "../../../../apps/web/src"),
+        path.resolve(process.cwd(), "apps/web/src"),
+    ];
+    for (const candidate of candidates) {
+        if (existsSync(path.join(candidate, "index.html"))) {
+            return candidate;
+        }
+    }
+    return null;
+}
+export class LocalDirectServer {
+    options;
+    delegate;
+    httpServer = createServer((req, res) => this.handleHttpRequest(req, res));
+    wsServer = new WebSocketServer({ noServer: true });
+    connections = new Map();
+    sessionToConnections = new Map();
+    workbenchRoot = findWorkbenchRoot();
+    constructor(options, delegate) {
+        this.options = options;
+        this.delegate = delegate;
+        this.httpServer.on("upgrade", (req, socket, head) => {
+            const pathname = new URL(req.url || "/", "http://127.0.0.1").pathname;
+            if (pathname !== "/ws") {
+                socket.destroy();
+                return;
+            }
+            this.wsServer.handleUpgrade(req, socket, head, (ws) => {
+                this.wsServer.emit("connection", ws, req);
+            });
+        });
+        this.wsServer.on("connection", (ws) => {
+            this.handleSocketConnection(ws);
+        });
+    }
+    async start() {
+        await new Promise((resolve, reject) => {
+            this.httpServer.once("error", reject);
+            this.httpServer.listen(this.options.port, this.options.host, () => {
+                this.httpServer.off("error", reject);
+                resolve();
+            });
+        });
+        const address = this.httpServer.address();
+        const port = typeof address === "object" && address ? address.port : this.options.port;
+        return {
+            host: this.options.host,
+            port,
+            webUrl: `http://${this.options.host}:${port}/`,
+            wsUrl: `ws://${this.options.host}:${port}/ws`,
+        };
+    }
+    async stop() {
+        for (const conn of this.connections.values()) {
+            conn.ws.close();
+        }
+        this.connections.clear();
+        this.sessionToConnections.clear();
+        await new Promise((resolve) => this.wsServer.close(() => resolve()));
+        await new Promise((resolve) => this.httpServer.close(() => resolve()));
+    }
+    handleNodeMessage(message) {
+        switch (message.type) {
+            case "output":
+            case "session":
+                if (message.sessionId) {
+                    this.sendToSession(message.sessionId, message);
+                }
+                return;
+            case "worker_list":
+            case "worker_detail":
+            case "dir_list":
+            case "node_reply":
+            case "attached":
+            case "auth_success":
+            case "pong":
+            case "error":
+                this.broadcast(message);
+                return;
+            case "control":
+                if (message.controlKind === "event" && String(message.controlName || "") === "session.subscription_changed") {
+                    return;
+                }
+                this.broadcast(message);
+                return;
+            default:
+                this.broadcast(message);
+        }
+    }
+    handleHttpRequest(req, res) {
+        const url = new URL(req.url || "/", "http://127.0.0.1");
+        if (url.pathname === "/health") {
+            res.writeHead(200, { "content-type": "application/json; charset=utf-8" });
+            res.end(JSON.stringify({
+                ok: true,
+                nodeId: this.options.nodeId,
+                connections: this.connections.size,
+            }));
+            return;
+        }
+        if (!this.workbenchRoot) {
+            res.writeHead(404, { "content-type": "text/plain; charset=utf-8" });
+            res.end("Workbench files not found");
+            return;
+        }
+        const relativePath = url.pathname === "/" ? "/index.html" : url.pathname;
+        const normalizedPath = path.normalize(relativePath).replace(/^(\.\.[/\\])+/, "");
+        const targetPath = path.join(this.workbenchRoot, normalizedPath);
+        const safeRoot = path.resolve(this.workbenchRoot);
+        const safeTarget = path.resolve(targetPath);
+        if (!safeTarget.startsWith(safeRoot) || !existsSync(safeTarget)) {
+            res.writeHead(404, { "content-type": "text/plain; charset=utf-8" });
+            res.end("Not found");
+            return;
+        }
+        res.writeHead(200, { "content-type": guessContentType(safeTarget) });
+        createReadStream(safeTarget).pipe(res);
+    }
+    handleSocketConnection(ws) {
+        const connectionId = createConnectionId();
+        const connection = {
+            id: connectionId,
+            ws,
+            authenticated: false,
+        };
+        this.connections.set(connectionId, connection);
+        ws.on("message", async (buffer) => {
+            let message;
+            try {
+                message = JSON.parse(buffer.toString());
+            }
+            catch {
+                this.send(connection, { type: "error", error: "Invalid message format" });
+                return;
+            }
+            await this.handleBrowserMessage(connection, message);
+        });
+        ws.on("close", () => {
+            void this.cleanupConnection(connectionId);
+        });
+    }
+    async handleBrowserMessage(connection, message) {
+        if (message.type === "auth") {
+            if (message.clientType !== "browser" || message.nodeId !== this.options.nodeId || message.password !== this.options.password) {
+                this.send(connection, { type: "error", error: "Invalid credentials" });
+                return;
+            }
+            connection.authenticated = true;
+            if (message.sessionId) {
+                await this.attachConnectionToSession(connection, message.sessionId);
+            }
+            this.send(connection, {
+                type: "auth_success",
+                sessionId: message.sessionId || `local-${Date.now()}`,
+            });
+            return;
+        }
+        if (!connection.authenticated) {
+            this.send(connection, { type: "error", error: "Authenticate first" });
+            return;
+        }
+        if (message.type === "control" && message.controlKind === "command" && message.controlName === "attach_session") {
+            const sessionId = message.target?.sessionId
+                || (typeof message.payload === "object" && message.payload && "sessionId" in message.payload
+                    ? String(message.payload.sessionId || "")
+                    : "");
+            if (!sessionId) {
+                this.send(connection, { type: "error", error: "Missing sessionId" });
+                return;
+            }
+            await this.attachConnectionToSession(connection, sessionId);
+            this.send(connection, {
+                type: "attached",
+                sessionId,
+            });
+        }
+        if (message.type === "input" || message.type === "resize") {
+            message.sessionId = message.sessionId || connection.sessionId;
+        }
+        await this.delegate.handleIncomingMessage(message);
+    }
+    async attachConnectionToSession(connection, sessionId) {
+        const previousSessionId = connection.sessionId;
+        if (previousSessionId && previousSessionId !== sessionId) {
+            await this.detachConnectionFromSession(connection, previousSessionId);
+        }
+        connection.sessionId = sessionId;
+        let connections = this.sessionToConnections.get(sessionId);
+        if (!connections) {
+            connections = new Set();
+            this.sessionToConnections.set(sessionId, connections);
+        }
+        connections.add(connection.id);
+        await this.delegate.handleSubscriptionChange(sessionId, connections.size);
+    }
+    async detachConnectionFromSession(connection, sessionId) {
+        const connections = this.sessionToConnections.get(sessionId);
+        if (!connections)
+            return;
+        connections.delete(connection.id);
+        if (connections.size === 0) {
+            this.sessionToConnections.delete(sessionId);
+        }
+        connection.sessionId = connection.sessionId === sessionId ? undefined : connection.sessionId;
+        await this.delegate.handleSubscriptionChange(sessionId, connections.size);
+    }
+    async cleanupConnection(connectionId) {
+        const connection = this.connections.get(connectionId);
+        if (!connection)
+            return;
+        if (connection.sessionId) {
+            await this.detachConnectionFromSession(connection, connection.sessionId);
+        }
+        this.connections.delete(connectionId);
+    }
+    sendToSession(sessionId, message) {
+        const connectionIds = this.sessionToConnections.get(sessionId);
+        if (!connectionIds?.size)
+            return;
+        for (const connectionId of connectionIds) {
+            const connection = this.connections.get(connectionId);
+            if (connection) {
+                this.send(connection, message);
+            }
+        }
+    }
+    broadcast(message) {
+        for (const connection of this.connections.values()) {
+            if (connection.authenticated) {
+                this.send(connection, message);
+            }
+        }
+    }
+    send(connection, message) {
+        if (connection.ws.readyState === WebSocket.OPEN) {
+            connection.ws.send(JSON.stringify(message));
+        }
+    }
+}

package/dist/node-conversation.d.ts

@@ -0,0 +1,21 @@
+import type { NodeReply } from "./node-reply.js";
+import type { AgentRecord } from "./types.js";
+export interface NodeConversationTurn {
+    role: "user" | "assistant";
+    text: string;
+    timestamp: number;
+    actionType?: "spawn" | "attach";
+    actionLabel?: string;
+    actionTaskSummary?: string;
+    actionSessionId?: string;
+}
+export interface NodeConversationState {
+    lastTaskSummary?: string;
+    lastWorkerSessionId?: string;
+    lastWorkerAgentId?: string;
+    lastUserMessage?: string;
+    history: NodeConversationTurn[];
+}
+export declare function createNodeConversationState(): NodeConversationState;
+export declare function recordConversationTurn(state: NodeConversationState, role: "user" | "assistant", text: string, extra?: Partial<NodeReply>): NodeConversationState;
+export declare function rememberNodeSpawn(state: NodeConversationState, taskSummary: string | undefined, sessionId: string, worker?: AgentRecord): NodeConversationState;

package/dist/node-conversation.js

@@ -0,0 +1,28 @@
+export function createNodeConversationState() {
+    return { history: [] };
+}
+export function recordConversationTurn(state, role, text, extra = {}) {
+    return {
+        ...state,
+        history: [
+            ...state.history,
+            {
+                role,
+                text,
+                timestamp: Date.now(),
+                actionType: extra.actionType,
+                actionLabel: extra.actionLabel,
+                actionTaskSummary: extra.actionTaskSummary,
+                actionSessionId: extra.actionSessionId,
+            },
+        ].slice(-30),
+    };
+}
+export function rememberNodeSpawn(state, taskSummary, sessionId, worker) {
+    return {
+        ...state,
+        lastTaskSummary: taskSummary || state.lastTaskSummary,
+        lastWorkerSessionId: sessionId,
+        lastWorkerAgentId: worker?.agentId,
+    };
+}

package/dist/node-intent.d.ts

@@ -0,0 +1,2 @@
+export type NodeIntent = "direct" | "follow_up" | "delegate";
+export declare function classifyNodeIntent(text: string): NodeIntent;

package/dist/node-intent.js

@@ -0,0 +1,40 @@
+export function classifyNodeIntent(text) {
+    const normalized = String(text || "").trim();
+    const lower = normalized.toLowerCase();
+    const isQuestionLike = normalized.endsWith("?")
+        || normalized.endsWith("？")
+        || lower === "status"
+        || lower === "state"
+        || lower === "workers";
+    const isCapabilityQuery = lower.includes("help")
+        || lower.includes("what can")
+        || lower.includes("how do")
+        || lower.includes("你能")
+        || lower.includes("能干什么")
+        || lower.includes("你会什么");
+    const isStatusQuery = lower.includes("现在什么情况")
+        || lower.includes("现在在忙什么")
+        || lower.includes("what's running")
+        || lower.includes("what is running")
+        || /^当前.*状态/.test(normalized)
+        || /^现在.*状态/.test(normalized)
+        || /^查看.*状态/.test(normalized);
+    const isPlanningQuery = lower.includes("怎么做")
+        || lower.includes("怎么安排")
+        || lower.includes("what should we do")
+        || lower.includes("how should")
+        || lower.includes("plan")
+        || lower.includes("安排一下")
+        || lower.includes("想想")
+        || lower.includes("讨论");
+    const isHelpQuery = isQuestionLike || isCapabilityQuery || isStatusQuery || isPlanningQuery;
+    const isFollowUp = /^(继续|开始吧|开工|推进|干活|你倒是让他干活啊\??|继续吧)$/u.test(normalized)
+        || lower.includes("keep going")
+        || lower.includes("continue")
+        || lower.includes("start working");
+    if (isHelpQuery)
+        return "direct";
+    if (isFollowUp)
+        return "follow_up";
+    return "delegate";
+}

package/dist/node-reply.d.ts

@@ -0,0 +1,30 @@
+import type { AgentRecord } from "./types.js";
+import type { NodeIntent } from "./node-intent.js";
+export interface NodeReply {
+    text: string;
+    actionType?: "spawn" | "attach";
+    actionLabel?: string;
+    actionTaskSummary?: string;
+    actionSessionId?: string;
+    workerMessage?: string;
+}
+export interface PrimaryAgentReplyContext {
+    pluginName: string;
+    launchMode: "headless" | "session";
+    status: "starting" | "running" | "stopped" | "failed" | "disabled" | "missing";
+    lastError?: string;
+}
+export interface DirectNodeReplyContext {
+    text: string;
+    intent: NodeIntent;
+    primaryAgent: PrimaryAgentReplyContext;
+    liveWorkers: AgentRecord[];
+    waitingWorkers: number;
+    busyWorkers: number;
+    focusCount: number;
+    liveLastWorker?: AgentRecord;
+    currentTaskText: string;
+}
+export declare function buildWorkerFollowUpMessage(text: string): string;
+export declare function describePrimaryAgent(primaryAgent: PrimaryAgentReplyContext): string;
+export declare function buildDirectNodeReply(context: DirectNodeReplyContext): NodeReply;

package/dist/node-reply.js

@@ -0,0 +1,77 @@
+export function buildWorkerFollowUpMessage(text) {
+    const normalized = String(text || "").trim();
+    const lower = normalized.toLowerCase();
+    if (/^(继续|继续吧|开始吧|开工|推进|干活|你倒是让他干活啊\??)$/u.test(normalized)
+        || lower === "continue"
+        || lower === "keep going"
+        || lower === "start working") {
+        return "Continue the current task now. Make visible progress, and briefly summarize what you are doing before you finish this turn.";
+    }
+    return normalized;
+}
+export function describePrimaryAgent(primaryAgent) {
+    switch (primaryAgent.status) {
+        case "running":
+            if (primaryAgent.lastError) {
+                return `Primary agent: ${primaryAgent.pluginName} is configured but currently unavailable (${primaryAgent.lastError}).`;
+            }
+            return primaryAgent.launchMode === "headless"
+                ? `Primary agent: ${primaryAgent.pluginName} bridge is ready.`
+                : `Primary agent: ${primaryAgent.pluginName} is online.`;
+        case "starting":
+            return `Primary agent: ${primaryAgent.pluginName} is starting.`;
+        case "missing":
+            return `Primary agent: ${primaryAgent.pluginName} plugin is not available on this node.`;
+        case "failed":
+            return `Primary agent: ${primaryAgent.pluginName} failed${primaryAgent.lastError ? ` (${primaryAgent.lastError})` : ""}.`;
+        case "disabled":
+            return "Primary agent is disabled for this node.";
+        default:
+            return `Primary agent: ${primaryAgent.pluginName} is idle.`;
+    }
+}
+export function buildDirectNodeReply(context) {
+    const normalized = String(context.text || "").trim();
+    const lower = normalized.toLowerCase();
+    const primaryText = describePrimaryAgent(context.primaryAgent);
+    const runtimeText = `Current node state: ${context.liveWorkers.length} live, ${context.waitingWorkers} waiting, ${context.busyWorkers} busy.`;
+    if (context.intent === "direct") {
+        const focusText = context.focusCount
+            ? `${context.focusCount} worker${context.focusCount > 1 ? "s" : ""} may need review.`
+            : "Nothing looks urgent right now.";
+        const intro = lower.includes("你能") || lower.includes("能干什么") || lower.includes("what can")
+            ? "AgentNode is running in deterministic control-plane mode. I can report runtime state and route you to explicit controls."
+            : "AgentNode is in deterministic mode. Use the web workbench, CLI, or a primary-agent skill for planning and orchestration.";
+        return {
+            text: [
+                intro,
+                primaryText,
+                runtimeText,
+                context.currentTaskText,
+                focusText,
+            ].join("\n"),
+        };
+    }
+    if (context.intent === "follow_up" && context.liveLastWorker) {
+        return {
+            text: [
+                "AgentNode will not reinterpret follow-up chat in deterministic mode.",
+                primaryText,
+                runtimeText,
+                `Attach to ${context.liveLastWorker.sessionId} or send explicit session input through the CLI/skill surface.`,
+            ].join("\n"),
+            actionType: "attach",
+            actionLabel: "ATTACH WORKER",
+            actionSessionId: context.liveLastWorker.sessionId,
+        };
+    }
+    return {
+        text: [
+            "AgentNode does not interpret free-form work requests in deterministic mode.",
+            primaryText,
+            runtimeText,
+            context.currentTaskText,
+            "Start or attach a worker explicitly from the workbench/CLI, or use a primary-agent skill to decide the next action.",
+        ].join("\n"),
+    };
+}

package/dist/node.d.ts

@@ -0,0 +1,132 @@
+import type { ClientMessage, ServerMessage } from "@cydm/magic-shell-protocol";
+export interface NodeOptions {
+    relayUrl: string;
+    nodeId: string;
+    password: string;
+    pluginDir: string;
+    autoReconnect?: boolean;
+    primaryPluginName?: string;
+    primaryLaunchMode?: "headless" | "session";
+    enableLocalDirect?: boolean;
+    localControlHost?: string;
+    localControlPort?: number;
+}
+export interface SpawnWorkerOptions {
+    sessionId: string;
+    pluginName: string;
+    cwd?: string;
+    displayName?: string;
+    taskSummary?: string;
+    parentAgentId?: string;
+}
+export declare class AgentNode {
+    private options;
+    private wsClient;
+    private localDirectServer?;
+    private localDirectInfo?;
+    private sessionManager;
+    private workerRegistry;
+    private plugins;
+    private running;
+    private sessionTitleBuffers;
+    private primaryAgent;
+    private nodeConversation;
+    private lastFailedNamedWorker?;
+    private preferredWorkerPluginName;
+    private syntheticSessionResults;
+    private liveAttachedSessions;
+    private remoteAttachedSessions;
+    private localAttachedSessions;
+    private relayConnectedOnce;
+    constructor(options: NodeOptions);
+    getOptions(): Readonly<NodeOptions>;
+    getLocalDirectInfo(): {
+        host: string;
+        port: number;
+        webUrl: string;
+        wsUrl: string;
+    } | undefined;
+    /**
+     * 启动 AgentNode
+     */
+    start(): Promise<void>;
+    /**
+     * 停止 AgentNode
+     */
+    stop(): Promise<void>;
+    /**
+     * 设置消息处理器
+     */
+    private setupMessageHandlers;
+    handleIncomingMessage(message: ClientMessage | ServerMessage, source?: "relay" | "local"): Promise<void>;
+    /**
+     * 创建新会话
+     */
+    spawnWorker(options: SpawnWorkerOptions): Promise<void>;
+    /**
+     * Backward-compatible wrapper while the transport still speaks in session terms.
+     */
+    createSession(sessionId: string, pluginName: string): Promise<void>;
+    private waitForPrimaryAgentSessionId;
+    private sendPromptToPrimarySession;
+    private formatSessionControlInput;
+    private queryPrimarySessionText;
+    private dispatchInitialWorkerTask;
+    private seedWorkerTask;
+    private primeInteractiveWorkerSession;
+    private seedClaudeWorkerTask;
+    private seedCodexWorkerTask;
+    private ensurePrimaryAgent;
+    private handleControlEnvelope;
+    private handleControlMessage;
+    private handleControlCommand;
+    private handleControlQuery;
+    private sendControlResult;
+    private buildRuntimeSnapshot;
+    private buildPrimaryAgentStatus;
+    private isProtectedPrimarySession;
+    private runSessionTurn;
+    private runClaudeWorkerTurn;
+    private runCodexWorkerTurn;
+    private isLikelyEchoedSessionInput;
+    private isUsablePieSessionTurnResult;
+    private getWorkerOutputSummary;
+    private getWorkerOutputMessage;
+    private readString;
+    private readNumber;
+    private readPayloadObject;
+    private recordPrimaryOutput;
+    private captureWorkerTitleFromInput;
+    private broadcastWorkerList;
+    private rememberNodeSpawn;
+    private handlePrimaryMessage;
+    private tryHandlePrimaryOrchestration;
+    private parseSpawnWorkerIntent;
+    private parseWorkerName;
+    private extractPathFragment;
+    private resolveWorkerCwd;
+    private handleSpawnWorkerIntent;
+    private parseNamedWorkerAction;
+    private parseNamedWorkerTaskIntent;
+    private findWorkerByName;
+    private getOrderedLiveWorkers;
+    private handleStopWorkerIntent;
+    private handleRestartWorkerIntent;
+    private handleWorkerTaskIntent;
+    private handleOrdinalMultiWorkerIntent;
+    private handleNamedMultiWorkerCommitIntent;
+    private handleWorkerRosterIntent;
+    private ensureSessionForInteractiveMessage;
+    handleSessionOutput(sessionId: string, output: {
+        content: string;
+    }): void;
+    private sendServerMessage;
+    private sendToSource;
+    private startLocalDirectServer;
+    private updateSessionSubscription;
+    private onRelayConnected;
+    private maybeNarrateWorkerStateChange;
+    private recordConversationTurn;
+}
+declare function main(): Promise<void>;
+export { main };