kubun 0.7.0 → 0.8.0

package/README.md

@@ -20,7 +20,7 @@ $ npm install -g kubun
 $ kubun COMMAND
 running command...
 $ kubun (--version)
-kubun/0.7.0 darwin-arm64 node-v24.14.0
+kubun/0.8.0 darwin-arm64 node-v24.14.1
 $ kubun --help [COMMAND]
 USAGE
   $ kubun COMMAND
@@ -163,7 +163,7 @@ DESCRIPTION
   Display help for kubun.
 ```
 
-_See code: [@oclif/plugin-help](https://github.com/oclif/plugin-help/blob/v6.2.37/src/commands/help.ts)_
+_See code: [@oclif/plugin-help](https://github.com/oclif/plugin-help/blob/6.2.44/src/commands/help.ts)_
 
 ## `kubun mcp`
 
@@ -227,17 +227,19 @@ Start a local Kubun server
 
 ```
 USAGE
-  $ kubun serve [-a <value>] [--db <value>] [-l trace|debug|info|warning|error|fatal] [-p <value>] [-k
-    <value> | --id <value>]
+  $ kubun serve [-a <value>] [--autoAcceptPeers <value> --p2p] [--db <value>] [-l
+    trace|debug|info|warning|error|fatal] [-p <value>] [-k <value> | --id <value>]
 
 FLAGS
-  -a, --allowedOrigin=<value>  [default: *, env: KUBUN_ALLOWED_ORIGIN] allowed HTTP origin
-  -k, --privateKey=<value>     [env: KUBUN_PRIVATE_KEY] base64-encoded private key
-  -l, --logLevel=<option>      [default: warning] log level
-                               <options: trace|debug|info|warning|error|fatal>
-  -p, --port=<value>           port to listen on
-      --db=<value>             path to the local SQLite database
-      --id=<value>             server ID
+  -a, --allowedOrigin=<value>    [default: *, env: KUBUN_ALLOWED_ORIGIN] allowed HTTP origin
+  -k, --privateKey=<value>       [env: KUBUN_PRIVATE_KEY] base64-encoded private key
+  -l, --logLevel=<option>        [default: warning] log level
+                                 <options: trace|debug|info|warning|error|fatal>
+  -p, --port=<value>             port to listen on
+      --autoAcceptPeers=<value>  comma-separated DIDs to auto-accept for peer join flows
+      --db=<value>               path to the local SQLite database
+      --id=<value>               server ID
+      --p2p                      enable P2P mode with sync and graph protocols over HTTP
 
 DESCRIPTION
   Start a local Kubun server

package/dist/commands/graphql/schema.js

@@ -1,5 +1,5 @@
 import { createSchema } from '@kubun/graphql';
-import { GraphModel } from '@kubun/protocol';
+import { clusterToRecord, GraphModel, } from '@kubun/protocol';
 import { Command, Flags } from '@oclif/core';
 import { printSchema } from 'graphql';
 import ora from 'ora';
