@geminilight/mindos 0.6.69 → 0.6.70

package/bin/commands/channel.js

@@ -0,0 +1,342 @@
+/**
+ * mindos channel — Manage IM platform configurations
+ * 
+ * OpenClaw-inspired design:
+ * - verb-noun pattern (add, remove, list, verify)
+ * - Progressive disclosure (help → subcommand → details)
+ * - Platform abstraction layer
+ * - Secure credential handling
+ */
+
+import { bold, dim, cyan, green, red, yellow } from '../lib/colors.js';
+import {
+  channelList,
+  channelAdd,
+  channelRemove,
+  channelVerify,
+  formatPlatformStatus,
+  getPlatformEmoji,
+} from '../lib/channel-mgmt.js';
+import {
+  promptHidden,
+  promptConfirm,
+  closePrompts,
+} from '../lib/channel-prompts.js';
+import {
+  validateFieldFormat,
+  getRequiredFields,
+  getFieldHelp,
+} from '../lib/channel-validate.js';
+import { CHANNEL_PLATFORMS } from '../lib/channel-constants.js';
+
+export const meta = {
+  name: 'channel',
+  group: 'IM Integration',
+  summary: 'Manage IM platform configurations',
+  usage: 'mindos channel [command]',
+  flags: {
+    '--skip-verify': 'Skip remote credential verification and only save/validate format',
+  },
+  examples: [
+    'mindos channel list',
+    'mindos channel add telegram',
+    'mindos channel add telegram --skip-verify',
+    'mindos channel verify discord',
+    'mindos channel remove feishu',
+  ],
+};
+
+// ────────────────────────────────────────────────────────────────────────────
+// MAIN ENTRY
+// ────────────────────────────────────────────────────────────────────────────
+
+export const run = async (args, flags) => {
+  const sub = args[0];
+
+  try {
+    switch (sub) {
+      case 'list':
+        await handleList(flags);
+        break;
+
+      case 'add':
+        await handleAdd(args[1], flags);
+        break;
+
+      case 'remove':
+      case 'rm':
+        await handleRemove(args[1], flags);
+        break;
+
+      case 'verify':
+      case 'test':
+        await handleVerify(args[1], flags);
+        break;
+
+      case undefined:
+      case 'help':
+      case '--help':
+      case '-h':
+        printHelp();
+        break;
+
+      default:
+        console.error(red(`Unknown subcommand: ${sub}`));
+        console.log();
+        printHelp();
+        process.exit(1);
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(red(`✗ Error: ${msg}`));
+    process.exit(1);
+  } finally {
+    closePrompts();
+  }
+};
+
+// ────────────────────────────────────────────────────────────────────────────
+// SUBCOMMAND HANDLERS
+// ────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Handler: list
+ */
+async function handleList(flags) {
+  console.log();
+  console.log(bold('Configured IM Platforms'));
+  console.log();
+
+  const result = await channelList();
+  
+  if (result.platforms.every((p) => p.status === 'not_configured')) {
+    console.log(dim('No IM platforms configured.'));
+    console.log();
+    console.log('Get started:');
+    console.log(`  ${cyan('mindos channel add telegram')}`);
+    console.log(`  ${cyan('mindos channel add discord')}`);
+    console.log(`  ${cyan('mindos channel add feishu')}`);
+    console.log();
+    return;
+  }
+
+  // Display table
+  result.platforms.forEach((platform) => {
+    const emoji = getPlatformEmoji(platform.platform);
+    const status = formatPlatformStatus(platform.status);
+    const name = platform.platform.padEnd(12);
+
+    let statusStr = '';
+    if (platform.status === 'configured') {
+      statusStr = `${green(status)} configured`;
+      if (platform.botName) {
+        statusStr += ` (${platform.botName})`;
+      }
+    } else if (platform.status === 'incomplete') {
+      statusStr = `${yellow(status)} incomplete`;
+      if (platform.missingFields) {
+        statusStr += ` (missing ${platform.missingFields.join(', ')})`;
+      }
+    } else {
+      statusStr = `${dim(status)} not configured`;
+    }
+
+    console.log(`  ${emoji} ${cyan(name)} ${statusStr}`);
+  });
+
+  console.log();
+  console.log(dim(`Run 'mindos channel add <platform>' to configure`));
+  console.log();
+}
+
+/**
+ * Handler: add <platform>
+ * @param {string} platform - Platform name
+ * @param {Object} flags - CLI flags
+ */
+async function handleAdd(platform, flags) {
+  if (!platform) {
+    console.error(red('Usage: mindos channel add <platform>'));
+    console.log(dim('  Supported: telegram, discord, feishu, slack, wecom, dingtalk, wechat, qq'));
+    process.exit(1);
+  }
+
+  if (!CHANNEL_PLATFORMS.includes(platform)) {
+    console.error(red(`Unknown platform: ${platform}`));
+    console.log(dim(`  Supported: ${CHANNEL_PLATFORMS.join(', ')}`));
+    process.exit(1);
+  }
+
+  console.log();
+  console.log(bold(`Configuring ${platform} platform`));
+  console.log();
+
+  // Prompt for credentials
+  /** @type {Record<string, string>} */
+  const credentials = {};
+  const requiredFields = getRequiredFields(platform);
+
+  for (const field of requiredFields) {
+    const help = getFieldHelp(platform, field);
+    if (help) {
+      console.log(dim(`Tip: ${help}`));
+    }
+
+    let attempts = 0;
+    const maxAttempts = 3;
+
+    while (attempts < maxAttempts) {
+      const prompt = field === 'bot_token' ? `Enter ${field} (hidden): ` : `Enter ${field}: `;
+      const value = await promptHidden(prompt);
+
+      const validation = validateFieldFormat(platform, field, value);
+      if (!validation.valid) {
+        console.log(red(`✗ ${validation.error}`));
+        attempts++;
+        continue;
+      }
+
+      credentials[field] = value;
+      break;
+    }
+
+    if (attempts >= maxAttempts) {
+      console.log(red(`✗ Too many invalid attempts for ${field}`));
+      console.log();
+      return;
+    }
+  }
+
+  // Verify and save
+  console.log();
+  console.log(`${yellow('⏳')} Verifying ${platform} credentials...`);
+
+  const result = await channelAdd(platform, credentials, { skipVerify: flags['skip-verify'] === true });
+
+  console.log();
+  if (result.ok) {
+    console.log(green(`✔ ${result.message}`));
+    if (result.details?.botName) {
+      console.log(`  Bot name: ${result.details.botName}`);
+    }
+    if (result.details?.botId) {
+      console.log(`  Bot ID: ${result.details.botId}`);
+    }
+    console.log();
+    console.log(dim(`You can now use ${platform} with MindOS agents.`));
+  } else {
+    console.log(red(`✗ ${result.message}`));
+    if (result.error) {
+      console.log(`  Error: ${result.error}`);
+    }
+  }
+  console.log();
+}
+
+/**
+ * Handler: remove <platform>
+ * @param {string} platform - Platform name
+ * @param {Object} flags - CLI flags
+ */
+async function handleRemove(platform, flags) {
+  if (!platform) {
+    console.error(red('Usage: mindos channel remove <platform>'));
+    process.exit(1);
+  }
+
+  console.log();
+  console.log(bold(`Remove ${platform} configuration`));
+  console.log(yellow(`⚠️  This action cannot be undone.`));
+  console.log();
+
+  const confirmed = await promptConfirm(`Remove ${platform} configuration?`);
+  if (!confirmed) {
+    console.log(dim('Aborted.'));
+    console.log();
+    return;
+  }
+
+  const result = await channelRemove(platform);
+
+  console.log();
+  if (result.ok) {
+    console.log(green(`✔ ${result.message}`));
+  } else {
+    console.log(red(`✗ ${result.message}`));
+    if (result.error) {
+      console.log(`  Error: ${result.error}`);
+    }
+  }
+  console.log();
+}
+
+/**
+ * Handler: verify <platform>
+ * @param {string} platform - Platform name
+ * @param {Object} flags - CLI flags
+ */
+async function handleVerify(platform, flags) {
+  if (!platform) {
+    console.error(red('Usage: mindos channel verify <platform>'));
+    process.exit(1);
+  }
+
+  console.log();
+  console.log(`${yellow('⏳')} Verifying ${platform} configuration...`);
+
+  const result = await channelVerify(platform, { skipVerify: flags['skip-verify'] === true });
+
+  console.log();
+  if (result.valid) {
+    console.log(green(`✔ ${result.message}`));
+    if (result.details?.botName) {
+      console.log(`  Bot name: ${result.details.botName}`);
+    }
+    if (result.details?.botId) {
+      console.log(`  Bot ID: ${result.details.botId}`);
+    }
+    if (result.details?.status) {
+      console.log(`  Status: ${result.details.status}`);
+    }
+  } else {
+    console.log(red(`✗ ${result.message}`));
+    if (result.error) {
+      console.log(`  Error: ${result.error}`);
+    }
+  }
+  console.log();
+}
+
+// ────────────────────────────────────────────────────────────────────────────
+// HELP TEXT
+// ────────────────────────────────────────────────────────────────────────────
+
+function printHelp() {
+  const row = (c, d) => `  ${cyan(c.padEnd(32))}${dim(d)}`;
+
+  console.log(`
+${bold('mindos channel')} — Manage IM platform configurations
+
+${bold('USAGE')}
+  ${cyan('mindos channel [command]')}
+
+${bold('COMMANDS')}
+${row('mindos channel list', 'Show configured platforms')}
+${row('mindos channel add <platform>', 'Add/update platform config')}
+${row('mindos channel remove <platform>', 'Remove platform config')}
+${row('mindos channel verify <platform>', 'Test platform credentials')}
+
+${bold('PLATFORMS SUPPORTED')}
+  ${CHANNEL_PLATFORMS.join(', ')}
+
+${bold('EXAMPLES')}
+  ${dim('mindos channel list')}
+  ${dim('mindos channel add telegram')}
+  ${dim('mindos channel add telegram --skip-verify')}
+  ${dim('mindos channel verify discord')}
+  ${dim('mindos channel verify discord --skip-verify')}
+  ${dim('mindos channel remove feishu')}
+
+${dim('Run "mindos channel <command> --help" for details on any command.')}
+`);
+}

package/bin/commands/update.js

@@ -11,6 +11,7 @@ import { dirname, resolve } from 'node:path';
 import { ROOT, BUILD_STAMP, CONFIG_PATH, LOG_PATH, MINDOS_DIR } from '../lib/constants.js';
 import { bold, dim, cyan, green, red, yellow } from '../lib/colors.js';
 import { execInherited } from '../lib/shell.js';
+import { safeRmSync, assertNotSymlink } from '../lib/safe-rm.js';
 import { EXIT } from '../lib/command.js';
 import { stopMindos } from '../lib/stop.js';
 import { getLocalIP } from '../lib/startup.js';
@@ -77,10 +78,16 @@ function buildIfNeeded(newRoot) {
   if (existsSync(appPkg)) {
     execInherited('npm install', resolve(newRoot, 'app'));
   }
-  const nextDir = resolve(newRoot, 'app', '.next');
-  if (existsSync(nextDir)) {
-    rmSync(nextDir, { recursive: true, force: true });
-  }
+    const nextDir = resolve(newRoot, 'app', '.next');
+    if (existsSync(nextDir)) {
+      try {
+        assertNotSymlink(nextDir);
+        safeRmSync(nextDir, { recursive: true, force: true });
+      } catch (err) {
+        console.error(red(`Failed to clean .next directory: ${err}`));
+        throw err;
+      }
+    }
   execInherited('node scripts/gen-renderer-index.js', newRoot);
   execInherited(`${newNextBin} build`, resolve(newRoot, 'app'));
   const version = JSON.parse(readFileSync(resolve(newRoot, 'package.json'), 'utf-8')).version;

package/bin/lib/build.js

@@ -5,6 +5,7 @@ import { resolve } from 'node:path';
 import { ROOT, BUILD_STAMP, DEPS_STAMP, STANDALONE_SERVER, STANDALONE_STAMP } from './constants.js';
 import { red, dim, yellow } from './colors.js';
 import { execInherited as run, npmInstall } from './shell.js';
+import { safeRmSync, assertNotSymlink } from './safe-rm.js';
 
 export function needsBuild() {
   // Prefer prebuilt standalone shipped with the npm package.
@@ -37,14 +38,25 @@ export function writeBuildStamp() {
 export function clearBuildLock() {
   const lockFile = resolve(ROOT, 'app', '.next', 'lock');
   if (existsSync(lockFile)) {
-    rmSync(lockFile, { force: true });
+    try {
+      assertNotSymlink(lockFile);
+      rmSync(lockFile, { force: true });
+    } catch (err) {
+      console.warn(`Warning: Failed to clear build lock: ${err}`);
+    }
   }
 }
 
 export function cleanNextDir() {
   const nextDir = resolve(ROOT, 'app', '.next');
   if (existsSync(nextDir)) {
-    rmSync(nextDir, { recursive: true, force: true });
+    try {
+      assertNotSymlink(nextDir);
+      safeRmSync(nextDir, { recursive: true, force: true });
+    } catch (err) {
+      console.error(red(`Failed to clean .next directory: ${err}`));
+      throw err;
+    }
   }
 }
 
@@ -140,23 +152,29 @@ export function ensureAppDeps({ force = false } = {}) {
   console.log(yellow(label));
   npmInstall(resolve(ROOT, 'app'), '--no-workspaces');
 
-  // Verify critical deps — npm tar extraction can silently fail (ENOENT race)
-  if (!verifyDeps()) {
-    console.log(yellow('Some dependencies are incomplete, retrying with clean install...\n'));
-    const nm = resolve(ROOT, 'app', 'node_modules');
-    rmSync(nm, { recursive: true, force: true });
-    run('npm install --no-workspaces', resolve(ROOT, 'app'));
+    // Verify critical deps — npm tar extraction can silently fail (ENOENT race)
     if (!verifyDeps()) {
-      console.error(red('\n✘ Failed to install dependencies after retry.\n'));
-      const appDir = resolve(ROOT, 'app');
-      if (process.platform === 'win32') {
-        console.error(`  Try manually: cd "${appDir}" && rmdir /s /q node_modules && npm install`);
-      } else {
-        console.error(`  Try manually: cd ${appDir} && rm -rf node_modules && npm install`);
+      console.log(yellow('Some dependencies are incomplete, retrying with clean install...\n'));
+      const nm = resolve(ROOT, 'app', 'node_modules');
+      try {
+        assertNotSymlink(nm);
+        safeRmSync(nm, { recursive: true, force: true });
+      } catch (err) {
+        console.error(red(`SECURITY: Failed to verify safe deletion of node_modules: ${err}`));
+        process.exit(1);
+      }
+      run('npm install --no-workspaces', resolve(ROOT, 'app'));
+      if (!verifyDeps()) {
+        console.error(red('\n✘ Failed to install dependencies after retry.\n'));
+        const appDir = resolve(ROOT, 'app');
+        if (process.platform === 'win32') {
+          console.error(`  Try manually: cd "${appDir}" && rmdir /s /q node_modules && npm install`);
+        } else {
+          console.error(`  Try manually: cd ${appDir} && rm -rf node_modules && npm install`);
+        }
+        process.exit(1);
       }
-      process.exit(1);
     }
-  }
 
   writeDepsStamp();
 }

package/bin/lib/channel-config.js

@@ -0,0 +1,168 @@
+/**
+ * Channel Configuration - Pure JavaScript
+ * Owns all read/write of ~/.mindos/im.json
+ * No TypeScript imports (CLI bootstrap safety)
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { CHANNEL_FIELD_PATTERNS, CHANNEL_REQUIRED_FIELDS } from './channel-constants.js';
+
+const IM_CONFIG_DIR = path.join(os.homedir(), '.mindos');
+const IM_CONFIG_PATH = path.join(IM_CONFIG_DIR, 'im.json');
+
+const EMPTY_CONFIG = { providers: {} };
+
+let cachedConfig = EMPTY_CONFIG;
+let cachedMtime = 0;
+
+/**
+ * Read IM config from ~/.mindos/im.json
+ * Implements mtime-based caching (same as app/lib/im/config.ts)
+ * @returns {Record<string, any>}
+ */
+export function readChannelConfig() {
+  let mtime = 0;
+  try {
+    mtime = fs.statSync(IM_CONFIG_PATH).mtimeMs;
+  } catch {
+    return EMPTY_CONFIG;
+  }
+
+  if (mtime > 0 && mtime === cachedMtime) {
+    return cachedConfig;
+  }
+
+  if (!fs.existsSync(IM_CONFIG_PATH)) {
+    cachedConfig = EMPTY_CONFIG;
+    cachedMtime = 0;
+    return EMPTY_CONFIG;
+  }
+
+  try {
+    const raw = fs.readFileSync(IM_CONFIG_PATH, 'utf-8');
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== 'object' || typeof parsed.providers !== 'object') {
+      console.warn('[channel] im.json has invalid structure, using empty config');
+      cachedConfig = EMPTY_CONFIG;
+    } else {
+      cachedConfig = parsed;
+    }
+    cachedMtime = mtime;
+    return cachedConfig;
+  } catch (err) {
+    console.warn('[channel] Failed to parse im.json:', err instanceof Error ? err.message : err);
+    cachedConfig = EMPTY_CONFIG;
+    cachedMtime = 0;
+    return EMPTY_CONFIG;
+  }
+}
+
+/**
+ * Write IM config atomically
+ * Sets 0o600 permissions on Unix
+ * @param {Record<string, any>} config
+ */
+export function writeChannelConfig(config, options = {}) {
+  const expectedMtime = options.expectedMtime ?? null;
+  const currentMtime = getChannelConfigMtime();
+
+  if (expectedMtime !== null && currentMtime !== expectedMtime) {
+    throw new Error('Configuration changed on disk. Retry your command.');
+  }
+
+  fs.mkdirSync(IM_CONFIG_DIR, { recursive: true });
+  const content = JSON.stringify(config, null, 2) + '\n';
+  const tmpPath = IM_CONFIG_PATH + '.tmp';
+  fs.writeFileSync(tmpPath, content, 'utf-8');
+  fs.renameSync(tmpPath, IM_CONFIG_PATH);
+  if (process.platform !== 'win32') {
+    try {
+      fs.chmodSync(IM_CONFIG_PATH, 0o600);
+    } catch {
+      // best effort
+    }
+  }
+
+  const writtenRaw = fs.readFileSync(IM_CONFIG_PATH, 'utf-8');
+  const writtenConfig = JSON.parse(writtenRaw);
+  if (JSON.stringify(writtenConfig) !== JSON.stringify(config)) {
+    throw new Error('Config write validation failed. Retry your command.');
+  }
+
+  cachedConfig = config;
+  cachedMtime = fs.statSync(IM_CONFIG_PATH).mtimeMs;
+}
+
+/**
+ * Validate platform config (per-platform validation rules)
+ * Pure JavaScript implementation (mirrors app/lib/im/config.ts)
+ * @param {string} platform
+ * @param {Record<string, any>} config
+ * @returns {{valid: boolean, missing?: string[]}}
+ */
+export function validateChannelConfig(platform, config) {
+  if (!config || typeof config !== 'object') {
+    return { valid: false, missing: ['(no config)'] };
+  }
+
+  const c = config;
+
+  const required = CHANNEL_REQUIRED_FIELDS[platform];
+
+  if (!required) {
+    return { valid: false, missing: ['(unknown platform)'] };
+  }
+
+  if (platform === 'wecom') {
+    if (typeof c.webhook_key === 'string' && c.webhook_key) return { valid: true };
+    const missing = ['corp_id', 'corp_secret'].filter((f) => typeof c[f] !== 'string' || !String(c[f]).trim());
+    return missing.length === 0 ? { valid: true } : { valid: false, missing };
+  }
+
+  if (platform === 'dingtalk') {
+    if (typeof c.webhook_url === 'string' && c.webhook_url) return { valid: true };
+    const missing = ['client_id', 'client_secret'].filter((f) => typeof c[f] !== 'string' || !String(c[f]).trim());
+    return missing.length === 0 ? { valid: true } : { valid: false, missing };
+  }
+
+  const platformPatterns = CHANNEL_FIELD_PATTERNS[platform] || {};
+  const missing = required.filter((f) => {
+    const val = c[f];
+    if (typeof val !== 'string' || !val.trim()) return true;
+    const pattern = platformPatterns[f];
+    if (pattern && !pattern.test(val)) return true;
+    return false;
+  });
+
+  return missing.length === 0 ? { valid: true } : { valid: false, missing };
+}
+
+/**
+ * Get list of configured platforms
+ * @returns {string[]}
+ */
+export function getConfiguredPlatforms() {
+  const config = readChannelConfig();
+  return Object.keys(config.providers || {}).filter((platform) => {
+    const validation = validateChannelConfig(platform, config.providers[platform]);
+    return validation.valid;
+  });
+}
+
+export function getChannelConfigMtime() {
+  try {
+    return fs.statSync(IM_CONFIG_PATH).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * Reset config cache (for testing)
+ */
+export function _resetConfigCache() {
+  cachedConfig = EMPTY_CONFIG;
+  cachedMtime = 0;
+}

package/bin/lib/channel-constants.js

@@ -0,0 +1,88 @@
+/**
+ * Shared channel CLI constants.
+ * Keep this file data-only so command/config/validation layers stay aligned.
+ */
+
+export const CHANNEL_PLATFORMS = [
+  'telegram',
+  'discord',
+  'feishu',
+  'slack',
+  'wecom',
+  'dingtalk',
+  'wechat',
+  'qq',
+];
+
+export const CHANNEL_REQUIRED_FIELDS = {
+  telegram: ['bot_token'],
+  discord: ['bot_token'],
+  feishu: ['app_id', 'app_secret'],
+  slack: ['bot_token'],
+  wecom: [],
+  dingtalk: [],
+  wechat: ['bot_token'],
+  qq: ['app_id', 'app_secret'],
+};
+
+export const CHANNEL_FIELD_PATTERNS = {
+  telegram: {
+    bot_token: /^\d+:[A-Za-z0-9_-]{25,}$/,
+  },
+  discord: {
+    bot_token: /^[A-Za-z0-9._-]{20,}$/,
+  },
+  slack: {
+    bot_token: /^xoxb-/,
+  },
+};
+
+export const CHANNEL_FIELD_EXAMPLES = {
+  telegram: {
+    bot_token: '123456789:ABCdefGHIjklMNOpqrSTUvwxYZ',
+  },
+  slack: {
+    bot_token: 'xoxb-1234567890-1234567890-abcdef',
+  },
+};
+
+export const CHANNEL_PLATFORM_HELP = {
+  telegram: {
+    bot_token: 'Get from @BotFather on Telegram (https://core.telegram.org/bots)',
+  },
+  discord: {
+    bot_token: 'Get from Discord Developer Portal (https://discord.com/developers)',
+  },
+  feishu: {
+    app_id: 'Get from Feishu Admin Console',
+    app_secret: 'Get from Feishu Admin Console',
+  },
+  slack: {
+    bot_token: 'Get from Slack API settings (https://api.slack.com/apps)',
+  },
+  wecom: {
+    webhook_key: 'Or use corp_id + corp_secret from WeCom admin',
+  },
+  dingtalk: {
+    client_id: 'Or use webhook_url from DingTalk Developer Console',
+    client_secret: 'Used with client_id when not using webhook_url',
+  },
+  wechat: {
+    bot_token: 'Get via ClawBot QR scan',
+  },
+  qq: {
+    app_id: 'Get from QQ Open Platform',
+    app_secret: 'Get from QQ Open Platform',
+  },
+};
+
+export const CHANNEL_PLATFORM_EMOJIS = {
+  telegram: '✈️',
+  discord: '🟣',
+  feishu: '🎎',
+  slack: '#️⃣',
+  wecom: '💼',
+  dingtalk: '🔔',
+  wechat: '💬',
+  qq: '🐧',
+};