@cydm/magic-shell 0.1.0

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,592 @@
+#!/usr/bin/env node
+import { MagicShellControlClient } from "@cydm/sdk";
+function parseArgs(argv) {
+    const options = {
+        command: undefined,
+        relayUrl: process.env.MAGIC_SHELL_RELAY_URL || "ws://localhost:8080",
+        nodeId: process.env.MAGIC_SHELL_NODE_ID || "test-node",
+        password: process.env.MAGIC_SHELL_PASSWORD || "123456",
+        json: false,
+        timeoutMs: 8000,
+        help: false,
+        debug: false,
+        intervalMs: 2000,
+        pluginName: "pie",
+        autoReconnect: true,
+        primaryPluginName: "pie",
+    };
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (!arg)
+            continue;
+        if (!arg.startsWith("-") && !options.command) {
+            if (arg === "primary" || arg === "primary-send" || arg === "status" || arg === "workers" || arg === "worker" || arg === "logs" || arg === "watch" || arg === "browse" || arg === "spawn" || arg === "attach" || arg === "input" || arg === "session-message" || arg === "session-summary" || arg === "session-send" || arg === "session-turn" || arg === "stop" || arg === "restart" || arg === "node") {
+                options.command = arg;
+                continue;
+            }
+            throw new Error(`Unknown command: ${arg}`);
+        }
+        if (!arg.startsWith("-") && options.command === "node" && !options.nodeCommand) {
+            if (arg === "start") {
+                options.nodeCommand = arg;
+                continue;
+            }
+            throw new Error(`Unknown node command: ${arg}`);
+        }
+        switch (arg) {
+            case "--relay":
+                options.relayUrl = readRequiredValue(argv, ++index, arg);
+                break;
+            case "--node-id":
+                options.nodeId = readRequiredValue(argv, ++index, arg);
+                break;
+            case "--password":
+                options.password = readRequiredValue(argv, ++index, arg);
+                break;
+            case "--timeout-ms":
+                options.timeoutMs = Number(readRequiredValue(argv, ++index, arg));
+                if (!Number.isFinite(options.timeoutMs) || options.timeoutMs <= 0) {
+                    throw new Error(`Invalid --timeout-ms value: ${argv[index]}`);
+                }
+                break;
+            case "--interval-ms":
+                options.intervalMs = Number(readRequiredValue(argv, ++index, arg));
+                if (!Number.isFinite(options.intervalMs) || options.intervalMs <= 0) {
+                    throw new Error(`Invalid --interval-ms value: ${argv[index]}`);
+                }
+                break;
+            case "--json":
+                options.json = true;
+                break;
+            case "--session":
+                options.sessionId = readRequiredValue(argv, ++index, arg);
+                break;
+            case "--plugin":
+                options.pluginName = readRequiredValue(argv, ++index, arg);
+                break;
+            case "--primary-plugin":
+                options.primaryPluginName = readRequiredValue(argv, ++index, arg);
+                break;
+            case "--task":
+                options.taskSummary = readRequiredValue(argv, ++index, arg);
+                break;
+            case "--name":
+                options.displayName = readRequiredValue(argv, ++index, arg);
+                break;
+            case "--cwd":
+                options.cwd = readRequiredValue(argv, ++index, arg);
+                break;
+            case "--path":
+                options.path = readRequiredValue(argv, ++index, arg);
+                break;
+            case "--data":
+                options.data = readRequiredValue(argv, ++index, arg);
+                break;
+            case "--mode": {
+                const mode = readRequiredValue(argv, ++index, arg);
+                if (mode !== "steer" && mode !== "follow_up") {
+                    throw new Error(`Invalid --mode value: ${mode}`);
+                }
+                options.mode = mode;
+                break;
+            }
+            case "--poll-interval-ms": {
+                const pollIntervalMs = Number(readRequiredValue(argv, ++index, arg));
+                if (!Number.isFinite(pollIntervalMs) || pollIntervalMs <= 0) {
+                    throw new Error(`Invalid --poll-interval-ms value: ${argv[index]}`);
+                }
+                options.pollIntervalMs = pollIntervalMs;
+                break;
+            }
+            case "--local-control-port": {
+                const localControlPort = Number(readRequiredValue(argv, ++index, arg));
+                if (!Number.isFinite(localControlPort) || localControlPort <= 0) {
+                    throw new Error(`Invalid --local-control-port value: ${argv[index]}`);
+                }
+                options.localControlPort = localControlPort;
+                break;
+            }
+            case "--local-bind":
+                options.localBind = readRequiredValue(argv, ++index, arg);
+                break;
+            case "--disable-local-direct":
+                options.disableLocalDirect = true;
+                break;
+            case "--no-reconnect":
+                options.autoReconnect = false;
+                break;
+            case "--debug":
+                options.debug = true;
+                break;
+            case "--help":
+            case "-h":
+                options.help = true;
+                break;
+            default:
+                throw new Error(`Unknown flag: ${arg}`);
+        }
+    }
+    return options;
+}
+function readRequiredValue(argv, index, flag) {
+    const value = argv[index];
+    if (!value) {
+        throw new Error(`Missing value for ${flag}`);
+    }
+    return value;
+}
+function printHelp() {
+    console.log(`Magic Shell CLI
+
+Usage:
+  magic-shell <command> [options]
+
+Commands:
+  node start        Start a local agent node and print connect URLs
+  primary           Show minimal primary-agent status
+  primary-send      Send a message to the primary agent
+  status            Show runtime summary and primary-agent status
+  workers           List workers in the runtime
+  worker            Show worker detail for a session
+  logs              Show buffered output for a worker session
+  watch             Poll runtime status or workers continuously
+  browse            List directories for a path
+  spawn             Start a worker
+  attach            Attach the current client to a worker session
+  input             Send input to a worker session
+  session-message   Read the latest meaningful message from a worker session
+  session-summary   Read a short summary of a worker session's recent output
+  session-send      Send a structured message to a worker session
+  session-turn      Send a structured message and wait for a fresh worker reply/summary
+  stop              Stop a worker
+  restart           Restart a worker
+
+Options:
+  --relay <url>     Relay WebSocket URL (default: ws://localhost:8080)
+  --node-id <id>    Target node ID (default: test-node)
+  --password <pwd>  Node password (default: 123456)
+  --session <id>    Target session ID for attach/stop/restart
+  --plugin <name>   Plugin name for spawn (default: pie)
+  --primary-plugin <name> Primary plugin for node start (default: pie)
+  --task <text>     Task summary for spawn
+  --name <text>     Display name for spawn
+  --cwd <path>      Working directory for spawn
+  --path <path>     Directory path for browse
+  --data <text>     Input text for the input command
+  --mode <kind>     Session-send mode: steer | follow_up
+  --local-control-port <n> Local direct workbench port for node start
+  --local-bind <host> Local direct bind host for node start
+  --disable-local-direct Disable the local direct workbench server
+  --no-reconnect    Disable relay auto-reconnect for node start
+  --poll-interval-ms <n>  Poll interval for session-turn waiting
+  --timeout-ms <n>  Request timeout in milliseconds (default: 8000)
+  --interval-ms <n> Poll interval for watch in milliseconds (default: 2000)
+  --json            Print machine-friendly JSON
+  --debug           Print connection/debug logs
+  --help, -h        Show help
+
+Environment:
+  MAGIC_SHELL_RELAY
+  MAGIC_SHELL_RELAY_URL
+  MAGIC_SHELL_NODE_ID
+  MAGIC_SHELL_PASSWORD
+  MAGIC_SHELL_PRIMARY_PLUGIN
+  MAGIC_SHELL_LOCAL_CONTROL_HOST
+  MAGIC_SHELL_LOCAL_CONTROL_PORT
+  MAGIC_SHELL_DISABLE_LOCAL_DIRECT`);
+}
+function printStatus(snapshot, json) {
+    if (json) {
+        console.log(JSON.stringify(snapshot, null, 2));
+        return;
+    }
+    const runtime = snapshot.runtime;
+    const primary = snapshot.primary;
+    const focus = snapshot.focus || [];
+    const workers = snapshot.workers || [];
+    console.log(`Node: ${snapshot.nodeId || workers[0]?.nodeId || "unknown"}`);
+    console.log(`Primary: ${formatPrimary(primary)}`);
+    console.log(`Workers: ${runtime?.liveWorkers ?? workers.filter(isLiveWorker).length} live / ${runtime?.totalWorkers ?? workers.length} total`);
+    console.log(`Attention: ${runtime?.attentionWorkers ?? 0} need attention`);
+    console.log(`Busy: ${runtime?.busyWorkers ?? 0} | Waiting: ${runtime?.waitingWorkers ?? 0} | Failed: ${runtime?.failedWorkers ?? 0}`);
+    if (focus.length > 0) {
+        console.log("");
+        console.log("Focus:");
+        for (const item of focus) {
+            const coordination = item.coordinationState ? ` ${item.coordinationState}` : "";
+            console.log(`- ${item.title} [${item.agentType}]${coordination} ${item.recommendedAction || "none"}${item.reason ? `: ${item.reason}` : ""}`);
+        }
+    }
+}
+function printWorkers(snapshot, json) {
+    const workers = snapshot.workers || [];
+    if (json) {
+        console.log(JSON.stringify(workers, null, 2));
+        return;
+    }
+    if (workers.length === 0) {
+        console.log("No workers");
+        return;
+    }
+    for (const worker of workers) {
+        const statusBits = [
+            worker.status,
+            worker.coordinationState,
+            worker.activityState,
+            worker.phase,
+        ].filter(Boolean).join(" / ");
+        console.log(`${worker.sessionId}  ${worker.displayName || worker.agentType}  ${statusBits}`);
+        console.log(`  task: ${worker.taskSummary || "(untitled)"}`);
+        console.log(`  cwd: ${worker.cwd}`);
+        if (worker.recommendedAction && worker.recommendedAction !== "none") {
+            console.log(`  action: ${worker.recommendedAction}${worker.recommendedActionReason ? ` (${worker.recommendedActionReason})` : ""}`);
+        }
+        if (worker.lastError) {
+            console.log(`  error: ${worker.lastError}`);
+        }
+    }
+}
+function printWorkerDetail(snapshot, json) {
+    if (json) {
+        console.log(JSON.stringify(snapshot.worker || null, null, 2));
+        return;
+    }
+    const detail = snapshot.worker;
+    if (!detail) {
+        console.log("Worker detail unavailable");
+        return;
+    }
+    const worker = detail.worker;
+    console.log(`${worker.sessionId}  ${worker.displayName || worker.agentType}`);
+    console.log(`Status: ${[worker.status, worker.coordinationState, worker.activityState, worker.phase].filter(Boolean).join(" / ")}`);
+    console.log(`Task: ${worker.taskSummary || "(untitled)"}`);
+    if (worker.coordinationTaskSummary) {
+        console.log(`Delegated: ${worker.coordinationTaskSummary}`);
+    }
+    console.log(`Cwd: ${worker.cwd}`);
+    if (worker.lastError) {
+        console.log(`Error: ${worker.lastError}`);
+    }
+    if (detail.lastBufferedOutput) {
+        console.log("");
+        console.log("Buffered output:");
+        console.log(detail.lastBufferedOutput);
+    }
+    if (detail.recentEvents.length > 0) {
+        console.log("");
+        console.log("Recent events:");
+        for (const event of detail.recentEvents.slice(-8)) {
+            console.log(`- ${new Date(event.timestamp).toLocaleTimeString()}: ${event.type} - ${event.message}`);
+        }
+    }
+}
+function printWorkerLogs(snapshot, json) {
+    const detail = snapshot.worker;
+    if (json) {
+        console.log(JSON.stringify({
+            sessionId: detail?.worker.sessionId || null,
+            lastBufferedOutput: detail?.lastBufferedOutput || "",
+        }, null, 2));
+        return;
+    }
+    if (!detail) {
+        console.log("Worker detail unavailable");
+        return;
+    }
+    if (!detail.lastBufferedOutput) {
+        console.log(`No buffered output for ${detail.worker.sessionId}`);
+        return;
+    }
+    console.log(detail.lastBufferedOutput);
+}
+function printDirectoryList(snapshot, json) {
+    if (json) {
+        console.log(JSON.stringify({
+            path: snapshot.path || null,
+            parentPath: snapshot.parentPath || null,
+            repoRoot: snapshot.repoRoot || null,
+            entries: snapshot.entries || [],
+        }, null, 2));
+        return;
+    }
+    console.log(`Path: ${snapshot.path || "(unknown)"}`);
+    if (snapshot.repoRoot) {
+        console.log(`Repo root: ${snapshot.repoRoot}`);
+    }
+    if ((snapshot.entries || []).length === 0) {
+        console.log("No directories");
+        return;
+    }
+    for (const entry of snapshot.entries || []) {
+        console.log(`- ${entry.name}  ${entry.path}`);
+    }
+}
+function isLiveWorker(worker) {
+    return worker.status !== "stopped" && worker.status !== "failed";
+}
+function formatPrimary(primary) {
+    if (!primary)
+        return "unavailable";
+    const details = [primary.pluginName, primary.status, primary.activityState].filter(Boolean).join(" / ");
+    return details || "unavailable";
+}
+async function runWatchLoop(client, options) {
+    const mode = options.sessionId ? "worker" : "status";
+    while (true) {
+        process.stdout.write("\x1bc");
+        if (mode === "worker") {
+            const snapshot = await client.getWorkerDetail(options.sessionId);
+            printWorkerDetail(snapshot, false);
+        }
+        else {
+            const snapshot = await client.getRuntimeSummary();
+            printStatus(snapshot, false);
+            console.log("");
+            printWorkers(snapshot, false);
+        }
+        console.log("");
+        console.log(`Watching ${mode}. Refresh: ${options.intervalMs}ms. Press Ctrl+C to stop.`);
+        await new Promise((resolve) => setTimeout(resolve, options.intervalMs));
+    }
+}
+async function main() {
+    const argv = process.argv.slice(2);
+    const options = parseArgs(argv);
+    if (options.help || !options.command || (options.command === "node" && !options.nodeCommand)) {
+        printHelp();
+        process.exit(options.help ? 0 : 1);
+    }
+    if (options.command === "node") {
+        switch (options.nodeCommand) {
+            case "start":
+                await import("./node-start.js").then(({ runNodeStart }) => runNodeStart({
+                    relayUrl: argv.includes("--relay") ? options.relayUrl : undefined,
+                    nodeId: argv.includes("--node-id") ? options.nodeId : undefined,
+                    password: argv.includes("--password") ? options.password : undefined,
+                    localControlPort: options.localControlPort,
+                    localBind: options.localBind,
+                    disableLocalDirect: options.disableLocalDirect,
+                    noReconnect: !options.autoReconnect,
+                    primaryPluginName: options.primaryPluginName,
+                }));
+                return;
+        }
+    }
+    const client = new MagicShellControlClient({
+        relayUrl: options.relayUrl,
+        nodeId: options.nodeId,
+        password: options.password,
+        timeoutMs: options.timeoutMs,
+        debug: options.debug,
+    });
+    switch (options.command) {
+        case "primary": {
+            const snapshot = await client.getPrimaryAgent();
+            printPrimary(snapshot, options.json);
+            return;
+        }
+        case "primary-send": {
+            requireData(options);
+            const payload = await client.sendPrimaryMessage(options.data);
+            printPrimaryReply(payload, options.json);
+            return;
+        }
+        case "status": {
+            const snapshot = await client.getRuntimeSummary();
+            printStatus(snapshot, options.json);
+            return;
+        }
+        case "workers": {
+            const snapshot = await client.listWorkers();
+            printWorkers(snapshot, options.json);
+            return;
+        }
+        case "worker": {
+            requireSession(options);
+            const snapshot = await client.getWorkerDetail(options.sessionId);
+            printWorkerDetail(snapshot, options.json);
+            return;
+        }
+        case "logs": {
+            requireSession(options);
+            const snapshot = await client.getWorkerDetail(options.sessionId);
+            printWorkerLogs(snapshot, options.json);
+            return;
+        }
+        case "watch": {
+            if (options.json) {
+                throw new Error("--json is not supported for watch");
+            }
+            if (options.sessionId) {
+                requireSession(options);
+            }
+            await runWatchLoop(client, options);
+            return;
+        }
+        case "browse": {
+            const snapshot = await client.browseDirectories(options.path);
+            printDirectoryList(snapshot, options.json);
+            return;
+        }
+        case "spawn": {
+            const result = await client.spawnWorker({
+                pluginName: options.pluginName,
+                taskSummary: options.taskSummary,
+                cwd: options.cwd,
+                displayName: options.displayName,
+            });
+            printMutationResult("spawned worker", result, options.json);
+            return;
+        }
+        case "attach": {
+            requireSession(options);
+            const result = await client.attachSession(options.sessionId);
+            printMutationResult(`attached ${options.sessionId}`, result, options.json);
+            return;
+        }
+        case "input": {
+            requireSession(options);
+            requireData(options);
+            const result = await client.sendInput(options.sessionId, options.data);
+            printMutationResult(`sent input to ${options.sessionId}`, result, options.json);
+            return;
+        }
+        case "session-message": {
+            requireSession(options);
+            const snapshot = await client.getSessionMessage(options.sessionId);
+            printSessionText(snapshot, "message", options.json);
+            return;
+        }
+        case "session-summary": {
+            requireSession(options);
+            const snapshot = await client.getSessionSummary(options.sessionId);
+            printSessionText(snapshot, "summary", options.json);
+            return;
+        }
+        case "session-send": {
+            requireSession(options);
+            requireData(options);
+            const result = await client.sendToSession(options.sessionId, options.data, options.mode || "follow_up");
+            printMutationResult(`sent session message to ${options.sessionId}`, result, options.json);
+            return;
+        }
+        case "session-turn": {
+            requireSession(options);
+            requireData(options);
+            const result = await client.sessionTurn(options.sessionId, options.data, {
+                mode: options.mode || "follow_up",
+                timeoutMs: options.timeoutMs,
+                pollIntervalMs: options.pollIntervalMs,
+            });
+            printSessionTurn(result, options.json);
+            return;
+        }
+        case "stop": {
+            requireSession(options);
+            const result = await client.stopWorker(options.sessionId);
+            printMutationResult(`stopped ${options.sessionId}`, result, options.json);
+            return;
+        }
+        case "restart": {
+            requireSession(options);
+            const result = await client.restartWorker(options.sessionId);
+            printMutationResult(`restarted ${options.sessionId}`, result, options.json);
+            return;
+        }
+    }
+}
+function requireSession(options) {
+    if (!options.sessionId) {
+        throw new Error(`--session is required for ${options.command}`);
+    }
+}
+function requireData(options) {
+    if (!options.data) {
+        throw new Error(`--data is required for ${options.command}`);
+    }
+}
+function printSessionText(payload, field, json) {
+    if (json) {
+        console.log(JSON.stringify({
+            sessionId: payload.sessionId || null,
+            [field]: payload[field] || null,
+        }, null, 2));
+        return;
+    }
+    console.log(payload[field] || `No ${field} available`);
+}
+function printPrimary(payload, json) {
+    if (json) {
+        console.log(JSON.stringify(payload.primary || null, null, 2));
+        return;
+    }
+    if (!payload.primary) {
+        console.log("Primary agent unavailable");
+        return;
+    }
+    console.log(`${payload.primary.pluginName} ${payload.primary.status}${payload.primary.activityState ? ` / ${payload.primary.activityState}` : ""}`);
+    if (payload.primary.lastError) {
+        console.log(`Error: ${payload.primary.lastError}`);
+    }
+}
+function printPrimaryReply(payload, json) {
+    if (json) {
+        console.log(JSON.stringify({
+            text: payload.text || null,
+            actionType: payload.actionType || null,
+            actionLabel: payload.actionLabel || null,
+            actionTaskSummary: payload.actionTaskSummary || null,
+            actionSessionId: payload.actionSessionId || null,
+        }, null, 2));
+        return;
+    }
+    console.log(payload.text || "Primary agent returned no reply");
+    if (payload.actionType) {
+        console.log(`Action: ${payload.actionType}${payload.actionSessionId ? ` (${payload.actionSessionId})` : ""}`);
+    }
+}
+function printMutationResult(label, payload, json) {
+    if (json) {
+        console.log(JSON.stringify(payload, null, 2));
+        return;
+    }
+    console.log(label);
+    if (payload.nodeId) {
+        console.log(`Node: ${payload.nodeId}`);
+    }
+    const sessionId = typeof payload.sessionId === "string"
+        ? payload.sessionId
+        : undefined;
+    if (sessionId) {
+        console.log(`Session: ${sessionId}`);
+    }
+}
+function printSessionTurn(payload, json) {
+    if (json) {
+        console.log(JSON.stringify({
+            sessionId: payload.sessionId || null,
+            mode: payload.mode || null,
+            message: payload.message || null,
+            summary: payload.summary || null,
+            changed: payload.changed ?? null,
+            timedOut: payload.timedOut ?? null,
+        }, null, 2));
+        return;
+    }
+    console.log(`Session: ${payload.sessionId || "unknown"}`);
+    console.log(`Changed: ${payload.changed ? "yes" : "no"}${payload.timedOut ? " (timed out)" : ""}`);
+    if (payload.message) {
+        console.log("");
+        console.log("Latest message:");
+        console.log(payload.message);
+    }
+    if (payload.summary) {
+        console.log("");
+        console.log("Summary:");
+        console.log(payload.summary);
+    }
+}
+main().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+});

