pikiloop 0.4.0

package/dist/core/config/user-config.js

@@ -0,0 +1,510 @@
+/**
+ * Persistent user configuration (~/.pikiloop/setting.json) load/save/sync.
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { STATE_DIR_NAME, USER_CONFIG_SYNC_DEFAULT_INTERVAL_MS } from '../constants.js';
+import { expandTilde } from '../platform.js';
+const MANAGED_ENV_KEYS = [
+    'PIKILOOP_CHANNEL',
+    'PIKILOOP_WORKDIR',
+    'DEFAULT_AGENT',
+    'TELEGRAM_BOT_TOKEN',
+    'TELEGRAM_ALLOWED_CHAT_IDS',
+    'FEISHU_APP_ID',
+    'FEISHU_APP_SECRET',
+    'WEIXIN_BASE_URL',
+    'WEIXIN_BOT_TOKEN',
+    'WEIXIN_ACCOUNT_ID',
+    'SLACK_BOT_TOKEN',
+    'SLACK_APP_TOKEN',
+    'DISCORD_BOT_TOKEN',
+    'DINGTALK_CLIENT_ID',
+    'DINGTALK_CLIENT_SECRET',
+    'WECOM_BOT_ID',
+    'WECOM_BOT_SECRET',
+    'WECOM_ENDPOINT',
+];
+// Snapshot env vars present at module load — these were set externally by the
+// process launcher (docker `-e`, shell `export`, systemd unit, ...) and reflect
+// the operator's intent. `applyUserConfig` with `clearMissing` must never
+// delete them, even if setting.json is silent on the same key. Without this,
+// `docker run -e TELEGRAM_BOT_TOKEN=...` would survive only until the first
+// config sync tick, at which point the token gets wiped from the environment.
+const EXTERNAL_ENV_PRESET = new Set(MANAGED_ENV_KEYS.filter(key => {
+    const value = process.env[key];
+    return typeof value === 'string' && value.trim() !== '';
+}));
+/**
+ * Channel-credential env vars that should hydrate a missing setting.json value
+ * back into the in-memory config. Display surfaces (dashboard channel cards,
+ * setup wizard) and channel resolution all read `config.telegramBotToken`-style
+ * fields, so if the operator only provided env vars (the docker default) the
+ * UI would otherwise show "not configured" even though the bot works fine.
+ */
+const ENV_TO_CONFIG_KEY = [
+    ['telegramBotToken', 'TELEGRAM_BOT_TOKEN'],
+    ['telegramAllowedChatIds', 'TELEGRAM_ALLOWED_CHAT_IDS'],
+    ['feishuAppId', 'FEISHU_APP_ID'],
+    ['feishuAppSecret', 'FEISHU_APP_SECRET'],
+    ['weixinBaseUrl', 'WEIXIN_BASE_URL'],
+    ['weixinBotToken', 'WEIXIN_BOT_TOKEN'],
+    ['weixinAccountId', 'WEIXIN_ACCOUNT_ID'],
+    ['slackBotToken', 'SLACK_BOT_TOKEN'],
+    ['slackAppToken', 'SLACK_APP_TOKEN'],
+    ['discordBotToken', 'DISCORD_BOT_TOKEN'],
+    ['dingtalkClientId', 'DINGTALK_CLIENT_ID'],
+    ['dingtalkClientSecret', 'DINGTALK_CLIENT_SECRET'],
+    ['wecomBotId', 'WECOM_BOT_ID'],
+    ['wecomBotSecret', 'WECOM_BOT_SECRET'],
+    ['wecomEndpoint', 'WECOM_ENDPOINT'],
+];
+/**
+ * Return a copy of `config` with channel credential fields hydrated from
+ * matching env vars when the setting.json value is empty. The returned object
+ * must NOT be used as input to `saveUserConfig` — that would persist env-only
+ * values into setting.json, which would defeat the purpose of running with
+ * `-e TELEGRAM_BOT_TOKEN=...` (the operator wants the env var to remain the
+ * source of truth across container restarts).
+ */
+export function applyChannelEnvFallback(config) {
+    let next = null;
+    for (const [key, envName] of ENV_TO_CONFIG_KEY) {
+        const current = String(config[key] || '').trim();
+        if (current)
+            continue;
+        const env = String(process.env[envName] || '').trim();
+        if (!env)
+            continue;
+        if (!next)
+            next = { ...config };
+        next[key] = env;
+    }
+    return next ?? config;
+}
+const USER_CONFIG_DIRNAME = STATE_DIR_NAME;
+const USER_CONFIG_FILENAME = 'setting.json';
+let activeUserConfig = {};
+// Parsed-config cache keyed by setting.json identity (path + mtime + size).
+// loadUserConfig() is hit from ~60 call sites — several times per HTTP request and
+// per agent stream (the MCP bridge resolves GUI config + per-extension OAuth) — so
+// re-reading + JSON.parse + normalize on every call is pure waste. A cache hit costs
+// one statSync (~100x cheaper). saveUserConfig refreshes this entry so writes are
+// visible immediately regardless of mtime granularity. Callers treat the result as
+// read-only and spread to mutate (the same contract getActiveUserConfig already uses).
+let userConfigCache = null;
+const userConfigListeners = new Set();
+let userConfigSyncTimer = null;
+let userConfigSyncRefCount = 0;
+let userConfigSyncRaw = '';
+let userConfigSyncOverrides = {};
+const expandHomeDir = expandTilde;
+/** Normalize workspace entries — resolve paths, deduplicate, sort by order. */
+function normalizeWorkspaces(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    const seen = new Set();
+    const entries = [];
+    for (const item of raw) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const rawPath = typeof item.path === 'string' ? item.path.trim() : '';
+        if (!rawPath)
+            continue;
+        const resolved = path.resolve(expandHomeDir(rawPath));
+        if (seen.has(resolved))
+            continue;
+        seen.add(resolved);
+        entries.push({
+            path: resolved,
+            name: typeof item.name === 'string' && item.name.trim()
+                ? item.name.trim()
+                : path.basename(resolved),
+            order: typeof item.order === 'number' ? item.order : entries.length,
+            preferredAgent: typeof item.preferredAgent === 'string' && item.preferredAgent.trim()
+                ? item.preferredAgent.trim()
+                : undefined,
+            addedAt: typeof item.addedAt === 'string' && item.addedAt.trim()
+                ? item.addedAt
+                : new Date().toISOString(),
+        });
+    }
+    entries.sort((a, b) => (a.order ?? 999) - (b.order ?? 999));
+    return entries;
+}
+/**
+ * Single canonical config path: ~/.pikiloop/setting.json
+ * Both CLI and dashboard read/write this file exclusively.
+ */
+export function getDevUserConfigPath() {
+    return path.join(os.homedir(), USER_CONFIG_DIRNAME, 'dev', USER_CONFIG_FILENAME);
+}
+export function getUserConfigPath() {
+    const custom = (process.env.PIKILOOP_CONFIG || '').trim();
+    if (custom)
+        return path.resolve(custom);
+    return path.join(os.homedir(), USER_CONFIG_DIRNAME, USER_CONFIG_FILENAME);
+}
+function loadJsonFile(filePath) {
+    try {
+        const raw = fs.readFileSync(filePath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        return typeof parsed === 'object' && parsed ? normalizeUserConfig(parsed) : {};
+    }
+    catch {
+        return {};
+    }
+}
+function normalizeUserConfig(config) {
+    const next = { ...config };
+    const workdir = typeof next.workdir === 'string' && next.workdir.trim() ? next.workdir.trim() : '';
+    if (workdir)
+        next.workdir = resolveUserWorkdir({ workdir });
+    else
+        delete next.workdir;
+    if (typeof next.browserEnabled !== 'boolean' && typeof next.browserUseProfile === 'boolean') {
+        next.browserEnabled = next.browserUseProfile;
+    }
+    if (typeof next.browserHeadless !== 'boolean' && typeof next.browserGuiHeadless === 'boolean') {
+        next.browserHeadless = next.browserGuiHeadless;
+    }
+    delete next.browserUseProfile;
+    delete next.browserCdpEndpoint;
+    delete next.browserGuiEnabled;
+    delete next.browserGuiHeadless;
+    delete next.browserGuiIsolated;
+    delete next.browserGuiUseExtension;
+    delete next.browserGuiExtensionToken;
+    if (Array.isArray(next.workspaces)) {
+        next.workspaces = normalizeWorkspaces(next.workspaces);
+    }
+    else {
+        delete next.workspaces;
+    }
+    return next;
+}
+export function loadUserConfig() {
+    const filePath = getUserConfigPath();
+    let stat;
+    try {
+        stat = fs.statSync(filePath);
+    }
+    catch {
+        userConfigCache = null;
+        return {};
+    }
+    const cached = userConfigCache;
+    if (cached && cached.path === filePath && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) {
+        return cached.config;
+    }
+    const config = loadJsonFile(filePath);
+    userConfigCache = { path: filePath, mtimeMs: stat.mtimeMs, size: stat.size, config };
+    return config;
+}
+export function hasUserConfigFile() {
+    try {
+        return fs.existsSync(getUserConfigPath());
+    }
+    catch {
+        return false;
+    }
+}
+export function getActiveUserConfig() {
+    return activeUserConfig;
+}
+export function saveUserConfig(config) {
+    const filePath = getUserConfigPath();
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const normalized = { version: 1, ...normalizeUserConfig(config) };
+    fs.writeFileSync(filePath, `${JSON.stringify(normalized, null, 2)}\n`, { mode: 0o600 });
+    try {
+        const stat = fs.statSync(filePath);
+        userConfigCache = { path: filePath, mtimeMs: stat.mtimeMs, size: stat.size, config: normalized };
+    }
+    catch {
+        userConfigCache = null;
+    }
+    return filePath;
+}
+export function updateUserConfig(patch) {
+    return saveUserConfig({ ...loadUserConfig(), ...patch });
+}
+export function resolveUserWorkdir(opts = {}) {
+    const raw = String(opts.workdir
+        || opts.config?.workdir
+        || process.env.PIKILOOP_WORKDIR
+        || opts.cwd
+        || process.cwd()).trim();
+    return path.resolve(expandHomeDir(raw));
+}
+function buildManagedEnv(config) {
+    const configuredWorkdir = config.workdir || '';
+    return {
+        PIKILOOP_CHANNEL: String(config.channel || '').trim(),
+        PIKILOOP_WORKDIR: configuredWorkdir ? resolveUserWorkdir({ workdir: configuredWorkdir }) : '',
+        DEFAULT_AGENT: String(config.defaultAgent || '').trim(),
+        TELEGRAM_BOT_TOKEN: String(config.telegramBotToken || '').trim(),
+        TELEGRAM_ALLOWED_CHAT_IDS: String(config.telegramAllowedChatIds || '').trim(),
+        FEISHU_APP_ID: String(config.feishuAppId || '').trim(),
+        FEISHU_APP_SECRET: String(config.feishuAppSecret || '').trim(),
+        WEIXIN_BASE_URL: String(config.weixinBaseUrl || '').trim(),
+        WEIXIN_BOT_TOKEN: String(config.weixinBotToken || '').trim(),
+        WEIXIN_ACCOUNT_ID: String(config.weixinAccountId || '').trim(),
+        SLACK_BOT_TOKEN: String(config.slackBotToken || '').trim(),
+        SLACK_APP_TOKEN: String(config.slackAppToken || '').trim(),
+        DISCORD_BOT_TOKEN: String(config.discordBotToken || '').trim(),
+        DINGTALK_CLIENT_ID: String(config.dingtalkClientId || '').trim(),
+        DINGTALK_CLIENT_SECRET: String(config.dingtalkClientSecret || '').trim(),
+        WECOM_BOT_ID: String(config.wecomBotId || '').trim(),
+        WECOM_BOT_SECRET: String(config.wecomBotSecret || '').trim(),
+        WECOM_ENDPOINT: String(config.wecomEndpoint || '').trim(),
+    };
+}
+function notifyUserConfigListeners(config, changedKeys) {
+    for (const listener of userConfigListeners) {
+        try {
+            listener(config, changedKeys);
+        }
+        catch { }
+    }
+}
+function readUserConfigRaw() {
+    try {
+        return fs.readFileSync(getUserConfigPath(), 'utf-8');
+    }
+    catch {
+        return '';
+    }
+}
+export function onUserConfigChange(listener) {
+    userConfigListeners.add(listener);
+    return () => userConfigListeners.delete(listener);
+}
+function configValuesEqual(a, b) {
+    if (Array.isArray(a) || Array.isArray(b))
+        return JSON.stringify(a ?? null) === JSON.stringify(b ?? null);
+    return a === b;
+}
+function diffConfigKeys(prev, next) {
+    const keys = new Set([...Object.keys(prev), ...Object.keys(next)]);
+    const changed = [];
+    for (const key of keys) {
+        if (!configValuesEqual(prev[key], next[key]))
+            changed.push(key);
+    }
+    return changed;
+}
+export function applyUserConfig(config, _channel, options = {}) {
+    const overwrite = options.overwrite ?? true;
+    const clearMissing = options.clearMissing ?? true;
+    const notify = options.notify ?? true;
+    const managed = buildManagedEnv(config);
+    const changedKeys = [];
+    const prevConfig = activeUserConfig;
+    for (const key of MANAGED_ENV_KEYS) {
+        const next = managed[key];
+        const prev = process.env[key] ?? '';
+        if (!next) {
+            // Never clobber an env var the launcher set externally — that's the
+            // `docker run -e ...` / `export FOO=...` contract. We only clear keys we
+            // know were written by a previous `applyUserConfig` (i.e. *not* in the
+            // boot-time snapshot).
+            if (clearMissing && key in process.env && !EXTERNAL_ENV_PRESET.has(key)) {
+                delete process.env[key];
+                changedKeys.push(key);
+            }
+            continue;
+        }
+        if (!overwrite && prev)
+            continue;
+        if (prev !== next) {
+            process.env[key] = next;
+            changedKeys.push(key);
+        }
+    }
+    activeUserConfig = { ...config };
+    const configChangedKeys = diffConfigKeys(prevConfig, activeUserConfig);
+    const notifyKeys = [...new Set([...changedKeys, ...configChangedKeys])];
+    if (notify && notifyKeys.length)
+        notifyUserConfigListeners(activeUserConfig, notifyKeys);
+    return changedKeys;
+}
+export function setUserWorkdir(workdir, options = {}) {
+    const resolvedWorkdir = resolveUserWorkdir({ workdir });
+    const config = normalizeUserConfig({ ...loadUserConfig(), workdir: resolvedWorkdir });
+    const configPath = saveUserConfig(config);
+    // Don't pin workdir into userConfigSyncOverrides: the periodic sync reads
+    // setting.json fresh each tick, so an external `npx pikiloop@latest` that
+    // updates the file should be honored, not clobbered by an in-memory lock.
+    applyUserConfig(config, undefined, { overwrite: true, clearMissing: true, notify: options.notify ?? true });
+    return { configPath, workdir: resolvedWorkdir, config };
+}
+export function startUserConfigSync(options = {}) {
+    const intervalMs = Math.max(250, Math.round(options.intervalMs ?? USER_CONFIG_SYNC_DEFAULT_INTERVAL_MS));
+    if (options.overrides)
+        userConfigSyncOverrides = { ...options.overrides };
+    const syncNow = () => {
+        const raw = readUserConfigRaw();
+        if (raw === userConfigSyncRaw && userConfigSyncTimer)
+            return;
+        userConfigSyncRaw = raw;
+        const merged = { ...loadUserConfig(), ...userConfigSyncOverrides };
+        const changedKeys = applyUserConfig(merged, undefined, { overwrite: true, clearMissing: true, notify: true });
+        if (changedKeys.length)
+            options.log?.(`config reloaded from setting.json (${changedKeys.join(', ')})`);
+    };
+    syncNow();
+    userConfigSyncRefCount++;
+    if (!userConfigSyncTimer) {
+        userConfigSyncTimer = setInterval(syncNow, intervalMs);
+        userConfigSyncTimer.unref?.();
+    }
+    return () => {
+        userConfigSyncRefCount = Math.max(0, userConfigSyncRefCount - 1);
+        if (userConfigSyncRefCount > 0 || !userConfigSyncTimer)
+            return;
+        clearInterval(userConfigSyncTimer);
+        userConfigSyncTimer = null;
+        userConfigSyncRaw = '';
+        userConfigSyncOverrides = {};
+    };
+}
+// ---------------------------------------------------------------------------
+// Known chat persistence
+// ---------------------------------------------------------------------------
+const KNOWN_CHAT_CONFIG_KEY = {
+    feishu: 'feishuKnownChatIds',
+    telegram: 'telegramKnownChatIds',
+};
+/**
+ * Append `chatId` to the persisted known-chat list for `channelType` if it
+ * isn't already there. The list survives crashes (env-based hand-off does
+ * not) so `sendStartupNotice` can greet known chats after any restart path.
+ */
+export function recordKnownChatId(channelType, chatId) {
+    const id = String(chatId ?? '').trim();
+    if (!id)
+        return;
+    const key = KNOWN_CHAT_CONFIG_KEY[channelType];
+    const config = loadUserConfig();
+    const existing = Array.isArray(config[key]) ? config[key] : [];
+    if (existing.includes(id))
+        return;
+    const next = [...existing, id];
+    try {
+        saveUserConfig({ ...config, [key]: next });
+    }
+    catch { }
+}
+/** Load the persisted known-chat list for a channel. */
+export function loadKnownChatIds(channelType) {
+    const key = KNOWN_CHAT_CONFIG_KEY[channelType];
+    const config = loadUserConfig();
+    const list = config[key];
+    return Array.isArray(list)
+        ? list.map(v => String(v ?? '').trim()).filter(Boolean)
+        : [];
+}
+// ---------------------------------------------------------------------------
+// Workspace registry
+// ---------------------------------------------------------------------------
+/** Load registered workspaces from config. Returns empty array if none. */
+export function loadWorkspaces() {
+    const config = loadUserConfig();
+    return normalizeWorkspaces(config.workspaces);
+}
+/** Add a workspace. Returns the new entry. Deduplicates by resolved path. */
+export function addWorkspace(workspacePath, name) {
+    const resolved = path.resolve(expandHomeDir(workspacePath));
+    const config = loadUserConfig();
+    const workspaces = normalizeWorkspaces(config.workspaces);
+    const existing = workspaces.find(w => w.path === resolved);
+    if (existing) {
+        if (name)
+            existing.name = name;
+        saveUserConfig({ ...config, workspaces });
+        return existing;
+    }
+    const entry = {
+        path: resolved,
+        name: name?.trim() || path.basename(resolved),
+        order: workspaces.length,
+        addedAt: new Date().toISOString(),
+    };
+    workspaces.push(entry);
+    saveUserConfig({ ...config, workspaces });
+    return entry;
+}
+/** Remove a workspace by path. Returns true if removed. */
+export function removeWorkspace(workspacePath) {
+    const resolved = path.resolve(expandHomeDir(workspacePath));
+    const config = loadUserConfig();
+    const workspaces = normalizeWorkspaces(config.workspaces);
+    const before = workspaces.length;
+    const filtered = workspaces.filter(w => w.path !== resolved);
+    if (filtered.length === before)
+        return false;
+    saveUserConfig({ ...config, workspaces: filtered });
+    return true;
+}
+/** Rename a workspace. Returns the updated entry or null if not found. */
+export function renameWorkspace(workspacePath, newName) {
+    const resolved = path.resolve(expandHomeDir(workspacePath));
+    const config = loadUserConfig();
+    const workspaces = normalizeWorkspaces(config.workspaces);
+    const entry = workspaces.find(w => w.path === resolved);
+    if (!entry)
+        return null;
+    entry.name = newName.trim() || entry.name;
+    saveUserConfig({ ...config, workspaces });
+    return entry;
+}
+/** Reorder workspaces by providing paths in desired order. */
+export function reorderWorkspaces(orderedPaths) {
+    const config = loadUserConfig();
+    const workspaces = normalizeWorkspaces(config.workspaces);
+    const byPath = new Map(workspaces.map(w => [w.path, w]));
+    const reordered = [];
+    const seen = new Set();
+    for (let i = 0; i < orderedPaths.length; i++) {
+        const resolved = path.resolve(expandHomeDir(orderedPaths[i]));
+        const entry = byPath.get(resolved);
+        if (entry && !seen.has(resolved)) {
+            entry.order = i;
+            reordered.push(entry);
+            seen.add(resolved);
+        }
+    }
+    // Append any workspaces not in the ordered list
+    for (const entry of workspaces) {
+        if (!seen.has(entry.path)) {
+            entry.order = reordered.length;
+            reordered.push(entry);
+        }
+    }
+    saveUserConfig({ ...config, workspaces: reordered });
+    return reordered;
+}
+/** Update workspace preferences (preferredAgent, etc.) */
+export function updateWorkspace(workspacePath, patch) {
+    const resolved = path.resolve(expandHomeDir(workspacePath));
+    const config = loadUserConfig();
+    const workspaces = normalizeWorkspaces(config.workspaces);
+    const entry = workspaces.find(w => w.path === resolved);
+    if (!entry)
+        return null;
+    if (patch.name !== undefined)
+        entry.name = patch.name.trim() || entry.name;
+    if (patch.preferredAgent !== undefined)
+        entry.preferredAgent = patch.preferredAgent || undefined;
+    if (patch.order !== undefined)
+        entry.order = patch.order;
+    saveUserConfig({ ...config, workspaces });
+    return entry;
+}
+/** Find a workspace entry by path. */
+export function findWorkspace(workspacePath) {
+    const resolved = path.resolve(expandHomeDir(workspacePath));
+    return loadWorkspaces().find(w => w.path === resolved) || null;
+}