ninedeploy 0.10.6 → 0.16.0

package/src/commands/githubApps.ts

@@ -0,0 +1,292 @@
+import { readFileSync } from 'node:fs';
+import process from 'node:process';
+import type { GithubApp, GithubAppInstallation, ServiceGithubLink } from '@ninedeploy/sdk';
+import type { NineDeployClient } from '../client.js';
+import { loadConfig } from '../config.js';
+import { prompt } from '../prompts.js';
+import { c, error, header, info, kv, spinner, success, table } from '../lib/format.js';
+import { plain } from './sources.js';
+
+/**
+ * 0.13: GitHub App registration (`ninedeploy github-app …`) and a service's
+ * App link (`ninedeploy services github <id>`). App names, slugs, owners,
+ * account logins and repository names come from GitHub, so every one of them
+ * goes through the F1011 terminal sanitiser before it is printed.
+ *
+ * Secrets never travel on argv: the private key is read from a file
+ * (`--key-file`) or `NINEDEPLOY_GITHUB_APP_KEY`, and a webhook secret only
+ * from `NINEDEPLOY_GITHUB_APP_WEBHOOK_SECRET`.
+ */
+
+const KEY_ENV = 'NINEDEPLOY_GITHUB_APP_KEY';
+const WEBHOOK_SECRET_ENV = 'NINEDEPLOY_GITHUB_APP_WEBHOOK_SECRET';
+
+/** Canonical decimal id only, as the server's parseId accepts it (F598). */
+function parseId(raw: string | undefined): number {
+  const t = (raw ?? '').trim();
+  return /^[1-9]\d*$/.test(t) && Number.isSafeInteger(Number(t)) ? Number(t) : 0;
+}
+
+const message = (err: unknown): string => plain(err instanceof Error ? err.message : String(err));
+
+function installationState(inst: GithubAppInstallation): string {
+  if (inst.removedAt) return c.red('removed');
+  if (inst.suspendedAt) return c.yellow('suspended');
+  return c.green('active');
+}
+
+function printInstallations(rows: GithubAppInstallation[]): void {
+  if (rows.length === 0) {
+    info('No installations yet. Install the App on GitHub, then run `ninedeploy github-app sync <id>`.');
+    return;
+  }
+  table(
+    rows.map((i) => ({
+      id: i.id,
+      account: plain(i.accountLogin ?? `installation ${i.installationId}`),
+      type: plain(i.accountType ?? '—'),
+      repos: i.repositorySelection,
+      state: installationState(i),
+      source: i.sourceId ?? '—',
+    })),
+    ['id', 'account', 'type', 'repos', 'state', 'source'],
+  );
+}
+
+/** `ninedeploy github-app list` */
+export async function githubAppList(client: NineDeployClient): Promise<void> {
+  header('GitHub Apps');
+  const apps = await spinner('Fetching GitHub Apps', () => client.githubApps.list());
+  if (apps.length === 0) {
+    const panel = loadConfig().baseUrl.replace(/\/+$/, '');
+    info(`No GitHub App registered. One-click setup runs in the browser: ${panel}/sources → GitHub Apps → Create GitHub App.`);
+    info('For GitHub Enterprise Server or an existing App: `ninedeploy github-app add-manual`.');
+    return;
+  }
+  table(
+    apps.map((a) => ({
+      id: a.id,
+      name: plain(a.name),
+      appId: a.appId,
+      owner: plain(a.ownerLogin ?? '—'),
+      host: plain(new URL(a.webBaseUrl).host),
+    })),
+    ['id', 'name', 'appId', 'owner', 'host'],
+  );
+}
+
+function printApp(app: GithubApp): void {
+  kv('Name', plain(app.name));
+  kv('App ID', app.appId);
+  kv('Slug', app.slug ? plain(app.slug) : null);
+  kv('Owner', app.ownerLogin ? `${plain(app.ownerLogin)}${app.ownerType ? ` (${plain(app.ownerType)})` : ''}` : null);
+  kv('GitHub', plain(app.webBaseUrl));
+  kv('API', plain(app.apiBaseUrl));
+  kv('Webhook URL', app.webhookUrl);
+  kv('Install URL', app.installUrl ? plain(app.installUrl) : null);
+  kv('Private key', app.hasPrivateKey ? c.green('✓ set') : c.red('missing'));
+}
+
+/** `ninedeploy github-app show <id>` */
+export async function githubAppShow(client: NineDeployClient, idArg: string): Promise<void> {
+  const id = parseId(idArg);
+  if (!id) return error('Usage: ninedeploy github-app show <id>');
+  header(`GitHub App #${id}`);
+  try {
+    const [app, installations] = await spinner('Fetching', () => Promise.all([client.githubApps.get(id), client.githubApps.installations(id)]));
+    printApp(app);
+    console.log();
+    printInstallations(installations);
+  } catch (err) {
+    error(message(err));
+  }
+}
+
+/** The private key from `--key-file`, else NINEDEPLOY_GITHUB_APP_KEY (with `\n` escapes turned back into newlines). */
+function readPrivateKey(keyFile: string | undefined): string | null {
+  if (keyFile) return readFileSync(keyFile, 'utf8').trim();
+  const fromEnv = process.env[KEY_ENV]?.trim();
+  return fromEnv ? fromEnv.replace(/(?:\\r)?\\n/g, '\n') : null;
+}
+
+export interface AddManualOptions {
+  name?: string;
+  appId?: string;
+  keyFile?: string;
+  webBaseUrl?: string;
+  apiBaseUrl?: string;
+}
+
+/** `ninedeploy github-app add-manual` — an existing App, or one on GitHub Enterprise Server. */
+export async function githubAppAddManual(client: NineDeployClient, opts: AddManualOptions = {}): Promise<void> {
+  header('Add GitHub App');
+  const name = (opts.name ?? (await prompt('Display name (e.g. NineDeploy GHES)'))).trim();
+  if (!name) return error('A name is required');
+  const appId = parseId(opts.appId ?? (await prompt('GitHub App ID')));
+  if (!appId) return error('A numeric GitHub App ID is required');
+  if ((opts.webBaseUrl === undefined) !== (opts.apiBaseUrl === undefined)) {
+    return error('--web-base-url and --api-base-url go together (omit both for github.com)');
+  }
+  let privateKey: string | null;
+  try {
+    privateKey = readPrivateKey(opts.keyFile);
+  } catch (err) {
+    return error(`Could not read the private key: ${message(err)}`);
+  }
+  if (!privateKey) return error(`A private key is required: pass --key-file <path.pem> or set ${KEY_ENV}`);
+  const key = privateKey;
+  const webhookSecret = process.env[WEBHOOK_SECRET_ENV]?.trim() || undefined;
+  try {
+    const app = await spinner('Verifying the key with GitHub and saving', () =>
+      client.githubApps.create({
+        name,
+        appId,
+        privateKey: key,
+        ...(webhookSecret ? { webhookSecret } : {}),
+        ...(opts.webBaseUrl !== undefined ? { webBaseUrl: opts.webBaseUrl, apiBaseUrl: opts.apiBaseUrl } : {}),
+      }),
+    );
+    success(`GitHub App "${plain(app.name)}" registered (id: ${app.id})`);
+    if (!webhookSecret) info('The panel generated a webhook secret and pointed the App\'s webhook at itself.');
+    if (app.installUrl) info(`Install it: ${plain(app.installUrl)} — then run \`ninedeploy github-app sync ${app.id}\`.`);
+  } catch (err) {
+    error(message(err));
+  }
+}
+
+/** `ninedeploy github-app sync <id>` */
+export async function githubAppSync(client: NineDeployClient, idArg: string): Promise<void> {
+  const id = parseId(idArg);
+  if (!id) return error('Usage: ninedeploy github-app sync <id>');
+  header(`Sync installations of GitHub App #${id}`);
+  try {
+    const res = await spinner('Syncing installations from GitHub', () => client.githubApps.syncInstallations(id));
+    success(`${res.created} new, ${res.updated} updated, ${res.removed} removed; ${res.sourcesCreated} source(s) created`);
+    if (res.truncated) info('The installation list hit the page cap; nothing was marked removed.');
+    printInstallations(res.installations);
+  } catch (err) {
+    error(message(err));
+  }
+}
+
+/** `ninedeploy github-app rotate-key <id> [--key-file <path>]` */
+export async function githubAppRotateKey(client: NineDeployClient, idArg: string, opts: { keyFile?: string } = {}): Promise<void> {
+  const id = parseId(idArg);
+  if (!id) return error('Usage: ninedeploy github-app rotate-key <id> --key-file <path.pem>');
+  header(`Rotate the private key of GitHub App #${id}`);
+  let privateKey: string | null;
+  try {
+    privateKey = readPrivateKey(opts.keyFile);
+  } catch (err) {
+    return error(`Could not read the private key: ${message(err)}`);
+  }
+  if (!privateKey) return error(`A private key is required: pass --key-file <path.pem> or set ${KEY_ENV}`);
+  const key = privateKey;
+  try {
+    await spinner('Verifying the new key with GitHub', () => client.githubApps.rotateKey(id, key));
+    success('Private key replaced. Revoke the old key on GitHub.');
+  } catch (err) {
+    error(message(err));
+  }
+}
+
+/** `ninedeploy github-app remove <id> [--yes]` */
+export async function githubAppRemove(client: NineDeployClient, idArg: string, opts: { yes?: boolean } = {}): Promise<void> {
+  const id = parseId(idArg);
+  if (!id) return error('Usage: ninedeploy github-app remove <id>');
+  header(`Remove GitHub App #${id}`);
+  if (!opts.yes) {
+    const confirm = await prompt(`Type "delete" to forget GitHub App #${id}`, '');
+    if (confirm.trim() !== 'delete') {
+      info('Aborted.');
+      return;
+    }
+  }
+  try {
+    await spinner('Removing', () => client.githubApps.remove(id));
+    success(`GitHub App #${id} removed.`);
+    info('Its installation sources stay; clones through them fail until the App is registered again.');
+  } catch (err) {
+    error(message(err));
+  }
+}
+
+export interface ServiceGithubOptions {
+  status?: string;
+  prComment?: string;
+  migrate?: string;
+  finalize?: boolean;
+  unlink?: boolean;
+}
+
+/** `on` / `off` → boolean; anything else is a usage error (null). */
+function onOff(value: string | undefined): boolean | undefined | null {
+  if (value === undefined) return undefined;
+  const v = value.trim().toLowerCase();
+  if (v === 'on') return true;
+  if (v === 'off') return false;
+  return null;
+}
+
+function printLink(link: ServiceGithubLink | null): void {
+  if (!link) {
+    info('Not linked to a GitHub App installation. Link it with `--migrate <sourceId>` (a gh-app:… source).');
+    return;
+  }
+  kv('Repository', plain(link.repoFullName));
+  kv('State', link.active ? c.green('active (App webhooks deploy it)') : c.yellow(link.enabled ? 'inactive (installation suspended or removed)' : 'disabled'));
+  kv('Token scope', link.tokenScope);
+  kv('Commit status', link.reportStatus ? 'on' : 'off');
+  kv('PR comment', link.prComment ? 'on' : 'off');
+  kv('Source', link.sourceId ?? null);
+  kv('Previous src', link.previousSourceId ?? null);
+}
+
+/**
+ * `ninedeploy services github <id> [--status on|off] [--pr-comment on|off]
+ *  [--migrate <sourceId>] [--finalize] [--unlink]` — without flags it shows
+ * the link. Steps run in order: migrate, feedback, finalize. `--unlink`
+ * (revert) runs alone; the server answers 409 with the reason when the
+ * service clones through the App source itself.
+ */
+export async function serviceGithub(client: NineDeployClient, idArg: string, opts: ServiceGithubOptions = {}): Promise<void> {
+  const id = parseId(idArg);
+  if (!id) return error('Usage: ninedeploy services github <id> [--status on|off] [--pr-comment on|off] [--migrate <sourceId>] [--finalize] [--unlink]');
+  const reportStatus = onOff(opts.status);
+  const prComment = onOff(opts.prComment);
+  if (reportStatus === null) return error('--status takes on or off');
+  if (prComment === null) return error('--pr-comment takes on or off');
+  const migrateTo = opts.migrate === undefined ? undefined : parseId(opts.migrate);
+  if (migrateTo === 0) return error(`Invalid --migrate source id: ${opts.migrate}`);
+  const changes = migrateTo !== undefined || reportStatus !== undefined || prComment !== undefined || opts.finalize === true;
+  if (opts.unlink && changes) return error('--unlink runs on its own');
+  header(`GitHub link of service #${id}`);
+  try {
+    if (opts.unlink) {
+      const res = await spinner('Reverting to the previous source', () => client.services.github.unlink(id));
+      success(`Unlinked. Source is now ${res.sourceId ?? 'none'}; ${res.webhooksReactivated} webhook(s) switched back on.`);
+      return;
+    }
+    if (migrateTo !== undefined) {
+      await spinner('Linking to the GitHub App installation', () => client.services.github.migrate(id, migrateTo));
+      success('Linked. The previous source and webhook stay as a fallback until --finalize.');
+    }
+    if (reportStatus !== undefined || prComment !== undefined) {
+      await spinner('Updating GitHub feedback', () =>
+        client.services.github.feedback(id, {
+          ...(reportStatus !== undefined ? { reportStatus } : {}),
+          ...(prComment !== undefined ? { prComment } : {}),
+        }),
+      );
+      success('GitHub feedback updated.');
+    }
+    if (opts.finalize) {
+      const res = await spinner('Finalizing', () => client.services.github.finalize(id));
+      success(`Finalized; ${res.webhooksDeactivated} webhook(s) switched off.`);
+    }
+    const { link } = await spinner('Fetching the link', () => client.services.github.get(id));
+    printLink(link);
+  } catch (err) {
+    error(message(err));
+  }
+}

