@jacebenson/jsn 4.3.7-dev.27 → 4.3.7-dev.29

package/package.json

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

package/src/commands/midservers.js

@@ -195,12 +195,14 @@ async function waitForMidServerUp(app, name, timeoutMs, intervalMs) {
 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', ['compose', '-f', composePath, 'down'], { cwd: installDir });
+    defaultRun('docker', composeArgs, { cwd: installDir });
   } catch {
     defaultRun('sudo', ['systemctl', 'start', 'docker']);
-    defaultRun('sudo', ['docker', 'compose', '-f', composePath, 'down'], { cwd: installDir });
+    defaultRun('sudo', ['docker', ...composeArgs], { cwd: installDir });
   }
   try {
     fs.rmSync(installDir, { recursive: true, force: true });
@@ -210,6 +212,21 @@ function removeLocalMidServer(instanceURL, name) {
   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]',
@@ -238,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',
@@ -246,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();
@@ -292,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']));
@@ -359,22 +397,48 @@ export function midserversCmd(wrap) {
         }),
       })
       .command({
-        command: 'execute <identifier>',
+        command: 'execute [identifier]',
         describe: 'Execute a shell command through a MID Server',
         builder: (b) => b
-          .option('command', { alias: 'c', type: 'string', demandOption: true, describe: 'Command line to execute on the MID Server host' })
+          .option('command', { alias: 'c', type: 'string', describe: 'Command line to execute on the MID Server host' })
           .option('timeout', { type: 'number', default: DEFAULT_TIMEOUT, describe: 'Response timeout in milliseconds' })
           .option('interval', { type: 'number', default: DEFAULT_INTERVAL, describe: 'Polling interval in milliseconds' }),
         handler: wrap(async (argv, app) => {
-          const record = await resolveMidServer(app.sdk, argv.identifier);
+          let record;
+          if (argv.identifier) {
+            record = await resolveMidServer(app.sdk, argv.identifier);
+          } else {
+            if (!canPrompt() || app.output.getFormat() !== FormatAuto) {
+              throw new Error('An identifier and --command are required outside an interactive terminal');
+            }
+            record = await interactiveList({
+              app,
+              table: AGENT_TABLE,
+              singular: 'MID Server',
+              columns: LIST_FIELDS,
+              limit: 50,
+              labelField: 'name',
+              message: 'Select a MID Server to execute on',
+              formatLabel: (candidate) => {
+                const name = getStringField(candidate, 'name') || getStringField(candidate, 'sys_id');
+                const status = getStringField(candidate, 'status');
+                return status ? `${name} [${status}]` : name;
+              },
+            });
+            if (!record) return;
+          }
+          const command = argv.command || await input({
+            message: 'Command to execute:',
+            validate: value => value.trim() ? true : 'Command is required',
+          });
           assertMidServerUp(record);
           const agent = agentName(record);
           const output = await app.sdk.create(QUEUE_TABLE, {
             agent,
             topic: 'Command',
             queue: 'output',
-            name: argv.command,
-            payload: buildCommandPayload(argv.command),
+            name: command,
+            payload: buildCommandPayload(command),
           });
           const outputSysId = unwrapSysId(output);
           if (!outputSysId) throw new Error('ServiceNow did not return the ECC Queue sys_id for the command');
@@ -384,7 +448,7 @@ export function midserversCmd(wrap) {
           const result = parseCommandResult(queueValue(response.payload));
           app.ok({
             mid_server: getStringField(record, 'name'),
-            command: argv.command,
+            command,
             output: { sys_id: outputSysId, ...output },
             response: { ...response, ...result },
           }, { summary: `Executed command on MID Server '${getStringField(record, 'name')}'` });

package/src/midserver-install.js

@@ -114,7 +114,8 @@ export async function installDockerMidServer({
   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);
@@ -148,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 });