kubun 0.9.0 → 0.11.0

package/dist/commands/mcp.js

@@ -1,33 +0,0 @@
-import { createConfig } from '@kubun/mcp';
-import { serveProcess } from '@mokei/context-server';
-import { Command, Flags } from '@oclif/core';
-import { getSigner } from '../account.js';
-export default class MCP extends Command {
-    static description = 'Start an MCP server for Kubun';
-    static flags = {
-        connect: Flags.string({
-            char: 'c',
-            description: 'URL of an existing Kubun HTTP server to connect to',
-            exclusive: ['db'],
-        }),
-        db: Flags.string({
-            char: 'd',
-            description: 'SQLite database path or PostgreSQL URL',
-            exclusive: ['connect'],
-        }),
-        privateKey: Flags.string({
-            char: 'k',
-            description: 'base64-encoded private key',
-            env: 'KUBUN_PRIVATE_KEY',
-        }),
-    };
-    async run() {
-        const { flags } = await this.parse(MCP);
-        const config = await createConfig({
-            connect: flags.connect,
-            database: flags.db,
-            identity: flags.privateKey ? getSigner(flags.privateKey) : undefined,
-        });
-        serveProcess(config);
-    }
-}

package/dist/commands/model/cluster.js

@@ -1,35 +0,0 @@
-import { ClusterBuilder } from '@kubun/protocol';
-import { Command, Flags } from '@oclif/core';
-import ora from 'ora';
-import { writeJSON } from '../../fs.js';
-export default class CreateClusterModel extends Command {
-    static description = 'Create a documents cluster model';
-    static flags = {
-        model: Flags.string({
-            description: 'document model as JSON string',
-            char: 'm',
-            multiple: true,
-            required: true,
-        }),
-        output: Flags.file({
-            description: 'output file for the cluster',
-            char: 'o',
-        }),
-    };
-    async run() {
-        const spinner = ora('Creating cluster model...').start();
-        const { flags } = await this.parse(CreateClusterModel);
-        const builder = new ClusterBuilder();
-        builder.addAll(flags.model.map((model) => JSON.parse(model)));
-        const cluster = builder.build();
-        if (flags.output == null) {
-            spinner.succeed('Cluster model created');
-            this.log(JSON.stringify(cluster));
-        }
-        else {
-            await writeJSON(flags.output, cluster);
-            spinner.succeed(`Cluster model written to ${flags.output}`);
-        }
-        return cluster;
-    }
-}

package/dist/commands/model/create.js

@@ -1,69 +0,0 @@
-import { ClusterBuilder, } from '@kubun/protocol';
-import { Args, Command, Flags } from '@oclif/core';
-import ora from 'ora';
-import { writeJSON } from '../../fs.js';
-export default class CreateDocumentModel extends Command {
-    static description = 'Create a document model';
-    static args = {
-        name: Args.string({ description: 'document model name', required: true }),
-        schema: Args.string({ description: 'document schema as JSON string', required: true }),
-    };
-    static flags = {
-        behavior: Flags.string({
-            description: 'behavior of the document',
-            char: 'b',
-            options: ['default', 'interface', 'unique'],
-            default: 'default',
-        }),
-        cluster: Flags.boolean({
-            description: 'create a cluster model instead of a document model',
-            char: 'c',
-        }),
-        output: Flags.file({
-            description: 'output file',
-            char: 'o',
-        }),
-        uniqueField: Flags.string({
-            description: 'unique field of the document when behavior is set to "unique"',
-            char: 'u',
-            multiple: true,
-        }),
-    };
-    async run() {
-        const spinner = ora('Creating document model...').start();
-        const { args, flags } = await this.parse(CreateDocumentModel);
-        const behavior = flags.behavior;
-        const model = {
-            name: args.name,
-            behavior,
-            schema: JSON.parse(args.schema),
-        };
-        if (behavior === 'unique') {
-            model.uniqueFields = flags.uniqueField;
-        }
-        const builder = new ClusterBuilder();
-        builder.add(model);
-        if (flags.cluster) {
-            const cluster = builder.build();
-            if (flags.output == null) {
-                spinner.succeed('Cluster model created');
-                this.log(JSON.stringify(cluster));
-            }
-            else {
-                await writeJSON(flags.output, cluster);
-                spinner.succeed(`Cluster model written to ${flags.output}`);
-            }
-            return cluster;
-        }
-        const document = builder.cluster[0];
-        if (flags.output == null) {
-            spinner.succeed('Document model created');
-            this.log(JSON.stringify(document));
-        }
-        else {
-            await writeJSON(flags.output, document);
-            spinner.succeed(`Document model written to ${flags.output}`);
-        }
-        return document;
-    }
-}

package/dist/commands/serve.js