package/src/commands/housekeeping.ts

@@ -0,0 +1,106 @@
+import type { NineDeployClient } from '@ninedeploy/sdk';
+import { InvalidArgumentError } from 'commander';
+import { error, fmtBytes, header, info, spinner, success, table } from '../lib/format.js';
+
+export async function housekeepingPrune(client: NineDeployClient): Promise<void> {
+  const res = await spinner('Running system prune', () => client.housekeeping.runPrune());
+  console.log('  ✓ System housekeeping prune completed.');
+  console.log(`    Space reclaimed: ${fmtBytes(res.freedBytes)}`);
+  console.log(`    Disk used after: ${res.diskUsedPercentAfter}%`);
+  if (res.details?.imagesFreed) {
+    console.log(`    Images freed:    ${res.details.imagesFreed}`);
+  }
+}
+
+/**
+ * `ninedeploy images ls` — every image on the host, with
+ * repo / tag / size / age / dangling / in-use columns. The
+ * default sort is by size descending so the operator sees
+ * the biggest offenders first; `--sort age` switches to
+ * "oldest first" which is what the panel usually wants for
+ * a prune sweep.
+ */
+export async function imagesList(
+  client: NineDeployClient,
+  opts: { sort?: 'size' | 'age' } = {},
+): Promise<void> {
+  header('Images');
+  const { images, totalBytes } = await spinner('Listing', () => client.housekeeping.listImages());
+  if (images.length === 0) {
+    info('No images on the host.');
+    return;
+  }
+  const sorted = [...images].sort((a, b) => {
+    if (opts.sort === 'age') return b.ageHours - a.ageHours;
+    return b.sizeBytes - a.sizeBytes;
+  });
+  table(
+    sorted.map((i) => ({
+      repository: i.repository,
+      tag: i.tag,
+      size: i.size,
+      ageHours: i.ageHours.toFixed(1),
+      dangling: i.dangling ? 'yes' : '',
+      inUse: i.inUse ? 'yes' : '',
+    })),
+    ['repository', 'tag', 'size', 'ageHours', 'dangling', 'inUse'],
+  );
+  info(`${images.length} images, total ${fmtBytes(totalBytes)}.`);
+}
+
+/**
+ * `ninedeploy images prune` — fine-grained retention.
+ * The CLI builds a small opts object from flags and posts
+ * to `/v1/housekeeping/images/prune`. `--dry-run` is the
+ * default expectation on a first run: the operator
+ * eyeballs the would-delete set, then re-runs without it.
+ */
+/**
+ * r554: commander option parser for a whole-number flag in `1..max`.
+ * `images prune` used to pass `Number(v)` straight through — `--older-than 1.5`
+ * or `--keep-last abc` sent 1.5 / NaN (JSON `null`) and the server answered an
+ * opaque 422. Commander prints this message and exits 1 before any request.
+ */
+export function positiveIntOption(max: number): (value: string) => number {
+  return (value: string) => {
+    const n = Number(value);
+    if (!/^\d+$/.test(value.trim()) || n < 1 || n > max) {
+      throw new InvalidArgumentError(`Expected a whole number between 1 and ${max} (got "${value}").`);
+    }
+    return n;
+  };
+}
+
+export async function imagesPrune(
+  client: NineDeployClient,
+  opts: {
+    keepLast?: number;
+    olderThan?: number;
+    dangling?: boolean;
+    dryRun?: boolean;
+  } = {},
+): Promise<void> {
+  header('Image prune');
+  if (!opts.dangling && !opts.keepLast && !opts.olderThan) {
+    error('Refusing to prune with no filter. Set --dangling, --keep-last <N>, or --older-than <hours>.');
+    process.exitCode = 1;
+    return;
+  }
+  const res = await spinner(opts.dryRun ? 'Computing candidate set' : 'Pruning', () =>
+    client.housekeeping.pruneImages({
+      keepLast: opts.keepLast,
+      olderThanHours: opts.olderThan,
+      danglingOnly: opts.dangling,
+      dryRun: opts.dryRun,
+    }),
+  );
+  if (res.dryRun) {
+    info(`dryRun: would remove ${res.removed.length} images, freeing ${fmtBytes(res.freedBytes)}.`);
+    for (const label of res.removedLabels.slice(0, 25)) console.log(`  ${label}`);
+    if (res.removedLabels.length > 25) info(`  …and ${res.removedLabels.length - 25} more.`);
+    return;
+  }
+  success(`Removed ${res.removed.length} images, freed ${fmtBytes(res.freedBytes)}.`);
+  console.log(res.output);
+}
+

