ninedeploy 0.10.6 → 0.16.0

package/src/commands/communityTemplates.ts

@@ -0,0 +1,97 @@
+/**
+ * `ninedeploy templates community {list,import,remove}` —
+ * G-13 community template contribution.
+ *
+ * The CLI is a thin renderer around
+ * `client.templates.community.{list,import,remove}`. The
+ * import command accepts `-` to read from stdin so a
+ * `curl -s https://.../template.json | ninedeploy
+ * templates community import -` pipeline lands the
+ * upstream contribution without writing it to disk
+ * first.
+ */
+import type { NineDeployClient } from '../client.js';
+import { c, error, header, info, spinner, success, table } from '../lib/format.js';
+import { readFile } from 'node:fs/promises';
+
+export async function communityTemplatesList(client: NineDeployClient): Promise<void> {
+  const res = await spinner('Reading community catalog', () => client.templates.community.list());
+  header('Community templates');
+  info(`Entries:    ${res.entries.length}`);
+  info(`Total size: ${res.totalBytes} bytes`);
+  if (res.entries.length === 0) {
+    info('(no community templates)');
+  } else {
+    console.log();
+    table(
+      res.entries.map((e) => ({
+        id: e.id,
+        name: e.template.name,
+        category: e.template.category,
+        bytes: e.bytes,
+      })),
+      ['id', 'name', 'category', 'bytes'],
+    );
+  }
+  if (res.errors.length > 0) {
+    console.log();
+    info(c.yellow(`Parse errors: ${res.errors.length}`));
+    for (const err of res.errors) {
+      console.log(`  ${c.red('✗')} ${err.file}: ${err.error}`);
+    }
+  }
+}
+
+/**
+ * `ninedeploy templates community import <file>` — the
+ * path can be `-` for stdin, in which case the CLI
+ * reads until EOF.
+ */
+export async function communityTemplatesImport(
+  client: NineDeployClient,
+  path: string,
+  opts: { replace?: boolean } = {},
+): Promise<void> {
+  if (!path) {
+    error('Usage: ninedeploy templates community import <file> [- | path.json]');
+    return;
+  }
+  let content: string;
+  if (path === '-') {
+    const chunks: Buffer[] = [];
+    for await (const chunk of process.stdin) chunks.push(chunk as Buffer);
+    content = Buffer.concat(chunks).toString('utf8');
+  } else {
+    try {
+      content = await readFile(path, 'utf8');
+    } catch (err) {
+      error(`Failed to read ${path}: ${err instanceof Error ? err.message : String(err)}`);
+      return;
+    }
+  }
+  try {
+    const res = await spinner('Validating + importing', () =>
+      client.templates.community.import(content, { replace: opts.replace }),
+    );
+    success(`Imported ${res.id} (${res.bytes} bytes, file: ${res.file}).`);
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+  }
+}
+
+export async function communityTemplatesRemove(client: NineDeployClient, idStr: string): Promise<void> {
+  if (!idStr) {
+    error('Usage: ninedeploy templates community remove <id>');
+    return;
+  }
+  try {
+    const res = await spinner('Removing', () => client.templates.community.remove(idStr));
+    if (!res.removed) {
+      error(`Community template "${idStr}" not found.`);
+      return;
+    }
+    success(`Removed ${idStr}.`);
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+  }
+}

package/src/commands/configCenter.ts

