@a1hvdy/cc-openclaw 0.3.2

package/dist/src/command-router/cc-handler.js

@@ -0,0 +1,980 @@
+/**
+ * cc-handler — OpenClaw plugin (TypeScript port of savvy-claude-code/cc-handler.js)
+ *
+ * Intercepts /cc <prompt> messages from Telegram via the before_dispatch hook,
+ * launches a Claude Code session through SessionManager, and lets the existing
+ * telegram-ux-bridge handle live card delivery.
+ *
+ * Supports per-session chat targeting and continuation:
+ *   /cc <prompt>           — start a new Claude Code session
+ *   /cc+ <prompt>          — continue the last session in this chat
+ *   /cc continue <prompt>  — alternative continuation syntax
+ *   /cc status             — check active session for this chat
+ *   /cc stop               — stop the active session for this chat
+ *   /cc resume [id|slug]   — resume by session ID (8-char hex) or slug
+ *   /cc list               — show resumable sessions for this chat
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as crypto from 'node:crypto';
+import { request as httpsRequest } from 'node:https';
+import { defaultRegisterGuard } from '../lib/register-guard.js';
+import { VENDOR_FILES } from '../lib/vendor-paths.js';
+// ── Constants ─────────────────────────────────────────────────────────────
+const PLUGIN_TAG = '[cc-openclaw/command-router]';
+const CC_PLUGIN_PATH = VENDOR_FILES.sessionManager;
+const SESSIONS_DIR = '/home/a1xai/.openclaw/sessions';
+const SESSIONS_INDEX_PATH = path.join(SESSIONS_DIR, 'index.json');
+const DEFAULT_CWD = '/home/a1xai/.openclaw';
+const IDLE_TIMEOUT_MS = 15 * 60 * 1000; // 15 min
+const ACK_TIMEOUT_MS = 5_000;
+// Max age for session recovery on warm restart.
+const RECOVERY_MAX_AGE_MS = 24 * 60 * 60 * 1000; // 24h
+const OPENCLAW_CONFIG_PATH = '/home/a1xai/.openclaw/openclaw.json';
+// ── Telegram Direct Send ──────────────────────────────────────────────────
+let BOT_TOKEN = '';
+function loadBotToken() {
+    if (BOT_TOKEN)
+        return;
+    try {
+        const raw = fs.readFileSync(OPENCLAW_CONFIG_PATH, 'utf8');
+        const cfg = JSON.parse(raw);
+        const tg = cfg.channels?.telegram;
+        if (tg?.accounts) {
+            const acctKey = tg.defaultAccount || 'default';
+            const acct = tg.accounts[acctKey] || {};
+            BOT_TOKEN = acct.botToken || '';
+        }
+        if (BOT_TOKEN)
+            logger.info(`${PLUGIN_TAG} Bot token loaded for direct replies`);
+    }
+    catch (err) {
+        logger.warn(`${PLUGIN_TAG} Failed to load bot token: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+function telegramApiDirect(method, params) {
+    return new Promise((resolve, reject) => {
+        const body = JSON.stringify(params);
+        const options = {
+            hostname: 'api.telegram.org',
+            path: `/bot${BOT_TOKEN}/${method}`,
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Content-Length': Buffer.byteLength(body),
+            },
+        };
+        const req = httpsRequest(options, (res) => {
+            let data = '';
+            res.on('data', (chunk) => (data += chunk));
+            res.on('end', () => {
+                try {
+                    resolve(JSON.parse(data));
+                }
+                catch {
+                    resolve({ ok: false });
+                }
+            });
+        });
+        req.on('error', reject);
+        req.setTimeout(10_000, () => req.destroy(new Error('Telegram API timeout')));
+        req.write(body);
+        req.end();
+    });
+}
+async function sendDirectReply(chatId, threadId, text) {
+    if (!BOT_TOKEN || !chatId)
+        return null;
+    try {
+        const params = {
+            chat_id: chatId,
+            text,
+            disable_web_page_preview: true,
+        };
+        if (threadId)
+            params.message_thread_id = Number(threadId);
+        const res = await telegramApiDirect('sendMessage', params);
+        if (!res.ok) {
+            logger.warn(`${PLUGIN_TAG} Direct reply failed: ${JSON.stringify(res.description || res)}`);
+            return null;
+        }
+        return res.result?.message_id ?? null;
+    }
+    catch (err) {
+        logger.warn(`${PLUGIN_TAG} Direct reply error: ${err instanceof Error ? err.message : String(err)}`);
+        return null;
+    }
+}
+// ── Slug Generator ────────────────────────────────────────────────────────
+const FILLER_WORDS = new Set([
+    'the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been', 'being',
+    'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could',
+    'should', 'may', 'might', 'shall', 'can', 'to', 'of', 'in', 'for',
+    'on', 'with', 'at', 'by', 'from', 'it', 'its', 'this', 'that', 'and',
+    'or', 'but', 'not', 'so', 'if', 'then', 'than', 'just', 'also',
+    'very', 'really', 'please', 'me', 'my', 'i',
+]);
+function makeSlug(instruction) {
+    const tokens = instruction
+        .toLowerCase()
+        .replace(/[^a-z0-9\s-]/g, '')
+        .split(/\s+/)
+        .filter((t) => t.length > 0 && !FILLER_WORDS.has(t));
+    const suffix = Date.now().toString(36).slice(-4);
+    if (tokens.length === 0) {
+        return `task-${suffix}`;
+    }
+    let slug = tokens.slice(0, 4).join('-');
+    if (slug.length > 24) {
+        slug = slug.slice(0, 24).replace(/-$/, '');
+    }
+    return `${slug}-${suffix}`;
+}
+// ── Session ID Generator ──────────────────────────────────────────────────
+function generateSessionId() {
+    return crypto.randomBytes(4).toString('hex');
+}
+// ── Session Index ─────────────────────────────────────────────────────────
+let sessionIndex = {};
+function loadSessionIndex() {
+    try {
+        if (fs.existsSync(SESSIONS_INDEX_PATH)) {
+            sessionIndex = JSON.parse(fs.readFileSync(SESSIONS_INDEX_PATH, 'utf8'));
+        }
+    }
+    catch {
+        sessionIndex = {};
+    }
+}
+function saveSessionIndex() {
+    try {
+        fs.mkdirSync(SESSIONS_DIR, { recursive: true });
+        const tmp = SESSIONS_INDEX_PATH + '.tmp';
+        fs.writeFileSync(tmp, JSON.stringify(sessionIndex, null, 2));
+        fs.renameSync(tmp, SESSIONS_INDEX_PATH);
+    }
+    catch { /* best effort */ }
+}
+// ── Session Store ─────────────────────────────────────────────────────────
+function saveSession(meta) {
+    const dir = path.join(SESSIONS_DIR, meta.slug);
+    fs.mkdirSync(dir, { recursive: true });
+    const filePath = path.join(dir, 'session.json');
+    const tmp = filePath + '.tmp';
+    fs.writeFileSync(tmp, JSON.stringify(meta, null, 2));
+    fs.renameSync(tmp, filePath);
+    if (meta.id) {
+        sessionIndex[meta.id] = meta.slug;
+        saveSessionIndex();
+    }
+}
+function loadSession(slug) {
+    const filePath = path.join(SESSIONS_DIR, slug, 'session.json');
+    try {
+        return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function loadSessionById(id) {
+    const slug = sessionIndex[id];
+    if (slug)
+        return loadSession(slug);
+    const all = scanAllSessions();
+    const match = all.find((s) => s.id === id);
+    if (match) {
+        sessionIndex[id] = match.slug;
+        saveSessionIndex();
+    }
+    return match ?? null;
+}
+function scanAllSessions() {
+    const results = [];
+    try {
+        if (!fs.existsSync(SESSIONS_DIR))
+            return results;
+        const entries = fs.readdirSync(SESSIONS_DIR, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const meta = loadSession(entry.name);
+            if (meta && meta.slug && meta.chatId) {
+                results.push(meta);
+            }
+        }
+    }
+    catch {
+        // Best effort — if sessions dir is unreadable, return empty
+    }
+    return results;
+}
+// ── Plugin Entry ──────────────────────────────────────────────────────────
+let logger = console;
+let sessionManager = null;
+const activeSessions = new Map();
+function sessionMapKey(chatId, threadId) {
+    return threadId ? `${chatId}:${threadId}` : String(chatId);
+}
+// ── parseCcCommand — pure exported parser ─────────────────────────────────
+/**
+ * Parse a raw input string into a CcCommand.
+ * Returns null if the input is not a /cc or /cc+ command.
+ *
+ * Recognised forms:
+ *   /cc+ <prompt>           → { subcommand: 'continue', prompt }
+ *   /cc <prompt>            → { subcommand: 'new', prompt }
+ *   /cc continue <prompt>   → { subcommand: 'continue', prompt }
+ *   /cc stop                → { subcommand: 'stop' }
+ *   /cc resume [id|slug]    → { subcommand: 'resume', target? }
+ *   /cc status              → { subcommand: 'status' }
+ *   /cc list                → { subcommand: 'list' }
+ */
+export function parseCcCommand(input) {
+    if (!input)
+        return null;
+    const content = input.trim();
+    if (!content)
+        return null;
+    // /cc+ <prompt>
+    const ccPlusMatch = content.match(/^\/cc\+\s*([\s\S]+)/i);
+    if (ccPlusMatch) {
+        const prompt = ccPlusMatch[1].trim();
+        if (!prompt)
+            return null;
+        return { subcommand: 'continue', prompt };
+    }
+    // Must start with /cc
+    if (!/^\/cc(\s|$)/i.test(content))
+        return null;
+    const afterCc = content.slice(3).trim();
+    // /cc continue <prompt>
+    const continueMatch = afterCc.match(/^continue\s+([\s\S]+)/i);
+    if (continueMatch) {
+        const prompt = continueMatch[1].trim();
+        if (!prompt)
+            return null;
+        return { subcommand: 'continue', prompt };
+    }
+    // /cc stop
+    if (afterCc.toLowerCase() === 'stop') {
+        return { subcommand: 'stop' };
+    }
+    // /cc resume [id|slug]
+    const resumeMatch = afterCc.match(/^resume(?:\s+(.+))?$/i);
+    if (resumeMatch) {
+        const target = (resumeMatch[1] || '').trim() || undefined;
+        return { subcommand: 'resume', target };
+    }
+    // /cc status
+    if (afterCc.toLowerCase() === 'status') {
+        return { subcommand: 'status' };
+    }
+    // /cc list
+    if (afterCc.toLowerCase() === 'list') {
+        return { subcommand: 'list' };
+    }
+    // /cc <prompt> — new session (may be empty)
+    if (!afterCc)
+        return null;
+    return { subcommand: 'new', prompt: afterCc };
+}
+// ── Status Handler ────────────────────────────────────────────────────────
+function buildPhase2FlagsLine() {
+    const allowBuiltins = process.env.CC_OPENCLAW_ALLOW_BUILTINS === '1';
+    const toolStream = process.env.CC_OPENCLAW_TOOL_STREAM === '1';
+    return `Flags: builtins=${allowBuiltins ? 'on' : 'off'} | toolstream=${toolStream ? 'on' : 'off'}`;
+}
+function handleStatus(chatId, threadId) {
+    const key = sessionMapKey(chatId, threadId);
+    const active = activeSessions.get(key);
+    const flagsLine = buildPhase2FlagsLine();
+    if (!active) {
+        const diskSessions = scanAllSessions()
+            .filter((s) => s.chatId === chatId &&
+            (s.threadId || undefined) === (threadId || undefined) &&
+            s.state !== 'failed')
+            .sort((a, b) => new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime());
+        if (diskSessions.length > 0) {
+            const last = diskSessions[0];
+            const id = last.id || '?';
+            return {
+                handled: true,
+                text: `No active session.\nLast: [${id}] ${last.slug} (${last.state}, ${last.turns || 0} turns)\nResume: /cc resume ${id}\n${flagsLine}`,
+            };
+        }
+        return { handled: true, text: `No active session in this chat.\n${flagsLine}` };
+    }
+    const elapsed = Math.round((Date.now() - new Date(active.meta.startedAt).getTime()) / 1000);
+    const turns = active.meta.turns || 1;
+    const id = active.meta.id || '?';
+    return {
+        handled: true,
+        text: `Active: [${id}] ${active.slug} (${turns} turn${turns > 1 ? 's' : ''}, ${elapsed}s)\n${flagsLine}`,
+    };
+}
+// ── List Handler ──────────────────────────────────────────────────────────
+function handleList(chatId, threadId) {
+    const sessions = scanAllSessions()
+        .filter((s) => s.chatId === chatId &&
+        (s.threadId || undefined) === (threadId || undefined))
+        .sort((a, b) => {
+        const timeA = new Date(a.lastContinuedAt || a.completedAt || a.startedAt).getTime();
+        const timeB = new Date(b.lastContinuedAt || b.completedAt || b.startedAt).getTime();
+        return timeB - timeA;
+    })
+        .slice(0, 10);
+    if (sessions.length === 0) {
+        return { handled: true, text: 'No sessions found for this chat.' };
+    }
+    const lines = sessions.map((s) => {
+        const id = s.id || '--------';
+        const state = s.state || '?';
+        const turns = s.turns || 0;
+        const resumable = !!s.claudeSessionId;
+        const marker = resumable ? '✅' : '❌';
+        const prompt = (s.instruction || '').slice(0, 30);
+        return `${marker} ${id} ${s.slug} (${state}, ${turns}t) ${prompt}`;
+    });
+    return {
+        handled: true,
+        text: `Sessions (last 10):\n${lines.join('\n')}\n\nResume: /cc resume <id>`,
+    };
+}
+// ── Continuation Handler ──────────────────────────────────────────────────
+function handleContinuation(prompt, chatId, threadId) {
+    if (!sessionManager) {
+        return {
+            handled: true,
+            text: 'Claude Code handler not ready — try again in a few seconds.',
+        };
+    }
+    const key = sessionMapKey(chatId, threadId);
+    const active = activeSessions.get(key);
+    if (!active) {
+        return {
+            handled: true,
+            text: 'No active session to continue. Start one with /cc <prompt> or /cc resume',
+        };
+    }
+    if (active.needsRehydration) {
+        if (!active.meta.claudeSessionId) {
+            activeSessions.delete(key);
+            return {
+                handled: true,
+                text: 'Recovered session has no Claude ID — start fresh with /cc <prompt>',
+            };
+        }
+        logger.info(`${PLUGIN_TAG} /cc+ rehydrating recovered session: slug=${active.slug} chat=${chatId} thread=${threadId || 'none'}`);
+        let resolveAckId;
+        const ackIdPromise = new Promise((r) => {
+            resolveAckId = r;
+        });
+        (async () => {
+            try {
+                await rehydrateSession(active.meta, chatId, threadId);
+                active.needsRehydration = false;
+                await continueTurn(active, prompt, chatId, threadId, ackIdPromise);
+            }
+            catch (err) {
+                logger.error(`${PLUGIN_TAG} Rehydrate+continue ${active.slug} failed: ${err instanceof Error ? err.message : String(err)}`);
+                scheduleIdle(key, active);
+            }
+        })();
+        return {
+            handled: true,
+            text: `⏳ [${active.meta.id || '?'}] Resuming & continuing ${active.slug}...`,
+            _resolveAckId: resolveAckId,
+        };
+    }
+    try {
+        sessionManager.getStatus(active.sessionName);
+    }
+    catch {
+        activeSessions.delete(key);
+        return {
+            handled: true,
+            text: 'Previous session expired. Use /cc resume or start fresh with /cc <prompt>',
+        };
+    }
+    if (active.idleTimer)
+        clearTimeout(active.idleTimer);
+    logger.info(`${PLUGIN_TAG} /cc+ continuation: slug=${active.slug} chat=${chatId} thread=${threadId || 'none'}`);
+    let resolveAckId;
+    const ackIdPromise = new Promise((r) => {
+        resolveAckId = r;
+    });
+    continueTurn(active, prompt, chatId, threadId, ackIdPromise).catch((err) => {
+        logger.error(`${PLUGIN_TAG} Continuation ${active.slug} failed: ${err instanceof Error ? err.message : String(err)}`);
+        scheduleIdle(key, active);
+    });
+    return {
+        handled: true,
+        text: `⏳ [${active.meta.id || '?'}] Continuing ${active.slug}...`,
+        _resolveAckId: resolveAckId,
+    };
+}
+// ── Stop Handler ──────────────────────────────────────────────────────────
+function handleStop(chatId, threadId) {
+    if (!sessionManager) {
+        return { handled: true, text: 'Claude Code handler not ready.' };
+    }
+    const key = sessionMapKey(chatId, threadId);
+    const active = activeSessions.get(key);
+    if (!active) {
+        return { handled: true, text: 'No active session to stop.' };
+    }
+    const { sessionName, slug, meta } = active;
+    if (active.idleTimer)
+        clearTimeout(active.idleTimer);
+    activeSessions.delete(key);
+    (async () => {
+        try {
+            await sessionManager.stopSession(sessionName);
+            logger.info(`${PLUGIN_TAG} Session ${sessionName} stopped by /cc stop`);
+        }
+        catch (err) {
+            logger.warn(`${PLUGIN_TAG} stopSession(${sessionName}) error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    })();
+    meta.state = 'stopped';
+    meta.completedAt = new Date().toISOString();
+    try {
+        saveSession(meta);
+    }
+    catch { /* best effort */ }
+    const sessionId = meta.id || slug;
+    return {
+        handled: true,
+        text: `⏹ Stopped [${sessionId}] ${slug}.\nResume: /cc resume ${sessionId}`,
+    };
+}
+// ── Resume Handler ────────────────────────────────────────────────────────
+function handleResume(chatId, threadId, targetSlug) {
+    if (!sessionManager) {
+        return { handled: true, text: 'Claude Code handler not ready.' };
+    }
+    const key = sessionMapKey(chatId, threadId);
+    const currentActive = activeSessions.get(key);
+    if (currentActive) {
+        return {
+            handled: true,
+            text: `Already have active session: ${currentActive.slug}\nUse /cc stop first, or /cc+ to continue it.`,
+        };
+    }
+    let meta = null;
+    if (targetSlug) {
+        const isSessionId = /^[0-9a-f]{8}$/i.test(targetSlug);
+        if (isSessionId) {
+            meta = loadSessionById(targetSlug.toLowerCase());
+        }
+        if (!meta) {
+            meta = loadSession(targetSlug);
+        }
+        if (!meta) {
+            return { handled: true, text: `Session "${targetSlug}" not found.` };
+        }
+        if (meta.chatId !== chatId) {
+            return {
+                handled: true,
+                text: `Session "${targetSlug}" belongs to a different chat.`,
+            };
+        }
+    }
+    else {
+        const candidates = scanAllSessions()
+            .filter((s) => s.chatId === chatId &&
+            (s.threadId || undefined) === (threadId || undefined) &&
+            !!s.claudeSessionId)
+            .sort((a, b) => {
+            const timeA = new Date(a.lastContinuedAt || a.completedAt || a.startedAt).getTime();
+            const timeB = new Date(b.lastContinuedAt || b.completedAt || b.startedAt).getTime();
+            return timeB - timeA;
+        });
+        if (candidates.length === 0) {
+            return {
+                handled: true,
+                text: 'No resumable session found. Start fresh with /cc <prompt>',
+            };
+        }
+        meta = candidates[0];
+    }
+    if (!meta.claudeSessionId) {
+        return {
+            handled: true,
+            text: `Session ${meta.slug} has no Claude session ID — cannot resume.\nStart fresh with /cc <prompt>`,
+        };
+    }
+    const { slug, id: resumeId } = meta;
+    logger.info(`${PLUGIN_TAG} /cc resume: id=${resumeId} slug=${slug} claudeId=${meta.claudeSessionId} chat=${chatId} thread=${threadId || 'none'}`);
+    rehydrateSession(meta, chatId, threadId).catch((err) => {
+        logger.error(`${PLUGIN_TAG} Resume ${slug} failed: ${err instanceof Error ? err.message : String(err)}`);
+        meta.state = 'failed';
+        meta.error = `Resume failed: ${err instanceof Error ? err.message : String(err)}`;
+        try {
+            saveSession(meta);
+        }
+        catch { /* best effort */ }
+        const active = activeSessions.get(key);
+        if (active?.slug === slug) {
+            if (active.idleTimer)
+                clearTimeout(active.idleTimer);
+            activeSessions.delete(key);
+        }
+    });
+    return { handled: true, text: `⏳ [${resumeId || '?'}] Resuming ${slug}...` };
+}
+// ── Session Launcher ──────────────────────────────────────────────────────
+async function launchSession(sessionName, prompt, slug, meta, chatId, threadId, ackIdPromise) {
+    logger.info(`${PLUGIN_TAG} Starting session ${sessionName}...`);
+    const key = sessionMapKey(chatId, threadId);
+    const preAssignedId = crypto.randomUUID();
+    meta.claudeSessionId = preAssignedId;
+    meta.state = 'starting';
+    try {
+        saveSession(meta);
+    }
+    catch { /* best effort */ }
+    await sessionManager.startSession({
+        name: sessionName,
+        cwd: DEFAULT_CWD,
+        engine: 'claude',
+        permissionMode: 'bypassPermissions',
+        effort: 'high',
+        customSessionId: preAssignedId,
+    });
+    meta.state = 'running';
+    try {
+        saveSession(meta);
+    }
+    catch { /* best effort */ }
+    const prevActive = activeSessions.get(key);
+    if (prevActive && prevActive.sessionName !== sessionName) {
+        if (prevActive.idleTimer)
+            clearTimeout(prevActive.idleTimer);
+        try {
+            await sessionManager.stopSession(prevActive.sessionName);
+        }
+        catch { /* may already be gone */ }
+    }
+    const activeEntry = { sessionName, slug, meta, idleTimer: null };
+    activeSessions.set(key, activeEntry);
+    logger.info(`${PLUGIN_TAG} Session ${sessionName} started — sending prompt...`);
+    const opts = { telegramChatId: chatId };
+    if (threadId)
+        opts.telegramThreadId = threadId;
+    const ackMsgId = await Promise.race([
+        ackIdPromise,
+        new Promise((r) => setTimeout(() => r(null), ACK_TIMEOUT_MS)),
+    ]);
+    if (ackMsgId)
+        opts.telegramAckMessageId = ackMsgId;
+    const result = await sessionManager.sendMessage(sessionName, prompt, opts);
+    meta.state = 'idle';
+    meta.turns = 1;
+    meta.completedAt = new Date().toISOString();
+    meta.output = (result?.output || '').slice(0, 2000);
+    meta.claudeSessionId = result?.sessionId ?? meta.claudeSessionId;
+    try {
+        saveSession(meta);
+    }
+    catch { /* best effort */ }
+    logger.info(`${PLUGIN_TAG} Session ${sessionName} turn 1 complete — idle for ${IDLE_TIMEOUT_MS / 1000}s`);
+    scheduleIdle(key, activeEntry);
+}
+// ── Rehydrate Session ─────────────────────────────────────────────────────
+async function rehydrateSession(meta, chatId, threadId) {
+    const { slug, sessionName, claudeSessionId } = meta;
+    const key = sessionMapKey(chatId, threadId);
+    logger.info(`${PLUGIN_TAG} Rehydrating ${sessionName} with claudeSessionId=${claudeSessionId}...`);
+    await sessionManager.startSession({
+        name: sessionName,
+        cwd: meta.cwd || DEFAULT_CWD,
+        engine: 'claude',
+        permissionMode: 'bypassPermissions',
+        effort: 'high',
+        resumeSessionId: claudeSessionId,
+    });
+    const prevActive = activeSessions.get(key);
+    if (prevActive && prevActive.sessionName !== sessionName) {
+        if (prevActive.idleTimer)
+            clearTimeout(prevActive.idleTimer);
+        try {
+            await sessionManager.stopSession(prevActive.sessionName);
+        }
+        catch { /* ignore */ }
+    }
+    meta.state = 'idle';
+    meta.threadId = threadId;
+    meta.lastContinuedAt = new Date().toISOString();
+    try {
+        saveSession(meta);
+    }
+    catch { /* best effort */ }
+    const activeEntry = { sessionName, slug, meta, idleTimer: null };
+    activeSessions.set(key, activeEntry);
+    logger.info(`${PLUGIN_TAG} Session ${sessionName} resumed — idle for ${IDLE_TIMEOUT_MS / 1000}s`);
+    scheduleIdle(key, activeEntry);
+}
+// ── Continuation Turn ─────────────────────────────────────────────────────
+async function continueTurn(active, prompt, chatId, threadId, ackIdPromise) {
+    const { sessionName, meta } = active;
+    const key = sessionMapKey(chatId, threadId);
+    meta.state = 'running';
+    try {
+        saveSession(meta);
+    }
+    catch { /* best effort */ }
+    const opts = { telegramChatId: chatId };
+    if (threadId)
+        opts.telegramThreadId = threadId;
+    const ackMsgId = await Promise.race([
+        ackIdPromise,
+        new Promise((r) => setTimeout(() => r(null), ACK_TIMEOUT_MS)),
+    ]);
+    if (ackMsgId)
+        opts.telegramAckMessageId = ackMsgId;
+    const result = await sessionManager.sendMessage(sessionName, prompt, opts);
+    meta.state = 'idle';
+    meta.turns = (meta.turns || 1) + 1;
+    meta.lastContinuedAt = new Date().toISOString();
+    meta.output = (result?.output || '').slice(0, 2000);
+    meta.claudeSessionId = result?.sessionId ?? meta.claudeSessionId;
+    try {
+        saveSession(meta);
+    }
+    catch { /* best effort */ }
+    logger.info(`${PLUGIN_TAG} Session ${sessionName} turn ${meta.turns} complete`);
+    scheduleIdle(key, active);
+}
+// ── Idle Timer ────────────────────────────────────────────────────────────
+function scheduleIdle(key, active) {
+    if (active.idleTimer)
+        clearTimeout(active.idleTimer);
+    active.idleTimer = setTimeout(() => {
+        logger.info(`${PLUGIN_TAG} Session ${active.sessionName} idle timeout — stopping`);
+        try {
+            sessionManager
+                ?.stopSession(active.sessionName)
+                .catch((e) => logger.warn(`${PLUGIN_TAG} idle stop error: ${e.message}`));
+        }
+        catch { /* may already be gone */ }
+        activeSessions.delete(key);
+        active.meta.state = 'idle';
+        active.meta.completedAt = new Date().toISOString();
+        try {
+            saveSession(active.meta);
+        }
+        catch { /* best effort */ }
+    }, IDLE_TIMEOUT_MS);
+}
+// ── Warm-Restart Recovery ─────────────────────────────────────────────────
+function recoverSessions() {
+    const now = Date.now();
+    const allSessions = scanAllSessions();
+    let indexDirty = false;
+    for (const meta of allSessions) {
+        if (!meta.id) {
+            meta.id = generateSessionId();
+            sessionIndex[meta.id] = meta.slug;
+            indexDirty = true;
+            try {
+                saveSession(meta);
+            }
+            catch { /* best effort */ }
+            logger.info(`${PLUGIN_TAG} Backfilled session ID ${meta.id} for ${meta.slug}`);
+        }
+        else if (!sessionIndex[meta.id]) {
+            sessionIndex[meta.id] = meta.slug;
+            indexDirty = true;
+        }
+    }
+    if (indexDirty)
+        saveSessionIndex();
+    let recovered = 0;
+    for (const meta of allSessions) {
+        if (!['running', 'idle', 'timed_out'].includes(meta.state))
+            continue;
+        const lastActivity = new Date(meta.lastContinuedAt || meta.completedAt || meta.startedAt).getTime();
+        if (now - lastActivity > RECOVERY_MAX_AGE_MS)
+            continue;
+        if (!meta.claudeSessionId)
+            continue;
+        const recoverKey = sessionMapKey(meta.chatId, meta.threadId);
+        if (activeSessions.has(recoverKey))
+            continue;
+        if (meta.state === 'running') {
+            meta.state = 'interrupted';
+            try {
+                saveSession(meta);
+            }
+            catch { /* best effort */ }
+        }
+        const activeEntry = {
+            sessionName: meta.sessionName,
+            slug: meta.slug,
+            meta,
+            idleTimer: null,
+            needsRehydration: true,
+        };
+        activeSessions.set(recoverKey, activeEntry);
+        recovered++;
+        logger.info(`${PLUGIN_TAG} Recovered session ${meta.slug} for chat ${meta.chatId} thread=${meta.threadId || 'none'} (was ${meta.state === 'interrupted' ? 'running' : 'idle'})`);
+    }
+    if (recovered > 0) {
+        logger.info(`${PLUGIN_TAG} Warm-restart recovery: ${recovered} session(s) restored`);
+    }
+    else {
+        logger.info(`${PLUGIN_TAG} Warm-restart recovery: no recent sessions to restore`);
+    }
+}
+// ── Plugin Object & register() ────────────────────────────────────────────
+/**
+ * Register the cc-handler plugin with the OpenClaw API.
+ * Idempotent: subsequent calls are no-ops (prevents listener stacking).
+ */
+export function register(api) {
+    logger = api.logger || console;
+    defaultRegisterGuard.guard('command-router/cc-handler', api, () => {
+        // ── Read Claude Code plugin config from gateway ──────────────────────
+        const ccConfig = {
+            claudeBin: 'claude',
+            defaultPermissionMode: 'bypassPermissions',
+            defaultEffort: 'high',
+            maxConcurrentSessions: 5,
+            sessionTtlMinutes: 120,
+        };
+        try {
+            const pluginConfigs = api.config?.plugins?.configs ?? {};
+            const ccPluginConfig = pluginConfigs['openclaw-claude-code'] ?? {};
+            if (ccPluginConfig.claudeBin)
+                ccConfig.claudeBin = ccPluginConfig.claudeBin;
+            if (ccPluginConfig.defaultPermissionMode)
+                ccConfig.defaultPermissionMode = ccPluginConfig.defaultPermissionMode;
+            if (ccPluginConfig.defaultEffort)
+                ccConfig.defaultEffort = ccPluginConfig.defaultEffort;
+            if (ccPluginConfig.maxConcurrentSessions)
+                ccConfig.maxConcurrentSessions = ccPluginConfig.maxConcurrentSessions;
+            if (ccPluginConfig.sessionTtlMinutes)
+                ccConfig.sessionTtlMinutes = ccPluginConfig.sessionTtlMinutes;
+        }
+        catch {
+            logger.warn(`${PLUGIN_TAG} Could not read openclaw-claude-code config — using defaults`);
+        }
+        loadBotToken();
+        // ── Lifecycle service ────────────────────────────────────────────────
+        api.registerService({
+            id: 'telegram-cc-handler',
+            start: async () => {
+                logger.info(`${PLUGIN_TAG} Initialising SessionManager...`);
+                loadSessionIndex();
+                try {
+                    // TODO(P2): refine import type when full plugin types land
+                    const mod = await import(CC_PLUGIN_PATH);
+                    const SessionManager = mod.SessionManager ??
+                        mod.default?.SessionManager;
+                    if (!SessionManager) {
+                        logger.error(`${PLUGIN_TAG} SessionManager class not found — plugin inactive`);
+                        return;
+                    }
+                    // ── Prevent orphan-cleanup race ───────────────────────────────────
+                    // The vendored SessionManager runs `_cleanupOrphanedPids` in its
+                    // constructor — reads the shared session-pids.json and kills any
+                    // alive PID listed there. In our gateway, TWO SessionManagers are
+                    // constructed: the eagerManager in cwd-patch.ts (for openai-compat)
+                    // and this one (for /cc commands). The second construction's
+                    // cleanup mistakes the first manager's prewarm session for an
+                    // orphan and kills it, defeating the cold-start prewarm.
+                    //
+                    // Fix: make this second SessionManager's cleanup a no-op. The
+                    // eagerManager (first to construct) already did the legitimate
+                    // post-crash cleanup at boot. Any further cleanup would only kill
+                    // peer-manager processes in the same gateway lifetime.
+                    const _ProtoSM = SessionManager.prototype;
+                    if (_ProtoSM._cleanupOrphanedPids && !_ProtoSM._cleanupOrphanedPids_orig) {
+                        _ProtoSM._cleanupOrphanedPids_orig = _ProtoSM._cleanupOrphanedPids;
+                        _ProtoSM._cleanupOrphanedPids = function () {
+                            // no-op; eagerManager handles cleanup at boot
+                        };
+                        logger.info(`${PLUGIN_TAG} SessionManager._cleanupOrphanedPids no-oped (peer-manager protection)`);
+                    }
+                    sessionManager = new SessionManager(ccConfig);
+                    logger.info(`${PLUGIN_TAG} SessionManager ready — /cc commands active`);
+                    recoverSessions();
+                }
+                catch (err) {
+                    logger.error(`${PLUGIN_TAG} Failed to init SessionManager: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            },
+            stop: () => {
+                for (const [, active] of activeSessions) {
+                    if (active.idleTimer)
+                        clearTimeout(active.idleTimer);
+                }
+                activeSessions.clear();
+                if (sessionManager) {
+                    sessionManager
+                        .shutdown()
+                        .catch((e) => logger.warn(`${PLUGIN_TAG} shutdown error: ${e.message}`));
+                    sessionManager = null;
+                }
+                logger.info(`${PLUGIN_TAG} Stopped`);
+            },
+        });
+        // ── before_dispatch hook ─────────────────────────────────────────────
+        const ccInnerHandler = async (event, ctx) => {
+            if (event.channel !== 'telegram')
+                return undefined;
+            const content = (typeof event.content === 'string' ? event.content : '').trim();
+            const senderId = typeof event.senderId === 'string' ? event.senderId : '';
+            const rawConvId = (ctx.conversationId || '').replace(/^telegram:/i, '');
+            const topicMatch = rawConvId.match(/^(-?\d+):topic:(\d+)$/);
+            const chatId = topicMatch
+                ? topicMatch[1]
+                : /^-?\d+$/.test(rawConvId)
+                    ? rawConvId
+                    : senderId;
+            const threadId = topicMatch ? topicMatch[2] : undefined;
+            logger.info(`${PLUGIN_TAG} target: conv=${ctx.conversationId || 'empty'} chat=${chatId} thread=${threadId || 'none'} sender=${senderId} group=${event.isGroup}`);
+            // /cc+ <prompt>
+            const ccPlusMatch = content.match(/^\/cc\+\s*([\s\S]+)/i);
+            if (ccPlusMatch) {
+                const prompt = ccPlusMatch[1].trim();
+                if (!prompt)
+                    return { handled: true, text: 'Usage: /cc+ <prompt>' };
+                return handleContinuation(prompt, chatId, threadId);
+            }
+            if (!content.match(/^\/cc(\s|$)/i))
+                return undefined;
+            const afterCc = content.slice(3).trim();
+            const continueMatch = afterCc.match(/^continue\s+([\s\S]+)/i);
+            if (continueMatch) {
+                const prompt = continueMatch[1].trim();
+                if (!prompt)
+                    return { handled: true, text: 'Usage: /cc continue <prompt>' };
+                return handleContinuation(prompt, chatId, threadId);
+            }
+            if (afterCc.toLowerCase() === 'stop') {
+                return handleStop(chatId, threadId);
+            }
+            const resumeMatch = afterCc.match(/^resume(?:\s+(.+))?$/i);
+            if (resumeMatch) {
+                const targetSlug = (resumeMatch[1] || '').trim() || null;
+                return handleResume(chatId, threadId, targetSlug);
+            }
+            if (afterCc.toLowerCase() === 'status') {
+                return handleStatus(chatId, threadId);
+            }
+            if (afterCc.toLowerCase() === 'list') {
+                return handleList(chatId, threadId);
+            }
+            const prompt = afterCc;
+            if (!prompt) {
+                return {
+                    handled: true,
+                    text: [
+                        'Usage:',
+                        '  /cc <prompt> — new session',
+                        '  /cc+ <prompt> — continue',
+                        '  /cc status — check active',
+                        '  /cc stop — halt session',
+                        '  /cc resume [id|slug] — resume previous',
+                        '  /cc list — show resumable sessions',
+                    ].join('\n'),
+                };
+            }
+            if (!sessionManager) {
+                return {
+                    handled: true,
+                    text: 'Claude Code handler not ready — try again in a few seconds.',
+                };
+            }
+            const slug = makeSlug(prompt);
+            const sessionId = generateSessionId();
+            const sessionName = `cc-${slug}`;
+            logger.info(`${PLUGIN_TAG} /cc claimed: id=${sessionId} slug=${slug} sender=${senderId} chat=${chatId}`);
+            const meta = {
+                id: sessionId,
+                slug,
+                sessionName,
+                chatId,
+                threadId,
+                senderId,
+                state: 'starting',
+                instruction: prompt,
+                turns: 0,
+                startedAt: new Date().toISOString(),
+                completedAt: null,
+                lastContinuedAt: null,
+                claudeSessionId: null,
+                output: null,
+                error: null,
+            };
+            try {
+                saveSession(meta);
+            }
+            catch (err) {
+                logger.error(`${PLUGIN_TAG} Failed to save session meta: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            let resolveAckId;
+            const ackIdPromise = new Promise((r) => {
+                resolveAckId = r;
+            });
+            const launchKey = sessionMapKey(chatId, threadId);
+            launchSession(sessionName, prompt, slug, meta, chatId, threadId, ackIdPromise).catch((err) => {
+                logger.error(`${PLUGIN_TAG} Session ${sessionName} failed: ${err.message}`);
+                try {
+                    const isTimeout = /timeout/i.test(err.message);
+                    meta.state = isTimeout ? 'timed_out' : 'failed';
+                    meta.error = err.message;
+                    meta.completedAt = new Date().toISOString();
+                    saveSession(meta);
+                }
+                catch { /* best effort */ }
+                const active = activeSessions.get(launchKey);
+                if (active?.sessionName === sessionName) {
+                    if (active.idleTimer)
+                        clearTimeout(active.idleTimer);
+                    activeSessions.delete(launchKey);
+                }
+            });
+            return {
+                handled: true,
+                text: `⏳ [${sessionId}] ${slug} — starting Claude Code session...`,
+                _resolveAckId: resolveAckId,
+            };
+        };
+        api.on('before_dispatch', async (...args) => {
+            const event = args[0];
+            const ctx = args[1];
+            const result = await ccInnerHandler(event, ctx);
+            if (!result?.handled)
+                return result;
+            if (event && typeof event === 'object')
+                event.content = '';
+            if (result.text && BOT_TOKEN) {
+                const convId = (ctx.conversationId || '').replace(/^telegram:/i, '');
+                const tm = convId.match(/^(-?\d+):topic:(\d+)$/);
+                const ackChat = tm
+                    ? tm[1]
+                    : /^-?\d+$/.test(convId)
+                        ? convId
+                        : event.senderId || '';
+                const ackThread = tm ? tm[2] : undefined;
+                logger.info(`${PLUGIN_TAG} direct-send ack to chat=${ackChat} thread=${ackThread || 'none'}`);
+                const ackMessageId = await sendDirectReply(ackChat, ackThread, result.text);
+                if (result._resolveAckId) {
+                    result._resolveAckId(ackMessageId ?? null);
+                }
+            }
+            else if (result._resolveAckId) {
+                result._resolveAckId(null);
+            }
+            return { handled: true, text: '' };
+        });
+        logger.info(`${PLUGIN_TAG} before_dispatch hook registered (/cc, /cc+, /cc stop, /cc resume, /cc status, /cc list)`);
+    }); // end defaultRegisterGuard.guard
+}
+// Default export compatible with the original plugin object shape
+export default { id: 'telegram-cc-handler', name: 'Telegram /cc Handler', register };
+//# sourceMappingURL=cc-handler.js.map