package/dist/node-start.d.ts

@@ -0,0 +1,11 @@
+export interface NodeStartOptions {
+    relayUrl?: string;
+    nodeId?: string;
+    password?: string;
+    localControlPort?: number;
+    localBind?: string;
+    disableLocalDirect?: boolean;
+    noReconnect?: boolean;
+    primaryPluginName?: string;
+}
+export declare function runNodeStart(options: NodeStartOptions): Promise<void>;

package/dist/node-start.js

@@ -0,0 +1,141 @@
+import { randomBytes } from "node:crypto";
+import { existsSync, readdirSync, chmodSync, mkdirSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { createRequire } from "node:module";
+import { AgentNode, getDefaultPluginDir } from "@cydm/agent-node";
+const require = createRequire(import.meta.url);
+export async function runNodeStart(options) {
+    ensureSpawnHelperExecutable();
+    const nodeOptions = {
+        relayUrl: options.relayUrl || process.env.MAGIC_SHELL_RELAY || "wss://magicshell.ai/ws",
+        nodeId: options.nodeId || process.env.MAGIC_SHELL_NODE_ID || `node-${generateId(8)}`,
+        password: options.password || process.env.MAGIC_SHELL_PASSWORD || randomPassword(24),
+        pluginDir: getDefaultPluginDir(),
+        primaryPluginName: options.primaryPluginName || process.env.MAGIC_SHELL_PRIMARY_PLUGIN || "pie",
+        autoReconnect: options.noReconnect ? false : true,
+        enableLocalDirect: options.disableLocalDirect ? false : process.env.MAGIC_SHELL_DISABLE_LOCAL_DIRECT !== "1",
+        localControlHost: options.localBind || process.env.MAGIC_SHELL_LOCAL_CONTROL_HOST || "127.0.0.1",
+        localControlPort: options.localControlPort || readNumber(process.env.MAGIC_SHELL_LOCAL_CONTROL_PORT) || randomLocalPort(),
+    };
+    const node = new AgentNode(nodeOptions);
+    const webUrl = inferWebUrl(nodeOptions.relayUrl);
+    process.on("SIGINT", async () => {
+        await node.stop();
+        process.exit(0);
+    });
+    process.on("SIGTERM", async () => {
+        await node.stop();
+        process.exit(0);
+    });
+    await node.start();
+    const localDirect = node.getLocalDirectInfo();
+    const remoteConnectUrl = `${webUrl}?node=${encodeURIComponent(nodeOptions.nodeId)}&pwd=${encodeURIComponent(nodeOptions.password)}`;
+    const localDirectUrl = localDirect
+        ? `${localDirect.webUrl}?relay=${encodeURIComponent(localDirect.wsUrl)}&node=${encodeURIComponent(nodeOptions.nodeId)}&pwd=${encodeURIComponent(nodeOptions.password)}&autoconnect=1`
+        : undefined;
+    printConnectionInfo({
+        webUrl,
+        nodeId: nodeOptions.nodeId,
+        password: nodeOptions.password,
+        localDirectUrl,
+        localDirectDisplay: localDirect?.webUrl,
+        relayUrl: nodeOptions.relayUrl,
+        remoteConnectUrl,
+    });
+    saveLastSession({
+        webUrl,
+        relayUrl: nodeOptions.relayUrl,
+        localDirectUrl,
+        nodeId: nodeOptions.nodeId,
+        password: nodeOptions.password,
+    });
+}
+function printConnectionInfo(info) {
+    console.log("");
+    console.log("Magic Shell node is running");
+    console.log(`Web: ${info.webUrl}`);
+    console.log(`Relay: ${info.relayUrl}`);
+    if (info.localDirectDisplay) {
+        console.log(`Local direct: ${info.localDirectDisplay}`);
+    }
+    console.log(`Node ID: ${info.nodeId}`);
+    console.log(`Password: ${info.password}`);
+    console.log("");
+    console.log(`Open remote: ${info.remoteConnectUrl}`);
+    if (info.localDirectUrl) {
+        console.log(`Open local:  ${info.localDirectUrl}`);
+    }
+    console.log("");
+    console.log("Press Ctrl+C to stop.");
+}
+function saveLastSession(info) {
+    const infoFile = path.join(os.homedir(), ".magic-shell-last-session.json");
+    mkdirSync(path.dirname(infoFile), { recursive: true });
+    writeFileSync(infoFile, JSON.stringify({
+        timestamp: new Date().toISOString(),
+        webUrl: info.webUrl,
+        relayUrl: info.relayUrl,
+        localDirectUrl: info.localDirectUrl || null,
+        nodeId: info.nodeId,
+        password: info.password,
+    }, null, 2));
+    console.log(`Saved connection info: ${infoFile}`);
+}
+function inferWebUrl(relayUrl) {
+    if (relayUrl.startsWith("wss://")) {
+        return `https://${relayUrl.replace(/^wss:\/\//, "").replace(/\/ws$/, "")}`;
+    }
+    if (relayUrl.startsWith("ws://")) {
+        return `http://${relayUrl.replace(/^ws:\/\//, "").replace(/\/ws$/, "")}`;
+    }
+    return relayUrl;
+}
+function randomPassword(length) {
+    return randomBytes(Math.max(length * 2, 32)).toString("base64").replace(/[^a-zA-Z0-9]/g, "").slice(0, length);
+}
+function generateId(length) {
+    const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+    let result = "";
+    for (let index = 0; index < length; index += 1) {
+        result += chars[Math.floor(Math.random() * chars.length)];
+    }
+    return result;
+}
+function randomLocalPort() {
+    return 43000 + Math.floor(Math.random() * 2000);
+}
+function readNumber(raw) {
+    if (!raw)
+        return undefined;
+    const value = Number(raw);
+    return Number.isFinite(value) ? value : undefined;
+}
+function ensureSpawnHelperExecutable() {
+    try {
+        const pkgPath = require.resolve("node-pty/package.json");
+        const prebuildRoot = path.join(path.dirname(pkgPath), "prebuilds");
+        if (!existsSync(prebuildRoot))
+            return;
+        for (const entry of walk(prebuildRoot)) {
+            if (path.basename(entry) === "spawn-helper") {
+                chmodSync(entry, 0o755);
+            }
+        }
+    }
+    catch {
+        // Ignore best-effort fixups during startup.
+    }
+}
+function walk(dir) {
+    const files = [];
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...walk(fullPath));
+            continue;
+        }
+        files.push(fullPath);
+    }
+    return files;
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@cydm/magic-shell",
+  "version": "0.1.0",
+  "description": "Magic Shell first-party CLI",
+  "type": "module",
+  "main": "./dist/cli.js",
+  "types": "./dist/cli.d.ts",
+  "bin": {
+    "magic-shell": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/cli.js"
+  },
+  "dependencies": {
+    "@cydm/agent-node": "0.1.0",
+    "@cydm/pie": "^1.0.5",
+    "@cydm/protocol": "0.1.0",
+    "@cydm/sdk": "0.1.0",
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "@types/ws": "^8.5.13",
+    "typescript": "^5.3.0"
+  }
+}