kubun 0.10.0 → 0.12.0

package/{dist → lib}/fs.js

@@ -4,10 +4,14 @@ export function resolvePath(value) {
     return isAbsolute(value) ? value : resolve(process.cwd(), value);
 }
 export async function readJSON(path) {
-    return JSON.parse(await read(resolvePath(path), { encoding: 'utf8' }));
+    return JSON.parse(await read(resolvePath(path), {
+        encoding: 'utf8'
+    }));
 }
 export async function writeFile(path, value) {
-    await write(resolvePath(path), value, { encoding: 'utf8' });
+    await write(resolvePath(path), value, {
+        encoding: 'utf8'
+    });
 }
 export async function writeJSON(path, value, format = false) {
     await writeFile(path, format ? JSON.stringify(value, null, 2) : JSON.stringify(value));

package/lib/hub.d.ts

@@ -0,0 +1,38 @@
+import { type HubAuthConfig, type Relay, type RelayObservers } from '@kubun/hub';
+export type StartHubParams = {
+    /**
+     * Who may use the relay. Required: an unset `auth` would leave `createRelay`
+     * with no access rules at all, which refuses every DID without saying so.
+     */
+    auth: HubAuthConfig;
+    /** SQLite path, `:memory:`, or a postgres URL. Defaults to `:memory:`. */
+    db?: string;
+    /**
+     * Base64 private key for the hub's signing identity. Absent generates an
+     * ephemeral one — every client holding the old DID then has to rediscover it
+     * from `/info`, which is why `resolveIdentity` warns about it.
+     */
+    privateKey?: string;
+    allowedOrigin?: string;
+    /** Bind port. Absent probes for a free one, preferring {@link DEFAULT_HUB_PORT}. */
+    port?: number;
+    /** Relay diagnostics — auth refusals, stores, fetches. */
+    observers?: RelayObservers;
+};
+export type StartedHub = {
+    /** The relay endpoint a device binds a group to. */
+    url: string;
+    /** The hub's DID — the audience of every token it accepts, served at `/info`. */
+    did: string;
+    relay: Relay;
+    dispose: () => Promise<void>;
+};
+/**
+ * Serve a blind relay hub over HTTP.
+ *
+ * The hub holds no group state and is a member of nothing: it stores encrypted
+ * envelopes and serves topic subscriptions for groups it cannot read. Its only
+ * authentication is `auth`, checked against the issuer of each signed Enkaku
+ * envelope — there is nothing to check at the HTTP layer.
+ */
+export declare function startHub(params: StartHubParams): Promise<StartedHub>;

package/lib/hub.js

@@ -0,0 +1,109 @@
+import { serve } from '@hono/node-server';
+import { NodeSQLiteAdapter } from '@kubun/db-node-sqlite';
+import { PostgresAdapter } from '@kubun/db-postgres';
+import { createRelay } from '@kubun/hub';
+import { getKubunLogger } from '@kubun/logger';
+import { getPort } from '@tejika/env';
+import { resolvePath } from './fs.js';
+import { resolveIdentity } from './identity.js';
+/**
+ * Where the relay's Enkaku transport is mounted. The relay is path-agnostic —
+ * it is one transport behind a `fetch` — so this prefix is ours to pick, and it
+ * is the URL a device binds a group to.
+ */ const RELAY_PATH = '/relay';
+/**
+ * The name `/info` advertises the relay mount under, mirroring how a device's
+ * HTTP surface advertises its own protocols. A device binds the mount path
+ * directly, so this is discovery for a reader that has only the origin.
+ */ const RELAY_PROTOCOL_NAME = 'relay';
+/** Preferred port when none is given; a taken one yields another free port. */ const DEFAULT_HUB_PORT = 4321;
+/**
+ * Serve a blind relay hub over HTTP.
+ *
+ * The hub holds no group state and is a member of nothing: it stores encrypted
+ * envelopes and serves topic subscriptions for groups it cannot read. Its only
+ * authentication is `auth`, checked against the issuer of each signed Enkaku
+ * envelope — there is nothing to check at the HTTP layer.
+ */ export async function startHub(params) {
+    const logger = getKubunLogger('cli');
+    // No `--id` counterpart here: the relay signs its own response tokens, so an
+    // identity that cannot sign is not a hub identity.
+    const identity = resolveIdentity({
+        privateKey: params.privateKey
+    }, logger);
+    const adapter = params.db == null || params.db === ':memory:' ? new NodeSQLiteAdapter({
+        database: ':memory:'
+    }) : params.db.startsWith('postgres://') || params.db.startsWith('postgresql://') ? new PostgresAdapter({
+        url: params.db
+    }) : new NodeSQLiteAdapter({
+        database: resolvePath(params.db)
+    });
+    const relay = await createRelay({
+        db: adapter,
+        identity,
+        auth: params.auth,
+        retention: {
+            olderThanSeconds: 30 * 24 * 60 * 60
+        },
+        ...params.allowedOrigin == null ? {} : {
+            allowedOrigin: params.allowedOrigin
+        },
+        ...params.observers == null ? {} : {
+            observers: params.observers
+        }
+    });
+    // OPTIONS is served alongside POST: the relay answers the CORS preflight
+    // itself, and a POST-only mount leaves a browser client unable to reach it.
+    const handler = async (request)=>{
+        const { pathname } = new URL(request.url);
+        if (pathname === RELAY_PATH || pathname.startsWith(`${RELAY_PATH}/`)) {
+            return request.method === 'POST' || request.method === 'OPTIONS' ? await relay.fetch(request) : new Response(null, {
+                status: 405
+            });
+        }
+        if (request.method === 'GET' && pathname === '/health') {
+            return Response.json({
+                status: 'ok'
+            });
+        }
+        // Discovery, in the shape a device already reads from another device's
+        // `/info`: the DID every token addressed to this hub must name, plus where
+        // the relay is mounted. A hub advertising a DID it cannot sign with is
+        // simply unreachable — its own server refuses the audience — so nothing
+        // here has to be verified by the reader.
+        if (request.method === 'GET' && pathname === '/info') {
+            return Response.json({
+                did: identity.id,
+                protocols: {
+                    [RELAY_PROTOCOL_NAME]: RELAY_PATH
+                }
+            });
+        }
+        return new Response(null, {
+            status: 404
+        });
+    };
+    const port = params.port ?? await getPort('kubun', {
+        default: DEFAULT_HUB_PORT
+    });
+    const httpServer = await new Promise((resolve)=>{
+        const server = serve({
+            fetch: handler,
+            port
+        }, ()=>resolve(server));
+    });
+    return {
+        url: `http://localhost:${port}${RELAY_PATH}`,
+        did: identity.id,
+        relay,
+        dispose: async ()=>{
+            await new Promise((resolve, reject)=>{
+                httpServer.close((error)=>{
+                    if (error == null) resolve();
+                    else reject(error);
+                });
+            });
+            await relay.dispose();
+        }
+    };
+}

package/lib/identity.d.ts

@@ -0,0 +1,19 @@
+import type { Identity, OwnIdentity } from '@kokuin/token';
+type Logger = {
+    warn: (message: string, properties?: Record<string, unknown>) => void;
+};
+export type IdentityOptions = {
+    privateKey?: string;
+    id?: string;
+    p2p?: boolean;
+};
+/**
+ * Resolve the server signing identity from CLI options.
+ *
+ * The random-identity fallback logs only the DID — never the private key — and
+ * flags that the identity is ephemeral so it is not mistaken for a persistent
+ * one. Logging the key would leak the server's signing secret to console sinks
+ * and log aggregation.
+ */
+export declare function resolveIdentity(opts: IdentityOptions, logger: Logger): Identity | OwnIdentity;
+export {};

package/lib/identity.js

@@ -0,0 +1,31 @@
+import { createFullIdentity, randomIdentity } from '@kokuin/token';
+import { fromB64 } from '@sozai/codec';
+/**
+ * Resolve the server signing identity from CLI options.
+ *
+ * The random-identity fallback logs only the DID — never the private key — and
+ * flags that the identity is ephemeral so it is not mistaken for a persistent
+ * one. Logging the key would leak the server's signing secret to console sinks
+ * and log aggregation.
+ */ export function resolveIdentity(opts, logger) {
+    if (opts.privateKey != null) {
+        const privateKey = fromB64(opts.privateKey);
+        return {
+            ...createFullIdentity(privateKey),
+            privateKey
+        };
+    }
+    if (opts.id != null) {
+        if (opts.p2p) {
+            throw new Error('P2P mode requires a signing identity. Use --private-key instead of --id.');
+        }
+        return {
+            id: opts.id
+        };
+    }
+    const generated = randomIdentity();
+    logger.warn('No identity provided; generated an ephemeral one (DID: {id}). It is discarded on exit — pass --private-key or --id to persist.', {
+        id: generated.id
+    });
+    return generated;
+}

package/lib/index.d.ts

@@ -0,0 +1,3 @@
+import { buildProgram } from './program.js';
+export { buildProgram };
+export declare function run(argv: Array<string>): Promise<void>;

package/lib/index.js

@@ -0,0 +1,19 @@
+import { buildProgram } from './program.js';
+export { buildProgram };
+export async function run(argv) {
+    const program = buildProgram();
+    if (argv.slice(2).length === 0) {
+        program.outputHelp();
+        return;
+    }
+    try {
+        await program.parseAsync(argv);
+    } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`✘ ${message}\n`);
+        if (process.env.KUBUN_DEBUG === '1' && error instanceof Error && error.stack != null) {
+            process.stderr.write(`${error.stack}\n`);
+        }
+        process.exitCode = 1;
+    }
+}

