swarmdo 1.4.8 → 1.5.0

package/v3/@swarmdo/plugin-iot-cognitum/dist/application/iot-coordinator.js

@@ -1,418 +0,0 @@
-import { SeedClientFactory } from '../infrastructure/seed-client-factory.js';
-import { DeviceLifecycleService } from '../domain/services/device-lifecycle-service.js';
-import { TelemetryService } from '../domain/services/telemetry-service.js';
-import { MeshService } from '../domain/services/mesh-service.js';
-import { AnomalyDetectionService } from '../domain/services/anomaly-detection-service.js';
-import { TelemetryIngestionService } from '../domain/services/telemetry-ingestion-service.js';
-import { FleetTopologyService } from '../domain/services/fleet-topology-service.js';
-import { InMemoryFleetRepository } from '../infrastructure/in-memory-fleet-repository.js';
-import { FirmwareOrchestrationService } from '../domain/services/firmware-orchestration-service.js';
-import { WitnessVerificationService } from '../domain/services/witness-verification-service.js';
-import { SONAIntegrationService } from '../domain/services/sona-integration-service.js';
-// ---------------------------------------------------------------------------
-// Coordinator
-// ---------------------------------------------------------------------------
-/**
- * Application-layer coordinator that wires domain services to the
- * Cognitum Seed SDK transport. Every public method resolves a
- * {@link SeedClient} from the internal registry and delegates to the
- * appropriate domain service.
- */
-export class IoTCoordinator {
-    factory;
-    devices = new Map();
-    lifecycle;
-    telemetry;
-    mesh;
-    anomalyDetection;
-    ingestion;
-    fleet;
-    firmware;
-    witnessVerification;
-    sona;
-    telemetryRepo;
-    config;
-    deviceRepo;
-    trustRepo;
-    constructor(config, callbacks) {
-        this.config = config;
-        this.deviceRepo = config.deviceRepository;
-        this.trustRepo = config.trustHistoryRepository;
-        this.factory = new SeedClientFactory({
-            defaultTls: config.defaultTls,
-            healthInterval: config.healthInterval,
-        });
-        // -----------------------------------------------------------------------
-        // Wire domain-service deps to real SDK calls via this.devices
-        // -----------------------------------------------------------------------
-        this.lifecycle = new DeviceLifecycleService({
-            getStatus: async (deviceId) => {
-                const client = this.resolveClient(deviceId);
-                return client.status();
-            },
-            getIdentity: async (deviceId) => {
-                const client = this.resolveClient(deviceId);
-                return client.identity();
-            },
-            getPairStatus: async (deviceId) => {
-                const client = this.resolveClient(deviceId);
-                return client.pair.status();
-            },
-            getWitnessChain: async (deviceId) => {
-                const client = this.resolveClient(deviceId);
-                const chain = await client.witness.chain();
-                return {
-                    depth: chain.length ?? chain.entries?.length ?? 0,
-                    epoch: chain.entries?.[0]?.epoch ?? 0,
-                    head_hash: chain.head ?? '',
-                };
-            },
-            getCustodyEpoch: async (deviceId) => {
-                const client = this.resolveClient(deviceId);
-                return client.custody.epoch();
-            },
-            pairDevice: async (deviceId, clientName) => {
-                const client = this.resolveClient(deviceId);
-                const resp = await client.pair.create({ clientName });
-                return { paired: true, token: resp.token.reveal() };
-            },
-            unpairDevice: async (deviceId, clientName) => {
-                const client = this.resolveClient(deviceId);
-                await client.pair.delete(clientName ?? 'swarmdo');
-            },
-            onDeviceRegistered: callbacks?.onDeviceRegistered,
-            onTrustChange: callbacks?.onTrustChange,
-        });
-        this.telemetry = new TelemetryService({
-            queryVectors: async (deviceId, vector, k) => {
-                const client = this.resolveClient(deviceId);
-                return client.store.query({ vector, k });
-            },
-            ingestVectors: async (deviceId, vectors) => {
-                const client = this.resolveClient(deviceId);
-                return client.store.ingest({ vectors });
-            },
-            getStoreStatus: async (deviceId) => {
-                const client = this.resolveClient(deviceId);
-                return client.store.status();
-            },
-        });
-        this.mesh = new MeshService({
-            getMeshStatus: async (deviceId) => {
-                const client = this.resolveClient(deviceId);
-                return client.mesh.status();
-            },
-            getPeers: async (deviceId) => {
-                const client = this.resolveClient(deviceId);
-                return client.mesh.peers();
-            },
-            getSwarmStatus: async (deviceId) => {
-                const client = this.resolveClient(deviceId);
-                return client.mesh.swarmStatus();
-            },
-            getClusterHealth: async (deviceId) => {
-                const client = this.resolveClient(deviceId);
-                return client.mesh.clusterHealth();
-            },
-        });
-        this.anomalyDetection = new AnomalyDetectionService(config.anomalyDetection);
-        this.ingestion = new TelemetryIngestionService({
-            queryDeviceStore: async (deviceId, vector, k) => {
-                const client = this.resolveClient(deviceId);
-                const result = await client.store.query({ vector, k });
-                return result.results;
-            },
-            getStoreStatus: async (deviceId) => {
-                const client = this.resolveClient(deviceId);
-                return client.store.status();
-            },
-        }, this.anomalyDetection);
-        this.fleet = new FleetTopologyService(config.fleetRepository ?? new InMemoryFleetRepository());
-        this.firmware = new FirmwareOrchestrationService({
-            getDeviceFirmwareVersion: async (deviceId) => {
-                const entry = this.requireEntry(deviceId);
-                return entry.agent.firmwareVersion;
-            },
-            deployFirmware: async (_deviceId, _version) => {
-                // OTA deployment requires Cognitum Cloud API (not available via local Seed SDK).
-                // Stub returns success; real implementation will use cloud control plane.
-                return { success: true };
-            },
-            getDeviceAnomalyScore: async (deviceId) => {
-                const entry = this.requireEntry(deviceId);
-                return 1 - entry.agent.trustScore.overall;
-            },
-        });
-        this.witnessVerification = new WitnessVerificationService({
-            getWitnessChain: async (deviceId) => {
-                const client = this.resolveClient(deviceId);
-                return client.witness.chain();
-            },
-        });
-        this.sona = new SONAIntegrationService(config.sonaClient ?? null);
-        this.telemetryRepo = config.telemetryRepository;
-    }
-    // -------------------------------------------------------------------------
-    // Device lifecycle
-    // -------------------------------------------------------------------------
-    /**
-     * Register a Seed device by its HTTP endpoint. Creates a
-     * {@link SeedClient}, fetches status and identity from the real
-     * hardware, and returns a fully populated {@link DeviceAgent}.
-     */
-    async registerDevice(endpoint, pairingToken) {
-        const client = await this.factory.createClient(endpoint, pairingToken);
-        // The lifecycle service makes two SDK calls during registration:
-        // getStatus(endpoint) -> returns the real device_id, then
-        // getIdentity(device_id) -> looked up by the device_id key.
-        // We need the client reachable under BOTH keys before lifecycle runs,
-        // so pre-fetch the device_id and register the client under both.
-        const initialStatus = await client.status();
-        const initialDeviceId = initialStatus.device_id;
-        this.devices.set(endpoint, { agent: {}, client });
-        this.devices.set(initialDeviceId, { agent: {}, client });
-        let agent;
-        try {
-            agent = await this.lifecycle.registerDevice(endpoint, this.config.defaultFleetId, this.config.defaultZoneId);
-        }
-        catch (err) {
-            this.devices.delete(endpoint);
-            this.devices.delete(initialDeviceId);
-            throw err;
-        }
-        // Promote: drop the temporary endpoint key and keep the device_id key
-        // (with the real agent attached).
-        this.devices.delete(endpoint);
-        this.devices.set(agent.deviceId, { agent, client });
-        await this.deviceRepo?.save(agent);
-        return agent;
-    }
-    /**
-     * Refresh a device's state from the real hardware and recalculate
-     * its trust score.
-     */
-    async getDeviceStatus(deviceId) {
-        const entry = this.requireEntry(deviceId);
-        const oldLevel = entry.agent.trustLevel;
-        const refreshed = await this.lifecycle.refreshDeviceState(entry.agent);
-        entry.agent = refreshed;
-        await this.deviceRepo?.save(refreshed);
-        if (oldLevel !== refreshed.trustLevel) {
-            await this.trustRepo?.append({
-                deviceId, timestamp: new Date(),
-                oldLevel, newLevel: refreshed.trustLevel,
-                score: refreshed.trustScore, trigger: 'refresh',
-            });
-        }
-        return refreshed;
-    }
-    /** Pair a registered device, promoting its trust level. */
-    async pairDevice(deviceId, clientName) {
-        const entry = this.requireEntry(deviceId);
-        const oldLevel = entry.agent.trustLevel;
-        const updated = await this.lifecycle.pairDevice(entry.agent, clientName);
-        entry.agent = updated;
-        await this.deviceRepo?.save(updated);
-        if (oldLevel !== updated.trustLevel) {
-            await this.trustRepo?.append({
-                deviceId, timestamp: new Date(),
-                oldLevel, newLevel: updated.trustLevel,
-                score: updated.trustScore, trigger: 'pair',
-            });
-        }
-        return updated;
-    }
-    /** Unpair a registered device, demoting its trust level. */
-    async unpairDevice(deviceId) {
-        const entry = this.requireEntry(deviceId);
-        const oldLevel = entry.agent.trustLevel;
-        const updated = await this.lifecycle.unpairDevice(entry.agent);
-        entry.agent = updated;
-        await this.deviceRepo?.save(updated);
-        if (oldLevel !== updated.trustLevel) {
-            await this.trustRepo?.append({
-                deviceId, timestamp: new Date(),
-                oldLevel, newLevel: updated.trustLevel,
-                score: updated.trustScore, trigger: 'unpair',
-            });
-        }
-        return updated;
-    }
-    // -------------------------------------------------------------------------
-    // Telemetry / vector store
-    // -------------------------------------------------------------------------
-    /** Run a k-NN query against a device's on-board vector store. */
-    async queryDeviceVectors(deviceId, vector, k) {
-        return this.telemetry.queryDevice(deviceId, vector, k);
-    }
-    /** Ingest raw vectors into a device's vector store. */
-    async ingestDeviceTelemetry(deviceId, vectors) {
-        const client = this.resolveClient(deviceId);
-        const result = await client.store.ingest({ vectors });
-        return {
-            deviceId,
-            ingested: result.ingested,
-            epoch: result.epoch,
-        };
-    }
-    /** Retrieve vector store health metrics for a device. */
-    async getDeviceStoreStatus(deviceId) {
-        return this.telemetry.getStoreHealth(deviceId);
-    }
-    // -------------------------------------------------------------------------
-    // Mesh
-    // -------------------------------------------------------------------------
-    /** Get the aggregated mesh topology snapshot for a device. */
-    async getDeviceMeshTopology(deviceId) {
-        return this.mesh.getTopology(deviceId);
-    }
-    // -------------------------------------------------------------------------
-    // Witness / custody — direct SDK pass-through
-    // -------------------------------------------------------------------------
-    /** Retrieve the full witness chain from a device. */
-    async getDeviceWitnessChain(deviceId) {
-        const client = this.resolveClient(deviceId);
-        return client.witness.chain();
-    }
-    /** Retrieve the current custody epoch from a device. */
-    async getDeviceCustodyEpoch(deviceId) {
-        const client = this.resolveClient(deviceId);
-        return client.custody.epoch();
-    }
-    /** Verify witness chain integrity for a device. */
-    async verifyWitnessChain(deviceId) {
-        this.requireEntry(deviceId);
-        return this.witnessVerification.verifyChain(deviceId);
-    }
-    // -------------------------------------------------------------------------
-    // Anomaly detection
-    // -------------------------------------------------------------------------
-    /** Detect anomalies in a batch of telemetry readings for a device. */
-    detectAnomalies(deviceId, readings) {
-        const result = this.ingestion.processBatch(deviceId, readings);
-        if (result.anomalies.length > 0) {
-            const baseline = this.ingestion.getBaseline(deviceId);
-            for (const anomaly of result.anomalies) {
-                void this.sona.learnAnomalyPattern(anomaly, baseline);
-            }
-            void this.sona.recordTelemetryTrajectory(deviceId, readings, result.anomalies);
-        }
-        if (this.telemetryRepo) {
-            void this.telemetryRepo.storeBatch(readings);
-            for (const anomaly of result.anomalies) {
-                void this.telemetryRepo.storeAnomaly(anomaly);
-            }
-        }
-        return {
-            anomalies: result.anomalies,
-            total: result.readingsProcessed,
-            anomalous: result.anomaliesDetected,
-        };
-    }
-    /** Compute a telemetry baseline for a device from readings. */
-    computeBaseline(deviceId, readings) {
-        const oldBaseline = this.ingestion.getBaseline(deviceId);
-        const newBaseline = this.ingestion.refreshBaseline(deviceId, readings);
-        void this.sona.learnBaselineShift(deviceId, oldBaseline, newBaseline);
-        return newBaseline;
-    }
-    /** Get the current baseline for a device, if computed. */
-    getBaseline(deviceId) {
-        return this.ingestion.getBaseline(deviceId);
-    }
-    // -------------------------------------------------------------------------
-    // Firmware orchestration
-    // -------------------------------------------------------------------------
-    async createFirmwareRollout(fleetId, firmwareVersion) {
-        const fleet = await this.fleet.getFleet(fleetId);
-        return this.firmware.createRollout(fleetId, firmwareVersion, fleet.deviceIds, fleet.firmwarePolicy);
-    }
-    async advanceFirmwareRollout(rolloutId) {
-        return this.firmware.advanceRollout(rolloutId);
-    }
-    rollbackFirmwareRollout(rolloutId) {
-        return this.firmware.rollbackRollout(rolloutId);
-    }
-    getFirmwareRollout(rolloutId) {
-        return this.firmware.getRollout(rolloutId);
-    }
-    listFirmwareRollouts(fleetId) {
-        return this.firmware.listRollouts(fleetId);
-    }
-    // -------------------------------------------------------------------------
-    // Fleet management
-    // -------------------------------------------------------------------------
-    async createFleet(options) {
-        return this.fleet.createFleet(options);
-    }
-    async getFleet(fleetId) {
-        return this.fleet.getFleet(fleetId);
-    }
-    async listFleets() {
-        return this.fleet.listFleets();
-    }
-    async addDeviceToFleet(fleetId, deviceId) {
-        this.requireEntry(deviceId);
-        return this.fleet.addDeviceToFleet(fleetId, deviceId);
-    }
-    async removeDeviceFromFleet(fleetId, deviceId) {
-        return this.fleet.removeDeviceFromFleet(fleetId, deviceId);
-    }
-    async updateFleetTopology(fleetId, topology) {
-        return this.fleet.updateTopology(fleetId, topology);
-    }
-    async updateFleetFirmwarePolicy(fleetId, policy) {
-        return this.fleet.updateFirmwarePolicy(fleetId, policy);
-    }
-    async deleteFleet(fleetId) {
-        return this.fleet.deleteFleet(fleetId);
-    }
-    // -------------------------------------------------------------------------
-    // Inventory
-    // -------------------------------------------------------------------------
-    /** List all registered device agents. */
-    listDevices() {
-        return Array.from(this.devices.values()).map((e) => e.agent);
-    }
-    /** Remove a device from the coordinator and close its SDK client. */
-    async removeDevice(deviceId) {
-        const entry = this.devices.get(deviceId);
-        if (!entry)
-            return;
-        await entry.client.close();
-        this.devices.delete(deviceId);
-        await this.deviceRepo?.delete(deviceId);
-        await this.trustRepo?.deleteByDevice(deviceId);
-    }
-    /** Shut down all SDK clients and clear internal state. */
-    async shutdown() {
-        await this.factory.closeAll();
-        this.devices.clear();
-    }
-    /** Health snapshot of the coordinator. */
-    getStatus() {
-        return {
-            healthy: this.devices.size >= 0,
-            deviceCount: this.devices.size,
-            devices: this.listDevices(),
-        };
-    }
-    // -------------------------------------------------------------------------
-    // Internals
-    // -------------------------------------------------------------------------
-    /**
-     * Resolve a SeedClient by device ID (or temporary endpoint key).
-     * Throws when the device has not been registered.
-     */
-    resolveClient(deviceId) {
-        return this.requireEntry(deviceId).client;
-    }
-    requireEntry(deviceId) {
-        const entry = this.devices.get(deviceId);
-        if (!entry) {
-            throw new Error(`Device ${deviceId} not registered with coordinator`);
-        }
-        return entry;
-    }
-}
-//# sourceMappingURL=iot-coordinator.js.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/bin.d.ts