package/src/commands/login.ts

@@ -0,0 +1,58 @@
+import { createClient, NineDeployError } from '@ninedeploy/sdk';
+import { loadConfig, saveConfig } from '../config.js';
+import { prompt, promptHidden } from '../prompts.js';
+import { normalizeServerUrl } from '../lib/serverRunner.js';
+
+/** `ninedeploy login` — authenticate and persist the access token locally. */
+export async function loginAction(): Promise<void> {
+  const existing = loadConfig();
+  const rawUrl = await prompt('Server URL', existing.baseUrl);
+  const baseUrl = normalizeServerUrl(rawUrl);
+  const email = await prompt('Email');
+  if (!email) {
+    console.error('Email is required.');
+    process.exitCode = 1;
+    return;
+  }
+  const password = await promptHidden('Password');
+  if (!password) {
+    console.error('Password is required.');
+    process.exitCode = 1;
+    return;
+  }
+
+  const client = createClient({ baseUrl });
+  try {
+    // r197: a 2FA account answers `totp_required`; the CLI used to print
+    // "Login failed (401)" with no way to supply the code, so any operator who
+    // enabled 2FA could not use the CLI at all.
+    let session: Awaited<ReturnType<typeof client.auth.login>>;
+    try {
+      session = await client.auth.login({ email, password });
+    } catch (err) {
+      if (!(err instanceof NineDeployError) || err.code !== 'totp_required') throw err;
+      const totpCode = (await prompt('Two-factor code')).trim();
+      if (!totpCode) {
+        console.error('Two-factor code is required.');
+        process.exitCode = 1;
+        return;
+      }
+      session = await client.auth.login({ email, password, totpCode });
+    }
+    // Both tokens: the access token alone dies with the 15-minute TTL and
+    // every scripted session used to die with it (client.ts now refreshes).
+    saveConfig({ baseUrl, token: session.tokens.accessToken, refreshToken: session.tokens.refreshToken });
+    console.log(`✓ Logged in as ${session.user.email} (${session.user.isOperator ? 'operator' : 'member'})`);
+  } catch (err) {
+    if (err instanceof NineDeployError) {
+      console.error(`✗ Login failed (${err.status}): ${err.message}`);
+    } else {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error('✗ Login failed:', msg);
+      if (msg.includes('fetch failed') || msg.includes('ECONNREFUSED') || msg.includes('ENOTFOUND')) {
+        console.error(`  Could not reach NineDeploy server at ${baseUrl}. Check your URL or ensure the server is running.`);
+      }
+    }
+    process.exitCode = 1;
+  }
+}

