@syrin/cli 1.3.0

package/dist/cli/commands/init.js

@@ -0,0 +1,90 @@
+/**
+ * `syrin init` command implementation.
+ * Initializes a new Syrin project with configuration.
+ */
+import { generateConfigFile, isProjectInitialized } from '../../config/generator.js';
+import { promptInitOptions, getDefaultInitOptions, } from '../../cli/prompts/init-prompt.js';
+import { ConfigurationError } from '../../utils/errors.js';
+import { logger } from '../../utils/logger.js';
+import { Messages, Paths } from '../../constants/index.js';
+import { ensureGitignorePattern } from '../../utils/gitignore.js';
+import { displayAlreadyInitialized, displayInitSuccess, } from '../../presentation/init-ui.js';
+import { showVersionBanner } from '../../cli/utils/version-banner.js';
+/**
+ * Execute the init command.
+ * @param options - Command options
+ */
+export async function executeInit(options = {}) {
+    await showVersionBanner();
+    const projectRoot = options.projectRoot || process.cwd();
+    // Check if project is already initialized
+    if (isProjectInitialized(projectRoot)) {
+        displayAlreadyInitialized();
+        // Exit gracefully without showing error stack
+        return;
+    }
+    let initOptions;
+    if (options.yes) {
+        // Non-interactive mode: use defaults
+        logger.info('Initializing project with default values (non-interactive mode)');
+        initOptions = getDefaultInitOptions(projectRoot);
+    }
+    else {
+        // Interactive mode: prompt user
+        logger.info('Starting interactive project initialization');
+        try {
+            initOptions = await promptInitOptions();
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === 'ExitPromptError') {
+                // User cancelled
+                logger.info('Initialization cancelled by user');
+                process.exit(0);
+            }
+            throw error;
+        }
+    }
+    try {
+        // Generate config file
+        const configPath = generateConfigFile(initOptions, projectRoot);
+        logger.info('Configuration file created successfully', {
+            configPath,
+            projectName: initOptions.projectName,
+            transport: initOptions.transport,
+        });
+        // Update .gitignore to exclude event files and dev history
+        try {
+            const eventsPatternAdded = await ensureGitignorePattern(projectRoot, Paths.EVENTS_DIR);
+            if (eventsPatternAdded) {
+                logger.info(`Added ${Paths.EVENTS_DIR} to .gitignore`);
+            }
+            const historyPatternAdded = await ensureGitignorePattern(projectRoot, Paths.DEV_HISTORY_FILE);
+            if (historyPatternAdded) {
+                logger.info('Added .syrin/.dev-history to .gitignore');
+            }
+            const dataPatternAdded = await ensureGitignorePattern(projectRoot, Paths.DATA_DIR);
+            if (dataPatternAdded) {
+                logger.info(`Added ${Paths.DATA_DIR} to .gitignore`);
+            }
+        }
+        catch (error) {
+            // Log but don't fail initialization if .gitignore update fails
+            logger.warn('Failed to update .gitignore', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+        // Display success message
+        displayInitSuccess(configPath);
+    }
+    catch (error) {
+        const configError = error instanceof ConfigurationError
+            ? error
+            : new ConfigurationError(Messages.ERROR_GENERATE_CONFIG, {
+                cause: error instanceof Error ? error : new Error(String(error)),
+                context: { projectRoot },
+            });
+        logger.error('Failed to initialize project', configError);
+        throw configError;
+    }
+}
+//# sourceMappingURL=init.js.map

package/dist/cli/commands/list.d.ts

@@ -0,0 +1,15 @@
+/**
+ * `syrin list` command implementation.
+ * Lists tools, resources, or prompts from an MCP server.
+ */
+import { type TransportCommandOptions } from '../../cli/utils/index.js';
+import type { ListType } from '../../constants/list.js';
+interface ListCommandOptions extends TransportCommandOptions {
+    type?: ListType;
+}
+/**
+ * Execute the list command.
+ */
+export declare function executeList(options: ListCommandOptions): Promise<void>;
+export {};
+//# sourceMappingURL=list.d.ts.map

package/dist/cli/commands/list.js

@@ -0,0 +1,50 @@
+/**
+ * `syrin list` command implementation.
+ * Lists tools, resources, or prompts from an MCP server.
+ */
+import { listTools, listResources, listPrompts } from '../../runtime/mcp/index.js';
+import { handleCommandError, resolveTransportConfig, establishConnection, safeCloseConnection, } from '../../cli/utils/index.js';
+import { Messages, ListTypes } from '../../constants/index.js';
+import { displayTools, displayResources, displayPrompts, } from '../../presentation/list-ui.js';
+/**
+ * Execute the list command.
+ */
+export async function executeList(options) {
+    try {
+        const { type = ListTypes.TOOLS } = options;
+        // Resolve transport configuration from options and config
+        const { transport: finalTransport, url: mcpUrl, script: mcpCommand, urlSource, env, authHeaders, } = resolveTransportConfig(options);
+        // Connect to MCP server with centralized error handling
+        const { client, transport: mcpTransport } = await establishConnection({
+            transport: finalTransport,
+            url: mcpUrl,
+            script: mcpCommand,
+            urlSource,
+            env,
+            authHeaders,
+        });
+        try {
+            // List based on type
+            if (type === ListTypes.TOOLS) {
+                const toolsResult = await listTools(client);
+                await displayTools(toolsResult.tools);
+            }
+            else if (type === ListTypes.RESOURCES) {
+                const resourcesResult = await listResources(client);
+                await displayResources(resourcesResult.resources);
+            }
+            else if (type === ListTypes.PROMPTS) {
+                const promptsResult = await listPrompts(client);
+                await displayPrompts(promptsResult.prompts);
+            }
+        }
+        finally {
+            // Always close the connection safely
+            await safeCloseConnection(mcpTransport);
+        }
+    }
+    catch (error) {
+        handleCommandError(error, Messages.LIST_ERROR_FAILED(options.type || 'items'));
+    }
+}
+//# sourceMappingURL=list.js.map

package/dist/cli/commands/rollback.d.ts

@@ -0,0 +1,12 @@
+/**
+ * `syrin rollback` command implementation.
+ * Rolls back Syrin to a previous version.
+ */
+export interface RollbackCommandOptions {
+    version: string;
+}
+/**
+ * Execute the rollback command.
+ */
+export declare function executeRollback(options: RollbackCommandOptions): Promise<void>;
+//# sourceMappingURL=rollback.d.ts.map

package/dist/cli/commands/rollback.js

@@ -0,0 +1,101 @@
+/**
+ * `syrin rollback` command implementation.
+ * Rolls back Syrin to a previous version.
+ */
+import { getCurrentVersion, fetchPackageInfo, compareVersions, } from '../../utils/version-checker.js';
+import { installPackageVersion, isValidVersion, normalizeVersion, detectInstallType, } from '../../utils/package-manager.js';
+import { handleCommandError } from '../../cli/utils/index.js';
+import { Messages } from '../../constants/index.js';
+import { Icons } from '../../constants/index.js';
+import { SYRIN_LINKS } from '../../constants/links.js';
+import { ConfigurationError } from '../../utils/errors.js';
+import { log } from '../../utils/logger.js';
+import { PACKAGE_NAME } from '../../constants/app.js';
+/**
+ * Execute the rollback command.
+ */
+export async function executeRollback(options) {
+    try {
+        const { version } = options;
+        // Validate version format
+        if (!isValidVersion(version)) {
+            throw new ConfigurationError(Messages.ROLLBACK_INVALID_VERSION(version));
+        }
+        const normalizedVersion = normalizeVersion(version);
+        const currentVersion = getCurrentVersion();
+        // Check if trying to rollback to current version
+        if (normalizedVersion === currentVersion) {
+            log.info(`Already on version v${normalizedVersion}`);
+            log.blank();
+            return;
+        }
+        // Verify version exists on npm registry
+        log.info(`Verifying version v${normalizedVersion} exists on npm registry...`);
+        try {
+            const packageInfo = await fetchPackageInfo(PACKAGE_NAME);
+            if (!packageInfo.versions ||
+                !(normalizedVersion in packageInfo.versions)) {
+                throw new ConfigurationError(Messages.ROLLBACK_VERSION_NOT_FOUND(`v${normalizedVersion}`));
+            }
+        }
+        catch (error) {
+            if (error instanceof ConfigurationError) {
+                throw error;
+            }
+            // If it's a network error, warn but continue
+            log.warning('Could not verify version on registry (continuing anyway...)');
+            log.blank();
+        }
+        // Compare versions to warn about rolling back
+        const comparison = compareVersions(currentVersion, normalizedVersion);
+        if (comparison > 0) {
+            log.warning(`Warning: Rolling back to an older version (v${currentVersion} -> v${normalizedVersion})`);
+            log.blank();
+        }
+        // Determine install type for better error messages
+        const installType = detectInstallType();
+        log.info(Messages.ROLLBACK_IN_PROGRESS(`v${normalizedVersion}`, PACKAGE_NAME));
+        // Install the specific version
+        const result = await installPackageVersion(normalizedVersion, PACKAGE_NAME);
+        if (result.success) {
+            const installedVersion = result.version || normalizedVersion;
+            log.blank();
+            log.success(`${Icons.CHECK} ${Messages.ROLLBACK_SUCCESS(`v${installedVersion}`)}`);
+            log.blank();
+            // Show helpful message about config compatibility
+            log.info('Make sure your config.yaml is compatible with this version.');
+            log.plain(`   Documentation: ${SYRIN_LINKS.DOCS}`);
+            log.blank();
+        }
+        else {
+            const errorMessage = result.error || Messages.ROLLBACK_FAILED;
+            // Check if it's a permission error
+            if (errorMessage.includes('EACCES') ||
+                errorMessage.includes('permission')) {
+                const sudoCommand = installType === 'global'
+                    ? `sudo npm install -g ${PACKAGE_NAME}@${normalizedVersion}`
+                    : `npm install ${PACKAGE_NAME}@${normalizedVersion}`;
+                log.blank();
+                log.error(Messages.UPDATE_PERMISSION_HINT(sudoCommand));
+                log.blank();
+            }
+            else {
+                log.blank();
+                log.error(Messages.ROLLBACK_ERROR(errorMessage));
+                log.blank();
+            }
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        if (error instanceof ConfigurationError) {
+            log.blank();
+            log.error(error.message);
+            log.blank();
+            process.exit(1);
+            return;
+        }
+        handleCommandError(error, Messages.ROLLBACK_FAILED);
+    }
+}
+//# sourceMappingURL=rollback.js.map

package/dist/cli/commands/test.d.ts

@@ -0,0 +1,31 @@
+/**
+ * `syrin test` command implementation.
+ * Tests MCP connection and validates tool contracts.
+ */
+import { type TransportCommandOptions } from '../../cli/utils/index.js';
+interface TestCommandOptions extends TransportCommandOptions {
+    /** Test connection only (legacy behavior) */
+    connection?: boolean;
+    /** Test specific tool only */
+    tool?: string;
+    /** Test all tools in a specific path (relative to tools directory) */
+    path?: string;
+    /** Strict mode (treat warnings as errors) */
+    strict?: boolean;
+    /** JSON output */
+    json?: boolean;
+    /** CI mode (minimal output, exit code 1 on errors) */
+    ci?: boolean;
+    /** Show sandbox process error output (stderr from MCP server) */
+    showErrors?: boolean;
+    /** Tools directory */
+    toolsDir?: string;
+}
+/**
+ * Execute the test command.
+ *
+ * @param options - Command options
+ */
+export declare function executeTest(options: TestCommandOptions): Promise<void>;
+export {};
+//# sourceMappingURL=test.d.ts.map

package/dist/cli/commands/test.js

@@ -0,0 +1,88 @@
+/**
+ * `syrin test` command implementation.
+ * Tests MCP connection and validates tool contracts.
+ */
+import { connectMCP } from '../../runtime/mcp/index.js';
+import { handleCommandError, resolveTransportConfig, } from '../../cli/utils/index.js';
+import { displayTestResults, formatCLIResults, formatCIResults, formatJSONResults, } from '../../presentation/test-ui.js';
+import { TestOrchestrator } from '../../runtime/test/orchestrator.js';
+import { log } from '../../utils/logger.js';
+/**
+ * Execute the test command.
+ *
+ * @param options - Command options
+ */
+export async function executeTest(options) {
+    try {
+        // If --connection flag is set, use legacy connection testing
+        if (options.connection) {
+            await executeConnectionTest(options);
+            return;
+        }
+        // Otherwise, run tool validation
+        const exitCode = await executeToolValidation(options);
+        process.exit(exitCode);
+    }
+    catch (error) {
+        handleCommandError(error);
+    }
+}
+/**
+ * Execute connection test (legacy behavior).
+ */
+async function executeConnectionTest(options) {
+    // Resolve transport configuration from options and config
+    const { transport, url, script, env, authHeaders } = resolveTransportConfig(options);
+    // Perform the test
+    const result = await connectMCP({
+        transport,
+        url,
+        command: script,
+        env,
+        headers: authHeaders,
+    });
+    // Display results using Ink UI
+    await displayTestResults({
+        result,
+        transport,
+    });
+    // Exit with appropriate code
+    if (!result.success) {
+        process.exit(1);
+    }
+}
+/**
+ * Execute tool validation.
+ * @returns Exit code (0 for pass, 1 for fail)
+ */
+async function executeToolValidation(options) {
+    const projectRoot = options.projectRoot || process.cwd();
+    // Create orchestrator
+    const orchestrator = new TestOrchestrator({
+        projectRoot,
+        toolsDir: options.toolsDir,
+        toolName: options.tool,
+        toolPath: options.path,
+        strictMode: options.strict,
+        ci: options.ci,
+        showErrors: options.showErrors,
+        // MCP command will be resolved from config
+        env: options.env,
+    });
+    // Run tests
+    const result = await orchestrator.run();
+    // Format output
+    if (options.json) {
+        const jsonOutput = formatJSONResults(result);
+        log.plain(jsonOutput);
+    }
+    else if (options.ci) {
+        formatCIResults(result);
+    }
+    else {
+        formatCLIResults(result);
+    }
+    // Return exit code (0 for pass, 1 for fail)
+    return result.verdict === 'pass' ? 0 : 1;
+}
+//# sourceMappingURL=test.js.map

package/dist/cli/commands/update.d.ts

@@ -0,0 +1,9 @@
+/**
+ * `syrin update` command implementation.
+ * Updates Syrin to the latest version.
+ */
+/**
+ * Execute the update command.
+ */
+export declare function executeUpdate(): Promise<void>;
+//# sourceMappingURL=update.d.ts.map

package/dist/cli/commands/update.js

@@ -0,0 +1,76 @@
+/**
+ * `syrin update` command implementation.
+ * Updates Syrin to the latest version.
+ */
+import { checkSyrinVersion, getCurrentVersion } from '../../utils/version-checker.js';
+import { updatePackage, detectInstallType } from '../../utils/package-manager.js';
+import { handleCommandError } from '../../cli/utils/index.js';
+import { Messages } from '../../constants/index.js';
+import { Icons } from '../../constants/index.js';
+import { SYRIN_LINKS } from '../../constants/links.js';
+import { log } from '../../utils/logger.js';
+import { PACKAGE_NAME } from '../../constants/app.js';
+/**
+ * Execute the update command.
+ */
+export async function executeUpdate() {
+    try {
+        const currentVersion = getCurrentVersion();
+        log.info(Messages.UPDATE_CHECKING);
+        log.info(Messages.UPDATE_CURRENT_VERSION(`v${currentVersion}`));
+        log.blank();
+        // Check for latest version
+        const versionInfo = await checkSyrinVersion();
+        if (!versionInfo.latest) {
+            log.warning('Could not check for updates (network error or registry unavailable)');
+            log.plain(`Current version: v${currentVersion}`);
+            log.blank();
+            return;
+        }
+        if (versionInfo.isLatest) {
+            log.success(Messages.UPDATE_ALREADY_LATEST(`v${currentVersion}`));
+            log.blank();
+            return;
+        }
+        log.info(Messages.UPDATE_LATEST_VERSION(`v${versionInfo.latest}`));
+        log.blank();
+        log.info(Messages.UPDATE_IN_PROGRESS(PACKAGE_NAME));
+        // Determine install type for better error messages
+        const installType = detectInstallType();
+        // Update the package
+        const result = await updatePackage(PACKAGE_NAME);
+        if (result.success) {
+            const newVersion = result.version || versionInfo.latest;
+            log.blank();
+            log.success(`${Icons.CHECK} ${Messages.UPDATE_SUCCESS(`v${newVersion}`)}`);
+            log.blank();
+            // Show helpful message about config migration if needed
+            log.info('If your config.yaml structure changed, check the migration guide.');
+            log.plain(`   Documentation: ${SYRIN_LINKS.DOCS}`);
+            log.blank();
+        }
+        else {
+            const errorMessage = result.error || Messages.UPDATE_FAILED;
+            // Check if it's a permission error
+            if (errorMessage.includes('EACCES') ||
+                errorMessage.includes('permission')) {
+                const sudoCommand = installType === 'global'
+                    ? `sudo npm install -g ${PACKAGE_NAME}@latest`
+                    : `npm install ${PACKAGE_NAME}@latest`;
+                log.blank();
+                log.error(Messages.UPDATE_PERMISSION_HINT(sudoCommand));
+                log.blank();
+            }
+            else {
+                log.blank();
+                log.error(Messages.UPDATE_ERROR(errorMessage));
+                log.blank();
+            }
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        handleCommandError(error, Messages.UPDATE_FAILED);
+    }
+}
+//# sourceMappingURL=update.js.map

package/dist/cli/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * CLI entry point for Syrin.
+ * Sets up command parsing and routes to command handlers.
+ */
+/**
+ * Initialize the CLI program.
+ */
+export declare function setupCLI(): void;
+/**
+ * Run the CLI.
+ */
+export declare function run(): void;
+//# sourceMappingURL=index.d.ts.map