lsh-framework 0.5.4

package/dist/services/api/api.js

@@ -0,0 +1,58 @@
+import AsyncLock from 'async-lock';
+import request from 'request';
+import { CONFIG } from './config.js';
+import { FILE } from './file.js';
+const semaphore = new AsyncLock();
+let pkgId;
+export const makePOSTRequest = async (typeName, method, data, onSuccess) => {
+    console.log("makePostRequest");
+    const url = CONFIG.URL + '/api/8' + '/' + typeName + '/' + method;
+    console.log(url);
+    // Prevent parallel writes/deletions
+    return semaphore.acquire('request', (done) => {
+        return request.post(url, {
+            method: 'POST',
+            body: data,
+            json: true,
+            headers: {
+                Authorization: CONFIG.AUTH_TOKEN,
+            },
+        }, (err, response, body) => {
+            console.log(body);
+            onSuccess?.(response);
+            done();
+        });
+    });
+};
+const getMetadataPath = (path) => {
+    console.log("getMetadataPath");
+    return path.substring(path.indexOf(CONFIG.PATH_TO_PACKAGE_REPO) + CONFIG.PATH_TO_PACKAGE_REPO.length);
+};
+const getPkgId = async () => {
+    console.log("getPkgId");
+    if (pkgId) {
+        return pkgId;
+    }
+    await makePOSTRequest('Pkg', 'inst', ['Pkg'], (body) => {
+        pkgId = body;
+    });
+    return pkgId;
+};
+const _writeContent = async (path) => {
+    console.log("writeContent");
+    const pkgId = await getPkgId();
+    const metadataPath = getMetadataPath(path);
+    const content = FILE.encodeContent(path);
+    if (await content === FILE.NO_CHANGE_TO_FILE) {
+        return;
+    }
+    return makePOSTRequest('Pkg', 'writeContent', [pkgId, metadataPath, {
+            type: 'ContentValue',
+            content,
+        }], () => console.log("Success"));
+};
+const _deleteContent = async (path) => {
+    const pkgId = await getPkgId();
+    const metadataPath = getMetadataPath(path);
+    return makePOSTRequest('Pkg', 'deleteContent', [pkgId, metadataPath, true], () => console.log("deleted!"));
+};

package/dist/services/api/auth.js

@@ -0,0 +1,35 @@
+import crypto from "crypto";
+import "dotenv/config";
+export const generateSessionToken = function () {
+    const USER = JSON.parse(process.env.USER || '{}');
+    return USER; // const basicUser: string = TestIdp.createTestUsersForGroup('GenAiSearch.Role.User')[0];
+    // const basicUserToken: string = SessionToken.generate(this.basicUser).signedToken;
+    // return basicUserToken;
+};
+/**
+ * Creates a function that generates key tokens based on a private key.
+ *
+ * @param user The username of the user to authenticate
+ * @param pvtKey The private key to use
+ */
+export const createGlobalAuthTokenGenerator = function (user, pvtKey) {
+    if (!pvtKey)
+        throw new Error("Cannot generate key auth token without private key");
+    const generatekeyAuthToken = function () {
+        // WARNING: The following logic is mostly copied from boot.js
+        const signAlgo = "RSA-SHA512";
+        const signatureText = Date.now().toString();
+        const signer = crypto.createSign(signAlgo);
+        signer.update(signatureText);
+        const signature = signer.sign(pvtKey, "base64");
+        const tokenString = user +
+            ":" +
+            Buffer.from(signatureText).toString("base64") +
+            ":" +
+            signature;
+        const authToken = "key " + Buffer.from(tokenString).toString("base64");
+        return authToken;
+    };
+    // Publish our generator to the global scope as the type system is expecting it.
+    global.generateAuthToken = generatekeyAuthToken;
+};

package/dist/services/api/config.js

@@ -0,0 +1,7 @@
+export const CONFIG = {
+    // Path to root repo. Exclude trailing slash
+    PATH_TO_PACKAGE_REPO: '/home/lefv/repos/lsh',
+    URL: "",
+    // Auth Token for Cluster Environment
+    AUTH_TOKEN: '00000000000000000000000000'
+};

package/dist/services/api/file.js

@@ -0,0 +1,22 @@
+import fprint from 'fprint';
+import fs from 'fs';
+const IN_MEMORY_FILE_FINGERPRINTS = {};
+const NO_CHANGE_TO_FILE = -1;
+const encodeContent = async (path) => {
+    const fileContents = fs.readFileSync(path);
+    const fingerprint = await fprint(fileContents, 'md5');
+    if (IN_MEMORY_FILE_FINGERPRINTS[path] !== fingerprint) {
+        IN_MEMORY_FILE_FINGERPRINTS[path] = fingerprint;
+        return fs.readFileSync(path, {
+            encoding: 'base64',
+        });
+    }
+    else {
+        return NO_CHANGE_TO_FILE;
+    }
+};
+export const FILE = {
+    encodeContent,
+    IN_MEMORY_FILE_FINGERPRINTS,
+    NO_CHANGE_TO_FILE,
+};

