cli-claw-kit 0.0.1

package/dist/channel-prefixes.js

@@ -0,0 +1,16 @@
+/** IM channel type → JID prefix mapping. Shared between main server and agent-runner. */
+export const CHANNEL_PREFIXES = {
+    feishu: 'feishu:',
+    telegram: 'telegram:',
+    qq: 'qq:',
+    wechat: 'wechat:',
+    dingtalk: 'dingtalk:',
+};
+/** Determine the channel type from a JID string. Returns 'web' for unrecognized prefixes. */
+export function getChannelFromJid(jid) {
+    for (const [type, prefix] of Object.entries(CHANNEL_PREFIXES)) {
+        if (jid.startsWith(prefix))
+            return type;
+    }
+    return 'web';
+}

package/dist/cli.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import { pathToFileURL } from 'node:url';
+const HELP_TEXT = [
+    'Usage: cli-claw <command>',
+    '',
+    'Commands:',
+    '  start',
+    '  version',
+    '  help',
+    '',
+    'Options:',
+    '  -h, --help',
+    '  -v, --version',
+].join('\n');
+function readPackageVersion() {
+    const packagePath = new URL('../package.json', import.meta.url);
+    const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+    return packageJson.version ?? '0.0.0';
+}
+export function parseCliArgs(argv) {
+    const [firstArg] = argv;
+    switch (firstArg) {
+        case undefined:
+        case 'help':
+        case '-h':
+        case '--help':
+            return { command: 'help' };
+        case 'start':
+            return { command: 'start' };
+        case 'version':
+        case '-v':
+        case '--version':
+            return { command: 'version' };
+        default:
+            return { command: 'help' };
+    }
+}
+export function formatHelpText(_version) {
+    return HELP_TEXT;
+}
+async function loadBackendStart() {
+    const mod = (await import('./index.js'));
+    const candidate = mod.startCliClaw ?? mod.start ?? mod.main ?? mod.runCliClaw ?? mod.default;
+    if (typeof candidate !== 'function') {
+        throw new Error('cli-claw backend start export is unavailable; expected a callable start function from src/index.ts');
+    }
+    return candidate;
+}
+export async function runCli(argv, deps = {}) {
+    const parsed = parseCliArgs(argv);
+    const version = deps.version ?? readPackageVersion();
+    const stdout = deps.stdout ?? ((line) => console.log(line));
+    const stderr = deps.stderr ?? ((line) => console.error(line));
+    if (parsed.command === 'version') {
+        stdout(version);
+        return 0;
+    }
+    if (parsed.command === 'help') {
+        stdout(formatHelpText(version));
+        return 0;
+    }
+    try {
+        const start = deps.start ?? (await loadBackendStart());
+        await start();
+        return 0;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        stderr(message);
+        return 1;
+    }
+}
+export async function main(argv = process.argv.slice(2)) {
+    const exitCode = await runCli(argv);
+    if (exitCode !== 0) {
+        process.exitCode = exitCode;
+    }
+}
+if (process.argv[1] &&
+    import.meta.url === pathToFileURL(process.argv[1]).href) {
+    void main().catch((error) => {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exitCode = 1;
+    });
+}

package/dist/commands.js