package/lib/options.d.ts

@@ -0,0 +1,19 @@
+import type { Command } from 'commander';
+/** Add `-k, --private-key <key>`, bound to KUBUN_PRIVATE_KEY, optionally required. */
+export declare function withPrivateKey(cmd: Command, opts?: {
+    required?: boolean;
+}): Command;
+/** Add `--url <url>` for the Kubun server URL. */
+export declare function withURL(cmd: Command): Command;
+/** Add `-l, --log-level <level>` with the `warning` default and the logtape level set. */
+export declare function withLogLevel(cmd: Command): Command;
+/** Add `-p, --port <port>`, default resolved lazily from @tejika/env at action time. */
+export declare function withPort(cmd: Command): Command;
+/**
+ * Add `-a, --allowed-origin <origin>`, bound to KUBUN_ALLOWED_ORIGIN.
+ *
+ * No default: an unset option denies cross-origin browser requests. Opening a
+ * surface is an explicit choice — pass `-a '*'` to reflect any origin, or a
+ * comma-separated list to allow only those.
+ */
+export declare function withAllowedOrigin(cmd: Command): Command;

package/lib/options.js

@@ -0,0 +1,47 @@
+import { getLogLevels } from '@logtape/logtape';
+import { getAppEnvVar, getPort } from '@tejika/env';
+/** Add `-k, --private-key <key>`, bound to KUBUN_PRIVATE_KEY, optionally required. */ export function withPrivateKey(cmd, opts = {}) {
+    cmd.option('-k, --private-key <key>', 'base64-encoded private key (env: KUBUN_PRIVATE_KEY)');
+    cmd.hook('preAction', (_thisCmd, actionCmd)=>{
+        if (actionCmd.opts().privateKey == null && process.env.KUBUN_PRIVATE_KEY != null) {
+            actionCmd.setOptionValue('privateKey', process.env.KUBUN_PRIVATE_KEY);
+        }
+        if (opts.required && actionCmd.opts().privateKey == null) {
+            throw new Error('--private-key is required (or set KUBUN_PRIVATE_KEY)');
+        }
+    });
+    return cmd;
+}
+/** Add `--url <url>` for the Kubun server URL. */ export function withURL(cmd) {
+    return cmd.option('--url <url>', 'Kubun server URL');
+}
+/** Add `-l, --log-level <level>` with the `warning` default and the logtape level set. */ export function withLogLevel(cmd) {
+    return cmd.option('-l, --log-level <level>', `log level (${getLogLevels().join(', ')})`, 'warning');
+}
+/** Add `-p, --port <port>`, default resolved lazily from @tejika/env at action time. */ export function withPort(cmd) {
+    cmd.option('-p, --port <port>', 'port to listen on');
+    cmd.hook('preAction', async (_thisCmd, actionCmd)=>{
+        if (actionCmd.opts().port == null) {
+            actionCmd.setOptionValue('port', await getPort('kubun'));
+        }
+    });
+    return cmd;
+}
+/**
+ * Add `-a, --allowed-origin <origin>`, bound to KUBUN_ALLOWED_ORIGIN.
+ *
+ * No default: an unset option denies cross-origin browser requests. Opening a
+ * surface is an explicit choice — pass `-a '*'` to reflect any origin, or a
+ * comma-separated list to allow only those.
+ */ export function withAllowedOrigin(cmd) {
+    cmd.option('-a, --allowed-origin <origin>', 'allowed HTTP origin(s), comma-separated (env: KUBUN_ALLOWED_ORIGIN); unset denies cross-origin browser requests');
+    cmd.hook('preAction', (_thisCmd, actionCmd)=>{
+        if (actionCmd.opts().allowedOrigin == null) {
+            const envOrigin = getAppEnvVar('kubun', 'ALLOWED_ORIGIN');
+            if (envOrigin != null) {
+                actionCmd.setOptionValue('allowedOrigin', envOrigin);
+            }
+        }
+    });
+    return cmd;
+}