@@ -1,15 +0,0 @@
-#!/usr/bin/env node
-/**
- * Standalone CLI shim for @swarmdo/plugin-iot-cognitum.
- * Maps `cognitum-iot <subcommand> [args]` -> CLICommandDefinition handlers.
- *
- * Endpoint defaults:
- *   - http://169.254.42.1 (USB-C link-local, no auth — read-only paths)
- *   - https://169.254.42.1:8443 (LAN/HTTPS + bearer — full access including writes)
- *
- * Auth: COGNITUM_SEED_TOKEN is read from process.env (loaded from .env in CWD
- * if present) and passed to register as the pairing/bearer token. When set,
- * the default endpoint switches to the HTTPS LAN address.
- */
-export {};
-//# sourceMappingURL=bin.d.ts.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/bin.js

@@ -1,240 +0,0 @@
-#!/usr/bin/env node
-/**
- * Standalone CLI shim for @swarmdo/plugin-iot-cognitum.
- * Maps `cognitum-iot <subcommand> [args]` -> CLICommandDefinition handlers.
- *
- * Endpoint defaults:
- *   - http://169.254.42.1 (USB-C link-local, no auth — read-only paths)
- *   - https://169.254.42.1:8443 (LAN/HTTPS + bearer — full access including writes)
- *
- * Auth: COGNITUM_SEED_TOKEN is read from process.env (loaded from .env in CWD
- * if present) and passed to register as the pairing/bearer token. When set,
- * the default endpoint switches to the HTTPS LAN address.
- */
-import { readFileSync, existsSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { IoTCognitumPlugin } from './plugin.js';
-const SEED_LINK_LOCAL = 'http://169.254.42.1';
-const SEED_LAN_HTTPS = 'https://169.254.42.1:8443';
-/**
- * Tiny .env loader. Walks up from CWD looking for a .env, reads KEY=VALUE
- * lines (ignoring blanks and # comments), and applies them to process.env
- * WITHOUT overwriting variables already set in the real environment.
- */
-function loadDotenv() {
-    let dir = process.cwd();
-    for (let i = 0; i < 8; i++) {
-        const candidate = resolve(dir, '.env');
-        if (existsSync(candidate)) {
-            const text = readFileSync(candidate, 'utf8');
-            let count = 0;
-            for (const rawLine of text.split('\n')) {
-                const line = rawLine.trim();
-                if (!line || line.startsWith('#'))
-                    continue;
-                const eq = line.indexOf('=');
-                if (eq < 1)
-                    continue;
-                const key = line.slice(0, eq).trim();
-                let val = line.slice(eq + 1).trim();
-                // Strip surrounding quotes
-                if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
-                    val = val.slice(1, -1);
-                }
-                if (process.env[key] === undefined) {
-                    process.env[key] = val;
-                    count++;
-                }
-            }
-            return { loaded: candidate, count };
-        }
-        const parent = resolve(dir, '..');
-        if (parent === dir)
-            break;
-        dir = parent;
-    }
-    return { loaded: null, count: 0 };
-}
-loadDotenv();
-const SEED_TOKEN = process.env.COGNITUM_SEED_TOKEN;
-const SEED_DEFAULT_ENDPOINT = process.env.COGNITUM_SEED_ENDPOINT ?? (SEED_TOKEN ? SEED_LAN_HTTPS : SEED_LINK_LOCAL);
-function makeContext() {
-    // Minimal in-memory context for standalone CLI use.
-    const noop = () => undefined;
-    return {
-        config: {
-            fleetId: process.env.IOT_FLEET_ID ?? 'default',
-            zoneId: process.env.IOT_ZONE_ID ?? 'zone-0',
-            tlsInsecure: process.env.IOT_TLS_INSECURE !== 'false',
-        },
-        eventBus: {
-            emit: noop,
-            on: noop,
-            off: noop,
-            once: noop,
-        },
-        logger: {
-            info: (...a) => console.log('[info]', ...a),
-            warn: (...a) => console.warn('[warn]', ...a),
-            error: (...a) => console.error('[error]', ...a),
-            debug: (...a) => process.env.DEBUG && console.error('[debug]', ...a),
-        },
-        services: {
-            get: () => undefined,
-            register: noop,
-            has: () => false,
-        },
-    };
-}
-/**
- * Parse argv minimally: positional -> _, --flag value, --flag=value, --boolean,
- * short -e value. Numeric values stay as strings (handlers coerce as needed).
- */
-function parseArgs(argv) {
-    const out = { _: [] };
-    for (let i = 0; i < argv.length; i++) {
-        const a = argv[i];
-        if (a.startsWith('--')) {
-            const eq = a.indexOf('=');
-            if (eq > -1) {
-                out[a.slice(2, eq)] = a.slice(eq + 1);
-            }
-            else {
-                const key = a.slice(2);
-                const next = argv[i + 1];
-                if (next === undefined || next.startsWith('-')) {
-                    out[key] = true;
-                }
-                else {
-                    out[key] = next;
-                    i++;
-                }
-            }
-        }
-        else if (a.startsWith('-') && a.length > 1) {
-            const key = a.slice(1);
-            const next = argv[i + 1];
-            if (next === undefined || next.startsWith('-')) {
-                out[key] = true;
-            }
-            else {
-                out[key] = next;
-                i++;
-            }
-        }
-        else {
-            out._.push(a);
-        }
-    }
-    return out;
-}
-function aliasShortToLong(args) {
-    // Most common short flags used across the iot commands.
-    const aliases = {
-        e: 'endpoint',
-        f: 'fleet-id',
-        z: 'zone-id',
-        d: 'device-id',
-        v: 'version',
-        k: 'k',
-        n: 'name',
-        t: 'token',
-    };
-    for (const [s, l] of Object.entries(aliases)) {
-        if (s in args && !(l in args)) {
-            args[l] = args[s];
-        }
-    }
-    return args;
-}
-/**
- * Resolve a subcommand path against command definitions.
- * Supports multi-word commands: `iot fleet add`, `iot firmware deploy`, etc.
- * Tries longest match first.
- */
-function resolveCommand(argv, commandNames) {
-    // Strip the leading "iot" prefix from each defined command for matching.
-    const tokens = argv.slice();
-    // Try longest match (3 tokens, then 2, then 1).
-    for (const len of [3, 2, 1]) {
-        if (tokens.length < len)
-            continue;
-        const probe = 'iot ' + tokens.slice(0, len).join(' ');
-        if (commandNames.includes(probe)) {
-            return { name: probe, rest: tokens.slice(len) };
-        }
-    }
-    return null;
-}
-function printHelp(commandNames) {
-    console.log('cognitum-iot — Cognitum Seed device-agent CLI');
-    console.log('');
-    console.log('Usage: cognitum-iot <subcommand> [options]');
-    console.log('');
-    console.log('Default endpoint: ' + SEED_DEFAULT_ENDPOINT);
-    console.log('  - http://169.254.42.1 (USB-C link-local, no auth, read-only)');
-    console.log('  - https://169.254.42.1:8443 (LAN/HTTPS, COGNITUM_SEED_TOKEN required, full access)');
-    console.log('');
-    console.log('Auth: set COGNITUM_SEED_TOKEN in .env or environment to use the bearer-protected');
-    console.log('      LAN endpoint and unlock writes (ingest, unpair, etc).');
-    console.log('      Status: ' + (SEED_TOKEN ? '✓ token loaded' : '✗ no token (link-local only)'));
-    console.log('');
-    console.log('Hardware: get a Seed at https://cognitum.one');
-    console.log('');
-    console.log('Subcommands:');
-    for (const n of commandNames) {
-        console.log('  ' + n.replace(/^iot /, ''));
-    }
-    console.log('');
-    console.log('Run "cognitum-iot <subcommand> --help" for command-specific options.');
-}
-async function main() {
-    const argv = process.argv.slice(2);
-    if (argv.length === 0 || argv[0] === '--help' || argv[0] === '-h') {
-        // Need to bootstrap to enumerate commands.
-    }
-    const plugin = new IoTCognitumPlugin();
-    const context = makeContext();
-    await plugin.initialize(context);
-    const commands = plugin.registerCLICommands();
-    const commandNames = commands.map((c) => c.name);
-    if (argv.length === 0 || argv[0] === '--help' || argv[0] === '-h') {
-        printHelp(commandNames);
-        return;
-    }
-    const resolved = resolveCommand(argv, commandNames);
-    if (!resolved) {
-        console.error('Unknown subcommand: ' + argv.join(' '));
-        console.error('Run "cognitum-iot --help" to list available subcommands.');
-        process.exitCode = 1;
-        return;
-    }
-    const cmd = commands.find((c) => c.name === resolved.name);
-    const args = aliasShortToLong(parseArgs(resolved.rest));
-    // Endpoint + token defaults for `iot register`.
-    if (resolved.name === 'iot register') {
-        if (!args['endpoint']) {
-            args['endpoint'] = SEED_DEFAULT_ENDPOINT;
-            console.error(`[info] No --endpoint supplied; defaulting to ${SEED_DEFAULT_ENDPOINT}`);
-        }
-        if (!args['token'] && SEED_TOKEN) {
-            args['token'] = SEED_TOKEN;
-            console.error('[info] Using COGNITUM_SEED_TOKEN from environment');
-        }
-    }
-    try {
-        await cmd.handler(args);
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        console.error('Error: ' + msg);
-        process.exitCode = 1;
-    }
-}
-main()
-    .then(() => process.exit(process.exitCode ?? 0))
-    .catch((err) => {
-    console.error('Fatal: ' + (err instanceof Error ? err.message : String(err)));
-    process.exit(1);
-});
-//# sourceMappingURL=bin.js.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/cli-commands.d.ts

@@ -1,7 +0,0 @@
-import type { CLICommandDefinition, PluginContext } from '@swarmdo/shared/src/plugin-interface.js';
-import type { IoTCoordinator } from './application/iot-coordinator.js';
-type CoordinatorGetter = () => IoTCoordinator | null;
-type ContextGetter = () => PluginContext | null;
-export declare function createCliCommands(getCoordinator: CoordinatorGetter, _getContext: ContextGetter): CLICommandDefinition[];
-export {};
-//# sourceMappingURL=cli-commands.d.ts.map