@@ -0,0 +1,79 @@
+/**
+ * Slash command handler — intercepts text commands (e.g. /clear) before they
+ * enter the normal message pipeline.
+ */
+import crypto from 'crypto';
+import fs from 'fs';
+import path from 'path';
+import { deleteSession, getJidsByFolder, storeMessageDirect, ensureChatExists, } from './db.js';
+import { DATA_DIR } from './config.js';
+import { logger } from './logger.js';
+// ─── Session file cleanup (mirrors groups.ts clearSessionJsonlFiles) ────
+function clearSessionFiles(folder, agentId) {
+    const claudeDir = agentId
+        ? path.join(DATA_DIR, 'sessions', folder, 'agents', agentId, '.claude')
+        : path.join(DATA_DIR, 'sessions', folder, '.claude');
+    if (!fs.existsSync(claudeDir))
+        return;
+    const keep = new Set(['settings.json']);
+    const entries = fs.readdirSync(claudeDir);
+    for (const entry of entries) {
+        if (keep.has(entry))
+            continue;
+        try {
+            fs.rmSync(path.join(claudeDir, entry), { recursive: true, force: true });
+        }
+        catch (err) {
+            logger.warn({ entry, folder, agentId, err }, 'Failed to remove session file, skipping');
+        }
+    }
+}
+// ─── Core reset ─────────────────────────────────────────────────
+export async function executeSessionReset(baseChatJid, folder, deps, agentId) {
+    const targetJid = agentId ? `${baseChatJid}#agent:${agentId}` : baseChatJid;
+    if (agentId) {
+        // Agent-specific reset: only stop the agent's virtual JID process
+        await deps.queue.stopGroup(targetJid, { force: true });
+    }
+    else {
+        // Main session reset: stop all processes for this folder
+        const siblingJids = getJidsByFolder(folder);
+        await Promise.all(siblingJids.map((j) => deps.queue.stopGroup(j, { force: true })));
+    }
+    // 2. Clear .claude/ session files (preserve settings.json)
+    clearSessionFiles(folder, agentId);
+    // 3. Delete session from DB (+ in-memory cache for main session)
+    deleteSession(folder, agentId);
+    if (!agentId) {
+        delete deps.sessions[folder];
+    }
+    // 4. Insert context_reset divider message into the correct JID
+    const dividerMessageId = crypto.randomUUID();
+    const timestamp = new Date().toISOString();
+    ensureChatExists(targetJid);
+    storeMessageDirect(dividerMessageId, targetJid, '__system__', 'system', 'context_reset', timestamp, true);
+    deps.broadcast(targetJid, {
+        id: dividerMessageId,
+        chat_jid: targetJid,
+        sender: '__system__',
+        sender_name: 'system',
+        content: 'context_reset',
+        timestamp,
+        is_from_me: true,
+    });
+    // 5. Advance lastAgentTimestamp so old messages before the reset are not
+    //    re-sent to the next fresh agent session.
+    if (agentId) {
+        deps.setLastAgentTimestamp(targetJid, { timestamp, id: dividerMessageId });
+    }
+    else {
+        const siblingJids = getJidsByFolder(folder);
+        for (const siblingJid of siblingJids) {
+            deps.setLastAgentTimestamp(siblingJid, {
+                timestamp,
+                id: dividerMessageId,
+            });
+        }
+    }
+    logger.info({ baseChatJid, targetJid, folder, agentId }, 'Session reset via /clear command');
+}

package/dist/config.js

