@jacebenson/jsn 4.3.7-dev.26 → 4.3.7-dev.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jacebenson/jsn",
-  "version": "4.3.7-dev.26",
+  "version": "4.3.7-dev.28",
   "description": "A command-line interface for ServiceNow that follows the Unix philosophy: simple, composable, and scriptable.",
   "type": "module",
   "bin": {

package/src/commands/midservers.js

@@ -1,9 +1,11 @@
+import fs from 'node:fs';
+import path from 'node:path';
 import { input, password as passwordPrompt, select } from '@inquirer/prompts';
 import { confirmDelete, formatRecordForDisplay, getStringField, interactiveList, canPrompt } from '../helpers.js';
 import { FormatAuto } from '../output.js';
 import { declareCapabilities } from '../capabilities.js';
 import { resolveRecord, unwrapSysId } from '../resolve-record.js';
-import { detectDocker, defaultRun, installDockerMidServer, validateMidCredentials } from '../midserver-install.js';
+import { detectDocker, defaultRun, installDockerMidServer, midInstallDirectory, validateMidCredentials } from '../midserver-install.js';
 
 const AGENT_TABLE = 'ecc_agent';
 const QUEUE_TABLE = 'ecc_queue';
@@ -190,6 +192,41 @@ async function waitForMidServerUp(app, name, timeoutMs, intervalMs) {
   throw new Error(`MID Server '${fullName}' did not report Up within ${timeoutMs}ms`);
 }
 
+function removeLocalMidServer(instanceURL, name) {
+  const installDir = midInstallDirectory(instanceURL, name);
+  const composePath = path.join(installDir, 'docker-compose.yaml');
+  const envPath = path.join(installDir, '.env');
+  if (!fs.existsSync(composePath)) return false;
+  const composeArgs = ['compose', ...(fs.existsSync(envPath) ? ['--env-file', envPath] : []), '-f', composePath, 'down'];
+  try {
+    defaultRun('docker', composeArgs, { cwd: installDir });
+  } catch {
+    defaultRun('sudo', ['systemctl', 'start', 'docker']);
+    defaultRun('sudo', ['docker', ...composeArgs], { cwd: installDir });
+  }
+  try {
+    fs.rmSync(installDir, { recursive: true, force: true });
+  } catch {
+    defaultRun('sudo', ['rm', '-rf', '--', installDir]);
+  }
+  return true;
+}
+
+function showMidServerLogs(app, identifier, argv) {
+  const installDir = midInstallDirectory(app.getEffectiveInstance(), identifier);
+  const composePath = path.join(installDir, 'docker-compose.yaml');
+  const envPath = path.join(installDir, '.env');
+  if (!fs.existsSync(composePath)) throw new Error(`No local Compose installation found for MID Server '${identifier}'`);
+  const args = ['compose', ...(fs.existsSync(envPath) ? ['--env-file', envPath] : []), '-f', composePath, 'logs', '--tail', String(argv.tail)];
+  if (argv.follow) args.push('--follow');
+  try {
+    defaultRun('docker', args, { cwd: installDir });
+  } catch {
+    defaultRun('sudo', ['systemctl', 'start', 'docker']);
+    defaultRun('sudo', ['docker', ...args], { cwd: installDir });
+  }
+}
+
 export function midserversCmd(wrap) {
   return {
     command: 'midservers [subcommand]',
@@ -218,6 +255,26 @@ export function midserversCmd(wrap) {
           app.ok(record, { summary: `MID Server: ${getStringField(record, 'name') || argv.identifier}` });
         }),
       })