package/dist/services/cron/cron-registrar.js

@@ -0,0 +1,235 @@
+/**
+ * Cron Command Registrar
+ * Registers all cron-related CLI commands using BaseCommandRegistrar
+ */
+import { BaseCommandRegistrar } from '../../lib/base-command-registrar.js';
+export class CronCommandRegistrar extends BaseCommandRegistrar {
+    constructor() {
+        super('CronService');
+    }
+    async register(program) {
+        const cronCmd = this.createCommand(program, 'cron', 'Cron job management with database integration');
+        this.registerTemplateCommands(cronCmd);
+        this.registerJobManagementCommands(cronCmd);
+        this.registerReportingCommands(cronCmd);
+    }
+    registerTemplateCommands(cronCmd) {
+        // List templates
+        this.addSubcommand(cronCmd, {
+            name: 'templates',
+            description: 'List available job templates',
+            action: async () => {
+                await this.withCronManager(async (manager) => {
+                    const templates = manager.listTemplates();
+                    this.logInfo('Available Job Templates:');
+                    templates.forEach(template => {
+                        this.logInfo(`\n  ${template.id}: ${template.name}`);
+                        this.logInfo(`    Description: ${template.description}`);
+                        this.logInfo(`    Command: ${template.command}`);
+                        this.logInfo(`    Schedule: ${template.schedule}`);
+                        this.logInfo(`    Category: ${template.category}`);
+                        this.logInfo(`    Tags: ${template.tags.join(', ')}`);
+                    });
+                }, { requireRunning: false });
+            }
+        });
+        // Create job from template
+        this.addSubcommand(cronCmd, {
+            name: 'create-from-template',
+            description: 'Create a job from a template',
+            arguments: [{ name: 'templateId', required: true }],
+            options: [
+                { flags: '-n, --name <name>', description: 'Custom job name' },
+                { flags: '-c, --command <command>', description: 'Custom command' },
+                { flags: '-s, --schedule <schedule>', description: 'Custom cron schedule' },
+                { flags: '-w, --working-dir <dir>', description: 'Working directory' },
+                { flags: '-e, --env <env>', description: 'Environment variables (JSON)' },
+                { flags: '-t, --tags <tags>', description: 'Comma-separated tags' },
+                { flags: '-p, --priority <priority>', description: 'Priority (0-10)', defaultValue: '5' }
+            ],
+            action: async (templateId, options) => {
+                const result = await this.withCronManager(async (manager) => {
+                    const customizations = {};
+                    if (options.name)
+                        customizations.name = options.name;
+                    if (options.command)
+                        customizations.command = options.command;
+                    if (options.schedule)
+                        customizations.schedule = { cron: options.schedule };
+                    if (options.workingDir)
+                        customizations.workingDirectory = options.workingDir;
+                    if (options.env)
+                        customizations.environment = this.parseJSON(options.env, 'environment variables');
+                    if (options.tags)
+                        customizations.tags = this.parseTags(options.tags);
+                    if (options.priority)
+                        customizations.priority = parseInt(options.priority);
+                    return await manager.createJobFromTemplate(templateId, customizations);
+                });
+                this.logSuccess('Job created from template:');
+                this.logInfo(`  Template: ${templateId}`);
+                this.logInfo(`  Job ID: ${result.id}`);
+                this.logInfo(`  Name: ${result.name}`);
+                this.logInfo(`  Command: ${result.command}`);
+                this.logInfo(`  Schedule: ${result.schedule.cron}`);
+            }
+        });
+    }
+    registerJobManagementCommands(cronCmd) {
+        // List jobs
+        this.addSubcommand(cronCmd, {
+            name: 'list',
+            description: 'List all cron jobs',
+            options: [
+                { flags: '-f, --filter <filter>', description: 'Filter by status' }
+            ],
+            action: async (options) => {
+                const jobs = await this.withCronManager(async (manager) => {
+                    return await manager.listJobs(options.filter ? { status: options.filter } : undefined);
+                });
+                this.logInfo(`Cron Jobs (${jobs.length} total):`);
+                jobs.forEach(job => {
+                    const schedule = job.schedule?.cron || `${job.schedule?.interval}ms interval`;
+                    this.logInfo(`\n  ${job.id}: ${job.name}`);
+                    this.logInfo(`    Command: ${job.command}`);
+                    this.logInfo(`    Schedule: ${schedule}`);
+                    this.logInfo(`    Status: ${job.status}`);
+                    this.logInfo(`    Priority: ${job.priority}`);
+                    this.logInfo(`    Tags: ${job.tags?.join(', ') || 'None'}`);
+                });
+            }
+        });
+        // Get job info
+        this.addSubcommand(cronCmd, {
+            name: 'info',
+            description: 'Get job information',
+            arguments: [{ name: 'jobId', required: true }],
+            action: async (jobId) => {
+                const job = await this.withCronManager(async (manager) => {
+                    return await manager.getJob(jobId);
+                });
+                if (!job) {
+                    throw new Error(`Job ${jobId} not found`);
+                }
+                this.logInfo(`Job Information: ${jobId}`);
+                this.logInfo(`  Name: ${job.name}`);
+                this.logInfo(`  Command: ${job.command}`);
+                this.logInfo(`  Status: ${job.status}`);
+                this.logInfo(`  Priority: ${job.priority}`);
+                this.logInfo(`  Working Directory: ${job.cwd}`);
+                this.logInfo(`  User: ${job.user}`);
+                this.logInfo(`  Tags: ${job.tags?.join(', ') || 'None'}`);
+                if (job.schedule) {
+                    const schedule = job.schedule.cron || `${job.schedule.interval}ms interval`;
+                    this.logInfo(`  Schedule: ${schedule}`);
+                }
+            }
+        });
+        // Start job
+        this.addSubcommand(cronCmd, {
+            name: 'start',
+            description: 'Start a job',
+            arguments: [{ name: 'jobId', required: true }],
+            action: async (jobId) => {
+                await this.withCronManager(async (manager) => {
+                    await manager.startJob(jobId);
+                });
+                this.logSuccess(`Job ${jobId} started`);
+            }
+        });
+        // Stop job
+        this.addSubcommand(cronCmd, {
+            name: 'stop',
+            description: 'Stop a job',
+            arguments: [{ name: 'jobId', required: true }],
+            options: [
+                { flags: '-s, --signal <signal>', description: 'Signal to send', defaultValue: 'SIGTERM' }
+            ],
+            action: async (jobId, options) => {
+                await this.withCronManager(async (manager) => {
+                    await manager.stopJob(jobId, options.signal);
+                });
+                this.logSuccess(`Job ${jobId} stopped with signal ${options.signal}`);
+            }
+        });
+        // Remove job
+        this.addSubcommand(cronCmd, {
+            name: 'remove',
+            description: 'Remove a job',
+            arguments: [{ name: 'jobId', required: true }],
+            options: [
+                { flags: '-f, --force', description: 'Force removal', defaultValue: false }
+            ],
+            action: async (jobId, options) => {
+                await this.withCronManager(async (manager) => {
+                    await manager.removeJob(jobId, options.force);
+                });
+                this.logSuccess(`Job ${jobId} removed`);
+            }
+        });
+    }
+    registerReportingCommands(cronCmd) {
+        // Get job report
+        this.addSubcommand(cronCmd, {
+            name: 'report',
+            description: 'Get detailed job execution report',
+            arguments: [{ name: 'jobId', required: true }],
+            action: async (jobId) => {
+                const report = await this.withCronManager(async (manager) => {
+                    return await manager.getJobReport(jobId);
+                });
+                this.displayJobReport(report);
+            }
+        });
+        // Get all job reports
+        this.addSubcommand(cronCmd, {
+            name: 'reports',
+            description: 'Get reports for all jobs',
+            action: async () => {
+                const reports = await this.withCronManager(async (manager) => {
+                    return await manager.getAllJobReports();
+                });
+                this.logInfo('All Job Reports:');
+                reports.forEach(report => {
+                    this.logInfo(`\n  ${report.jobId}:`);
+                    this.logInfo(`    Executions: ${report.executions}`);
+                    this.logInfo(`    Success Rate: ${report.successRate.toFixed(1)}%`);
+                    this.logInfo(`    Last Execution: ${report.lastExecution?.toISOString() || 'Never'}`);
+                });
+            }
+        });
+        // Generate comprehensive report
+        this.addSubcommand(cronCmd, {
+            name: 'comprehensive-report',
+            description: 'Generate comprehensive job report',
+            action: async () => {
+                const report = await this.withCronManager(async (manager) => {
+                    return await manager.generateComprehensiveReport();
+                });
+                this.logInfo(report);
+            }
+        });
+        // Export job data
+        this.addSubcommand(cronCmd, {
+            name: 'export',
+            description: 'Export job data',
+            options: [
+                { flags: '-f, --format <format>', description: 'Export format (json or csv)', defaultValue: 'json' },
+                { flags: '-o, --output <file>', description: 'Output file path' }
+            ],
+            action: async (options) => {
+                const data = await this.withCronManager(async (manager) => {
+                    return await manager.exportJobData(options.format);
+                });
+                if (options.output) {
+                    const fs = await import('fs');
+                    fs.writeFileSync(options.output, data);
+                    this.logSuccess(`Data exported to ${options.output}`);
+                }
+                else {
+                    this.logInfo(data);
+                }
+            }
+        });
+    }
+}

package/dist/services/cron/cron.js

@@ -0,0 +1,9 @@
+/**
+ * Cron Service - CLI command registration
+ * Uses CronCommandRegistrar for clean, maintainable command setup
+ */
+import { CronCommandRegistrar } from './cron-registrar.js';
+export async function init_cron(program) {
+    const registrar = new CronCommandRegistrar();
+    await registrar.register(program);
+}