@@ -0,0 +1,120 @@
+import path from 'path';
+import fs from 'fs';
+import crypto from 'crypto';
+import os from 'os';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { APP_ROOT } from './app-root.js';
+export const ASSISTANT_NAME = process.env.ASSISTANT_NAME || 'cli-claw';
+export const POLL_INTERVAL = 2000;
+export const SCHEDULER_POLL_INTERVAL = 60000;
+// Mount security: allowlist in project config/ directory
+export const MOUNT_ALLOWLIST_PATH = path.resolve(APP_ROOT, 'config', 'mount-allowlist.json');
+export const DATA_DIR = path.join(os.homedir(), '.cli-claw');
+export const STORE_DIR = path.join(DATA_DIR, 'db');
+export const GROUPS_DIR = path.join(DATA_DIR, 'groups');
+export const MAIN_GROUP_FOLDER = 'main';
+export const CONTAINER_IMAGE = process.env.CONTAINER_IMAGE || 'cli-claw-agent:latest';
+// Timezone for scheduled tasks (cron expressions, etc.)
+// Uses TZ env var with Asia/Shanghai fallback
+export const TIMEZONE = process.env.TZ ||
+    Intl.DateTimeFormat().resolvedOptions().timeZone ||
+    'Asia/Shanghai';
+// Web server configuration
+export const WEB_PORT = parseInt(process.env.WEB_PORT || '3000', 10);
+// Cookie configuration
+// When accessed over HTTPS: use __Host- prefix (requires Secure; Path=/; no Domain)
+// When accessed over HTTP (localhost dev or no TLS): use plain name
+// Determined per-request via isSecureRequest(), not at startup
+export const SESSION_COOKIE_NAME_SECURE = '__Host-cli-claw-session';
+export const SESSION_COOKIE_NAME_PLAIN = 'cli-claw-session';
+const SESSION_SECRET_FILE = path.join(DATA_DIR, 'config', 'session-secret.key');
+function getOrCreateSessionSecret() {
+    // 1. Environment variable (highest priority — allows container/operator override)
+    if (process.env.WEB_SESSION_SECRET) {
+        return process.env.WEB_SESSION_SECRET;
+    }
+    // 2. File-persisted secret (survives restarts)
+    try {
+        if (fs.existsSync(SESSION_SECRET_FILE)) {
+            const stored = fs.readFileSync(SESSION_SECRET_FILE, 'utf-8').trim();
+            if (stored)
+                return stored;
+        }
+    }
+    catch {
+        // ignore read errors, fall through
+    }
+    // 3. Generate and persist
+    const generated = crypto.randomBytes(32).toString('hex');
+    try {
+        fs.mkdirSync(path.dirname(SESSION_SECRET_FILE), { recursive: true });
+        fs.writeFileSync(SESSION_SECRET_FILE, generated + '\n', {
+            encoding: 'utf-8',
+            mode: 0o600,
+        });
+    }
+    catch {
+        // non-fatal: secret works for this process, just won't survive restart
+    }
+    return generated;
+}
+export const WEB_SESSION_SECRET = getOrCreateSessionSecret();
+// Ensure WeChat iLink API domains bypass HTTP proxy.
+// These Chinese domestic services are unreachable through most overseas proxies.
+const WECHAT_NO_PROXY_DOMAINS = [
+    'ilinkai.weixin.qq.com',
+    'novac2c.cdn.weixin.qq.com',
+];
+/** Add or remove WeChat domains from NO_PROXY based on bypassProxy flag. */
+export function updateWeChatNoProxy(bypassProxy) {
+    const current = process.env.NO_PROXY || process.env.no_proxy || '';
+    const existing = new Set(current
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean));
+    if (bypassProxy) {
+        const toAdd = WECHAT_NO_PROXY_DOMAINS.filter((d) => !existing.has(d));
+        if (toAdd.length) {
+            const updated = current
+                ? `${current},${toAdd.join(',')}`
+                : toAdd.join(',');
+            process.env.NO_PROXY = updated;
+            process.env.no_proxy = updated;
+        }
+    }
+    else {
+        for (const d of WECHAT_NO_PROXY_DOMAINS)
+            existing.delete(d);
+        const updated = [...existing].join(',');
+        process.env.NO_PROXY = updated;
+        process.env.no_proxy = updated;
+    }
+}
+/** Check if WeChat domains are currently in NO_PROXY. */
+export function isWeChatBypassingProxy() {
+    const current = process.env.NO_PROXY || process.env.no_proxy || '';
+    const existing = new Set(current
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean));
+    return WECHAT_NO_PROXY_DOMAINS.every((d) => existing.has(d));
+}
+// Proxy trust configuration
+// Set TRUST_PROXY=true when behind a reverse proxy (nginx, Cloudflare, etc.)
+export const TRUST_PROXY = process.env.TRUST_PROXY === 'true';
+// Docker availability check (cached for the lifetime of the process)
+const execFileAsync = promisify(execFile);
+let _dockerAvailable = null;
+export async function isDockerAvailable() {
+    if (_dockerAvailable !== null)
+        return _dockerAvailable;
+    try {
+        await execFileAsync('docker', ['info'], { timeout: 10000 });
+        _dockerAvailable = true;
+    }
+    catch {
+        _dockerAvailable = false;
+    }
+    return _dockerAvailable;
+}