@cydm/magic-shell-agent-node 0.1.3 → 0.1.4

package/dist/adapters/pty-adapter.js

@@ -1,5 +1,5 @@
 import { spawn } from "node-pty";
-import { dirname } from "path";
+import { delimiter, dirname, join } from "path";
 import { fileURLToPath } from "url";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -16,13 +16,26 @@ export class PtyAdapter {
     }
     async start(config) {
         const agentId = `pty-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-        const pty = spawn(config.command, config.args || [], {
-            name: "xterm-256color",
-            cols: 80,
-            rows: 24,
-            cwd: config.cwd || process.cwd(),
-            env: { ...process.env, ...config.env },
-        });
+        const spawnCwd = config.cwd || process.cwd();
+        const spawnEnv = { ...process.env, ...config.env };
+        console.log(`[PtyAdapter] Starting ${agentId}: command=${JSON.stringify(config.command)} args=${JSON.stringify(config.args || [])} cwd=${JSON.stringify(spawnCwd)} platform=${process.platform}`);
+        if (process.platform === "win32" && !isAbsoluteOrQualifiedCommand(config.command)) {
+            console.log(`[PtyAdapter] Windows bare command probe for ${agentId}: ${JSON.stringify(findWindowsCommandCandidates(config.command, spawnEnv.PATH))}`);
+        }
+        let pty;
+        try {
+            pty = spawn(config.command, config.args || [], {
+                name: "xterm-256color",
+                cols: 80,
+                rows: 24,
+                cwd: spawnCwd,
+                env: spawnEnv,
+            });
+        }
+        catch (error) {
+            console.error(`[PtyAdapter] Failed to start ${agentId}:`, error instanceof Error ? error.stack || error.message : error);
+            throw error;
+        }
         const agent = {
             id: agentId,
             pty,
@@ -97,3 +110,21 @@ export class PtyAdapter {
         this.exitCallbacks.push(callback);
     }
 }
+function isAbsoluteOrQualifiedCommand(command) {
+    return command.includes("/") || command.includes("\\") || /\.(exe|cmd|bat|com|ps1)$/i.test(command);
+}
+function findWindowsCommandCandidates(command, pathValue) {
+    if (!pathValue)
+        return [];
+    const pathext = (process.env.PATHEXT || ".COM;.EXE;.BAT;.CMD;.PS1")
+        .split(";")
+        .map((value) => value.trim())
+        .filter(Boolean);
+    const results = [];
+    for (const dir of pathValue.split(delimiter).filter(Boolean)) {
+        for (const ext of ["", ...pathext]) {
+            results.push(join(dir, ext ? `${command}${ext}` : command));
+        }
+    }
+    return results.slice(0, 20);
+}

package/dist/node.js

@@ -641,11 +641,13 @@ export class AgentNode {
                 const cwd = this.readString(payload.cwd) || message.cwd;
                 const displayName = this.readString(payload.displayName) || message.displayName;
                 const sessionId = this.readString(payload.sessionId) || message.target?.sessionId || generateSessionId();
+                console.log(`[AgentNode] control spawn_worker start: session=${sessionId} plugin=${pluginName} cwd=${JSON.stringify(cwd || "")} displayName=${JSON.stringify(displayName || "")} task=${JSON.stringify(taskSummary || "")}`);
                 try {
                     await this.spawnWorker({ sessionId, pluginName, cwd, displayName, taskSummary });
                     if (taskSummary) {
                         this.rememberNodeSpawn(taskSummary, sessionId);
                     }
+                    console.log(`[AgentNode] control spawn_worker success: session=${sessionId} plugin=${pluginName}`);
                     this.sendControlResult(source, message.requestId, name, true, {
                         sessionId,
                         pluginName,
@@ -654,6 +656,7 @@ export class AgentNode {
                     });
                 }
                 catch (err) {
+                    console.error(`[AgentNode] control spawn_worker failed: session=${sessionId} plugin=${pluginName}`, err instanceof Error ? err.stack || err.message : err);
                     this.sendControlResult(source, message.requestId, name, false, {
                         error: err instanceof Error ? err.message : String(err),
                     });

package/dist/plugin-loader.js

@@ -1,6 +1,7 @@
 import { readFileSync, readdirSync, existsSync } from "fs";
 import { join, extname, dirname, isAbsolute, resolve } from "path";
 import { fileURLToPath } from "url";
+import { createRequire } from "module";
 /**
  * 加载单个插件配置
  */
@@ -29,12 +30,13 @@ export function loadPlugin(path) {
     if (!["stdio", "pty", "rpc"].includes(config.type)) {
         throw new Error(`Plugin ${path} invalid type: ${config.type}`);
     }
-    return {
+    const normalized = {
         ...config,
         command: resolveCommandPath(config.command, configDir, repoRoot),
         args: resolveArgPaths(config.args, configDir, repoRoot),
         cwd: resolveOptionalPath(config.cwd, configDir, repoRoot),
     };
+    return maybeResolveBundledPieCommand(normalized, configDir, repoRoot);
 }
 function resolveOptionalPath(value, configDir, repoRoot) {
     if (!value)
@@ -82,6 +84,62 @@ function resolveArgPaths(args, configDir, repoRoot) {
         return arg;
     });
 }
+function maybeResolveBundledPieCommand(config, configDir, repoRoot) {
+    if (config.name !== "pie" || config.command !== "pie") {
+        return config;
+    }
+    const pieEntry = resolveInstalledPackageBin("@cydm/pie", configDir, repoRoot);
+    if (!pieEntry) {
+        return config;
+    }
+    return {
+        ...config,
+        command: process.execPath,
+        args: [pieEntry, ...(config.args || [])],
+    };
+}
+function resolveInstalledPackageBin(packageName, configDir, repoRoot) {
+    const requireFromHere = createRequire(import.meta.url);
+    try {
+        const packageJsonPath = requireFromHere.resolve(`${packageName}/package.json`);
+        const direct = readPackageBin(packageJsonPath);
+        if (direct)
+            return direct;
+    }
+    catch {
+        // Fall through to alternate roots below.
+    }
+    const searchRoots = [
+        configDir,
+        repoRoot,
+        process.cwd(),
+        dirname(fileURLToPath(import.meta.url)),
+    ];
+    for (const root of searchRoots) {
+        try {
+            const packageJsonPath = requireFromHere.resolve(`${packageName}/package.json`, { paths: [resolve(root)] });
+            const resolved = readPackageBin(packageJsonPath);
+            if (resolved)
+                return resolved;
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+function readPackageBin(packageJsonPath) {
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    const packageRoot = dirname(packageJsonPath);
+    const binField = packageJson.bin;
+    const relativeBin = typeof binField === "string"
+        ? binField
+        : (binField && Object.values(binField)[0]) || null;
+    if (!relativeBin)
+        return null;
+    const binPath = resolve(packageRoot, relativeBin);
+    return existsSync(binPath) ? binPath : null;
+}
 /**
  * 扫描目录加载所有插件
  */

package/dist/worker-runtime.js

@@ -16,6 +16,7 @@ function normalizeWorkerCwd(cwd, pluginCwd) {
     return path.resolve(pluginCwd || process.cwd(), value);
 }
 export async function spawnManagedWorker(options, deps) {
+    console.log(`[WorkerRuntime] spawnManagedWorker start: session=${options.sessionId} plugin=${options.pluginName} cwd=${JSON.stringify(options.cwd || "")} displayName=${JSON.stringify(options.displayName || "")}`);
     const plugin = deps.plugins.get(options.pluginName);
     if (!plugin) {
         throw new Error(`Plugin not found: ${options.pluginName}`);
@@ -27,7 +28,9 @@ export async function spawnManagedWorker(options, deps) {
             : plugin.args,
         cwd: normalizeWorkerCwd(options.cwd, plugin.cwd),
     };
+    console.log(`[WorkerRuntime] resolved plugin: session=${options.sessionId} command=${JSON.stringify(runtimePlugin.command)} args=${JSON.stringify(runtimePlugin.args || [])} cwd=${JSON.stringify(runtimePlugin.cwd || process.cwd())}`);
     await deps.sessionManager.createSession(options.sessionId, runtimePlugin);
+    console.log(`[WorkerRuntime] session created: ${options.sessionId}`);
     const session = deps.sessionManager.getSession(options.sessionId);
     if (!session) {
         throw new Error(`Session failed to start: ${options.sessionId}`);
@@ -60,6 +63,7 @@ export async function spawnManagedWorker(options, deps) {
     deps.workerRegistry.updateWorkerStatus(session.agentId, "running", {
         startedAt: Date.now(),
     });
+    console.log(`[WorkerRuntime] worker record ready: session=${options.sessionId} agent=${session.agentId}`);
     return {
         type: "session",
         sessionId: options.sessionId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cydm/magic-shell-agent-node",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Magic Shell Agent Node - Local agent connector",
   "homepage": "https://magicshell.ai",
   "keywords": [