package/lib/program.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function buildProgram(): Command;

package/lib/program.js

@@ -0,0 +1,32 @@
+import { readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { buildProgram as tejikaBuildProgram } from '@tejika/cli';
+import { createAccountCommand } from './commands/account.js';
+import { createGraphCommand } from './commands/graph.js';
+import { createGraphQLCommand } from './commands/graphql.js';
+import { createHubCommand } from './commands/hub.js';
+import { createMCPCommand } from './commands/mcp.js';
+import { createModelCommand } from './commands/model.js';
+import { createPeerCommand } from './commands/peer.js';
+import { createServeCommand } from './commands/serve.js';
+const pkgPath = resolve(dirname(fileURLToPath(import.meta.url)), '../package.json');
+const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+export function buildProgram() {
+    const program = tejikaBuildProgram({
+        name: 'kubun',
+        version: pkg.version,
+        commands: [
+            createAccountCommand(),
+            createGraphCommand(),
+            createGraphQLCommand(),
+            createHubCommand(),
+            createModelCommand(),
+            createMCPCommand(),
+            createPeerCommand(),
+            createServeCommand()
+        ]
+    });
+    program.description(pkg.description);
+    return program;
+}

package/lib/ui.d.ts

@@ -0,0 +1,5 @@
+import { type SystemNoticeVariant } from '@tejika/ui';
+/** Render a one-shot status notice to stderr, then unmount. */
+export declare function renderNotice(variant: SystemNoticeVariant, text: string): void;
+/** Show a live spinner on stderr for the duration of `fn`, then unmount. */
+export declare function withSpinner<T>(label: string, fn: () => Promise<T>): Promise<T>;

package/lib/ui.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Spinner, SystemNotice } from '@tejika/ui';
+import { render } from 'ink';
+const renderToStderr = {
+    stdout: process.stderr
+};
+/** Render a one-shot status notice to stderr, then unmount. */ export function renderNotice(variant, text) {
+    const { unmount } = render(/*#__PURE__*/ _jsx(SystemNotice, {
+        variant: variant,
+        text: text
+    }), {
+        ...renderToStderr,
+        // Nothing to protect from interleaved logs: this mounts and unmounts in one
+        // turn. Patching the global console for that costs a process-wide side
+        // effect, and throws outright wherever `console` is already a stand-in.
+        patchConsole: false
+    });
+    unmount();
+}
+/** Show a live spinner on stderr for the duration of `fn`, then unmount. */ export async function withSpinner(label, fn) {
+    const app = render(/*#__PURE__*/ _jsx(Spinner, {
+        label: label
+    }), renderToStderr);
+    try {
+        return await fn();
+    } finally{
+        app.unmount();
+    }
+}

