@inkeep/agents-cli 0.1.0 → 0.1.1

package/dist/commands/mcp-start-simple.js

@@ -1,193 +0,0 @@
-import { execSync, spawn } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
-import { pathToFileURL } from 'node:url';
-import chalk from 'chalk';
-import ora from 'ora';
-export async function mcpStartCommand(graphPath, options) {
-    let spinner = ora('Loading graph configuration...').start();
-    try {
-        // Resolve the graph path
-        const fullPath = resolve(graphPath);
-        if (!existsSync(fullPath)) {
-            spinner.fail(`Graph file not found: ${graphPath}`);
-            process.exit(1);
-        }
-        spinner.text = 'Starting MCP servers...';
-        // Get the directory of the graph file for proper module resolution
-        const graphDir = dirname(fullPath);
-        // Check if it's a TypeScript file
-        if (fullPath.endsWith('.ts')) {
-            spinner.text = 'Checking TypeScript runtime...';
-            // Check if tsx is available in the graph directory
-            try {
-                execSync('npx tsx --version', {
-                    stdio: 'pipe',
-                    cwd: graphDir,
-                });
-            }
-            catch {
-                spinner.fail('TypeScript runtime not found');
-                console.log(chalk.yellow('\nTo use TypeScript graph files:'));
-                console.log(chalk.gray('  Option 1: Compile your graph first'));
-                console.log(chalk.gray('    cd inkeep-chat && pnpm build'));
-                console.log(chalk.gray('    inkeep mcp start inkeep-chat/dist/examples/graph.graph.js'));
-                console.log(chalk.gray('\n  Option 2: Ensure tsx is installed in the graph directory'));
-                console.log(chalk.gray('    cd inkeep-chat && pnpm add -D tsx'));
-                process.exit(1);
-            }
-        }
-        // Convert to file URL for import
-        const fileUrl = pathToFileURL(fullPath).href;
-        // Spawn tsx process to run the runner with the graph file
-        const child = spawn('npx', [
-            'tsx',
-            '--eval',
-            `
-            import('${fileUrl}').then(async module => {
-                const servers = module.servers || module.tools || [];
-                const graph = module.graph;
-                
-                let graphId = 'unknown';
-                if (graph && typeof graph.getId === 'function') {
-                    graphId = graph.getId();
-                }
-                
-                const startedServers = [];
-                let nextPort = 3100;
-                
-                for (const server of servers) {
-                    if (!server) continue;
-                    
-                    // Try to get name using getName() method or direct property access
-                    let name = 'unnamed';
-                    if (typeof server.getName === 'function') {
-                        name = server.getName();
-                    } else if (server.config && server.config.name) {
-                        name = server.config.name;
-                    } else if (server.name) {
-                        name = server.name;
-                    }
-                    
-                    // Try to get server URL
-                    let serverUrl = undefined;
-                    if (typeof server.getServerUrl === 'function') {
-                        serverUrl = server.getServerUrl();
-                    } else if (server.config && server.config.serverUrl) {
-                        serverUrl = server.config.serverUrl;
-                    } else if (server.serverUrl) {
-                        serverUrl = server.serverUrl;
-                    }
-                    
-                    const isLocal = !serverUrl;
-                    const port = isLocal ? (server.port || server.config?.port || nextPort++) : undefined;
-                    
-                    console.log(JSON.stringify({
-                        type: 'server_started',
-                        name,
-                        port,
-                        serverUrl,
-                        deployment: isLocal ? 'local' : 'remote'
-                    }));
-                    
-                    startedServers.push(name);
-                }
-                
-                console.log(JSON.stringify({
-                    type: 'all_started',
-                    count: startedServers.length,
-                    graphId
-                }));
-                
-                if (!${options.detached || false}) {
-                    // Keep process alive
-                    process.stdin.resume();
-                    
-                    process.on('SIGINT', () => {
-                        console.log(JSON.stringify({ type: 'shutting_down' }));
-                        process.exit(0);
-                    });
-                }
-            }).catch(error => {
-                console.error(JSON.stringify({
-                    type: 'error',
-                    message: error.message
-                }));
-                process.exit(1);
-            });
-        `,
-        ], {
-            stdio: ['inherit', 'pipe', 'pipe'],
-            cwd: graphDir, // Set working directory to graph file's directory
-            env: {
-                ...process.env,
-                ENVIRONMENT: process.env.ENVIRONMENT || 'test',
-                DB_FILE_NAME: process.env.DB_FILE_NAME || ':memory:',
-                INKEEP_TENANT_ID: process.env.INKEEP_TENANT_ID || 'test-tenant',
-                ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY || 'test-key',
-            },
-        });
-        let serverCount = 0;
-        let graphId = 'unknown';
-        // Handle stdout
-        child.stdout?.on('data', (data) => {
-            const lines = data.toString().split('\n').filter(Boolean);
-            for (const line of lines) {
-                try {
-                    const msg = JSON.parse(line);
-                    if (msg.type === 'server_started') {
-                        const icon = msg.deployment === 'local' ? '🏠' : '☁️';
-                        const location = msg.deployment === 'local'
-                            ? `on port ${chalk.cyan(msg.port)}`
-                            : `at ${chalk.cyan(msg.serverUrl)}`;
-                        spinner.succeed(`${icon} Started ${chalk.green(msg.name)} ${location}`);
-                        spinner = ora().start(); // Create new spinner for next server
-                        serverCount++;
-                    }
-                    else if (msg.type === 'all_started') {
-                        spinner.stop();
-                        console.log(chalk.green(`\n✅ Started ${msg.count} MCP server(s)`));
-                        graphId = msg.graphId || 'unknown';
-                        if (!options.detached) {
-                            console.log(chalk.gray('\nServers are running. Press Ctrl+C to stop all servers.\n'));
-                        }
-                    }
-                    else if (msg.type === 'shutting_down') {
-                        console.log(chalk.yellow('\n\nShutting down MCP servers...'));
-                    }
-                    else if (msg.type === 'error') {
-                        spinner.fail(`Error: ${msg.message}`);
-                    }
-                }
-                catch {
-                    // Not JSON, just print it
-                    if (options.verbose) {
-                        console.log(chalk.gray(line));
-                    }
-                }
-            }
-        });
-        // Handle stderr
-        child.stderr?.on('data', (data) => {
-            if (options.verbose) {
-                console.error(chalk.red(data.toString()));
-            }
-        });
-        // Handle exit
-        child.on('exit', (code) => {
-            if (code !== 0 && code !== null) {
-                spinner.fail('Failed to start MCP servers');
-                process.exit(code);
-            }
-        });
-        // Forward SIGINT to child
-        process.on('SIGINT', () => {
-            child.kill('SIGINT');
-        });
-    }
-    catch (error) {
-        spinner.fail('Failed to start MCP servers');
-        console.error(chalk.red('Error:'), error instanceof Error ? error.message : error);
-        process.exit(1);
-    }
-}