@@ -1,126 +0,0 @@
-import { fromB64, toB64 } from '@enkaku/codec';
-import { createFullIdentity, randomIdentity } from '@enkaku/token';
-import { NodeSQLiteAdapter } from '@kubun/db-node-sqlite';
-import { PostgresAdapter } from '@kubun/db-postgres';
-import { KubunEngine } from '@kubun/engine';
-import { getKubunLogger } from '@kubun/logger';
-import { createHTTPPlugin } from '@kubun/plugin-http';
-import { createP2PPlugin } from '@kubun/plugin-p2p';
-import { createRPCPlugin } from '@kubun/plugin-rpc';
-import { configureSync, getConsoleSink, getLogLevels } from '@logtape/logtape';
-import { Command, Flags } from '@oclif/core';
-import ora from 'ora';
-import { resolvePath } from '../fs.js';
-export default class Serve extends Command {
-    static description = 'Start a local Kubun server';
-    static flags = {
-        allowedOrigin: Flags.string({
-            char: 'a',
-            description: 'allowed HTTP origin',
-            env: 'KUBUN_ALLOWED_ORIGIN',
-            default: '*',
-        }),
-        autoAcceptPeers: Flags.string({
-            description: 'comma-separated DIDs to auto-accept for peer join flows',
-            dependsOn: ['p2p'],
-        }),
-        db: Flags.file({ description: 'path to the local SQLite database' }),
-        id: Flags.string({ description: 'server ID' }),
-        logLevel: Flags.string({
-            char: 'l',
-            description: 'log level',
-            options: getLogLevels(),
-            default: 'warning',
-        }),
-        p2p: Flags.boolean({ description: 'enable P2P mode with sync and graph protocols over HTTP' }),
-        port: Flags.integer({ char: 'p', description: 'port to listen on' }),
-        privateKey: Flags.string({
-            char: 'k',
-            description: 'base64-encoded private key',
-            env: 'KUBUN_PRIVATE_KEY',
-            exclusive: ['id'],
-        }),
-    };
-    async run() {
-        const spinner = ora();
-        const { flags } = await this.parse(Serve);
-        spinner.start('Starting the server...');
-        // Configure logging
-        configureSync({
-            reset: true,
-            sinks: { console: getConsoleSink() },
-            loggers: [
-                { category: ['logtape', 'meta'], lowestLevel: 'error', sinks: ['console'] },
-                {
-                    category: ['kubun'],
-                    lowestLevel: (flags.logLevel ?? 'warning'),
-                    sinks: ['console'],
-                },
-            ],
-        });
-        // Resolve identity
-        const logger = getKubunLogger('cli');
-        let identity;
-        if (flags.privateKey != null) {
-            const privateKey = fromB64(flags.privateKey);
-            identity = { ...createFullIdentity(privateKey), privateKey };
-        }
-        else if (flags.id != null) {
-            if (flags.p2p) {
-                this.error('P2P mode requires a signing identity. Use --private-key instead of --id.');
-            }
-            identity = { id: flags.id };
-        }
-        else {
-            const generated = randomIdentity();
-            logger.warn('Generated random identity for server: {privateKey}, DID: {id}', {
-                id: generated.id,
-                privateKey: toB64(generated.privateKey),
-            });
-            identity = generated;
-        }
-        // Create DB adapter
-        const adapter = flags.db == null || flags.db === ':memory:'
-            ? new NodeSQLiteAdapter({ database: ':memory:' })
-            : flags.db.startsWith('postgres://') || flags.db.startsWith('postgresql://')
-                ? new PostgresAdapter({ url: flags.db })
-                : new NodeSQLiteAdapter({ database: resolvePath(flags.db) });
-        // Build plugin list
-        const autoAcceptPeers = flags.autoAcceptPeers
-            ? flags.autoAcceptPeers.split(',').map((s) => s.trim())
-            : undefined;
-        const rpcAccessRules = autoAcceptPeers != null ? { '*': { allow: [identity.id, ...autoAcceptPeers] } } : undefined;
-        const plugins = [
-            createRPCPlugin({
-                ...(rpcAccessRules != null ? { accessRules: rpcAccessRules } : undefined),
-                allowDelegatedMutations: flags.p2p,
-            }),
-            createHTTPPlugin({ port: flags.port, allowedOrigin: flags.allowedOrigin }),
-        ];
-        if (flags.p2p) {
-            plugins.push(createP2PPlugin({ http: true, autoAcceptPeers }));
-        }
-        // Create engine with plugins
-        const engine = new KubunEngine({
-            db: adapter,
-            identity,
-            plugins,
-        });
-        const http = await engine.getAPI('http');
-        await http.listening;
-        if (flags.p2p) {
-            const p2p = await engine.getAPI('p2p');
-            await p2p.syncReady;
-        }
-        spinner.succeed(`HTTP server listening at ${http.getURL()}\n  DID: ${identity.id}\n`);
-        if (flags.p2p && autoAcceptPeers) {
-            this.log(`  Auto-accept peers: ${autoAcceptPeers.length} DID(s)`);
-        }
-        // Keep process alive until SIGINT/SIGTERM
-        await new Promise((resolve) => {
-            process.once('SIGINT', resolve);
-            process.once('SIGTERM', resolve);
-        });
-        await engine.dispose();
-    }
-}

package/dist/index.js

@@ -1 +0,0 @@
-export { run } from '@oclif/core';