@@ -0,0 +1,71 @@
+import type { NineDeployClient } from '@ninedeploy/sdk';
+import { table } from '../lib/format.js';
+
+export async function configCenterList(
+  client: NineDeployClient,
+  opts: { category?: string; plugin?: string; reveal?: boolean },
+): Promise<void> {
+  const { entries } = await client.config.list({
+    category: opts.category,
+    pluginId: opts.plugin,
+    reveal: opts.reveal,
+  });
+
+  if (entries.length === 0) {
+    console.log('  No configuration entries found.');
+    return;
+  }
+
+  table(
+    entries.map((e) => ({
+      key: e.key,
+      category: e.category,
+      type: e.type,
+      secret: e.isSecret ? 'yes' : 'no',
+      value: String(e.value ?? ''),
+      status: e.isConfigured ? 'configured' : 'default',
+    })),
+    ['key', 'category', 'type', 'secret', 'value', 'status'],
+  );
+}
+
+export async function configCenterGet(client: NineDeployClient, key: string): Promise<void> {
+  const item = await client.config.get(key);
+  console.log(`  Key:         ${item.key}`);
+  console.log(`  Label:       ${item.label}`);
+  console.log(`  Category:    ${item.category}`);
+  console.log(`  Type:        ${item.type}`);
+  console.log(`  Secret:      ${item.isSecret ? 'yes' : 'no'}`);
+  console.log(`  Value:       ${String(item.value ?? '')}`);
+  console.log(`  Status:      ${item.isConfigured ? 'configured' : 'default'}`);
+  if (item.description) console.log(`  Description: ${item.description}`);
+  if (item.tags.length > 0) console.log(`  Tags:        ${item.tags.join(', ')}`);
+}
+
+export async function configCenterSet(
+  client: NineDeployClient,
+  key: string,
+  value: string,
+  opts: { secret?: boolean; desc?: string; tags?: string },
+): Promise<void> {
+  let parsedValue: unknown = value;
+  if (value === 'true') parsedValue = true;
+  else if (value === 'false') parsedValue = false;
+  else if (!Number.isNaN(Number(value)) && value.trim() !== '') parsedValue = Number(value);
+
+  const tags = opts.tags ? opts.tags.split(',').map((t) => t.trim()).filter(Boolean) : undefined;
+
+  const res = await client.config.set(key, {
+    value: parsedValue,
+    isSecret: opts.secret,
+    description: opts.desc,
+    tags,
+  });
+
+  console.log(`  ✓ Configuration key "${res.key}" saved.`);
+}
+
+export async function configCenterDelete(client: NineDeployClient, key: string): Promise<void> {
+  const res = await client.config.delete(key);
+  console.log(`  ✓ Configuration key "${res.key}" deleted.`);
+}

package/src/commands/configPresets.ts

