ninedeploy 0.17.1 → 0.18.4

package/src/commands/volumeFiles.ts

@@ -0,0 +1,65 @@
+import { open, writeFile } from 'node:fs/promises';
+import { managedVolumeName } from '@ninedeploy/schemas';
+import type { NineDeployClient } from '../client.js';
+import { error, info, success, table } from '../lib/format.js';
+import { prompt } from '../prompts.js';
+
+export interface VolumeFileOptions { server?: string; json?: boolean; file?: string; output?: string; force?: boolean; yes?: boolean }
+function target(name: string, raw: string, options: VolumeFileOptions, root = false) {
+  managedVolumeName.parse(name);
+  if (options.server !== undefined && (!/^[1-9]\d*$/.test(options.server) || !Number.isSafeInteger(Number(options.server)))) throw Error('--server must be a positive decimal node id');
+  if (raw.startsWith('/') || /[\0\r\n]/.test(raw) || raw.length > 2048) throw Error('Use a relative path inside the volume');
+  const parts: string[] = [];
+  for (const part of raw.split('/')) {
+    if (!part || part === '.') continue;
+    if (part === '..') { if (!parts.length) throw Error('Path escapes the volume'); parts.pop(); }
+    else parts.push(part);
+  }
+  const path = parts.join('/');
+  if (!path && !root) throw Error('A path inside the volume is required');
+  const host: [] | [{serverId:number}] = options.server === undefined ? [] : [{serverId:Number(options.server)}];
+  return {path,host};
+}
+const fail=(err:unknown)=>error(err instanceof Error?err.message:String(err));
+export async function volumeFilesList(client: NineDeployClient,name:string,path='',options:VolumeFileOptions={}) {
+  try {
+    const selected=target(name,path,options,true),result=await client.volumes.listFiles(name,selected.path,...selected.host);
+    if(options.json)console.log(JSON.stringify(result));
+    else if(!result.entries.length)info('Empty directory.');
+    else table(result.entries.map(entry=>({name:entry.name,type:entry.type,size:entry.sizeBytes})),['name','type','size']);
+  }catch(err){fail(err);}
+}
+export async function volumeFileRead(client:NineDeployClient,name:string,path:string,options:VolumeFileOptions={}) {
+  try {
+    const selected=target(name,path,options),result=await client.volumes.readFile(name,selected.path,...selected.host);
+    const bytes=Buffer.from(result.content,result.encoding==='base64'?'base64':'utf8');
+    if(options.output){await writeFile(options.output,bytes,{flag:options.force?'w':'wx'});success(`Saved ${bytes.length} bytes to ${options.output}`);}
+    else process.stdout.write(bytes);
+  }catch(err){fail(err);}
+}
+export async function volumeFileWrite(client:NineDeployClient,name:string,path:string,options:VolumeFileOptions={}) {
+  try {
+    const selected=target(name,path,options);
+    if(!options.file)throw Error('--file <local-file> is required');
+    const input=await open(options.file,'r');let bytes:Buffer;
+    try {
+      if(!(await input.stat()).isFile())throw Error('--file must name a regular file');
+      const buffer=Buffer.alloc(1024*1024+1);let length=0;
+      while(length<buffer.length){const read=await input.read(buffer,length,buffer.length-length,null);if(!read.bytesRead)break;length+=read.bytesRead;}
+      if(length>1024*1024)throw Error('File exceeds the 1 MiB editor limit');
+      bytes=buffer.subarray(0,length);
+    }finally{await input.close();}
+    await client.volumes.writeFile(name,{path:selected.path,contentBase64:bytes.toString('base64')},...selected.host);
+    success(`Wrote ${bytes.length} bytes to ${name}:${selected.path}${options.server?` on node #${options.server}`:''}`);
+  }catch(err){fail(err);}
+}
+export async function volumeFileMkdir(client:NineDeployClient,name:string,path:string,options:VolumeFileOptions={}) {
+  try {const selected=target(name,path,options);await client.volumes.mkdir(name,{path:selected.path},...selected.host);success('Directory created');}catch(err){fail(err);}
+}
+export async function volumeFileDelete(client:NineDeployClient,name:string,path:string,options:VolumeFileOptions={}) {
+  try {
+    const selected=target(name,path,options);
+    if(!options.yes){const answer=await prompt(`Type ${selected.path} to delete it recursively from ${name}${options.server?` on node #${options.server}`:''}`);if(answer!==selected.path)return error('Cancelled.');}
+    await client.volumes.deleteFile(name,selected.path,...selected.host);success('Volume path deleted');
+  }catch(err){fail(err);}
+}

package/src/index.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { volumeFilesList, volumeFileRead, volumeFileWrite, volumeFileMkdir, volumeFileDelete, type VolumeFileOptions } from './commands/volumeFiles.js';
 import { createRequire } from 'node:module';
 import { Command } from 'commander';
 import { getClient } from './client.js';
@@ -9,6 +10,7 @@ import { setupAction } from './commands/setup.js';
 import {
   servicesCompose, servicesCreate, servicesDelete, servicesDeploy, servicesExport,
   servicesGet, servicesInspect, servicesLifecycle, servicesList, servicesLogs,
+  servicesLifecycleStatus,
   servicesStickyAction,
   servicesPortsAction,
   servicesDeployHookAction,
@@ -112,8 +114,9 @@ import {
   configPresetListAction, configPresetRegisterAction, configPresetRemoveAction,
 } from './commands/configPresets.js';
 import {
-  metricsFlushAction, metricsShowAction,
+  metricsFlushAction, metricsShowAction, resourceMetricsSettingsAction, resourceMetricsConfigureAction,
 } from './commands/metrics.js';
+import { logDrainQueueAction, logDrainRetryAction, logDrainDiscardAction } from './commands/logDrains.js';
 import {
   buildCacheStatsAction,
 } from './commands/buildCache.js';
@@ -274,6 +277,8 @@ services.command('stop <id>').description('Stop a running service').action((id:
 services.command('start <id>').description('Start a stopped service').action((id: string) => servicesLifecycle(getClient(), 'start', id));
 
 services.command('restart <id>').description('Restart a service').action((id: string) => servicesLifecycle(getClient(), 'restart', id));
+services.command('lifecycle <id>').description('Show the last node runtime command and its pending reason').option('--retry', 'Retry the same command without changing its revision')
+  .action((id: string, opts: { retry?: boolean }) => servicesLifecycleStatus(getClient(), id, opts));
 
 services.command('delete <id>').description('Delete a service (with confirmation)').action((id: string) => servicesDelete(getClient(), id));
 
@@ -594,10 +599,26 @@ configPresetsCmd.command('apply <id>')
 configPresetsCmd.command('remove <id>').description('Unregister a preset (does NOT undo the live apply)').action((id: string) => configPresetRemoveAction(getClient(), id));
 
 // ── Metrics (G-09) ────────────────────────────────────────────────────────
-const metricsCmd = program.command('metrics').description('Metric history plugin — archive kernel events to a pluggable backend (G-09)');
+const metricsCmd = program.command('metrics').description('Resource monitoring and kernel event history');
+metricsCmd.command('settings').description('Resource retention, Prometheus and collector settings').action(() => resourceMetricsSettingsAction(getClient()));
+metricsCmd.command('configure').description('Update resource monitoring settings')
+  .option('--retention-days <days>', 'Service history retention, 1–90 days')
+  .option('--prometheus <on|off>', 'Enable or disable authenticated Prometheus scraping')
+  .option('--otlp-endpoint <url>', 'OTLP/HTTP JSON metrics endpoint, empty disables export')
+  .option('--otlp-authorization-env <name>', 'Read collector Authorization from this environment variable')
+  .option('--clear-otlp-authorization', 'Remove the saved collector credential')
+  .option('--log-queue-mb <mb>', 'Encrypted log payload limit per destination, 1–256 MiB')
+  .action((opts) => resourceMetricsConfigureAction(getClient(), opts));
 metricsCmd.command('show').description('Show the active backend, events, and last flush marker').action(() => metricsShowAction(getClient()));
 metricsCmd.command('flush').description('Run the built-in backend retention sweep').action(() => metricsFlushAction(getClient()));
 
+const logDrainsCmd = program.command('log-drains').description('Inspect and recover durable log delivery');
+logDrainsCmd.command('queue <id>').description('Show pending, blocked and paused log delivery').action((id: string) => logDrainQueueAction(getClient(), id));
+logDrainsCmd.command('retry <id>').description('Schedule pending logs for the next delivery cycle').action((id: string) => logDrainRetryAction(getClient(), id));
+logDrainsCmd.command('discard <id>').description('Permanently discard pending logs')
+  .option('--yes', 'Confirm permanent removal of queued logs')
+  .action((id: string, opts) => logDrainDiscardAction(getClient(), id, opts));
+
 // ── Build Cache (G-01) ────────────────────────────────────────────────────
 const buildCacheCmd = program.command('build-cache').description('Build cache plugin — per-backend LRU stats (G-01)');
 buildCacheCmd.command('stats').description('Show per-backend cache counters and the merged totals').action(() => buildCacheStatsAction(getClient()));
@@ -677,6 +698,23 @@ ssoCmd.command('remove <id>').description('Remove a provider by id').action((id:
 // ── Volumes ────────────────────────────────────────────────────────────────
 const volumesCmd = program.command('volumes').description('Manage Docker volumes');
 
+volumesCmd.command('files <name> [path]').description('List files inside a managed volume')
+  .option('--server <id>', 'Read this node instead of the panel host').option('--json', 'Print raw JSON')
+  .action((name:string,path:string|undefined,opts:VolumeFileOptions)=>volumeFilesList(getClient(),name,path??'',opts));
+volumesCmd.command('read <name> <path>').description('Read exact file bytes from a managed volume')
+  .option('--server <id>', 'Read this node instead of the panel host').option('--output <file>', 'Save to a local file instead of stdout').option('--force', 'Overwrite an existing output file')
+  .action((name:string,path:string,opts:VolumeFileOptions)=>volumeFileRead(getClient(),name,path,opts));
+volumesCmd.command('write <name> <path>').description('Write a local file into a managed volume (maximum 1 MiB)')
+  .requiredOption('--file <file>', 'Local input file').option('--server <id>', 'Write this node instead of the panel host')
+  .action((name:string,path:string,opts:VolumeFileOptions)=>volumeFileWrite(getClient(),name,path,opts));
+volumesCmd.command('mkdir <name> <path>').description('Create a directory inside a managed volume')
+  .option('--server <id>', 'Use this node instead of the panel host')
+  .action((name:string,path:string,opts:VolumeFileOptions)=>volumeFileMkdir(getClient(),name,path,opts));
+volumesCmd.command('delete-file <name> <path>').description('Delete a file or directory inside a volume, with confirmation')
+  .option('--server <id>', 'Use this node instead of the panel host').option('--yes', 'Confirm this exact path without prompting')
+  .action((name:string,path:string,opts:VolumeFileOptions)=>volumeFileDelete(getClient(),name,path,opts));
+
+
 volumesCmd.command('list')
   .description('List all volumes')
   .option('--server <id>', 'A node\'s volumes instead of the panel host\'s')