package/src/commands/logs.ts

@@ -0,0 +1,91 @@
+/**
+ * `ninedeploy logs search` — G-16 cluster log search via
+ * the configured Loki drain. The CLI is a thin renderer
+ * around `client.logDrains.search(...)`: the heavy
+ * lifting is the upstream Loki query.
+ */
+import type { NineDeployClient } from '../client.js';
+import { c, error, header, info, spinner } from '../lib/format.js';
+
+const num = (v: string, usage: string): number => {
+  const n = Number(v);
+  if (Number.isNaN(n)) {
+    error(usage);
+    throw new Error(usage);
+  }
+  return n;
+};
+
+/**
+ * F880: a searched line is container stdout of any tenant's service (and its
+ * `service` label comes from the shipping pipeline), so it must not drive the
+ * operator's terminal. Same filter as F538 (`deploys watch`, manage.ts): SGR
+ * colours are kept; OSC/DCS strings (OSC 52 clipboard write, window title),
+ * non-SGR CSI (cursor moves, erase, clear screen), stray escapes and C0/DEL/C1
+ * controls other than tab, LF and CR are dropped.
+ */
+const ESC = String.fromCharCode(27);
+const TERMINAL_CONTROL = new RegExp(
+  `${ESC}[\\]PX^_][\\s\\S]*?(?:${String.fromCharCode(7)}|${ESC}\\\\|$)` +
+    `|${ESC}\\[[0-?]*[ -/]*[@-~]` +
+    `|${ESC}[\\s\\S]?` +
+    '|[\\u0000-\\u0008\\u000b\\u000c\\u000e-\\u001f\\u007f-\\u009f]',
+  'g',
+);
+const SGR_ONLY = new RegExp(`^${ESC}\\[[0-9;]*m$`);
+const terminalSafe = (s: string): string => s.replace(TERMINAL_CONTROL, (m) => (SGR_ONLY.test(m) ? m : ''));
+
+export async function logsSearch(
+  client: NineDeployClient,
+  query: string,
+  opts: { service?: string; since?: string; limit?: string; drain?: string; json?: boolean } = {},
+): Promise<void> {
+  if (!query) {
+    error('Usage: ninedeploy logs search <query> [--service <id>] [--since 15m] [--drain <id>]');
+    return;
+  }
+  const sinceMinutes = parseSinceMinutes(opts.since ?? '15m');
+  const limit = opts.limit ? num(opts.limit, 'Usage: --limit <N>') : undefined;
+  const drainId = opts.drain ? num(opts.drain, 'Usage: --drain <id>') : undefined;
+  const serviceId = opts.service ? num(opts.service, 'Usage: --service <id>') : undefined;
+  const result = await spinner('Searching logs', () =>
+    client.logDrains.search({ query, serviceId, sinceMinutes, limit, drainId }),
+  );
+  if (opts.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  header('Log search');
+  info(`Drain:      ${result.drain.name} (${result.drain.type})`);
+  info(`Window:     ${result.window.since} → ${result.window.until}`);
+  if (result.serviceId != null) info(`Service ID: ${result.serviceId}`);
+  info(`Matches:    ${result.lines.length}`);
+  if (result.lines.length === 0) {
+    info('(no matches in the window)');
+    return;
+  }
+  console.log();
+  for (const line of result.lines) {
+    const ts = new Date(line.ts).toISOString();
+    const svc = line.service ? c.dim(`[${terminalSafe(line.service)}]`) : '';
+    console.log(`${c.dim(ts)} ${svc} ${terminalSafe(line.line)}`);
+  }
+}
+
+/** Parse `15m` / `2h` / `30s` / `1d` into minutes. The
+ *  search route caps at 7d, so anything larger is clamped. */
+function parseSinceMinutes(input: string): number {
+  const m = /^(\d+)([smhd])$/.exec(input.trim());
+  if (!m) {
+    error(`Invalid --since value "${input}" (expected e.g. 15m, 2h, 1d)`);
+    throw new Error(`Invalid --since value: ${input}`);
+  }
+  const n = Number(m[1]);
+  switch (m[2]) {
+    case 's': return Math.max(1, Math.ceil(n / 60));
+    case 'm': return n;
+    case 'h': return Math.min(7 * 24 * 60, n * 60);
+    case 'd': return Math.min(7 * 24 * 60, n * 24 * 60);
+    default: return 15;
+  }
+}