commanderclaw 1.1.16 → 1.1.20

package/dist/plugin/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/plugin/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAgXH,QAAA,MAAM,MAAM;;;;;kBAKI,GAAG;CAQlB,CAAC;AAEF,eAAe,MAAM,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/plugin/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAwaH,QAAA,MAAM,MAAM;;;;;kBAKI,GAAG;CAQlB,CAAC;AAEF,eAAe,MAAM,CAAC"}

package/dist/plugin/index.mjs

@@ -4276,6 +4276,314 @@ Note: Some commands may require King-level permissions.`,
     };
 }
 
+/**
+ * OpenClaw Session Strategy
+ *
+ * Uses ACP Runtime to create and manage sessions for OpenClaw-based agents (QClaw, OpenCode, etc.).
+ */
+class OpenClawSessionStrategy {
+    name;
+    runtime = null;
+    sessions = new Map();
+    activeSessionId = null;
+    initialized = false;
+    initPromise = null;
+    constructor(backendType) {
+        this.name = backendType;
+        this.initPromise = this.initRuntime();
+    }
+    async initRuntime() {
+        try {
+            // Dynamic import to handle cases where openclaw is not available
+            const openclaw = await import('openclaw/plugin-sdk');
+            const backend = openclaw.requireAcpRuntimeBackend();
+            this.runtime = backend?.runtime;
+            this.initialized = true;
+            console.log(`[CommanderClaw] ACP Runtime initialized for ${this.name}`);
+        }
+        catch (e) {
+            console.warn(`[CommanderClaw] ACP Runtime not available for ${this.name}:`, e);
+            this.initialized = true; // Mark as initialized even on failure
+        }
+    }
+    async ensureInitialized() {
+        if (!this.initialized && this.initPromise) {
+            await this.initPromise;
+        }
+    }
+    isAvailable() {
+        return !!this.runtime;
+    }
+    async createSession(sessionId, options) {
+        await this.ensureInitialized();
+        if (!this.runtime) {
+            throw new Error('ACP Runtime not available');
+        }
+        const sessionKey = options?.sessionKey || `commanderclaw:${sessionId}`;
+        try {
+            const handle = await this.runtime.ensureSession({
+                sessionKey,
+                agent: 'default',
+                mode: options?.mode || 'persistent',
+                cwd: options?.cwd,
+                env: options?.env,
+            });
+            const sessionHandle = {
+                sessionId,
+                localSessionKey: handle.sessionKey,
+                createdAt: new Date(),
+                metadata: {
+                    backendSessionId: handle.backendSessionId,
+                    agentSessionId: handle.agentSessionId,
+                    cwd: handle.cwd,
+                },
+            };
+            this.sessions.set(sessionId, sessionHandle);
+            this.activeSessionId = sessionId;
+            console.log(`[CommanderClaw] Session created via ACP Runtime: ${sessionId} -> ${handle.sessionKey}`);
+            return sessionHandle;
+        }
+        catch (e) {
+            console.error(`[CommanderClaw] Failed to create session ${sessionId}:`, e);
+            throw e;
+        }
+    }
+    getSession(sessionId) {
+        return this.sessions.get(sessionId) || null;
+    }
+    switchSession(sessionId) {
+        if (!this.sessions.has(sessionId)) {
+            throw new Error(`Session ${sessionId} not found`);
+        }
+        this.activeSessionId = sessionId;
+        console.log(`[CommanderClaw] Switched to session: ${sessionId}`);
+    }
+    getActiveSession() {
+        if (!this.activeSessionId)
+            return null;
+        return this.sessions.get(this.activeSessionId) || null;
+    }
+    async closeSession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return;
+        if (this.runtime?.close) {
+            try {
+                await this.runtime.close({
+                    handle: { sessionKey: session.localSessionKey },
+                    reason: 'Session closed by CommanderClaw',
+                });
+            }
+            catch (e) {
+                console.warn(`[CommanderClaw] Failed to close session ${sessionId} via ACP Runtime:`, e);
+            }
+        }
+        this.sessions.delete(sessionId);
+        if (this.activeSessionId === sessionId) {
+            this.activeSessionId = null;
+        }
+        console.log(`[CommanderClaw] Session closed: ${sessionId}`);
+    }
+}
+
+/**
+ * Simple Session Strategy
+ *
+ * Fallback strategy that uses in-memory session mapping.
+ * Used when ACP Runtime is not available.
+ */
+class SimpleSessionStrategy {
+    name = 'simple';
+    sessions = new Map();
+    activeSessionId = null;
+    isAvailable() {
+        return true; // Always available as fallback
+    }
+    async createSession(sessionId, options) {
+        const existing = this.sessions.get(sessionId);
+        if (existing) {
+            this.activeSessionId = sessionId;
+            return existing;
+        }
+        const sessionKey = options?.sessionKey || `simple:${sessionId}:${Date.now()}`;
+        const sessionHandle = {
+            sessionId,
+            localSessionKey: sessionKey,
+            createdAt: new Date(),
+        };
+        this.sessions.set(sessionId, sessionHandle);
+        this.activeSessionId = sessionId;
+        console.log(`[CommanderClaw] Simple session created: ${sessionId} -> ${sessionKey}`);
+        return sessionHandle;
+    }
+    getSession(sessionId) {
+        return this.sessions.get(sessionId) || null;
+    }
+    switchSession(sessionId) {
+        if (!this.sessions.has(sessionId)) {
+            throw new Error(`Session ${sessionId} not found`);
+        }
+        this.activeSessionId = sessionId;
+        console.log(`[CommanderClaw] Switched to simple session: ${sessionId}`);
+    }
+    getActiveSession() {
+        if (!this.activeSessionId)
+            return null;
+        return this.sessions.get(this.activeSessionId) || null;
+    }
+    async closeSession(sessionId) {
+        this.sessions.delete(sessionId);
+        if (this.activeSessionId === sessionId) {
+            this.activeSessionId = null;
+        }
+        console.log(`[CommanderClaw] Simple session closed: ${sessionId}`);
+    }
+}
+
+/**
+ * Backend Detector
+ *
+ * Detects the ACP backend type for the current environment.
+ */
+function detectBackend() {
+    // 1. Check environment variables
+    if (process.env.QCLAW_BACKEND)
+        return 'qclaw';
+    if (process.env.OPENCODE_BACKEND)
+        return 'opencode';
+    // 2. Try to load OpenClaw SDK and detect backend
+    try {
+        // Use require for synchronous detection
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const openclaw = require('openclaw/plugin-sdk');
+        const backend = openclaw.requireAcpRuntimeBackend();
+        if (!backend)
+            return 'simple';
+        const id = (backend.id || '').toLowerCase();
+        if (id.includes('qclaw'))
+            return 'qclaw';
+        if (id.includes('opencode'))
+            return 'opencode';
+        if (id.includes('claude'))
+            return 'claude';
+        if (id.includes('cursor'))
+            return 'cursor';
+        // Has backend but unknown type
+        return 'custom';
+    }
+    catch {
+        // OpenClaw SDK not available or backend not registered
+    }
+    return 'simple';
+}
+
+/**
+ * Session Manager
+ *
+ * Manages session strategies and provides a unified interface for session operations.
+ */
+class SessionManager {
+    activeStrategy = null;
+    backendType = 'unknown';
+    constructor() {
+        this.initStrategy();
+    }
+    initStrategy() {
+        const backend = detectBackend();
+        this.backendType = backend;
+        console.log(`[CommanderClaw] Detected backend: ${backend}`);
+        if (backend === 'simple') {
+            // No ACP Runtime available, use simple strategy
+            this.activeStrategy = new SimpleSessionStrategy();
+            console.log(`[CommanderClaw] Using strategy: simple (no ACP Runtime)`);
+        }
+        else {
+            // Try OpenClaw strategy first
+            const openclawStrategy = new OpenClawSessionStrategy(backend);
+            // Check availability asynchronously
+            openclawStrategy['initPromise']?.then(() => {
+                if (openclawStrategy.isAvailable()) {
+                    console.log(`[CommanderClaw] Using strategy: ${backend} (ACP Runtime)`);
+                }
+                else {
+                    console.warn(`[CommanderClaw] OpenClaw strategy not available, using simple fallback`);
+                    this.activeStrategy = new SimpleSessionStrategy();
+                }
+            });
+            this.activeStrategy = openclawStrategy;
+        }
+    }
+    /**
+     * Get the backend type that was detected
+     */
+    getBackendType() {
+        return this.backendType;
+    }
+    /**
+     * Get the active strategy name
+     */
+    getStrategyName() {
+        return this.activeStrategy?.name || 'none';
+    }
+    /**
+     * Get the active strategy
+     */
+    getActiveStrategy() {
+        return this.activeStrategy;
+    }
+    /**
+     * Create a new session
+     */
+    async createSession(sessionId, options) {
+        if (!this.activeStrategy) {
+            console.warn('[CommanderClaw] No session strategy available');
+            return null;
+        }
+        try {
+            return await this.activeStrategy.createSession(sessionId, options);
+        }
+        catch (e) {
+            console.error(`[CommanderClaw] Failed to create session ${sessionId}:`, e);
+            return null;
+        }
+    }
+    /**
+     * Get an existing session
+     */
+    getSession(sessionId) {
+        return this.activeStrategy?.getSession(sessionId) || null;
+    }
+    /**
+     * Switch to an existing session
+     */
+    switchSession(sessionId) {
+        this.activeStrategy?.switchSession(sessionId);
+    }
+    /**
+     * Get the currently active session
+     */
+    getActiveSession() {
+        return this.activeStrategy?.getActiveSession() || null;
+    }
+    /**
+     * Close a session
+     */
+    async closeSession(sessionId) {
+        await this.activeStrategy?.closeSession(sessionId);
+    }
+}
+// Singleton instance
+let sessionManager$1 = null;
+/**
+ * Get the singleton SessionManager instance
+ */
+function getSessionManager() {
+    if (!sessionManager$1) {
+        sessionManager$1 = new SessionManager();
+    }
+    return sessionManager$1;
+}
+
 /**
  * CommanderClaw Channel Plugin for OpenClaw
  *
@@ -4288,6 +4596,7 @@ let client = null;
 let pluginConfig = null;
 let currentLog = null;
 let currentSessionKey = null;
+const sessionManager = getSessionManager();
 const DEFAULT_CONFIG = {
     deviceName: "OpenClaw Agent",
     autoConnect: true,
@@ -4345,6 +4654,8 @@ async function handleChatMessage(msg) {
                 id: senderId,
             },
         });
+        const sessionHandle = sessionManager.getActiveSession();
+        const sessionKey = sessionHandle?.localSessionKey || currentSessionKey || route.sessionKey;
         const ctxPayload = rt.channel.reply.finalizeInboundContext({
             Body: content,
             RawBody: content,
@@ -4353,7 +4664,7 @@ async function handleChatMessage(msg) {
             From: `${CHANNEL_ID}:${senderId}`,
             To: `${CHANNEL_ID}:${nodeId}`,
             SenderId: senderId,
-            SessionKey: route.sessionKey,
+            SessionKey: sessionKey,
             AccountId: "default",
             ChatType: "direct",
             ConversationLabel: `user:${senderId}`,
@@ -4432,11 +4743,56 @@ function initializeClient(config, log) {
         const payload = event.data;
         log.info("SESSION_SWITCH received", {
             sessionId: payload.sessionId,
-            action: payload.action || "legacy",
             sessionKey: payload.sessionKey,
+            action: payload.action || "legacy",
         });
-        currentSessionKey = payload.sessionKey;
-        log.info("Session key updated", { sessionKey: currentSessionKey });
+        const action = payload.action || "switch";
+        switch (action) {
+            case "create": {
+                try {
+                    const handle = await sessionManager.createSession(payload.sessionId, { ...payload.options, sessionKey: payload.sessionKey });
+                    currentSessionKey = handle.localSessionKey;
+                    log.info("Session created", {
+                        sessionId: payload.sessionId,
+                        localSessionKey: handle.localSessionKey,
+                    });
+                }
+                catch (e) {
+                    log.error("Failed to create session", {
+                        sessionId: payload.sessionId,
+                        error: String(e),
+                    });
+                }
+                break;
+            }
+            case "switch": {
+                const existing = sessionManager.getSession(payload.sessionId);
+                if (existing) {
+                    sessionManager.switchSession(payload.sessionId);
+                    currentSessionKey = existing.localSessionKey;
+                    log.info("Session switched", { sessionId: payload.sessionId });
+                }
+                else {
+                    log.info("Session not found, creating", { sessionId: payload.sessionId });
+                    try {
+                        const handle = await sessionManager.createSession(payload.sessionId, { sessionKey: payload.sessionKey });
+                        currentSessionKey = handle.localSessionKey;
+                    }
+                    catch (e) {
+                        log.error("Failed to create session on switch", {
+                            sessionId: payload.sessionId,
+                            error: String(e),
+                        });
+                    }
+                }
+                break;
+            }
+            case "close":
+                await sessionManager.closeSession(payload.sessionId);
+                currentSessionKey = null;
+                log.info("Session closed", { sessionId: payload.sessionId });
+                break;
+        }
     });
     client.connect().catch((error) => {
         log.error("Failed to connect to CommanderClaw server", {