@bbigbang/core 0.1.0

package/dist/config.js

@@ -0,0 +1,380 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { createInterface } from 'node:readline/promises';
+import Database from 'better-sqlite3';
+import { z } from 'zod';
+import { AGENT_SURFACE_MODE_ENV, normalizeAgentSurfaceMode } from '@bbigbang/protocol';
+const DEFAULT_CODEX_ACP_NPX_ARGS = [
+    '-y',
+    '@zed-industries/codex-acp@latest',
+    '-c',
+    'sandbox_mode="danger-full-access"',
+    '-c',
+    'approval_policy="never"',
+];
+function resolveHomeDir() {
+    return os.homedir();
+}
+export function resolveGatewayHomeDir() {
+    const env = process.env.BIGBANG_HOME;
+    if (env?.trim())
+        return expandPath(env.trim(), resolveHomeDir());
+    const homeDir = resolveHomeDir();
+    const bigbangHome = path.join(homeDir, '.bigbang');
+    const legacyHome = path.join(homeDir, '.agent-collab');
+    const bigbangConfigPath = configFilePath(bigbangHome);
+    const legacyConfigPath = configFilePath(legacyHome);
+    if (fs.existsSync(legacyConfigPath)
+        && (!fs.existsSync(bigbangConfigPath) || isUninitializedGeneratedDefaultConfig(bigbangConfigPath, bigbangHome, homeDir))) {
+        return legacyHome;
+    }
+    return bigbangHome;
+}
+function isUninitializedGeneratedDefaultConfig(filePath, gatewayHome, homeDir) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        const looksGenerated = parsed.serverSlug === 'default'
+            && parsed.serverName === 'Default'
+            && parsed.publicServerUrl === ''
+            && parsed.publicBasePath === ''
+            && parsed.hubRegistryPath === '';
+        if (!looksGenerated)
+            return false;
+        const dbPath = typeof parsed.dbPath === 'string' && parsed.dbPath.trim()
+            ? resolvePathRelativeTo(parsed.dbPath, gatewayHome, homeDir)
+            : path.join(gatewayHome, 'data', 'gateway.db');
+        return !sqliteDatabaseHasUsers(dbPath);
+    }
+    catch {
+        return false;
+    }
+}
+function sqliteDatabaseHasUsers(dbPath) {
+    if (!fs.existsSync(dbPath))
+        return false;
+    let db = null;
+    try {
+        db = new Database(dbPath, { readonly: true, fileMustExist: true });
+        const usersTable = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='users'").get();
+        if (!usersTable)
+            return false;
+        const row = db.prepare('SELECT COUNT(*) as count FROM users').get();
+        return row.count > 0;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        db?.close();
+    }
+}
+export function configFilePath(gatewayHome) {
+    return path.join(gatewayHome, 'config.json');
+}
+function expandPath(raw, homeDir) {
+    if (raw === '~')
+        return homeDir;
+    if (raw.startsWith('~/'))
+        return path.join(homeDir, raw.slice(2));
+    return raw;
+}
+function resolvePathRelativeTo(raw, baseDir, homeDir) {
+    const expanded = expandPath(raw, homeDir);
+    if (path.isAbsolute(expanded))
+        return expanded;
+    return path.join(baseDir, expanded);
+}
+function createConfigSchema(defaults) {
+    const absPath = z
+        .string()
+        .min(1)
+        .refine((p) => path.isAbsolute(p), {
+        message: 'must be an absolute path',
+    });
+    const serverSlug = z
+        .string()
+        .trim()
+        .min(1)
+        .regex(/^[A-Za-z0-9][A-Za-z0-9_-]{0,62}$/, {
+        message: 'must be a single URL-safe path segment',
+    });
+    const publicBasePath = z
+        .string()
+        .trim()
+        .refine((value) => value === '' || /^\/[A-Za-z0-9][A-Za-z0-9_/-]*[A-Za-z0-9_-]$/.test(value), {
+        message: 'must be empty or a leading-slash path prefix without a trailing slash',
+    })
+        .refine((value) => !value.includes('//'), {
+        message: 'must not contain empty path segments',
+    });
+    return z.object({
+        webPort: z.number().int().min(1).max(65535).default(3100),
+        webHost: z.string().min(1).default('0.0.0.0'),
+        publicServerUrl: z.string().default(''),
+        agentBridgeServerUrl: z.string().default(''),
+        hubRegistryPath: z.string().default(''),
+        hubServerJoinPackageSpec: z.string().default(''),
+        hubServerJoinNpxPackageSpecs: z.array(z.string()).default([]),
+        hubServerJoinInstallPackages: z.array(z.string()).default([]),
+        serverId: z.string().min(1),
+        serverSlug: serverSlug.default('default'),
+        serverName: z.string().min(1).default('Default'),
+        publicBasePath: publicBasePath.default(''),
+        internalAgentAuthToken: z.string().min(1).default('internal-agent-auth-token'),
+        nodeDispatchAckTimeoutMs: z.number().int().min(100).max(60_000).default(5_000),
+        acpAgentCommand: z.string().min(1).default('npx'),
+        acpAgentArgs: z
+            .array(z.string())
+            .default([...DEFAULT_CODEX_ACP_NPX_ARGS]),
+        acpPromptTimeoutMs: z.number().int().min(1_000).max(3_600_000).default(3_600_000),
+        // Default workspace is ~ (switchable per conversation via /workspace)
+        workspaceRoot: absPath.default(defaults.defaultWorkspaceRoot),
+        panelAbsolutePathRoots: z.array(absPath).default([]),
+        // Default DB path lives under ~/.bigbang
+        dbPath: z.string().min(1).default(defaults.defaultDbPath),
+        runtimeIdleTtlSeconds: z.number().int().min(10).default(15 * 60),
+        maxBindingRuntimes: z.number().int().min(1).max(200).default(30),
+        workspaceToolMaxActivePersistentRunsPerAgent: z.number().int().min(1).max(100).default(3),
+        uiDefaultMode: z.enum(['verbose', 'summary']).default('summary'),
+        uiJsonMaxChars: z.number().int().min(200).max(200_000).default(12_000),
+        contextReplayEnabled: z.boolean().default(true),
+        contextReplayRuns: z.number().int().min(0).max(100).default(16),
+        contextReplayMaxChars: z.number().int().min(200).max(512_000).default(128_000),
+        humanUserName: z.string().min(1).default('yanzong'),
+        agentSurfaceMode: z.enum(['bigbang', 'mcp']).default('bigbang'),
+    }).superRefine((value, ctx) => {
+        if (value.publicBasePath.trim() && !value.agentBridgeServerUrl.trim()) {
+            ctx.addIssue({
+                code: 'custom',
+                path: ['agentBridgeServerUrl'],
+                message: 'is required when publicBasePath is configured',
+            });
+        }
+    });
+}
+export async function loadConfig(options = {}) {
+    const homeDir = resolveHomeDir();
+    const gatewayHome = resolveGatewayHomeDir();
+    fs.mkdirSync(gatewayHome, { recursive: true });
+    const defaults = {
+        defaultWorkspaceRoot: homeDir,
+        defaultDbPath: path.join(gatewayHome, 'data', 'gateway.db'),
+    };
+    const schema = createConfigSchema(defaults);
+    const file = configFilePath(gatewayHome);
+    let raw;
+    if (fs.existsSync(file)) {
+        raw = JSON.parse(fs.readFileSync(file, 'utf8'));
+    }
+    else {
+        const input = options.input ?? process.stdin;
+        const output = options.output ?? process.stdout;
+        const shouldRunWizard = options.interactiveBootstrap === true &&
+            isInteractiveTerminal(input, output);
+        raw = shouldRunWizard
+            ? await runFirstTimeSetup({
+                defaults,
+                file,
+                input,
+                output,
+            })
+            : createDefaultConfig(defaults);
+        fs.writeFileSync(file, JSON.stringify(raw, null, 2) + '\n', 'utf8');
+    }
+    // Normalize paths.
+    if (typeof raw?.workspaceRoot === 'string') {
+        raw.workspaceRoot = resolvePathRelativeTo(raw.workspaceRoot, gatewayHome, homeDir);
+    }
+    if (Array.isArray(raw?.panelAbsolutePathRoots)) {
+        raw.panelAbsolutePathRoots = raw.panelAbsolutePathRoots
+            .filter((entry) => typeof entry === 'string' && entry.trim().length > 0)
+            .map((entry) => resolvePathRelativeTo(entry, gatewayHome, homeDir));
+    }
+    if (typeof raw?.dbPath === 'string') {
+        raw.dbPath = resolvePathRelativeTo(raw.dbPath, gatewayHome, homeDir);
+    }
+    if (typeof raw?.publicServerUrl !== 'string') {
+        raw.publicServerUrl = '';
+    }
+    if (typeof raw?.agentBridgeServerUrl !== 'string') {
+        raw.agentBridgeServerUrl = '';
+    }
+    if (typeof raw?.hubRegistryPath === 'string' && raw.hubRegistryPath.trim()) {
+        raw.hubRegistryPath = resolvePathRelativeTo(raw.hubRegistryPath, gatewayHome, homeDir);
+    }
+    else {
+        raw.hubRegistryPath = '';
+    }
+    if (typeof raw?.hubServerJoinPackageSpec !== 'string') {
+        raw.hubServerJoinPackageSpec = '';
+    }
+    if (!Array.isArray(raw?.hubServerJoinNpxPackageSpecs)) {
+        raw.hubServerJoinNpxPackageSpecs = [];
+    }
+    if (!Array.isArray(raw?.hubServerJoinInstallPackages)) {
+        raw.hubServerJoinInstallPackages = [];
+    }
+    const identityChanged = ensureServerIdentity(raw);
+    if (typeof raw?.internalAgentAuthToken !== 'string' || !raw.internalAgentAuthToken.trim()) {
+        raw.internalAgentAuthToken = randomUUID();
+        fs.writeFileSync(file, JSON.stringify(raw, null, 2) + '\n', 'utf8');
+    }
+    else if (identityChanged) {
+        fs.writeFileSync(file, JSON.stringify(raw, null, 2) + '\n', 'utf8');
+    }
+    if (typeof raw?.nodeDispatchAckTimeoutMs !== 'number') {
+        raw.nodeDispatchAckTimeoutMs = 5_000;
+    }
+    raw.agentSurfaceMode = normalizeAgentSurfaceMode(process.env[AGENT_SURFACE_MODE_ENV] ?? (typeof raw?.agentSurfaceMode === 'string' ? raw.agentSurfaceMode : undefined));
+    return schema.parse(raw);
+}
+function createDefaultConfig(defaults) {
+    return {
+        workspaceRoot: defaults.defaultWorkspaceRoot,
+        panelAbsolutePathRoots: [],
+        dbPath: defaults.defaultDbPath,
+        acpAgentCommand: 'npx',
+        acpAgentArgs: [...DEFAULT_CODEX_ACP_NPX_ARGS],
+        acpPromptTimeoutMs: 3_600_000,
+        uiDefaultMode: 'summary',
+        webPort: 3100,
+        webHost: '0.0.0.0',
+        publicServerUrl: '',
+        agentBridgeServerUrl: '',
+        hubRegistryPath: '',
+        hubServerJoinPackageSpec: '',
+        hubServerJoinNpxPackageSpecs: [],
+        hubServerJoinInstallPackages: [],
+        serverId: randomUUID(),
+        serverSlug: 'default',
+        serverName: 'Default',
+        publicBasePath: '',
+        internalAgentAuthToken: randomUUID(),
+        nodeDispatchAckTimeoutMs: 5_000,
+        workspaceToolMaxActivePersistentRunsPerAgent: 3,
+    };
+}
+function ensureServerIdentity(raw) {
+    let changed = false;
+    if (typeof raw.serverId !== 'string' || !raw.serverId.trim()) {
+        raw.serverId = randomUUID();
+        changed = true;
+    }
+    else if (raw.serverId !== raw.serverId.trim()) {
+        raw.serverId = raw.serverId.trim();
+        changed = true;
+    }
+    if (typeof raw.serverSlug !== 'string' || !raw.serverSlug.trim()) {
+        raw.serverSlug = 'default';
+        changed = true;
+    }
+    else if (raw.serverSlug !== raw.serverSlug.trim()) {
+        raw.serverSlug = raw.serverSlug.trim();
+        changed = true;
+    }
+    if (typeof raw.serverName !== 'string' || !raw.serverName.trim()) {
+        raw.serverName = 'Default';
+        changed = true;
+    }
+    else if (raw.serverName !== raw.serverName.trim()) {
+        raw.serverName = raw.serverName.trim();
+        changed = true;
+    }
+    if (typeof raw.publicBasePath !== 'string') {
+        raw.publicBasePath = '';
+        changed = true;
+    }
+    else {
+        let normalized = raw.publicBasePath.trim();
+        if (normalized && !normalized.startsWith('/')) {
+            normalized = `/${normalized}`;
+        }
+        normalized = normalized.replace(/\/+$/u, '');
+        if (raw.publicBasePath !== normalized) {
+            raw.publicBasePath = normalized;
+            changed = true;
+        }
+    }
+    return changed;
+}
+function isInteractiveTerminal(input, output) {
+    return Boolean(input.isTTY && output.isTTY);
+}
+async function runFirstTimeSetup(params) {
+    params.output.write('\n');
+    params.output.write('bigbang first-time setup\n');
+    params.output.write(`Config file: ${params.file}\n`);
+    params.output.write('Press Enter to accept defaults.\n\n');
+    const rl = createInterface({
+        input: params.input,
+        output: params.output,
+    });
+    try {
+        const acpAgentCommand = await askWithDefault(rl, 'ACP agent command', 'npx');
+        const acpArgsRaw = await askWithDefault(rl, 'ACP agent args (space-separated)', '-y @zed-industries/codex-acp@latest -c sandbox_mode="danger-full-access" -c approval_policy="never"');
+        const workspaceRoot = await askWithDefault(rl, 'Default workspace root', params.defaults.defaultWorkspaceRoot);
+        const dbPath = await askWithDefault(rl, 'SQLite DB path', params.defaults.defaultDbPath);
+        const webPort = await askPortWithDefault(rl, 'Web server port', 3100);
+        const publicServerUrl = await askOptional(rl, 'Public browser URL origin (optional, e.g. https://acac.cpolar.top)');
+        const agentBridgeServerUrl = await askOptional(rl, 'Agent bridge server URL for node callbacks (optional, e.g. http://10.0.0.5:3100)');
+        const raw = {
+            workspaceRoot,
+            dbPath,
+            acpAgentCommand,
+            acpAgentArgs: splitArgs(acpArgsRaw),
+            acpPromptTimeoutMs: 3_600_000,
+            uiDefaultMode: 'summary',
+            webPort,
+            webHost: '0.0.0.0',
+            publicServerUrl,
+            agentBridgeServerUrl,
+            internalAgentAuthToken: randomUUID(),
+            nodeDispatchAckTimeoutMs: 5_000,
+        };
+        params.output.write('\nSaved config. You can edit it later at:\n');
+        params.output.write(`${params.file}\n\n`);
+        return raw;
+    }
+    finally {
+        rl.close();
+    }
+}
+async function askWithDefault(rl, label, defaultValue) {
+    const answer = (await rl.question(`${label} [${defaultValue}]: `)).trim();
+    return answer || defaultValue;
+}
+async function askOptional(rl, label) {
+    return (await rl.question(`${label}: `)).trim();
+}
+async function askYesNo(rl, label, defaultValue) {
+    const hint = defaultValue ? 'Y/n' : 'y/N';
+    const answer = (await rl.question(`${label} [${hint}]: `)).trim().toLowerCase();
+    if (!answer)
+        return defaultValue;
+    if (answer === 'y' || answer === 'yes')
+        return true;
+    if (answer === 'n' || answer === 'no')
+        return false;
+    return defaultValue;
+}
+async function askPortWithDefault(rl, label, defaultValue) {
+    const answer = (await rl.question(`${label} [${defaultValue}]: `)).trim();
+    if (!answer)
+        return defaultValue;
+    const num = Number.parseInt(answer, 10);
+    if (!Number.isInteger(num) || num < 1 || num > 65535) {
+        return defaultValue;
+    }
+    return num;
+}
+function splitArgs(raw) {
+    const parts = raw
+        .split(/\s+/)
+        .map((v) => v.trim())
+        .filter(Boolean);
+    if (parts.length > 0)
+        return parts;
+    return [...DEFAULT_CODEX_ACP_NPX_ARGS];
+}