@reshapr/reshapr-cli 0.0.1 → 0.0.4

package/dist/cli.js

@@ -16,7 +16,7 @@
  */
 import { program } from 'commander';
 import * as yaml from 'js-yaml';
-import { loginCommand, infoCommand, logoutCommand, importCommand, attachCommand, quotasCommand } from './commands/index.js';
+import { loginCommand, infoCommand, logoutCommand, importCommand, attachCommand, quotasCommand, runCommand, statusCommand, stopCommand } from './commands/index.js';
 import { ConfigUtil } from './utils/config.js';
 import { Logger } from './utils/logger.js';
 import { Context } from './utils/context.js';
@@ -28,7 +28,8 @@ program
     .version(CLI_VERSION)
     .hook('preAction', (thisCommand, actionCommand) => {
     ConfigUtil.readConfig();
-    if (actionCommand.name() != 'login' && actionCommand.name() != 'logout') {
+    const noAuthCommands = ['login', 'logout', 'run', 'status', 'stop'];
+    if (!noAuthCommands.includes(actionCommand.name())) {
         if (!ConfigUtil.config.token) {
             Logger.warn(`You are not logged in. Please login first using the \`${CLI_NAME} login\` command.`);
             process.exit(1);
@@ -93,4 +94,7 @@ program.addCommand(logoutCommand);
 program.addCommand(importCommand);
 program.addCommand(attachCommand);
 program.addCommand(quotasCommand);
+program.addCommand(runCommand);
+program.addCommand(statusCommand);
+program.addCommand(stopCommand);
 program.parse(process.argv);

package/dist/commands/index.js

@@ -25,3 +25,6 @@ export { configCommand } from './config.js';
 export { gatewayGroupCommand } from './gateway-group.js';
 export { tokenCommand } from './api-token.js';
 export { quotasCommand } from './quotas.js';
+export { runCommand } from './run.js';
+export { statusCommand } from './status.js';
+export { stopCommand } from './stop.js';

package/dist/commands/login.js

@@ -115,50 +115,96 @@ async function handleOnPremisesLogin(options) {
 async function handleSaaSLogin(options) {
     // Prepare a token for reception.
     let token = null;
-    // Start starting a lightweight web server to handle OAuth2 login.
+    // Start a lightweight web server to receive the OAuth2 callback.
     const server = http.createServer((req, res) => {
-        // Handle Authentication callback here. Parse the URL.
+        // Parse the URL and extract query parameters.
         const parsedUrl = url.parse(req.url || '', true);
-        // Get query parts of the URL.
         const query = parsedUrl.query;
         if (query.token && query.token.length > 0) {
             token = query.token;
+            // The SaaS also sends the control plane URL for subsequent CLI calls.
+            const ctrlUrl = query.ctrl_url || options.server;
             Logger.success('Login successful!');
-            const tokenPayload = token.split('.')[1];
-            const decodedPayload = Buffer.from(tokenPayload, 'base64').toString('utf8');
-            const username = JSON.parse(decodedPayload).sub || 'unknown';
-            Logger.info(`Welcome, ${username}!`);
-            // Here you would typically save the authentication token or session.
-            let config = {
-                username: username,
-                server: options.server,
-                insecure: options.insecure,
-                token: token
-            };
-            ConfigUtil.writeConfig(config);
-            res.writeHead(200, { 'Content-Type': 'text/plain' });
-            res.end('Login successful! You can close this window now.');
+            // Decode the JWT payload to extract username and org.
+            try {
+                const tokenPayload = token.split('.')[1];
+                const decodedPayload = Buffer.from(tokenPayload, 'base64').toString('utf8');
+                const payload = JSON.parse(decodedPayload);
+                const username = payload.sub || 'unknown';
+                const org = payload.org || '';
+                Logger.info(`Welcome, ${username}!`);
+                if (org) {
+                    Logger.info(`Organization: ${org}`);
+                }
+                // Save the configuration — server points to the control plane, not the SaaS.
+                const config = {
+                    username: username,
+                    server: ctrlUrl,
+                    insecure: options.insecure,
+                    token: token
+                };
+                ConfigUtil.writeConfig(config);
+            }
+            catch (err) {
+                Logger.warn('Could not decode token payload: ' + err);
+                // Still save the config with what we have.
+                const config = {
+                    username: 'unknown',
+                    server: ctrlUrl,
+                    insecure: options.insecure,
+                    token: token
+                };
+                ConfigUtil.writeConfig(config);
+            }
+            res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+            res.end(`
+          <html>
+            <head><meta charset="utf-8"></head>
+            <body style="font-family: sans-serif; display: flex; align-items: center; justify-content: center; height: 100vh; margin: 0; background: #f8fafc;">
+              <div style="text-align: center;">
+                <h1 style="color: #16a34a;">&#10003; Login successful!</h1>
+                <p style="color: #64748b;">You can close this window and return to your terminal.</p>
+              </div>
+            </body>
+          </html>
+        `);
+            // Close the server and exit after a short delay.
+            setTimeout(() => {
+                server.close();
+                process.exit(0);
+            }, 500);
         }
         else {
-            Logger.error('Login failed: No token received.');
-            res.writeHead(400, { 'Content-Type': 'text/plain' });
-            res.end(`Login failed: No token received. Please login on ${options.server} before trying again.`);
+            // We may receive other requests to this server that don't have a token, so just respond with an error page.
+            if (!token) {
+                Logger.error('Login failed: No token received.');
+                res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });
+                res.end(`
+            <html>
+              <head><meta charset="utf-8"></head>
+              <body style="font-family: sans-serif; display: flex; align-items: center; justify-content: center; height: 100vh; margin: 0; background: #f8fafc;">
+                <div style="text-align: center;">
+                  <h1 style="color: #dc2626;">&#10007; Login failed</h1>
+                  <p style="color: #64748b;">No token received. Please try again.</p>
+                </div>
+              </body>
+            </html>
+          `);
+            }
         }
-        process.exit(0);
     });
     server.on('error', (err) => {
-        Logger.error('Failed to start server for OAuth2 login: ' + err.message);
+        Logger.error('Failed to start local server for authentication: ' + err.message);
         process.exit(1);
     });
+    // Find an available port.
     const localPort = await getPort({ port: portNumbers(5556, 5599) });
     server.listen(localPort, () => {
-        Logger.info(`Listening for OAuth2 callback on http://localhost:${localPort}`);
+        Logger.info(`Listening for authentication callback on http://localhost:${localPort}`);
     });
+    // Open the browser to the SaaS CLI login page.
+    const loginUrl = `${options.server}/cli/login?redirect_uri=http://localhost:${localPort}`;
+    Logger.info(`Opening browser: ${loginUrl}`);
     // Opens the URL in the default browser.
-    await open(`${options.server}/auth/login/saas?redirect_uri=http://localhost:${localPort}`, {
-        wait: true
-    });
-    server.close(() => {
-        Logger.info('Server closed after handling OAuth2 callback.');
-    });
+    await open(loginUrl, { wait: false });
 }

package/dist/commands/run.js

@@ -0,0 +1,114 @@
+/*
+ * Copyright The Reshapr Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import * as os from 'node:os';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { Command } from "commander";
+import { Logger } from "../utils/logger.js";
+import { runDockerCompose } from '../utils/containers.js';
+import { CLI_NAME, CLI_LABEL } from '../constants.js';
+const GITHUB_REPO = 'reshaprio/reshapr';
+const GITHUB_RAW_BASE = `https://raw.githubusercontent.com/${GITHUB_REPO}`;
+const GITHUB_API_BASE = `https://api.github.com/repos/${GITHUB_REPO}`;
+const COMPOSE_FILE_NAME = 'docker-compose-all-in-one.yml';
+const COMPOSE_REMOTE_PATH = `install/${COMPOSE_FILE_NAME}`;
+const RESHAPR_DIR = path.join(os.homedir(), `.${CLI_NAME}`);
+const RUN_STATE_FILE = path.join(RESHAPR_DIR, 'run-state.json');
+export const runCommand = new Command('run')
+    .description(`Start ${CLI_LABEL} locally using Docker Compose`)
+    .option('-r, --release <release>', 'Release of the containers to run', 'latest')
+    .action(async (options) => {
+    let release = options.release;
+    // Resolve 'latest' to the actual latest GitHub release tag.
+    if (release === 'latest') {
+        release = await resolveLatestRelease();
+        Logger.info(`Resolved 'latest' to release '${release}'.`);
+    }
+    const composeFile = getComposeFilePath(release);
+    // Download compose file if not already cached for this release.
+    if (!fs.existsSync(composeFile)) {
+        await downloadComposeFile(release, composeFile);
+    }
+    else {
+        Logger.info(`Using cached compose file for release '${release}'.`);
+    }
+    Logger.info(`Starting ${CLI_LABEL} containers (release: ${release})...`);
+    const exitCode = await runDockerCompose(['up', '-d'], composeFile);
+    if (exitCode !== 0) {
+        Logger.error(`docker compose exited with code ${exitCode}.`);
+        process.exit(exitCode);
+    }
+    saveRunState(release, composeFile);
+    Logger.success(`${CLI_LABEL} containers started successfully.`);
+});
+function getComposeFilePath(release) {
+    return path.join(RESHAPR_DIR, `docker-compose-${release}.yml`);
+}
+async function resolveLatestRelease() {
+    const url = `${GITHUB_API_BASE}/releases/latest`;
+    const response = await fetch(url, {
+        headers: { 'Accept': 'application/vnd.github+json' },
+    });
+    if (!response.ok) {
+        Logger.error(`Failed to fetch latest release from GitHub: ${response.status} ${response.statusText}`);
+        process.exit(1);
+    }
+    const data = await response.json();
+    return data.tag_name;
+}
+function getGitHubRef(release) {
+    if (release === 'nightly') {
+        return 'refs/heads/main';
+    }
+    return `refs/tags/${release}`;
+}
+async function downloadComposeFile(release, destPath) {
+    const ref = getGitHubRef(release);
+    const url = `${GITHUB_RAW_BASE}/${ref}/${COMPOSE_REMOTE_PATH}`;
+    Logger.info(`Downloading compose file from ${url}...`);
+    const response = await fetch(url);
+    if (!response.ok) {
+        Logger.error(`Failed to download compose file: ${response.status} ${response.statusText}`);
+        Logger.error(`Make sure the release '${release}' exists on the GitHub repository.`);
+        process.exit(1);
+    }
+    let content = await response.text();
+    // Replace image tags with the requested release.
+    content = content.replace(/(quay\.io\/reshapr\/[^:]+):[\w.-]+/g, `$1:${release}`);
+    fs.mkdirSync(RESHAPR_DIR, { recursive: true });
+    fs.writeFileSync(destPath, content, 'utf-8');
+    Logger.success(`Compose file saved to ${destPath}`);
+}
+function saveRunState(release, composeFile) {
+    const state = { release, composeFile, startedAt: new Date().toISOString() };
+    fs.writeFileSync(RUN_STATE_FILE, JSON.stringify(state, null, 2), 'utf-8');
+}
+export function readRunState() {
+    if (!fs.existsSync(RUN_STATE_FILE)) {
+        return null;
+    }
+    try {
+        return JSON.parse(fs.readFileSync(RUN_STATE_FILE, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+export function removeRunState() {
+    if (fs.existsSync(RUN_STATE_FILE)) {
+        fs.unlinkSync(RUN_STATE_FILE);
+    }
+}

package/dist/commands/status.js

@@ -0,0 +1,35 @@
+/*
+ * Copyright The Reshapr Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Command } from "commander";
+import { Logger } from "../utils/logger.js";
+import { runDockerCompose } from '../utils/containers.js';
+import { CLI_LABEL } from '../constants.js';
+import { readRunState } from './run.js';
+export const statusCommand = new Command('status')
+    .description(`Show the status of locally running ${CLI_LABEL}`)
+    .action(async () => {
+    const state = readRunState();
+    if (!state) {
+        Logger.warn(`No ${CLI_LABEL} containers have been started. Use \`reshapr run\` to start them.`);
+        process.exit(0);
+    }
+    Logger.info(`${CLI_LABEL} containers (release: ${state.release}, started at: ${state.startedAt})`);
+    const exitCode = await runDockerCompose(['ps'], state.composeFile);
+    if (exitCode !== 0) {
+        Logger.error(`docker compose exited with code ${exitCode}.`);
+        process.exit(exitCode);
+    }
+});

package/dist/commands/stop.js

@@ -0,0 +1,37 @@
+/*
+ * Copyright The Reshapr Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Command } from "commander";
+import { Logger } from "../utils/logger.js";
+import { runDockerCompose } from '../utils/containers.js';
+import { CLI_LABEL } from '../constants.js';
+import { readRunState, removeRunState } from './run.js';
+export const stopCommand = new Command('stop')
+    .description(`Stop locally running ${CLI_LABEL} containers`)
+    .action(async () => {
+    const state = readRunState();
+    if (!state) {
+        Logger.warn(`No ${CLI_LABEL} containers have been started. Nothing to stop.`);
+        process.exit(0);
+    }
+    Logger.info(`Stopping ${CLI_LABEL} containers (release: ${state.release})...`);
+    const exitCode = await runDockerCompose(['down'], state.composeFile);
+    if (exitCode !== 0) {
+        Logger.error(`docker compose exited with code ${exitCode}.`);
+        process.exit(exitCode);
+    }
+    removeRunState();
+    Logger.success(`${CLI_LABEL} containers stopped successfully.`);
+});

package/dist/utils/containers.js

@@ -0,0 +1,30 @@
+/*
+ * Copyright The Reshapr Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { spawn } from 'node:child_process';
+import { Logger } from "./logger.js";
+export function runDockerCompose(args, composeFile) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn('docker', ['compose', '-f', composeFile, ...args], {
+            stdio: 'inherit',
+            shell: false,
+        });
+        proc.on('close', (code) => resolve(code ?? 1));
+        proc.on('error', (err) => {
+            Logger.error(`Failed to execute docker compose: ${err.message}`);
+            reject(err);
+        });
+    });
+}

package/dist/version.js

@@ -1 +1 @@
-export const CLI_VERSION = "0.0.1";
+export const CLI_VERSION = "0.0.4";

package/package.json

@@ -1,12 +1,16 @@
 {
   "name": "@reshapr/reshapr-cli",
-  "version": "0.0.1",
+  "version": "0.0.4",
   "description": "CLI for reshapr.io - The MCP Gateway for AI-Native API Access!",
   "type": "module",
   "main": "src/cli.ts",
   "bin": {
     "reshapr": "dist/cli.js"
   },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/reshaprio/reshapr.git"
+  },
   "license": "Apache-2.0",
   "publishConfig": {
     "access": "public"

package/src/cli.ts

@@ -17,7 +17,7 @@
 
 import { program } from 'commander';
 import * as yaml from 'js-yaml';
-import { loginCommand, infoCommand, logoutCommand, importCommand, attachCommand, quotasCommand } from './commands/index.js';
+import { loginCommand, infoCommand, logoutCommand, importCommand, attachCommand, quotasCommand, runCommand, statusCommand, stopCommand } from './commands/index.js';
 import { ConfigUtil } from './utils/config.js';
 import { Logger } from './utils/logger.js';
 import { Context } from './utils/context.js';
@@ -30,7 +30,8 @@ program
   .version(CLI_VERSION)
   .hook('preAction', (thisCommand, actionCommand) => {
     ConfigUtil.readConfig();
-    if (actionCommand.name() != 'login' && actionCommand.name() != 'logout') {
+    const noAuthCommands = ['login', 'logout', 'run', 'status', 'stop'];
+    if (!noAuthCommands.includes(actionCommand.name())) {
       if (!ConfigUtil.config.token) {
         Logger.warn(`You are not logged in. Please login first using the \`${CLI_NAME} login\` command.`);
         process.exit(1);
@@ -100,5 +101,8 @@ program.addCommand(logoutCommand);
 program.addCommand(importCommand);
 program.addCommand(attachCommand);
 program.addCommand(quotasCommand);
+program.addCommand(runCommand);
+program.addCommand(statusCommand);
+program.addCommand(stopCommand);
 
 program.parse(process.argv);