+      .command({
+        command: 'logs <identifier>',
+        describe: 'Show local Docker Compose logs for a MID Server',
+        builder: (b) => b
+          .option('tail', { type: 'number', default: 100, describe: 'Number of log lines' })
+          .option('follow', { type: 'boolean', default: false, describe: 'Follow the logs' }),
+        handler: wrap(async (argv, app) => {
+          showMidServerLogs(app, argv.identifier, argv);
+        }),
+      })
+      .command({
+        command: '<identifier> logs',
+        describe: 'Show local Docker Compose logs for a MID Server',
+        builder: (b) => b
+          .option('tail', { type: 'number', default: 100, describe: 'Number of log lines' })
+          .option('follow', { type: 'boolean', default: false, describe: 'Follow the logs' }),
+        handler: wrap(async (argv, app) => {
+          showMidServerLogs(app, argv.identifier, argv);
+        }),
+      })
       .command({
         command: 'add',
         describe: 'Install and verify a MID Server',
@@ -226,7 +283,7 @@ export function midserversCmd(wrap) {
           .option('username', { type: 'string', describe: 'MID Server username (password is always prompted)' })
           .option('install-method', { type: 'string', choices: ['docker', 'direct'], describe: 'Installation method (prompted when omitted)' })
           .option('directory', { type: 'string', describe: 'Docker installation directory' })
-          .option('wait-timeout', { type: 'number', default: 120000, describe: 'How long to wait for the MID Server to report Up' })
+          .option('wait-timeout', { type: 'number', default: 300000, describe: 'How long to wait for the MID Server to report Up' })
           .option('wait-interval', { type: 'number', default: 3000, describe: 'MID Server status polling interval in milliseconds' }),
         handler: wrap(async (argv, app) => {
           app.requireInstance();
@@ -272,13 +329,14 @@ export function midserversCmd(wrap) {
           });
           if (installMethod === 'sudo') {
             defaultRun('sudo', ['systemctl', 'start', 'docker']);
-            defaultRun('sudo', ['docker', 'compose', '-f', installation.composePath, 'up', '-d'], { cwd: installation.installDir });
+            defaultRun('sudo', ['docker', 'compose', '--env-file', path.join(installation.installDir, '.env'), '-f', installation.composePath, 'up', '-d'], { cwd: installation.installDir });
             installation.prepared = false;
           }
           if (installation.prepared) {
             app.ok(installation, { summary: `Prepared MID Server files in ${installation.installDir}. Run: ${installation.runCommand}` });
             return;
           }
+          console.log('MID Server container started. ServiceNow may take a few minutes to register it and report Up.');
           let record;
           try {
             record = await waitForMidServerUp(app, installation.name, Math.max(1, argv['wait-timeout']), Math.max(500, argv['wait-interval']));
@@ -302,7 +360,14 @@ export function midserversCmd(wrap) {
         handler: wrap(async (argv, app) => {
           let record;
           if (argv.identifier) {
-            record = await resolveMidServer(app.sdk, argv.identifier);
+            try {
+              record = await resolveMidServer(app.sdk, argv.identifier);
+            } catch (error) {
+              if (error.code !== 'not_found') throw error;
+              const localDir = midInstallDirectory(app.getEffectiveInstance(), argv.identifier);
+              if (!fs.existsSync(path.join(localDir, 'docker-compose.yaml'))) throw error;
+              record = null;
+            }
           } else {
             if (!canPrompt() || app.output.getFormat() !== FormatAuto) {
               throw new Error('An identifier is required outside an interactive terminal');
@@ -323,11 +388,12 @@ export function midserversCmd(wrap) {
             });
             if (!record) return;
           }
-          const sysId = unwrapSysId(record);
+          const sysId = record ? unwrapSysId(record) : null;
           const name = getStringField(record, 'name') || argv.identifier || sysId;
           await confirmDelete(app, argv, `Remove MID Server '${name}'`);
-          await app.sdk.delete(AGENT_TABLE, sysId);
-          app.ok({ name, sys_id: sysId, deleted: true }, { summary: `Removed MID Server '${name}'` });
+          const localRemoved = removeLocalMidServer(app.getEffectiveInstance(), name);
+          if (record) await app.sdk.delete(AGENT_TABLE, sysId);
+          app.ok({ name, sys_id: sysId, deleted: Boolean(record), local_compose_removed: localRemoved }, { summary: `Removed MID Server '${name}'${localRemoved ? ' and its local Compose stack' : ''}` });
         }),
       })
       .command({

package/src/midserver-install.js

@@ -90,6 +90,11 @@ function instanceName(instanceURL) {
   return hostname.replace(/\.service-now\.com$|\.servicenowservices\.com$/i, '').replace(/[^A-Za-z0-9._-]/g, '_');
 }
 
+export function midInstallDirectory(instanceURL, name, homeDirectory = os.homedir()) {
+  const shortName = normalizeMidName(name);
+  return path.join(homeDirectory, '.servicenow', 'mids', instanceName(instanceURL), shortName);
+}
+
 export async function installDockerMidServer({
   instanceURL,
   username,
@@ -106,11 +111,11 @@ export async function installDockerMidServer({
   const displayName = `mid.server.${shortName}`;
   const releaseName = suppliedReleaseName || (await validateMidCredentials(instanceURL, username, password, fetchImpl)).releaseName;
   const recipeURL = buildMidRecipeUrl(releaseName);
-  const serviceNowInstance = instanceName(instanceURL);
-  const installDir = directory || path.join(os.homedir(), '.servicenow', 'mids', serviceNowInstance, shortName);
+  const installDir = directory || midInstallDirectory(instanceURL, name);
   fs.mkdirSync(installDir, { recursive: true, mode: 0o700 });
   const exportDir = path.join(installDir, 'export');
-  fs.mkdirSync(exportDir, { recursive: true, mode: 0o700 });
+  fs.mkdirSync(exportDir, { recursive: true, mode: 0o777 });
+  fs.chmodSync(exportDir, 0o777);
   const workDir = fs.mkdtempSync(path.join(os.tmpdir(), 'jsn-mid-'));
   const filename = path.basename(recipeURL);
   const archive = path.join(workDir, filename);
@@ -144,18 +149,18 @@ export async function installDockerMidServer({
         composePath,
         serviceName,
         prepared: true,
-        runCommand: `docker compose -f ${composePath} up -d`,
+        runCommand: `docker compose --env-file ${envPath} -f ${composePath} up -d`,
       };
     }
     run('docker', ['build', '--tag', `${serviceName}:${releaseName}`, persistedRecipeDir]);
-    run('docker', ['compose', '-f', composePath, 'up', '-d'], { cwd: installDir, env });
+    run('docker', ['compose', '--env-file', envPath, '-f', composePath, 'up', '-d'], { cwd: installDir, env });
     return {
       name: displayName,
       releaseName,
       installDir,
       composePath,
       serviceName,
-      rollback: () => run('docker', ['compose', '-f', composePath, 'down'], { cwd: installDir, env }),
+      rollback: () => run('docker', ['compose', '--env-file', envPath, '-f', composePath, 'down'], { cwd: installDir, env }),
     };
   } finally {
     fs.rmSync(workDir, { recursive: true, force: true });