@spekn/cli 1.0.0

package/dist/backlog-generate.js

@@ -0,0 +1,308 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * backlog-generate CLI Tool
+ *
+ * Auto-generate tasks from specification anchors.
+ *
+ * Usage: npm run backlog-generate <spec-file-path> [OPTIONS]
+ * Example: npm run backlog-generate specs/WORKFLOW.md --project-id=<uuid>
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const agents_1 = require("@spekn/agents");
+const shared_1 = require("@spekn/shared");
+const shared_2 = require("@spekn/shared");
+const shared_3 = require("@spekn/shared");
+const cli_runtime_1 = require("./utils/cli-runtime");
+function parseArgs(args) {
+    const options = { dryRun: false, verbose: false };
+    let filePath;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg.startsWith("--project-id=")) {
+            options.projectId = arg.split("=")[1];
+        }
+        else if (arg.startsWith("--spec-id=")) {
+            options.specId = arg.split("=")[1];
+        }
+        else if (arg.startsWith("--priority=")) {
+            const priority = arg.split("=")[1];
+            if (Object.values(shared_2.TaskPriority).includes(priority)) {
+                options.priority = priority;
+            }
+        }
+        else if (arg === "--dry-run" || arg === "-d") {
+            options.dryRun = true;
+        }
+        else if (arg === "--verbose" || arg === "-v") {
+            options.verbose = true;
+        }
+        else if (!arg.startsWith("-")) {
+            filePath = arg;
+        }
+    }
+    if (!filePath) {
+        throw new Error("missing required argument: <spec-file-path>");
+    }
+    return { filePath, options };
+}
+function printHelp() {
+    console.log(`
+backlog-generate - Auto-generate tasks from specification anchors
+
+USAGE:
+  npm run backlog-generate <spec-file-path> [OPTIONS]
+
+ARGUMENTS:
+  <spec-file-path>    Path to the specification markdown file
+
+OPTIONS:
+  --project-id=<id>   Project ID to associate tasks with (required for DB insert)
+  --spec-id=<id>      Specification ID to associate tasks with (required for DB insert)
+  --priority=<level>  Default task priority (low|medium|high|critical, default: medium)
+  -d, --dry-run       Preview tasks without creating them
+  -v, --verbose       Show detailed output
+  -h, --help          Show this help message
+
+EXAMPLES:
+  npm run backlog-generate specs/WORKFLOW.md --dry-run
+  npm run backlog-generate specs/WORKFLOW.md --project-id=abc123 --spec-id=def456
+  npm run backlog-generate specs/SPECIFICATION.md --priority=high --verbose
+`);
+}
+function extractAcceptanceCriteria(content) {
+    const criteria = [];
+    // Look for "Acceptance Criteria" section
+    const lines = content.split("\n");
+    let inCriteriaSection = false;
+    for (const line of lines) {
+        if (line.match(/^\*\*Acceptance Criteria\*\*:|^##\s*Acceptance Criteria|^###\s*Acceptance Criteria/i)) {
+            inCriteriaSection = true;
+            continue;
+        }
+        // Stop at next section heading or bold marker
+        if (inCriteriaSection &&
+            (line.match(/^##[^#]|^\*\*[^*]+\*\*:/) || line.trim() === "---")) {
+            break;
+        }
+        // Extract list items
+        if (inCriteriaSection && line.match(/^[-*]\s+/)) {
+            const criterion = line.replace(/^[-*]\s+/, "").trim();
+            if (criterion) {
+                criteria.push(criterion);
+            }
+        }
+    }
+    // If no explicit criteria found, look for bullet points
+    if (criteria.length === 0) {
+        for (const line of lines) {
+            if (line.match(/^[-*]\s+/)) {
+                const item = line.replace(/^[-*]\s+/, "").trim();
+                if (item && !item.startsWith("**")) {
+                    criteria.push(item);
+                }
+            }
+        }
+    }
+    return criteria;
+}
+function extractDependencies(content) {
+    const dependencies = [];
+    // Look for "Dependencies" section
+    const dependencyMatch = content.match(/\*\*Dependencies\*\*:([^\n]+)/i);
+    if (dependencyMatch) {
+        const dependencyText = dependencyMatch[1];
+        const dependencyAnchors = dependencyText.match(/#[a-z0-9._-]+/gi);
+        if (dependencyAnchors) {
+            dependencies.push(...dependencyAnchors.map((d) => d.replace(/^#/, "")));
+        }
+    }
+    return dependencies;
+}
+async function main(argv) {
+    const args = argv ?? process.argv.slice(2);
+    if ((0, cli_runtime_1.hasHelpFlag)(args)) {
+        printHelp();
+        return 0;
+    }
+    let filePath;
+    let options;
+    try {
+        ({ filePath, options } = parseArgs(args));
+    }
+    catch {
+        console.error("Error: Missing required argument <spec-file-path>");
+        printHelp();
+        return 1;
+    }
+    // Resolve file path
+    const resolvedPath = path.resolve(process.cwd(), filePath);
+    // Check if file exists
+    if (!fs.existsSync(resolvedPath)) {
+        console.error(`Error: File not found: ${resolvedPath}`);
+        return 1;
+    }
+    // Read file content
+    let content;
+    try {
+        content = fs.readFileSync(resolvedPath, "utf-8");
+    }
+    catch (error) {
+        console.error(`Error reading file: ${(0, cli_runtime_1.errorMessage)(error)}`);
+        return 1;
+    }
+    // Extract anchors
+    const anchors = (0, agents_1.extractAnchors)(content);
+    if (anchors.length === 0) {
+        console.log("No anchors found in the specification.");
+        return 0;
+    }
+    console.log(`\nFound ${anchors.length} anchor(s) in ${path.basename(filePath)}`);
+    // Generate tasks from anchors
+    const tasksToCreate = [];
+    for (const anchor of anchors) {
+        const anchorContent = (0, agents_1.extractAnchorContent)(anchor.anchor, content);
+        if (!anchorContent)
+            continue;
+        const acceptanceCriteria = extractAcceptanceCriteria(anchorContent);
+        const dependencies = extractDependencies(anchorContent);
+        // Extract first paragraph as description
+        const lines = anchorContent.split("\n").filter((l) => l.trim());
+        const descriptionLines = lines
+            .slice(1)
+            .filter((l) => !l.match(/^#{1,6}\s/) &&
+            !l.match(/^[-*]\s/) &&
+            !l.match(/^\*\*[^*]+\*\*:/) &&
+            l.trim() !== "---");
+        const description = descriptionLines.slice(0, 3).join("\n").trim() ||
+            `Implementation of ${anchor.anchor}`;
+        tasksToCreate.push({
+            title: anchor.headingText.replace(/^#+\s*#[a-z0-9._-]+\s*/i, "").trim() ||
+                anchor.anchor,
+            description,
+            anchor: anchor.anchor,
+            acceptanceCriteria: acceptanceCriteria.length > 0
+                ? acceptanceCriteria
+                : ["Implementation complete", "Tests passing"],
+            dependencies,
+            priority: options.priority || shared_2.TaskPriority.MEDIUM,
+        });
+    }
+    // Display preview
+    console.log(`\nGenerated ${tasksToCreate.length} task(s):\n`);
+    tasksToCreate.forEach((task, index) => {
+        console.log(`${index + 1}. ${task.title}`);
+        console.log(`   Anchor: ${task.anchor}`);
+        console.log(`   Priority: ${task.priority}`);
+        if (task.dependencies.length > 0) {
+            console.log(`   Dependencies: ${task.dependencies.join(", ")}`);
+        }
+        if (options.verbose) {
+            console.log(`   Description: ${task.description}`);
+            console.log(`   Acceptance Criteria:`);
+            task.acceptanceCriteria.forEach((criterion) => {
+                console.log(`     - ${criterion}`);
+            });
+        }
+        console.log();
+    });
+    // Create tasks in database if not dry-run
+    if (!options.dryRun) {
+        if (!options.projectId || !options.specId) {
+            console.error("\nError: --project-id and --spec-id are required for task creation");
+            console.log("Use --dry-run to preview without creating tasks");
+            return 1;
+        }
+        console.log("Connecting to database...");
+        await shared_1.AppDataSource.initialize();
+        try {
+            // Verify project and spec exist
+            const specification = await shared_1.AppDataSource.getRepository(shared_3.Specification).findOne({
+                where: { id: options.specId },
+            });
+            if (!specification) {
+                console.error(`Error: Specification with ID ${options.specId} not found`);
+                return 1;
+            }
+            if (specification.projectId !== options.projectId) {
+                console.error(`Error: Specification belongs to project ${specification.projectId}, not ${options.projectId}`);
+                return 1;
+            }
+            // Create tasks
+            const taskRepository = shared_1.AppDataSource.getRepository(shared_2.Task);
+            const createdTasks = [];
+            for (const taskData of tasksToCreate) {
+                const task = taskRepository.create({
+                    title: taskData.title,
+                    description: taskData.description,
+                    status: shared_2.TaskStatus.OPEN,
+                    priority: taskData.priority,
+                    acceptanceCriteria: taskData.acceptanceCriteria,
+                    dependencies: taskData.dependencies,
+                    specAnchor: taskData.anchor,
+                    specificationId: options.specId,
+                    projectId: options.projectId,
+                });
+                const saved = await taskRepository.save(task);
+                createdTasks.push(saved);
+            }
+            console.log(`\nSuccessfully created ${createdTasks.length} task(s)!`);
+            if (options.verbose) {
+                console.log("\nCreated Task IDs:");
+                createdTasks.forEach((task, index) => {
+                    console.log(`  ${index + 1}. ${task.id} - ${task.title}`);
+                });
+            }
+        }
+        catch (error) {
+            console.error(`\nError creating tasks: ${(0, cli_runtime_1.errorMessage)(error)}`);
+            return 1;
+        }
+        finally {
+            await shared_1.AppDataSource.destroy();
+        }
+    }
+    else {
+        console.log("Dry-run mode: Tasks not created. Use --project-id and --spec-id to create tasks.");
+    }
+    return 0;
+}
+if (require.main === module) {
+    void (0, cli_runtime_1.runCliMain)(main, { errorPrefix: "backlog-generate failed" });
+}

package/dist/backlog-health.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+/**
+ * backlog-health CLI Tool
+ *
+ * Report backlog health metrics.
+ *
+ * Usage: npm run backlog-health [OPTIONS]
+ * Example: npm run backlog-health --project-id=<uuid>
+ */
+declare function main(argv?: string[]): Promise<number>;
+export { main };

package/dist/backlog-health.js

@@ -0,0 +1,287 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * backlog-health CLI Tool
+ *
+ * Report backlog health metrics.
+ *
+ * Usage: npm run backlog-health [OPTIONS]
+ * Example: npm run backlog-health --project-id=<uuid>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+const shared_1 = require("@spekn/shared");
+const shared_2 = require("@spekn/shared");
+const cli_runtime_1 = require("./utils/cli-runtime");
+function parseArgs(args) {
+    const options = {};
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg.startsWith("--project-id=")) {
+            options.projectId = arg.split("=")[1];
+        }
+        else if (arg.startsWith("--spec-id=")) {
+            options.specId = arg.split("=")[1];
+        }
+        else if (arg === "--verbose" || arg === "-v") {
+            options.verbose = true;
+        }
+        else if (arg === "--json" || arg === "-j") {
+            options.json = true;
+        }
+    }
+    return options;
+}
+function printHelp() {
+    console.log(`
+backlog-health - Report backlog health metrics
+
+USAGE:
+  npm run backlog-health [OPTIONS]
+
+OPTIONS:
+  --project-id=<id>   Filter by project ID
+  --spec-id=<id>      Filter by specification ID
+  -v, --verbose       Show detailed breakdown
+  -j, --json          Output in JSON format
+  -h, --help          Show this help message
+
+EXAMPLES:
+  npm run backlog-health
+  npm run backlog-health --project-id=abc123
+  npm run backlog-health --verbose --json
+`);
+}
+async function calculateMetrics(options) {
+    const taskRepository = shared_1.AppDataSource.getRepository(shared_2.Task);
+    // Build query
+    const queryBuilder = taskRepository.createQueryBuilder("task");
+    if (options.projectId) {
+        queryBuilder.andWhere("task.projectId = :projectId", {
+            projectId: options.projectId,
+        });
+    }
+    if (options.specId) {
+        queryBuilder.andWhere("task.specificationId = :specId", {
+            specId: options.specId,
+        });
+    }
+    const tasks = await queryBuilder.getMany();
+    // Fetch specifications with relations for drift detection
+    const tasksWithSpec = await taskRepository
+        .createQueryBuilder("task")
+        .leftJoinAndSelect("task.specification", "specification")
+        .where(options.projectId ? "task.projectId = :projectId" : "1=1", {
+        projectId: options.projectId,
+    })
+        .andWhere(options.specId ? "task.specificationId = :specId" : "1=1", {
+        specId: options.specId,
+    })
+        .getMany();
+    // Calculate spec version drift
+    const outdatedTasks = tasksWithSpec.filter((task) => {
+        if (!task.specification || !task.specVersion)
+            return false;
+        return task.specVersion !== task.specification.version;
+    });
+    const specVersionDrift = {
+        count: outdatedTasks.length,
+        outdatedTasks: outdatedTasks.map((task) => ({
+            id: task.id,
+            title: task.title,
+            taskSpecVersion: task.specVersion,
+            currentSpecVersion: task.specification?.version || "unknown",
+            specTitle: task.specification?.title || "unknown",
+        })),
+    };
+    // Calculate metrics
+    const total = tasks.length;
+    const byStatus = {
+        [shared_2.TaskStatus.OPEN]: 0,
+        [shared_2.TaskStatus.IN_PROGRESS]: 0,
+        [shared_2.TaskStatus.BLOCKED]: 0,
+        [shared_2.TaskStatus.COMPLETED]: 0,
+        [shared_2.TaskStatus.CANCELLED]: 0,
+    };
+    const completionTimes = [];
+    let tasksWithoutAnchors = 0;
+    let tasksWithDependencies = 0;
+    tasks.forEach((task) => {
+        byStatus[task.status]++;
+        if (!task.specAnchor) {
+            tasksWithoutAnchors++;
+        }
+        if (task.dependencies && task.dependencies.length > 0) {
+            tasksWithDependencies++;
+        }
+        // Calculate completion time for completed tasks
+        if (task.status === shared_2.TaskStatus.COMPLETED && task.completedAt) {
+            const completionTime = task.completedAt.getTime() - task.createdAt.getTime();
+            completionTimes.push(completionTime);
+        }
+    });
+    const byStatusPercentage = {
+        [shared_2.TaskStatus.OPEN]: total > 0 ? (byStatus[shared_2.TaskStatus.OPEN] / total) * 100 : 0,
+        [shared_2.TaskStatus.IN_PROGRESS]: total > 0 ? (byStatus[shared_2.TaskStatus.IN_PROGRESS] / total) * 100 : 0,
+        [shared_2.TaskStatus.BLOCKED]: total > 0 ? (byStatus[shared_2.TaskStatus.BLOCKED] / total) * 100 : 0,
+        [shared_2.TaskStatus.COMPLETED]: total > 0 ? (byStatus[shared_2.TaskStatus.COMPLETED] / total) * 100 : 0,
+        [shared_2.TaskStatus.CANCELLED]: total > 0 ? (byStatus[shared_2.TaskStatus.CANCELLED] / total) * 100 : 0,
+    };
+    const blockedCount = byStatus[shared_2.TaskStatus.BLOCKED];
+    const blockedPercentage = byStatusPercentage[shared_2.TaskStatus.BLOCKED];
+    const completedCount = byStatus[shared_2.TaskStatus.COMPLETED];
+    const completedPercentage = byStatusPercentage[shared_2.TaskStatus.COMPLETED];
+    // Calculate average completion time
+    let averageCompletionTimeHours;
+    if (completionTimes.length > 0) {
+        const avgMillis = completionTimes.reduce((a, b) => a + b, 0) / completionTimes.length;
+        averageCompletionTimeHours = avgMillis / (1000 * 60 * 60);
+    }
+    // Find oldest open task
+    let oldestOpenTask;
+    const openTasks = tasks
+        .filter((t) => t.status === shared_2.TaskStatus.OPEN)
+        .sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+    if (openTasks.length > 0) {
+        const oldest = openTasks[0];
+        const ageInDays = (Date.now() - oldest.createdAt.getTime()) / (1000 * 60 * 60 * 24);
+        oldestOpenTask = {
+            id: oldest.id,
+            title: oldest.title,
+            createdAt: oldest.createdAt,
+            ageInDays,
+        };
+    }
+    return {
+        total,
+        byStatus,
+        byStatusPercentage,
+        blockedCount,
+        blockedPercentage,
+        completedCount,
+        completedPercentage,
+        averageCompletionTimeHours,
+        oldestOpenTask,
+        tasksWithoutAnchors,
+        tasksWithDependencies,
+        specVersionDrift,
+    };
+}
+function formatPercentage(value) {
+    return value.toFixed(1) + "%";
+}
+function formatHours(hours) {
+    if (hours < 1) {
+        return (hours * 60).toFixed(0) + " minutes";
+    }
+    else if (hours < 24) {
+        return hours.toFixed(1) + " hours";
+    }
+    else {
+        return (hours / 24).toFixed(1) + " days";
+    }
+}
+async function main(argv) {
+    const args = argv ?? process.argv.slice(2);
+    if ((0, cli_runtime_1.hasHelpFlag)(args)) {
+        printHelp();
+        return 0;
+    }
+    const options = parseArgs(args);
+    console.log("Connecting to database...");
+    await shared_1.AppDataSource.initialize();
+    try {
+        const metrics = await calculateMetrics(options);
+        if (options.json) {
+            console.log(JSON.stringify(metrics, null, 2));
+        }
+        else {
+            console.log("\n=== Backlog Health Report ===\n");
+            // Overall stats
+            console.log("Overall Statistics:");
+            console.log(`  Total tasks: ${metrics.total}`);
+            console.log(`  Completed: ${metrics.completedCount} (${formatPercentage(metrics.completedPercentage)})`);
+            console.log(`  Blocked: ${metrics.blockedCount} (${formatPercentage(metrics.blockedPercentage)})`);
+            if (metrics.averageCompletionTimeHours !== undefined) {
+                console.log(`  Average completion time: ${formatHours(metrics.averageCompletionTimeHours)}`);
+            }
+            // Status breakdown
+            console.log("\nStatus Breakdown:");
+            Object.entries(metrics.byStatus).forEach(([status, count]) => {
+                const percentage = metrics.byStatusPercentage[status];
+                console.log(`  ${status.padEnd(15)}: ${count.toString().padStart(4)} (${formatPercentage(percentage)})`);
+            });
+            // Quality metrics
+            console.log("\nQuality Metrics:");
+            console.log(`  Tasks without spec anchors: ${metrics.tasksWithoutAnchors}`);
+            console.log(`  Tasks with dependencies: ${metrics.tasksWithDependencies}`);
+            // Spec version drift
+            if (metrics.specVersionDrift.count > 0) {
+                console.log("\nSpec Version Drift:");
+                console.log(`  Tasks with outdated spec versions: ${metrics.specVersionDrift.count}`);
+                if (options.verbose &&
+                    metrics.specVersionDrift.outdatedTasks.length > 0) {
+                    console.log("  Outdated tasks:");
+                    metrics.specVersionDrift.outdatedTasks.slice(0, 5).forEach((task) => {
+                        console.log(`    - ${task.title}`);
+                        console.log(`      Version: ${task.taskSpecVersion} → ${task.currentSpecVersion} (${task.specTitle})`);
+                    });
+                    if (metrics.specVersionDrift.count > 5) {
+                        console.log(`    ... and ${metrics.specVersionDrift.count - 5} more`);
+                    }
+                }
+            }
+            // Oldest open task
+            if (metrics.oldestOpenTask) {
+                console.log("\nOldest Open Task:");
+                console.log(`  Title: ${metrics.oldestOpenTask.title}`);
+                console.log(`  ID: ${metrics.oldestOpenTask.id}`);
+                console.log(`  Age: ${metrics.oldestOpenTask.ageInDays.toFixed(1)} days`);
+                console.log(`  Created: ${metrics.oldestOpenTask.createdAt.toISOString()}`);
+            }
+            // Health assessment
+            console.log("\nHealth Assessment:");
+            const healthIssues = [];
+            if (metrics.blockedPercentage > 20) {
+                healthIssues.push(`High blocked task percentage (${formatPercentage(metrics.blockedPercentage)})`);
+            }
+            if (metrics.completedPercentage < 30 && metrics.total > 10) {
+                healthIssues.push(`Low completion rate (${formatPercentage(metrics.completedPercentage)})`);
+            }
+            if (metrics.tasksWithoutAnchors > metrics.total * 0.1) {
+                healthIssues.push(`Many tasks without spec anchors (${metrics.tasksWithoutAnchors})`);
+            }
+            // Check for spec version drift
+            if (metrics.specVersionDrift.count > 0) {
+                const driftPercentage = (metrics.specVersionDrift.count / metrics.total) * 100;
+                if (driftPercentage > 20) {
+                    healthIssues.push(`High spec version drift (${formatPercentage(driftPercentage)} of tasks reference outdated specs)`);
+                }
+            }
+            if (metrics.oldestOpenTask && metrics.oldestOpenTask.ageInDays > 30) {
+                healthIssues.push(`Oldest open task is ${metrics.oldestOpenTask.ageInDays.toFixed(1)} days old`);
+            }
+            if (healthIssues.length === 0) {
+                console.log("  ✓ Backlog is healthy!");
+            }
+            else {
+                console.log("  ⚠ Issues detected:");
+                healthIssues.forEach((issue) => {
+                    console.log(`    - ${issue}`);
+                });
+            }
+            console.log();
+        }
+        return 0;
+    }
+    catch (error) {
+        console.error(`Error calculating metrics: ${(0, cli_runtime_1.errorMessage)(error)}`);
+        return 1;
+    }
+    finally {
+        await shared_1.AppDataSource.destroy();
+    }
+}
+if (require.main === module) {
+    void (0, cli_runtime_1.runCliMain)(main, { errorPrefix: "backlog-health failed" });
+}

package/dist/bridge-login.d.ts

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+/**
+ * bridge login CLI command
+ *
+ * Authenticates the CLI user via the Keycloak Device Authorization Grant,
+ * then registers the bridge device with the Spekn SaaS API. This combines
+ * `auth login` (credentials) with bridge device registration in a single step.
+ *
+ * Usage: spekn bridge login [--name <device-name>] [--api-url <url>] [--force]
+ */
+import type { DeviceFlowDeps, DeviceFlowResult } from "./auth/device-flow.js";
+import { CredentialsStore } from "./auth/credentials-store.js";
+import { BridgeConfigStore } from "@spekn/bridge";
+interface CLIOptions {
+    deviceName: string;
+    apiUrl: string;
+    force: boolean;
+    keycloakUrl: string;
+    realm: string;
+}
+interface Deps {
+    stdout: {
+        write(s: string): void;
+    };
+    stderr: {
+        write(s: string): void;
+    };
+    performDeviceFlow: (keycloakUrl: string, realm: string, clientId: string, deps?: Partial<DeviceFlowDeps>) => Promise<DeviceFlowResult>;
+    credentialsStore: CredentialsStore;
+    bridgeConfigStore: BridgeConfigStore;
+}
+declare function parseArgs(args: string[]): CLIOptions;
+/**
+ * Decode the payload of a JWT access token without verification.
+ * Returns the raw claims object, or null if decoding fails.
+ */
+declare function decodeJwtPayload(token: string): Record<string, unknown> | null;
+export declare function runBridgeLoginCli(args: string[], deps?: Partial<Deps>): Promise<number>;
+declare function main(): Promise<void>;
+export { main, parseArgs, decodeJwtPayload };