package/package.json

@@ -1,68 +1,65 @@
 {
   "name": "kubun",
-  "version": "0.10.0",
-  "license": "see LICENSE.md",
+  "version": "0.12.0",
   "description": "Kubun CLI",
   "keywords": [],
+  "license": "see LICENSE.md",
   "type": "module",
-  "engines": {
-    "node": ">=22.0.0"
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "bin": {
+    "kubun": "./bin/run.js"
   },
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
   "files": [
     "/bin",
-    "/dist",
-    "/oclif.manifest.json"
+    "/lib"
   ],
-  "bin": {
-    "kubun": "./bin/run.js"
-  },
-  "oclif": {
-    "bin": "kubun",
-    "dirname": "kubun",
-    "commands": "./dist/commands",
-    "plugins": [
-      "@oclif/plugin-help"
-    ],
-    "topicSeparator": " "
-  },
   "dependencies": {
-    "@enkaku/codec": "^0.16.0",
-    "@enkaku/token": "^0.16.0",
-    "@logtape/logtape": "^2.1.1",
-    "@mokei/context-server": "^0.7.0",
-    "@oclif/core": "^4.11.4",
-    "@oclif/plugin-help": "^6.2.49",
-    "@oclif/plugin-plugins": "^5.4.69",
-    "graphql": "^16.13.2",
-    "ora": "^9.4.0",
-    "@kubun/client": "^0.10.0",
-    "@kubun/db-node-sqlite": "^0.10.0",
-    "@kubun/db-postgres": "^0.10.0",
-    "@kubun/graphql": "^0.10.0",
-    "@kubun/engine": "^0.10.0",
-    "@kubun/plugin-http": "^0.10.0",
-    "@kubun/http-client": "^0.10.0",
-    "@kubun/plugin-p2p": "^0.10.0",
-    "@kubun/mcp": "^0.10.0",
-    "@kubun/logger": "^0.10.0",
-    "@kubun/plugin-rpc": "^0.10.0",
-    "@kubun/protocol": "^0.10.0"
+    "@hono/node-server": "^2.1.0",
+    "@kokuin/token": "^0.3.0",
+    "@logtape/logtape": "^2.3.0",
+    "@mokei/context-server": "^0.11.0",
+    "@sozai/codec": "^0.4.0",
+    "@tejika/cli": "^0.4.0",
+    "@tejika/env": "^0.4.0",
+    "@tejika/ui": "^0.4.0",
+    "commander": "^15.0.0",
+    "graphql": "^16.14.2",
+    "ink": "^7.1.1",
+    "react": "19.2.3",
+    "@kubun/db": "^0.12.0",
+    "@kubun/client": "^0.12.0",
+    "@kubun/db-node-sqlite": "^0.12.0",
+    "@kubun/graphql": "^0.12.0",
+    "@kubun/http-client": "^0.12.0",
+    "@kubun/logger": "^0.12.0",
+    "@kubun/db-postgres": "^0.12.0",
+    "@kubun/mcp": "^0.12.0",
+    "@kubun/hub": "^0.12.0",
+    "@kubun/engine": "^0.12.0",
+    "@kubun/plugin-p2p": "^0.12.0",
+    "@kubun/plugin-http": "^0.12.0",
+    "@kubun/protocol": "^0.12.0",
+    "@kubun/plugin-rpc": "^0.12.0"
   },
   "devDependencies": {
-    "@oclif/test": "^4.1.17",
-    "oclif": "^4.23.8",
-    "ts-node": "^10",
-    "typescript": "^6.0.3"
+    "ink-testing-library": "^4.0.0",
+    "@kubun/store-graph": "^0.12.0",
+    "@kubun/id": "^0.12.0",
+    "@kubun/store-p2p": "^0.12.0"
+  },
+  "engines": {
+    "node": ">=22.0.0"
   },
   "scripts": {
+    "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",
+    "build:clean": "del lib",
+    "build:js": "swc src -d ./lib --config-file ../../node_modules/@kigu/dev/swc.json --strip-leading-paths",
+    "build:types": "tsc --emitDeclarationOnly --skipLibCheck",
+    "build:types:ci": "tsc --emitDeclarationOnly --skipLibCheck --declarationMap false",
     "kubun": "./bin/dev.js",
-    "build": "del dist && tsc -b",
-    "posttest": "pnpm run lint",
-    "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"
+    "test:types": "tsc --noEmit --skipLibCheck -p tsconfig.test.json",
+    "test:unit": "vitest run"
   }
 }

package/bin/dev.cmd

@@ -1,3 +0,0 @@
-@echo off
-
-node --loader ts-node/esm --no-warnings=ExperimentalWarning "%~dp0\dev" %*

package/bin/run.cmd

@@ -1,3 +0,0 @@
-@echo off
-
-node "%~dp0\run" %*

package/dist/account.js

@@ -1,5 +0,0 @@
-import { fromB64 } from '@enkaku/codec';
-import { createSigningIdentity } from '@enkaku/token';
-export function getSigner(key) {
-    return createSigningIdentity(fromB64(key));
-}

package/dist/commands/account/generate.js

@@ -1,10 +0,0 @@
-import { toB64 } from '@enkaku/codec';
-import { randomPrivateKey } from '@enkaku/token';
-import { Command } from '@oclif/core';
-export default class GenerateAccount extends Command {
-    static description = 'Generate a random private key to use as account signer';
-    async run() {
-        const key = await randomPrivateKey();
-        this.log(toB64(key));
-    }
-}

package/dist/commands/account/id.js

@@ -1,18 +0,0 @@
-import { Command, Flags } from '@oclif/core';
-import { getSigner } from '../../account.js';
-export default class AccountID extends Command {
-    static description = 'Display the DID of an account given its private key';
-    static flags = {
-        privateKey: Flags.string({
-            description: 'base64-encoded private key',
-            char: 'k',
-            env: 'KUBUN_PRIVATE_KEY',
-            required: true,
-        }),
-    };
-    async run() {
-        const { flags } = await this.parse(AccountID);
-        const signer = getSigner(flags.privateKey);
-        this.log(signer.id);
-    }
-}

package/dist/commands/graph/deploy.js

@@ -1,32 +0,0 @@
-import { Command, Flags } from '@oclif/core';
-import ora from 'ora';
-import { createClient } from '../../client.js';
-import { readJSON } from '../../fs.js';
-export default class DeployGraph extends Command {
-    static description = 'Deploy a documents model graph';
-    static flags = {
-        cluster: Flags.string({
-            description: 'path of the JSON file of the cluster',
-            char: 'c',
-            required: true,
-            multiple: true,
-        }),
-        id: Flags.string({ description: 'graph ID' }),
-        name: Flags.string({ description: 'graph name', char: 'n' }),
-        privateKey: Flags.string({
-            description: 'base64-encoded private key',
-            char: 'k',
-            env: 'KUBUN_PRIVATE_KEY',
-            required: true,
-        }),
-        url: Flags.string({ description: 'Kubun server URL' }),
-    };
-    async run() {
-        const spinner = ora('Deploying graph clusters...').start();
-        const { flags } = await this.parse(DeployGraph);
-        const client = createClient(flags.privateKey, flags.url);
-        const clusters = await Promise.all(flags.cluster.map((path) => readJSON(path)));
-        const graph = await client.deployGraph({ clusters, id: flags.id, name: flags.name });
-        spinner.succeed(`Deployed graph with ID: ${graph.id}`);
-    }
-}

package/dist/commands/graph/mutate.js

@@ -1,32 +0,0 @@
-import { Args, Command, Flags } from '@oclif/core';
-import ora from 'ora';
-import { createClient } from '../../client.js';
-export default class MutateGraph extends Command {
-    static description = 'Execute a GraphQL mutation on a graph';
-    static args = {
-        id: Args.string({ description: 'graph ID', required: true }),
-        text: Args.string({ description: 'mutation text', required: true }),
-    };
-    static flags = {
-        privateKey: Flags.string({
-            description: 'base64-encoded private key',
-            char: 'k',
-            env: 'KUBUN_PRIVATE_KEY',
-            required: true,
-        }),
-        url: Flags.string({ description: 'Kubun server URL' }),
-        variables: Flags.string({ description: 'query variables as JSON string' }),
-    };
-    async run() {
-        const spinner = ora('Executing graph mutation...').start();
-        const { args, flags } = await this.parse(MutateGraph);
-        const client = createClient(flags.privateKey, flags.url);
-        const result = await client.mutateGraph({
-            id: args.id,
-            text: args.text,
-            variables: flags.variables ? JSON.parse(flags.variables) : {},
-        });
-        spinner.succeed('Graph mutation executed');
-        this.log(JSON.stringify(result, null, 2));
-    }
-}

package/dist/commands/graph/query.js

@@ -1,32 +0,0 @@
-import { Args, Command, Flags } from '@oclif/core';
-import ora from 'ora';
-import { createClient } from '../../client.js';
-export default class QueryGraph extends Command {
-    static description = 'Execute a GraphQL query on a graph';
-    static args = {
-        id: Args.string({ description: 'graph ID', required: true }),
-        text: Args.string({ description: 'query text', required: true }),
-    };
-    static flags = {
-        privateKey: Flags.string({
-            description: 'base64-encoded private key',
-            char: 'k',
-            env: 'KUBUN_PRIVATE_KEY',
-            required: true,
-        }),
-        url: Flags.string({ description: 'Kubun server URL' }),
-        variables: Flags.string({ description: 'query variables as JSON string' }),
-    };
-    async run() {
-        const spinner = ora('Querying graph...').start();
-        const { args, flags } = await this.parse(QueryGraph);
-        const client = createClient(flags.privateKey, flags.url);
-        const result = await client.queryGraph({
-            id: args.id,
-            text: args.text,
-            variables: flags.variables ? JSON.parse(flags.variables) : {},
-        });
-        spinner.succeed('Graph query executed');
-        this.log(JSON.stringify(result, null, 2));
-    }
-}