@bbigbang/core 0.1.0

package/dist/services/droidModelOptions.js

@@ -0,0 +1,165 @@
+import { execFileSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import path from 'node:path';
+const DROID_EXEC_HELP_TIMEOUT_MS = 1500;
+export function listDroidModelOptions(input) {
+    const settingsPath = input?.settingsPath ?? process.env.FACTORY_SETTINGS_PATH ?? path.join(homedir(), '.factory', 'settings.json');
+    const options = new Map();
+    const defaults = {
+        orchestratorModel: null,
+        workerModel: null,
+        validatorModel: null,
+        sessionModel: null,
+    };
+    let loadedFromSettings = false;
+    let loadedFromCliHelp = false;
+    let error = null;
+    try {
+        const settings = parseJsonObject(readFileSync(settingsPath, 'utf8'));
+        loadedFromSettings = true;
+        defaults.orchestratorModel = normalizeModelId(settings.missionOrchestratorModel);
+        defaults.workerModel = normalizeModelId(asRecord(settings.missionModelSettings).workerModel);
+        defaults.validatorModel = normalizeModelId(asRecord(settings.missionModelSettings).validationWorkerModel);
+        defaults.sessionModel = normalizeModelId(asRecord(settings.sessionDefaultSettings).model);
+        addOption(options, defaults.orchestratorModel, {
+            label: defaults.orchestratorModel,
+            source: 'Droid mission orchestrator setting',
+            recommendedFor: ['orchestrator'],
+        });
+        addOption(options, defaults.workerModel, {
+            label: defaults.workerModel,
+            source: 'Droid mission worker setting',
+            recommendedFor: ['worker'],
+        });
+        addOption(options, defaults.validatorModel, {
+            label: defaults.validatorModel,
+            source: 'Droid mission validator setting',
+            recommendedFor: ['validator'],
+        });
+        addOption(options, defaults.sessionModel, {
+            label: defaults.sessionModel,
+            source: 'Droid session default setting',
+            recommendedFor: ['session_default'],
+        });
+        for (const item of asArray(asRecord(settings).customModels)) {
+            const record = asRecord(item);
+            const id = normalizeModelId(record.id);
+            addOption(options, id, {
+                label: normalizeDisplayLabel(record.displayName) ?? id,
+                source: 'Droid custom model',
+                provider: normalizeString(record.provider),
+                model: normalizeString(record.model),
+            });
+        }
+    }
+    catch (err) {
+        error = `Unable to read Droid settings: ${String(err?.message ?? err)}`;
+    }
+    const shouldReadCliHelp = input?.includeCliHelp !== false
+        && (!loadedFromSettings || options.size === 0 || process.env.DROID_MODEL_OPTIONS_INCLUDE_CLI_HELP === '1');
+    if (shouldReadCliHelp) {
+        try {
+            for (const item of parseDroidExecHelpModels(execFileSync('droid', ['exec', '--help'], {
+                encoding: 'utf8',
+                timeout: DROID_EXEC_HELP_TIMEOUT_MS,
+                maxBuffer: 1024 * 1024,
+            }))) {
+                addOption(options, item.id, {
+                    label: item.label,
+                    source: item.custom ? 'Droid CLI custom model' : 'Droid CLI available model',
+                });
+            }
+            loadedFromCliHelp = true;
+        }
+        catch (err) {
+            error = error ?? `Unable to read Droid CLI models: ${String(err?.message ?? err)}`;
+        }
+    }
+    return {
+        options: Array.from(options.values())
+            .sort((a, b) => a.order - b.order || a.id.localeCompare(b.id))
+            .map(({ order: _order, ...option }) => option),
+        defaults,
+        settingsPath,
+        loadedFromSettings,
+        loadedFromCliHelp,
+        error,
+    };
+}
+export function parseDroidExecHelpModels(helpText) {
+    const out = [];
+    let section = null;
+    for (const rawLine of helpText.split(/\r?\n/)) {
+        const line = rawLine.trimEnd();
+        if (/^Available Models:/i.test(line)) {
+            section = 'available';
+            continue;
+        }
+        if (/^Custom Models:/i.test(line)) {
+            section = 'custom';
+            continue;
+        }
+        if (/^Model details:/i.test(line))
+            break;
+        if (!section || !line.trim())
+            continue;
+        const match = line.match(/^\s{2,}(\S+)\s{2,}(.+?)\s*$/);
+        if (!match)
+            continue;
+        const id = normalizeModelId(match[1]);
+        if (!id)
+            continue;
+        out.push({ id, label: match[2].trim(), custom: section === 'custom' });
+    }
+    return out;
+}
+function addOption(options, value, input) {
+    const id = normalizeModelId(value);
+    if (!id)
+        return;
+    const existing = options.get(id);
+    if (existing) {
+        existing.recommendedFor = Array.from(new Set([...existing.recommendedFor, ...(input.recommendedFor ?? [])]));
+        if (existing.source !== input.source && !existing.source.includes(input.source))
+            existing.source = `${existing.source}; ${input.source}`;
+        existing.provider = existing.provider ?? input.provider ?? null;
+        existing.model = existing.model ?? input.model ?? null;
+        return;
+    }
+    options.set(id, {
+        id,
+        label: input.label?.trim() || id,
+        source: input.source,
+        provider: input.provider ?? null,
+        model: input.model ?? null,
+        recommendedFor: input.recommendedFor ?? [],
+        order: options.size,
+    });
+}
+function parseJsonObject(value) {
+    return asRecord(JSON.parse(value));
+}
+function asRecord(value) {
+    return value != null && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function asArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+function normalizeString(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+function normalizeDisplayLabel(value) {
+    const label = normalizeString(value);
+    if (!label || label === '[redacted]')
+        return null;
+    return label;
+}
+function normalizeModelId(value) {
+    const model = normalizeString(value);
+    if (!model || model === '[redacted]' || /\s/.test(model) || model.length > 160)
+        return null;
+    if (/^(bearer|sk-|pk-|secret|token|key)[-_a-z0-9]*/i.test(model))
+        return null;
+    return model;
+}

package/dist/services/hubServerRegistrationService.js

@@ -0,0 +1,268 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createHash, randomUUID } from 'node:crypto';
+const SLUG_RE = /^[A-Za-z0-9][A-Za-z0-9_-]{0,62}$/u;
+const DEFAULT_TOKEN_TTL_MS = 24 * 60 * 60 * 1000;
+const MIN_TOKEN_TTL_MS = 60 * 1000;
+const MAX_TOKEN_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+export class HubServerRegistrationService {
+    params;
+    tokenStorePath;
+    claimLock = Promise.resolve();
+    constructor(params) {
+        this.params = params;
+        this.tokenStorePath = path.join(path.dirname(params.registryPath), 'hub-server-registration-tokens.json');
+    }
+    static isConfigured(registryPath) {
+        return typeof registryPath === 'string' && registryPath.trim().length > 0;
+    }
+    createToken(input) {
+        const serverSlug = normalizeSlug(input.serverSlug);
+        const serverName = normalizeName(input.serverName);
+        const version = normalizeVersion(this.params.defaultVersion);
+        const expiresAt = Date.now() + normalizeTtlMs(input.expiresInSeconds);
+        const serverId = randomUUID();
+        const token = `hsr_${randomUUID().replace(/-/gu, '')}${randomUUID().replace(/-/gu, '')}`;
+        const tokenHash = hashToken(token);
+        const store = this.readTokenStore();
+        store.tokens = store.tokens.filter((record) => record.claimedAt == null && record.expiresAt > Date.now());
+        store.tokens.push({
+            tokenHash,
+            serverId,
+            serverSlug,
+            serverName,
+            version,
+            expectedVersion: version,
+            expiresAt,
+            claimedAt: null,
+            createdAt: Date.now(),
+        });
+        this.writeJsonAtomic(this.tokenStorePath, store);
+        return {
+            token,
+            expiresAt,
+            installCommand: buildInstallCommand({
+                hubUrl: this.params.publicServerUrl,
+                token,
+                serverId,
+                serverSlug,
+                serverName,
+                version,
+                packageSpec: this.params.joinPackageSpec,
+                npxPackageSpecs: this.params.joinNpxPackageSpecs,
+                installPackages: this.params.joinInstallPackages,
+            }),
+            serverId,
+            serverSlug,
+            serverName,
+            version,
+        };
+    }
+    async claim(input) {
+        return this.withClaimLock(() => this.claimLocked(input));
+    }
+    async claimLocked(input) {
+        const token = readRequired(input.token, 'token');
+        const tokenHash = hashToken(token);
+        const serverId = readRequired(input.serverId, 'serverId');
+        const serverSlug = normalizeSlug(input.serverSlug);
+        const serverName = normalizeName(input.serverName);
+        const upstream = normalizeHttpUrl(input.upstream, 'upstream');
+        const bridgeUrl = normalizeHttpUrl(input.bridgeUrl, 'bridgeUrl');
+        const version = normalizeVersion(input.version);
+        const now = Date.now();
+        const store = this.readTokenStore();
+        const record = store.tokens.find((candidate) => candidate.tokenHash === tokenHash);
+        if (!record)
+            throw new HubServerRegistrationError(401, 'Invalid registration token.');
+        if (record.claimedAt != null)
+            throw new HubServerRegistrationError(409, 'Registration token has already been claimed.');
+        if (record.expiresAt <= now)
+            throw new HubServerRegistrationError(410, 'Registration token has expired.');
+        if (record.serverId !== serverId || record.serverSlug !== serverSlug || record.serverName !== serverName || record.version !== version) {
+            throw new HubServerRegistrationError(409, 'Registration payload does not match the issued token.');
+        }
+        const identity = await fetchServerIdentity(upstream);
+        if (identity.serverId !== serverId || identity.serverSlug !== serverSlug) {
+            throw new HubServerRegistrationError(409, 'Upstream server identity does not match the issued token.');
+        }
+        if (identity.publicBasePath !== `/s/${serverSlug}`) {
+            throw new HubServerRegistrationError(409, 'Upstream server publicBasePath does not match its Hub slug.');
+        }
+        if (identity.version !== version) {
+            throw new HubServerRegistrationError(409, 'Upstream server version does not match the issued token.');
+        }
+        if (bridgeUrl !== upstream) {
+            const bridgeIdentity = await fetchServerIdentity(bridgeUrl);
+            if (bridgeIdentity.serverId !== serverId || bridgeIdentity.serverSlug !== serverSlug || bridgeIdentity.version !== version) {
+                throw new HubServerRegistrationError(409, 'Bridge URL does not reach the claimed server identity.');
+            }
+        }
+        const registry = this.readRegistry();
+        const existingIndex = registry.servers.findIndex((server) => server.serverId === serverId || server.serverSlug === serverSlug);
+        if (existingIndex >= 0) {
+            const existing = registry.servers[existingIndex];
+            if (existing.serverId !== serverId || existing.serverSlug !== serverSlug) {
+                throw new HubServerRegistrationError(409, 'Hub registry already contains a conflicting server id or slug.');
+            }
+            registry.servers[existingIndex] = { serverId, serverSlug, serverName, upstream, bridgeUrl, enabled: true, expectedVersion: record.expectedVersion ?? record.version, remoteVersion: identity.version };
+        }
+        else {
+            registry.servers.push({ serverId, serverSlug, serverName, upstream, bridgeUrl, enabled: true, expectedVersion: record.expectedVersion ?? record.version, remoteVersion: identity.version });
+        }
+        validateRegistry(registry);
+        record.claimedAt = now;
+        this.writeJsonAtomic(this.tokenStorePath, store);
+        this.writeJsonAtomic(this.params.registryPath, registry);
+        return {
+            ok: true,
+            serverId,
+            serverSlug,
+            serverName,
+            upstream,
+            replaced: existingIndex >= 0,
+        };
+    }
+    readTokenStore() {
+        if (!fs.existsSync(this.tokenStorePath))
+            return { tokens: [] };
+        try {
+            const parsed = JSON.parse(fs.readFileSync(this.tokenStorePath, 'utf8'));
+            return { tokens: Array.isArray(parsed.tokens) ? parsed.tokens : [] };
+        }
+        catch {
+            return { tokens: [] };
+        }
+    }
+    readRegistry() {
+        if (!fs.existsSync(this.params.registryPath))
+            return { servers: [] };
+        const parsed = JSON.parse(fs.readFileSync(this.params.registryPath, 'utf8'));
+        return { servers: Array.isArray(parsed.servers) ? parsed.servers.map((server) => ({ ...server })) : [] };
+    }
+    async withClaimLock(fn) {
+        const previous = this.claimLock;
+        let release;
+        this.claimLock = new Promise((resolve) => {
+            release = resolve;
+        });
+        await previous.catch(() => undefined);
+        try {
+            return await fn();
+        }
+        finally {
+            release();
+        }
+    }
+    writeJsonAtomic(filePath, value) {
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+        fs.writeFileSync(tempPath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+        fs.renameSync(tempPath, filePath);
+    }
+}
+export class HubServerRegistrationError extends Error {
+    statusCode;
+    constructor(statusCode, message) {
+        super(message);
+        this.statusCode = statusCode;
+    }
+}
+function buildInstallCommand(params) {
+    const hubUrl = params.hubUrl.replace(/\/+$/u, '');
+    const packageSpec = params.packageSpec?.trim() || `@bbigbang/cli@${params.version}`;
+    const installPackages = params.installPackages?.map((item) => item.trim()).filter(Boolean) ?? [];
+    const configuredNpxPackageSpecs = params.npxPackageSpecs?.map((item) => item.trim()).filter(Boolean) ?? [];
+    const npxPackageSpecs = uniqueStrings(configuredNpxPackageSpecs.length > 0 ? configuredNpxPackageSpecs : [packageSpec]);
+    const lines = [
+        `npx -y ${npxPackageSpecs.map((spec) => `--package ${shellQuote(spec)}`).join(' ')} bigbang server join`,
+        `  --hub-url ${shellQuote(hubUrl)}`,
+        `  --token ${shellQuote(params.token)}`,
+        `  --server-id ${shellQuote(params.serverId)}`,
+        `  --server-slug ${shellQuote(params.serverSlug)}`,
+        `  --server-name ${shellQuote(params.serverName)}`,
+        `  --version ${shellQuote(params.version)}`,
+    ];
+    if (installPackages.length > 0) {
+        lines.push(`  --install-packages ${shellQuote(installPackages.join(','))}`);
+    }
+    return lines.join(' \\\n');
+}
+function uniqueStrings(values) {
+    return Array.from(new Set(values.filter(Boolean)));
+}
+function shellQuote(value) {
+    return `'${value.replace(/'/gu, `'\\''`)}'`;
+}
+function hashToken(token) {
+    return createHash('sha256').update(token).digest('hex');
+}
+function normalizeTtlMs(seconds) {
+    if (typeof seconds !== 'number' || !Number.isFinite(seconds))
+        return DEFAULT_TOKEN_TTL_MS;
+    return Math.min(Math.max(Math.floor(seconds * 1000), MIN_TOKEN_TTL_MS), MAX_TOKEN_TTL_MS);
+}
+function normalizeSlug(raw) {
+    const value = readRequired(raw, 'serverSlug');
+    if (!SLUG_RE.test(value))
+        throw new HubServerRegistrationError(400, 'serverSlug must be a safe path segment.');
+    return value;
+}
+function normalizeName(raw) {
+    return readRequired(raw, 'serverName');
+}
+function normalizeVersion(raw) {
+    return readRequired(raw, 'version');
+}
+function readRequired(raw, field) {
+    if (typeof raw !== 'string' || !raw.trim())
+        throw new HubServerRegistrationError(400, `${field} is required.`);
+    return raw.trim();
+}
+function normalizeHttpUrl(raw, field) {
+    const value = readRequired(raw, field).replace(/\/+$/u, '');
+    try {
+        const parsed = new URL(value);
+        if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:')
+            throw new Error('bad protocol');
+        return value;
+    }
+    catch {
+        throw new HubServerRegistrationError(400, `${field} must be an http(s) URL.`);
+    }
+}
+async function fetchServerIdentity(upstream) {
+    let response;
+    try {
+        response = await fetch(new URL('/api/server/identity', `${upstream}/`));
+    }
+    catch (error) {
+        throw new HubServerRegistrationError(502, `Failed to reach upstream identity: ${String(error?.message ?? error)}`);
+    }
+    if (!response.ok) {
+        throw new HubServerRegistrationError(502, `Upstream identity returned HTTP ${response.status}.`);
+    }
+    return await response.json();
+}
+function validateRegistry(registry) {
+    const ids = new Set();
+    const slugs = new Set();
+    for (const server of registry.servers) {
+        if (!server.serverId || !server.serverSlug || !server.serverName) {
+            throw new HubServerRegistrationError(500, 'Hub registry contains an invalid server entry.');
+        }
+        if (!SLUG_RE.test(server.serverSlug)) {
+            throw new HubServerRegistrationError(500, 'Hub registry contains an invalid server slug.');
+        }
+        if (server.connectionMode !== 'bridge') {
+            normalizeHttpUrl(server.upstream, 'upstream');
+        }
+        if (server.bridgeUrl)
+            normalizeHttpUrl(server.bridgeUrl, 'bridgeUrl');
+        if (ids.has(server.serverId) || slugs.has(server.serverSlug)) {
+            throw new HubServerRegistrationError(500, 'Hub registry contains duplicate server ids or slugs.');
+        }
+        ids.add(server.serverId);
+        slugs.add(server.serverSlug);
+    }
+}

package/dist/services/libraryManifest.js

@@ -0,0 +1,43 @@
+export function parseLibraryManifest(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || !Array.isArray(parsed.documents))
+            return null;
+        return {
+            version: typeof parsed.version === 'number' ? parsed.version : 1,
+            documents: parsed.documents.filter((doc) => Boolean(doc)
+                && typeof doc.title === 'string'
+                && typeof doc.relativePath === 'string'
+                && doc.relativePath.trim().length > 0),
+            processedSavedItemIds: Array.isArray(parsed.processedSavedItemIds)
+                ? parsed.processedSavedItemIds.filter((id) => typeof id === 'string' && id.trim().length > 0)
+                : [],
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function manifestDocumentsToLibraryDocuments(params) {
+    return params.documents.map((doc) => ({
+        userId: params.userId,
+        title: doc.title.trim(),
+        category: (doc.category ?? '').trim(),
+        topicPath: (doc.topicPath ?? '').trim(),
+        relativePath: doc.relativePath.trim().replace(/^\/+/, ''),
+        summary: (doc.summary ?? '').trim(),
+        sourceSavedItemIds: Array.isArray(doc.sourceSavedItemIds)
+            ? doc.sourceSavedItemIds.filter((id) => typeof id === 'string' && id.trim())
+            : [],
+        createdAt: params.now,
+        updatedAt: params.now,
+        lastRunId: params.runId,
+        notionPageId: doc.notionPageId ?? null,
+        notionPageUrl: doc.notionPageUrl ?? null,
+    }));
+}
+export const LIBRARY_MANIFEST_RELATIVE_PATH = '.meta/manifest.json';
+export const LIBRARY_LAST_RUN_RELATIVE_PATH = '.meta/last-run.json';
+export function buildDefaultLibraryManifest() {
+    return { version: 1, documents: [], processedSavedItemIds: [] };
+}

package/dist/services/libraryScaffold.js

@@ -0,0 +1,26 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { buildDefaultLibraryManifest, LIBRARY_MANIFEST_RELATIVE_PATH } from './libraryManifest.js';
+export function buildDefaultLibraryIndexContent() {
+    return [
+        '# Library Index',
+        '',
+        'Curated knowledge documents organized by category and topic.',
+        '',
+        'See `.meta/manifest.json` for the machine-readable index.',
+        '',
+    ].join('\n');
+}
+/** 初始化用户文库目录结构 */
+export function ensureLocalLibraryScaffold(libraryRoot) {
+    fs.mkdirSync(libraryRoot, { recursive: true });
+    fs.mkdirSync(path.join(libraryRoot, '.meta'), { recursive: true });
+    const indexPath = path.join(libraryRoot, 'INDEX.md');
+    if (!fs.existsSync(indexPath)) {
+        fs.writeFileSync(indexPath, buildDefaultLibraryIndexContent(), 'utf8');
+    }
+    const manifestPath = path.join(libraryRoot, LIBRARY_MANIFEST_RELATIVE_PATH);
+    if (!fs.existsSync(manifestPath)) {
+        fs.writeFileSync(manifestPath, `${JSON.stringify(buildDefaultLibraryManifest(), null, 2)}\n`, 'utf8');
+    }
+}