@@ -21,7 +21,11 @@ export default class CreateGraphQLSchema extends Command {
     async run() {
         const spinner = ora('Loading clusters...').start();
         const { flags } = await this.parse(CreateGraphQLSchema);
-        const clusters = await Promise.all(flags.cluster.map((path) => readJSON(path)));
+        const clusterModels = await Promise.all(flags.cluster.map((path) => readJSON(path)));
+        const clusters = {};
+        for (const cluster of clusterModels) {
+            Object.assign(clusters, clusterToRecord(cluster));
+        }
         const model = GraphModel.fromClusters({ clusters });
         const schema = printSchema(createSchema(model));
         if (flags.output == null) {

package/dist/commands/mcp.js

@@ -23,7 +23,7 @@ export default class MCP extends Command {
     };
     async run() {
         const { flags } = await this.parse(MCP);
-        const config = createConfig({
+        const config = await createConfig({
             connect: flags.connect,
             database: flags.db,
             identity: flags.privateKey ? getSigner(flags.privateKey) : undefined,

package/dist/commands/serve.js

@@ -1,5 +1,13 @@
-import { startServer } from '@kubun/http-server';
-import { getLogLevels } from '@logtape/logtape';
+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';
@@ -12,6 +20,10 @@ export default class Serve extends Command {
             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({
@@ -20,6 +32,7 @@ export default class Serve extends Command {
             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',
@@ -32,28 +45,79 @@ export default class Serve extends Command {
         const spinner = ora();
         const { flags } = await this.parse(Serve);
         spinner.start('Starting the server...');
-        const options = {
-            allowedOrigin: flags.allowedOrigin,
-            logLevel: flags.logLevel,
-        };
-        if (flags.port != null) {
-            options.port = flags.port;
-        }
+        // 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) {
-            options.privateKey = flags.privateKey;
+            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 rpcAccessControl = autoAcceptPeers != null ? { '*': [identity.id, ...autoAcceptPeers] } : undefined;
+        const plugins = [
+            createRPCPlugin(rpcAccessControl != null ? { accessControl: rpcAccessControl } : undefined),
+            createHTTPPlugin({ port: flags.port, allowedOrigin: flags.allowedOrigin }),
+        ];
+        if (flags.p2p) {
+            plugins.push(createP2PPlugin({ http: true, autoAcceptPeers }));
         }
-        if (flags.id != null) {
-            options.identity = { id: flags.id };
+        // 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;
         }
-        if (flags.db != null) {
-            options.db =
-                flags.db.startsWith('postgres://') || flags.db.startsWith('postgresql://')
-                    ? flags.db
-                    : resolvePath(flags.db);
+        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)`);
         }
-        const server = await startServer(options);
-        spinner.succeed(`HTTP server listening at ${server.url}`);
-        // Keep process alive until server is closed (via SIGINT/SIGTERM handled by @kubun/http-server)
-        await new Promise(() => { });
+        // Keep process alive until SIGINT/SIGTERM
+        await new Promise((resolve) => {
+            process.once('SIGINT', resolve);
+            process.once('SIGTERM', resolve);
+        });
+        await engine.dispose();
     }
 }

package/oclif.manifest.json

@@ -67,6 +67,16 @@
           "multiple": false,
           "type": "option"
         },
+        "autoAcceptPeers": {
+          "dependsOn": [
+            "p2p"
+          ],
+          "description": "comma-separated DIDs to auto-accept for peer join flows",
+          "name": "autoAcceptPeers",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
         "db": {
           "description": "path to the local SQLite database",
           "name": "db",
@@ -98,6 +108,12 @@
           ],
           "type": "option"
         },
+        "p2p": {
+          "description": "enable P2P mode with sync and graph protocols over HTTP",
+          "name": "p2p",
+          "allowNo": false,
+          "type": "boolean"
+        },
         "port": {
           "char": "p",
           "description": "port to listen on",
@@ -513,5 +529,5 @@
       ]
     }
   },
-  "version": "0.7.0"
+  "version": "0.8.0"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kubun",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "license": "see LICENSE.md",
   "description": "Kubun CLI",
   "keywords": [],
@@ -29,32 +29,38 @@
   },
   "dependencies": {
     "@enkaku/codec": "^0.14.0",
-    "@enkaku/token": "0.14.0",
-    "@logtape/logtape": "^2.0.4",
+    "@enkaku/token": "0.14.1",
+    "@logtape/logtape": "^2.0.5",
     "@mokei/context-server": "^0.6.0",
-    "@oclif/core": "^4.8.3",
-    "@oclif/plugin-help": "^6.2.37",
-    "@oclif/plugin-plugins": "^5.4.57",
-    "graphql": "^16.13.1",
+    "@oclif/core": "^4.10.3",
+    "@oclif/plugin-help": "^6.2.44",
+    "@oclif/plugin-plugins": "^5.4.60",
+    "graphql": "^16.13.2",
     "ora": "^9.3.0",
-    "@kubun/client": "^0.7.0",
-    "@kubun/http-client": "^0.7.0",
-    "@kubun/graphql": "^0.7.0",
-    "@kubun/http-server": "^0.7.0",
-    "@kubun/protocol": "^0.7.0",
-    "@kubun/mcp": "^0.7.0"
+    "@kubun/graphql": "^0.8.0",
+    "@kubun/client": "^0.8.0",
+    "@kubun/db-node-sqlite": "^0.8.0",
+    "@kubun/http-client": "^0.8.0",
+    "@kubun/engine": "^0.8.0",
+    "@kubun/db-postgres": "^0.8.0",
+    "@kubun/plugin-http": "^0.8.0",
+    "@kubun/plugin-p2p": "^0.8.0",
+    "@kubun/plugin-rpc": "^0.8.0",
+    "@kubun/protocol": "^0.8.0",
+    "@kubun/logger": "^0.8.0",
+    "@kubun/mcp": "^0.8.0"
   },
   "devDependencies": {
-    "@oclif/test": "^4.1.16",
-    "oclif": "^4.22.85",
+    "@oclif/test": "^4.1.17",
+    "oclif": "^4.22.96",
     "ts-node": "^10",
-    "typescript": "^5.9.3"
+    "typescript": "^6.0.2"
   },
   "scripts": {
     "kubun": "./bin/dev.js",
     "build": "del dist && tsc -b",
     "posttest": "pnpm run lint",
-    "test:types": "tsc --noEmit --skipLibCheck",
+    "test:types": "tsc --noEmit",
     "test:unit": "OCLIF_TEST_ROOT=. vitest run",
     "test": "pnpm run test:types && pnpm run test:unit",
     "version": "oclif readme && git add README.md"