@@ -0,0 +1,215 @@
+/**
+ * `ninedeploy config-preset {list,get,register,apply,remove}` — Sprint 3, Gap G-23, PR-A.
+ *
+ * A preset is a named bundle of `configCenter` writes an operator can
+ * register once and apply to a fresh instance with one call. The CLI
+ * is the operator-side counterpart of the kernel plugin (which owns
+ * the schema) and the HTTP surface (which is the actual apply engine).
+ *
+ * Split:
+ *   - `list` and `get` are read-only — they hit `GET /v1/config-presets`
+ *     and `GET /v1/config-presets/:id` and pretty-print the result.
+ *   - `register <id>` reads a JSON values object from `--file` (or
+ *     stdin) and POSTs it. A future PR will let the panel also
+ *     register via the UI; today the CLI is the only registration
+ *     path because the schema is intentionally a thin wrapper.
+ *   - `apply <id>` is the one-shot "I just want it to work" command.
+ *     The body is empty unless the operator wants to override a
+ *     single value for this call only (handy for smoke tests).
+ *   - `remove <id>` unregisters. It does NOT undo the apply — the
+ *     values are still in configCenter. Re-running the preset
+ *     later would write the same values back; that is the entire
+ *     point of a registry.
+ */
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import type { NineDeployClient } from '../client.js';
+import { error, header, info, success } from '../lib/format.js';
+
+export interface ConfigPresetRegisterOptions {
+  /** Path to a JSON file holding the preset's values. */
+  file?: string;
+  /** Inline description (free text, max 500 chars). */
+  description?: string;
+}
+
+// ── `ninedeploy config-preset list` ────────────────────────────────────────
+
+/** Pure entry point — same shape used by the CLI action and the unit test. */
+export async function configPresetList(client: NineDeployClient): Promise<{ presets: string[] }> {
+  return await client.configPresets.list();
+}
+
+export async function configPresetListAction(client: NineDeployClient): Promise<void> {
+  header('Config presets');
+  let result: { presets: string[] };
+  try {
+    result = await configPresetList(client);
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exitCode = 1;
+    return;
+  }
+  if (result.presets.length === 0) {
+    info('No presets are registered. Run `ninedeploy config-preset register <id> --file <path>`.');
+    return;
+  }
+  for (const name of result.presets) info(`• ${name}`);
+}
+
+// ── `ninedeploy config-preset get <id>` ────────────────────────────────────
+
+/** Pure entry point — same shape used by the CLI action and the unit test. */
+export async function configPresetGet(
+  client: NineDeployClient,
+  id: string,
+): Promise<{
+  id: string;
+  description: string | null;
+  values: Record<string, unknown>;
+  createdAt: string;
+}> {
+  return await client.configPresets.get(id);
+}
+
+export async function configPresetGetAction(client: NineDeployClient, id: string): Promise<void> {
+  header(`Config preset: ${id}`);
+  let result: Awaited<ReturnType<typeof configPresetGet>>;
+  try {
+    result = await configPresetGet(client, id);
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exitCode = 1;
+    return;
+  }
+  if (result.description) info(result.description);
+  info(`${Object.keys(result.values).length} key(s) in this preset:`);
+  for (const [key, value] of Object.entries(result.values)) {
+    info(`  ${key} = ${JSON.stringify(value)}`);
+  }
+}
+
+// ── `ninedeploy config-preset register <id>` ──────────────────────────────
+
+/** Pure entry point — reads the file, parses JSON, posts to the server. */
+export async function configPresetRegister(
+  client: NineDeployClient,
+  id: string,
+  opts: ConfigPresetRegisterOptions = {},
+): Promise<{ ok: boolean; id: string; keyCount: number }> {
+  if (!opts.file) {
+    throw new Error('--file <path> is required (a JSON object of key → value pairs)');
+  }
+  const filePath = resolve(opts.file);
+  const raw = readFileSync(filePath, 'utf8');
+  let values: unknown;
+  try {
+    values = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(`Invalid JSON in ${opts.file}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  if (!values || typeof values !== 'object' || Array.isArray(values)) {
+    throw new Error(`${opts.file} must contain a JSON object (key → value)`);
+  }
+  return await client.configPresets.register({
+    id,
+    description: opts.description,
+    values: values as Record<string, unknown>,
+  });
+}
+
+export async function configPresetRegisterAction(
+  client: NineDeployClient,
+  id: string,
+  opts: ConfigPresetRegisterOptions = {},
+): Promise<void> {
+  header('Config preset register');
+  if (!id) {
+    error('Usage: ninedeploy config-preset register <id> --file <path> [--description <text>]');
+    process.exitCode = 1;
+    return;
+  }
+  let result: Awaited<ReturnType<typeof configPresetRegister>>;
+  try {
+    result = await configPresetRegister(client, id, opts);
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exitCode = 1;
+    return;
+  }
+  success(`Registered preset "${result.id}" with ${result.keyCount} key(s)`);
+}
+
+// ── `ninedeploy config-preset apply <id>` ──────────────────────────────────
+
+/** Pure entry point — same shape used by the CLI action and the unit test. */
+export async function configPresetApply(
+  client: NineDeployClient,
+  id: string,
+  opts: { override?: Record<string, unknown> } = {},
+): Promise<{
+  ok: boolean;
+  id: string;
+  keyCount: number;
+  failureCount?: number;
+  failures?: Array<{ key: string; status: 'failed'; reason?: string }>;
+}> {
+  return await client.configPresets.apply(id, opts);
+}
+
+export async function configPresetApplyAction(
+  client: NineDeployClient,
+  id: string,
+  opts: { override?: Record<string, unknown> } = {},
+): Promise<void> {
+  header('Config preset apply');
+  if (!id) {
+    error('Usage: ninedeploy config-preset apply <id> [--override <json>]');
+    process.exitCode = 1;
+    return;
+  }
+  let result: Awaited<ReturnType<typeof configPresetApply>>;
+  try {
+    result = await configPresetApply(client, id, opts);
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exitCode = 1;
+    return;
+  }
+  if (!result.ok) {
+    error(
+      `Preset "${result.id}" applied with ${result.failureCount ?? 0} failure(s) of ${result.keyCount} key(s)`,
+    );
+    process.exitCode = 1;
+    return;
+  }
+  success(`Applied preset "${result.id}" — ${result.keyCount} key(s) written`);
+}
+
+// ── `ninedeploy config-preset remove <id>` ─────────────────────────────────
+
+/** Pure entry point — same shape used by the CLI action and the unit test. */
+export async function configPresetRemove(
+  client: NineDeployClient,
+  id: string,
+): Promise<{ ok: boolean; id: string }> {
+  return await client.configPresets.remove(id);
+}
+
+export async function configPresetRemoveAction(client: NineDeployClient, id: string): Promise<void> {
+  header('Config preset remove');
+  if (!id) {
+    error('Usage: ninedeploy config-preset remove <id>');
+    process.exitCode = 1;
+    return;
+  }
+  let result: Awaited<ReturnType<typeof configPresetRemove>>;
+  try {
+    result = await configPresetRemove(client, id);
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exitCode = 1;
+    return;
+  }
+  success(`Removed preset "${result.id}" (live configCenter values are unchanged)`);
+}