package/dist/commands/mcp-start.d.ts

@@ -1,5 +0,0 @@
-export interface McpStartOptions {
-    detached?: boolean;
-    verbose?: boolean;
-}
-export declare function mcpStartCommand(graphPath: string, options: McpStartOptions): Promise<void>;

package/dist/commands/mcp-start.js

@@ -1,217 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { join, resolve } from 'node:path';
-import chalk from 'chalk';
-import ora from 'ora';
-import { PortManager } from '../utils/port-manager.js';
-import { loadTypeScriptModule } from '../utils/ts-loader.js';
-const MCP_DIR = join(homedir(), '.inkeep', 'mcp');
-const REGISTRY_FILE = join(MCP_DIR, 'servers.json');
-// Ensure MCP directory exists
-if (!existsSync(MCP_DIR)) {
-    mkdirSync(MCP_DIR, { recursive: true });
-}
-function loadRegistry() {
-    if (!existsSync(REGISTRY_FILE)) {
-        return { servers: [] };
-    }
-    try {
-        return JSON.parse(readFileSync(REGISTRY_FILE, 'utf-8'));
-    }
-    catch {
-        return { servers: [] };
-    }
-}
-function saveRegistry(registry) {
-    writeFileSync(REGISTRY_FILE, JSON.stringify(registry, null, 2));
-}
-function cleanupStaleServers(registry) {
-    // Remove servers whose processes are no longer running
-    const activeServers = registry.servers.filter((server) => {
-        try {
-            // Check if process is still running
-            process.kill(server.pid, 0);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    });
-    return { servers: activeServers };
-}
-export async function mcpStartCommand(graphPath, options) {
-    const spinner = ora('Loading graph configuration...').start();
-    try {
-        // Resolve the graph path
-        const fullPath = resolve(graphPath);
-        if (!existsSync(fullPath)) {
-            spinner.fail(`Graph file not found: ${graphPath}`);
-            process.exit(1);
-        }
-        spinner.text = 'Importing graph configuration...';
-        // Import the graph module
-        let module;
-        if (fullPath.endsWith('.ts')) {
-            // For TypeScript files, use our loader
-            try {
-                module = await loadTypeScriptModule(fullPath);
-            }
-            catch (error) {
-                spinner.fail('Failed to load TypeScript graph configuration');
-                console.error(chalk.red('Error:'), error.message);
-                process.exit(1);
-            }
-        }
-        else {
-            // For JavaScript files, import directly
-            module = await import(fullPath);
-        }
-        // Find exported tools (both regular exports and default export)
-        const tools = [];
-        const toolMap = new Map();
-        // Check for exported servers (new convention)
-        if (module.servers && module.servers.__type === 'array' && module.servers.items) {
-            tools.push(...module.servers.items);
-        }
-        // Check for exported tools (backwards compatibility)
-        if (module.tools && module.tools.__type === 'array' && module.tools.items) {
-            tools.push(...module.tools.items);
-        }
-        // Check for individual tool exports
-        for (const [key, value] of Object.entries(module)) {
-            if (key === 'default' || key === 'graph' || key === 'tools' || key === 'servers')
-                continue;
-            // Check if it looks like a tool (has execute function or is an IPC tool)
-            if (value && typeof value === 'object') {
-                const hasExecute = value.hasExecute === true;
-                const hasInit = value.hasInit === true;
-                const hasGetServerUrl = value.hasGetServerUrl === true;
-                if (hasExecute || (hasInit && hasGetServerUrl)) {
-                    tools.push(value);
-                    toolMap.set(key, value);
-                }
-            }
-        }
-        // Get graph ID
-        let graphId = 'unknown';
-        if (module.graph && module.graph.graphId) {
-            graphId = module.graph.graphId;
-        }
-        if (tools.length === 0) {
-            spinner.warn('No MCP tools found in graph configuration');
-            console.log(chalk.gray('\nTo use MCP tools, export them from your graph file:'));
-            console.log(chalk.gray('  export const myTool = ipcTool({ ... });'));
-            console.log(chalk.gray('  export const tools = [myTool, anotherTool];'));
-            process.exit(0);
-        }
-        spinner.succeed(`Found ${tools.length} MCP tool(s) in graph`);
-        // Load and clean registry
-        const registry = cleanupStaleServers(loadRegistry());
-        // Start each tool
-        const startedServers = [];
-        const portManager = PortManager.getInstance();
-        for (const tool of tools) {
-            const toolSpinner = ora(`Starting MCP server: ${tool.name || 'unnamed'}`).start();
-            try {
-                // Check if tool is already running
-                const existingServer = registry.servers.find((s) => s.graphId === graphId && s.toolId === (tool.id || tool.name));
-                if (existingServer) {
-                    // Check if process is still alive
-                    try {
-                        process.kill(existingServer.pid, 0);
-                        toolSpinner.warn(`Server ${tool.name} already running (PID: ${existingServer.pid})`);
-                        continue;
-                    }
-                    catch {
-                        // Process is dead, remove from registry
-                        registry.servers = registry.servers.filter((s) => s.pid !== existingServer.pid);
-                        portManager.releasePort(existingServer.port);
-                    }
-                }
-                // Determine deployment type
-                const isLocal = tool.hasExecute === true ||
-                    tool.hasInit === true ||
-                    (!tool.serverUrl && !tool.deployment);
-                const deployment = tool.deployment || (isLocal ? 'local' : 'remote');
-                // For TypeScript files, we can't actually initialize or call methods
-                // We just use the metadata we extracted
-                // Get server details
-                let port;
-                let serverUrl;
-                if (deployment === 'local') {
-                    // Allocate port for local server
-                    if (tool.port) {
-                        port = await portManager.allocatePort(tool.port);
-                    }
-                    else {
-                        port = await portManager.allocatePort();
-                    }
-                    serverUrl = `http://localhost:${port}/mcp`;
-                }
-                else {
-                    // Remote server
-                    serverUrl = tool.serverUrl;
-                }
-                const server = {
-                    pid: process.pid, // Will be updated if we spawn a subprocess
-                    graphId,
-                    toolId: tool.id || tool.name || 'unknown',
-                    name: tool.name || 'unnamed',
-                    port,
-                    serverUrl,
-                    deployment,
-                    transport: tool.transport || 'ipc',
-                    command: graphPath,
-                    startedAt: new Date().toISOString(),
-                    description: tool.description,
-                };
-                startedServers.push(server);
-                registry.servers.push(server);
-                const deploymentIcon = deployment === 'local' ? '🏠' : '☁️';
-                toolSpinner.succeed(`${deploymentIcon} Started ${chalk.green(tool.name || 'unnamed')} ` +
-                    (deployment === 'local' ? `on port ${chalk.cyan(port)}` : `at ${chalk.cyan(serverUrl)}`));
-                if (options.verbose) {
-                    console.log(chalk.gray(`  ID: ${tool.id}`));
-                    console.log(chalk.gray(`  Type: ${deployment} MCP server`));
-                    console.log(chalk.gray(`  Description: ${tool.description || 'N/A'}`));
-                }
-            }
-            catch (error) {
-                toolSpinner.fail(`Failed to start ${tool.name || 'unnamed'}: ${error}`);
-            }
-        }
-        // Save updated registry
-        saveRegistry(registry);
-        console.log(chalk.green(`\n✅ Started ${startedServers.length} MCP server(s)`));
-        if (!options.detached) {
-            console.log(chalk.gray('\nServers are running. Press Ctrl+C to stop all servers.\n'));
-            // Handle graceful shutdown
-            process.on('SIGINT', () => {
-                console.log(chalk.yellow('\n\nShutting down MCP servers...'));
-                // Stop all tools
-                for (const tool of tools) {
-                    if (typeof tool.stop === 'function') {
-                        try {
-                            tool.stop();
-                        }
-                        catch (error) {
-                            console.error(chalk.red(`Error stopping tool: ${error}`));
-                        }
-                    }
-                }
-                // Remove from registry
-                const updatedRegistry = loadRegistry();
-                updatedRegistry.servers = updatedRegistry.servers.filter((s) => !startedServers.some((started) => started.pid === s.pid));
-                saveRegistry(updatedRegistry);
-                process.exit(0);
-            });
-            // Keep process alive
-            process.stdin.resume();
-        }
-    }
-    catch (error) {
-        spinner.fail('Failed to start MCP servers');
-        console.error(chalk.red('Error:'), error instanceof Error ? error.message : error);
-        process.exit(1);
-    }
-}

package/dist/commands/mcp-status.d.ts

@@ -1 +0,0 @@
-export declare function mcpStatusCommand(): Promise<void>;

package/dist/commands/mcp-status.js

@@ -1,96 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import chalk from 'chalk';
-import Table from 'cli-table3';
-const MCP_DIR = join(homedir(), '.inkeep', 'mcp');
-const REGISTRY_FILE = join(MCP_DIR, 'servers.json');
-function loadRegistry() {
-    if (!existsSync(REGISTRY_FILE)) {
-        return { servers: [] };
-    }
-    try {
-        return JSON.parse(readFileSync(REGISTRY_FILE, 'utf-8'));
-    }
-    catch {
-        return { servers: [] };
-    }
-}
-function isProcessRunning(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function formatUptime(ms) {
-    const seconds = Math.floor(ms / 1000);
-    const minutes = Math.floor(seconds / 60);
-    const hours = Math.floor(minutes / 60);
-    const days = Math.floor(hours / 24);
-    if (days > 0)
-        return `${days}d ${hours % 24}h`;
-    if (hours > 0)
-        return `${hours}h ${minutes % 60}m`;
-    if (minutes > 0)
-        return `${minutes}m ${seconds % 60}s`;
-    return `${seconds}s`;
-}
-export async function mcpStatusCommand() {
-    const registry = loadRegistry();
-    if (registry.servers.length === 0) {
-        console.log(chalk.gray('No MCP servers registered'));
-        console.log(chalk.gray('\nStart servers with: inkeep mcp start <graph-file>'));
-        return;
-    }
-    // Create table
-    const table = new Table({
-        head: [
-            chalk.cyan('PID'),
-            chalk.cyan('Graph'),
-            chalk.cyan('Tool'),
-            chalk.cyan('Port'),
-            chalk.cyan('Status'),
-            chalk.cyan('Uptime'),
-        ],
-        style: {
-            head: [],
-            border: ['gray'],
-        },
-    });
-    let activeCount = 0;
-    let staleCount = 0;
-    for (const server of registry.servers) {
-        const isRunning = isProcessRunning(server.pid);
-        const uptime = new Date().getTime() - new Date(server.startedAt).getTime();
-        const uptimeStr = formatUptime(uptime);
-        if (isRunning) {
-            activeCount++;
-        }
-        else {
-            staleCount++;
-        }
-        table.push([
-            isRunning ? chalk.green(server.pid.toString()) : chalk.red(server.pid.toString()),
-            server.graphId,
-            server.toolId,
-            server.port ? chalk.cyan(server.port.toString()) : chalk.gray('N/A'),
-            isRunning ? chalk.green('● Running') : chalk.red('● Stopped'),
-            isRunning ? uptimeStr : chalk.gray('N/A'),
-        ]);
-    }
-    console.log(chalk.bold('\n📡 MCP Server Status\n'));
-    console.log(table.toString());
-    console.log();
-    console.log(chalk.gray('Summary:'));
-    console.log(chalk.green(`  ● ${activeCount} active`), chalk.red(`  ● ${staleCount} stopped`));
-    if (staleCount > 0) {
-        console.log(chalk.yellow('\n⚠️  Some servers have stopped. Run "inkeep mcp stop --all" to clean up.'));
-    }
-    console.log(chalk.gray('\nCommands:'));
-    console.log(chalk.gray('  • Start servers:  inkeep mcp start <graph-file>'));
-    console.log(chalk.gray('  • Stop servers:   inkeep mcp stop'));
-    console.log(chalk.gray('  • Stop all:       inkeep mcp stop --all'));
-}

package/dist/commands/mcp-stop.d.ts

@@ -1,5 +0,0 @@
-export interface McpStopOptions {
-    all?: boolean;
-    graph?: string;
-}
-export declare function mcpStopCommand(options: McpStopOptions): Promise<void>;

package/dist/commands/mcp-stop.js

@@ -1,160 +0,0 @@
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import chalk from 'chalk';
-import inquirer from 'inquirer';
-import ora from 'ora';
-const MCP_DIR = join(homedir(), '.inkeep', 'mcp');
-const REGISTRY_FILE = join(MCP_DIR, 'servers.json');
-function loadRegistry() {
-    if (!existsSync(REGISTRY_FILE)) {
-        return { servers: [] };
-    }
-    try {
-        return JSON.parse(readFileSync(REGISTRY_FILE, 'utf-8'));
-    }
-    catch {
-        return { servers: [] };
-    }
-}
-function saveRegistry(registry) {
-    writeFileSync(REGISTRY_FILE, JSON.stringify(registry, null, 2));
-}
-function stopServer(server) {
-    try {
-        process.kill(server.pid, 'SIGTERM');
-        // Give it a moment to terminate gracefully
-        setTimeout(() => {
-            try {
-                // Check if still running and force kill if needed
-                process.kill(server.pid, 0);
-                process.kill(server.pid, 'SIGKILL');
-            }
-            catch {
-                // Process already terminated
-            }
-        }, 1000);
-        return true;
-    }
-    catch (error) {
-        // Process might already be dead
-        return false;
-    }
-}
-export async function mcpStopCommand(options) {
-    const spinner = ora('Loading MCP server registry...').start();
-    try {
-        const registry = loadRegistry();
-        if (registry.servers.length === 0) {
-            spinner.info('No MCP servers are currently running');
-            process.exit(0);
-        }
-        spinner.stop();
-        let serversToStop = [];
-        if (options.all) {
-            // Stop all servers
-            serversToStop = registry.servers;
-        }
-        else if (options.graph) {
-            // Stop servers for specific graph
-            serversToStop = registry.servers.filter((s) => s.graphId === options.graph);
-            if (serversToStop.length === 0) {
-                console.log(chalk.yellow(`No servers found for graph: ${options.graph}`));
-                process.exit(0);
-            }
-        }
-        else {
-            // Interactive selection
-            const groupedServers = new Map();
-            // Group servers by graph
-            for (const server of registry.servers) {
-                const servers = groupedServers.get(server.graphId) || [];
-                servers.push(server);
-                groupedServers.set(server.graphId, servers);
-            }
-            // Create choices
-            const choices = [
-                { name: chalk.red('Stop all servers'), value: 'all' },
-                new inquirer.Separator(),
-            ];
-            for (const [graphId, servers] of groupedServers) {
-                choices.push({
-                    name: `${chalk.cyan(graphId)} (${servers.length} server${servers.length > 1 ? 's' : ''})`,
-                    value: graphId,
-                });
-                for (const server of servers) {
-                    const uptime = new Date().getTime() - new Date(server.startedAt).getTime();
-                    const uptimeStr = formatUptime(uptime);
-                    choices.push({
-                        name: chalk.gray(`  └─ ${server.toolId} `) +
-                            (server.port ? chalk.gray(`(port ${server.port}) `) : '') +
-                            chalk.gray(`[${uptimeStr}]`),
-                        value: `tool:${server.pid}`,
-                    });
-                }
-            }
-            const answer = await inquirer.prompt([
-                {
-                    type: 'list',
-                    name: 'selection',
-                    message: 'Select servers to stop:',
-                    choices,
-                    pageSize: 15,
-                },
-            ]);
-            if (answer.selection === 'all') {
-                serversToStop = registry.servers;
-            }
-            else if (answer.selection.startsWith('tool:')) {
-                const pid = parseInt(answer.selection.replace('tool:', ''));
-                serversToStop = registry.servers.filter((s) => s.pid === pid);
-            }
-            else {
-                serversToStop = registry.servers.filter((s) => s.graphId === answer.selection);
-            }
-        }
-        if (serversToStop.length === 0) {
-            console.log(chalk.yellow('No servers selected'));
-            process.exit(0);
-        }
-        // Stop the servers
-        const stopSpinner = ora(`Stopping ${serversToStop.length} server(s)...`).start();
-        let stoppedCount = 0;
-        for (const server of serversToStop) {
-            const stopped = stopServer(server);
-            if (stopped) {
-                stoppedCount++;
-                if (options.all || options.graph) {
-                    console.log(chalk.gray(`  • Stopped ${server.toolId} (PID: ${server.pid})`));
-                }
-            }
-        }
-        // Update registry
-        registry.servers = registry.servers.filter((s) => !serversToStop.some((toStop) => toStop.pid === s.pid));
-        saveRegistry(registry);
-        if (stoppedCount > 0) {
-            stopSpinner.succeed(`Stopped ${stoppedCount} MCP server(s)`);
-        }
-        else {
-            stopSpinner.warn('No servers were stopped (they may have already terminated)');
-        }
-    }
-    catch (error) {
-        spinner.fail('Failed to stop MCP servers');
-        console.error(chalk.red('Error:'), error instanceof Error ? error.message : error);
-        process.exit(1);
-    }
-}
-function formatUptime(ms) {
-    const seconds = Math.floor(ms / 1000);
-    const minutes = Math.floor(seconds / 60);
-    const hours = Math.floor(minutes / 60);
-    const days = Math.floor(hours / 24);
-    if (days > 0)
-        return `${days}d ${hours % 24}h`;
-    if (hours > 0)
-        return `${hours}h ${minutes % 60}m`;
-    if (minutes > 0)
-        return `${minutes}m ${seconds % 60}s`;
-    return `${seconds}s`;
-}