@localctl/cli 0.2.0 → 0.4.0

package/src/lib/ui.js

@@ -1,50 +1,50 @@
-const chalk = require('chalk');
-
-// eslint-disable-next-line no-control-regex
-const ANSI_RE = /\x1b\[[0-9;]*m/g;
-
-function visibleLength(str) {
-  return String(str).replace(ANSI_RE, '').length;
-}
-
-function padVisible(str, width) {
-  const pad = Math.max(0, width - visibleLength(str));
-  return str + ' '.repeat(pad);
-}
-
-// Column widths computed from visible (non-ANSI) length, so colored cells still line up.
-function printTable(headers, rows) {
-  const widths = headers.map((h, i) =>
-    Math.max(visibleLength(h), ...rows.map((r) => visibleLength(r[i])), 0),
-  );
-  console.log(headers.map((h, i) => padVisible(chalk.bold(h), widths[i])).join('  ').trimEnd());
-  rows.forEach((row) => {
-    console.log(row.map((cell, i) => padVisible(String(cell), widths[i])).join('  ').trimEnd());
-  });
-}
-
-const ok = (s) => chalk.green(s);
-const warn = (s) => chalk.yellow(s);
-const dim = (s) => chalk.gray(s);
-
-// `ready`/`desired` replica counts -> a colored "x/y" string. Used anywhere a workload's
-// readiness is summarized (app status, addon status) so the coloring rule stays in one place.
-function readyLabel(ready, desired) {
-  const text = `${ready}/${desired}`;
-  return ready >= desired && desired > 0 ? ok(text) : warn(text);
-}
-
-module.exports = {
-  printTable,
-  visibleLength,
-  padVisible,
-  readyLabel,
-  ok,
-  warn,
-  err: (s) => chalk.red(s),
-  dim,
-  bold: (s) => chalk.bold(s),
-  url: (s) => chalk.cyan.underline(s),
-  check: chalk.green('✔'),
-  cross: chalk.red('✖'),
-};
+const chalk = require('chalk');
+
+// eslint-disable-next-line no-control-regex
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+
+function visibleLength(str) {
+  return String(str).replace(ANSI_RE, '').length;
+}
+
+function padVisible(str, width) {
+  const pad = Math.max(0, width - visibleLength(str));
+  return str + ' '.repeat(pad);
+}
+
+// Column widths computed from visible (non-ANSI) length, so colored cells still line up.
+function printTable(headers, rows) {
+  const widths = headers.map((h, i) =>
+    Math.max(visibleLength(h), ...rows.map((r) => visibleLength(r[i])), 0),
+  );
+  console.log(headers.map((h, i) => padVisible(chalk.bold(h), widths[i])).join('  ').trimEnd());
+  rows.forEach((row) => {
+    console.log(row.map((cell, i) => padVisible(String(cell), widths[i])).join('  ').trimEnd());
+  });
+}
+
+const ok = (s) => chalk.green(s);
+const warn = (s) => chalk.yellow(s);
+const dim = (s) => chalk.gray(s);
+
+// `ready`/`desired` replica counts -> a colored "x/y" string. Used anywhere a workload's
+// readiness is summarized (app status, addon status) so the coloring rule stays in one place.
+function readyLabel(ready, desired) {
+  const text = `${ready}/${desired}`;
+  return ready >= desired && desired > 0 ? ok(text) : warn(text);
+}
+
+module.exports = {
+  printTable,
+  visibleLength,
+  padVisible,
+  readyLabel,
+  ok,
+  warn,
+  err: (s) => chalk.red(s),
+  dim,
+  bold: (s) => chalk.bold(s),
+  url: (s) => chalk.cyan.underline(s),
+  check: chalk.green('✔'),
+  cross: chalk.red('✖'),
+};

package/src/lib/updateCheck.js

@@ -0,0 +1,84 @@
+// Tells the user when a newer @localctl/cli is on npm. Never slows a command down: the notice is
+// printed from a cached result, and the cache is refreshed (at most once a day) by a detached
+// background process that outlives this one. Silent in CI, when stderr isn't a terminal, when
+// running from a source checkout, or with LOCALCTL_NO_UPDATE_CHECK=1.
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+const chalk = require('chalk');
+const { HOME_STATE_DIR } = require('./paths');
+
+const PACKAGE_NAME = '@localctl/cli';
+const CACHE_PATH = path.join(HOME_STATE_DIR, 'update-check.json');
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
+const DEV_VERSION = '0.0.0-development';
+
+function parse(version) {
+  const [core, pre] = String(version).split('-');
+  return { nums: core.split('.').map((n) => parseInt(n, 10) || 0), pre: pre || null };
+}
+
+// Plain x.y.z comparison; a pre-release is older than the same x.y.z without one. Good enough to
+// decide "is there something newer" without pulling in a semver dependency.
+function isNewer(candidate, current) {
+  const a = parse(candidate);
+  const b = parse(current);
+  for (let i = 0; i < 3; i += 1) {
+    if (a.nums[i] !== b.nums[i]) return a.nums[i] > b.nums[i];
+  }
+  if (a.pre === b.pre) return false;
+  if (!a.pre) return true;
+  if (!b.pre) return false;
+  return a.pre.localeCompare(b.pre, undefined, { numeric: true }) > 0;
+}
+
+function readCache() {
+  try {
+    return JSON.parse(fs.readFileSync(CACHE_PATH, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+function enabled(currentVersion) {
+  return !process.env.LOCALCTL_NO_UPDATE_CHECK
+    && !process.env.CI
+    && process.stderr.isTTY
+    && currentVersion !== DEV_VERSION;
+}
+
+function start(currentVersion) {
+  if (!enabled(currentVersion)) return;
+  const cache = readCache();
+
+  // Users on a pre-release also get told about newer pre-releases on their own channel.
+  const { pre } = parse(currentVersion);
+  const channel = pre ? pre.split('.')[0] : null;
+  const candidates = [cache.distTags?.latest, channel && cache.distTags?.[channel]].filter(Boolean);
+  const newest = candidates.filter((v) => isNewer(v, currentVersion))
+    .sort((x, y) => (isNewer(x, y) ? -1 : 1))[0];
+
+  if (newest) {
+    const tag = newest.includes('-') ? `@${channel}` : '';
+    process.on('exit', () => {
+      console.error();
+      console.error(`${chalk.yellow('Update available:')} ${currentVersion} -> ${chalk.green(newest)}`);
+      console.error(`Run ${chalk.cyan(`npm install -g ${PACKAGE_NAME}${tag}`)} to update.`);
+    });
+  }
+
+  if (!cache.checkedAt || Date.now() - cache.checkedAt > CHECK_INTERVAL_MS) {
+    try {
+      const child = spawn(process.execPath, [path.join(__dirname, 'updateCheckWorker.js'), CACHE_PATH, PACKAGE_NAME], {
+        detached: true,
+        stdio: 'ignore',
+        windowsHide: true,
+      });
+      child.unref();
+    } catch {
+      // Best effort - a failed check must never affect the command the user actually ran.
+    }
+  }
+}
+
+module.exports = { start, isNewer };

package/src/lib/updateCheckWorker.js

@@ -0,0 +1,46 @@
+// Background half of updateCheck.js: fetches the package's npm dist-tags and caches them. Runs
+// detached, so it may outlive the command that started it; every failure is swallowed.
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+
+const [cachePath, packageName] = process.argv.slice(2);
+
+function write(data) {
+  try {
+    fs.mkdirSync(path.dirname(cachePath), { recursive: true });
+    fs.writeFileSync(cachePath, JSON.stringify(data));
+  } catch {
+    // Nothing useful to do - the next command simply tries again.
+  }
+}
+
+let previous = {};
+try {
+  previous = JSON.parse(fs.readFileSync(cachePath, 'utf8'));
+} catch {
+  // No cache yet.
+}
+
+// Record the attempt up front, so a slow or failing registry is retried tomorrow, not on every
+// command in between.
+write({ ...previous, checkedAt: Date.now() });
+
+const req = https.get(`https://registry.npmjs.org/-/package/${packageName}/dist-tags`, { timeout: 5000 }, (res) => {
+  if (res.statusCode !== 200) {
+    res.resume();
+    return;
+  }
+  let body = '';
+  res.setEncoding('utf8');
+  res.on('data', (chunk) => { body += chunk; });
+  res.on('end', () => {
+    try {
+      write({ checkedAt: Date.now(), distTags: JSON.parse(body) });
+    } catch {
+      // Malformed response - keep the previous cache.
+    }
+  });
+});
+req.on('timeout', () => req.destroy());
+req.on('error', () => {});

package/src/lib/workloadReadiness.js

@@ -1,35 +1,35 @@
-const { capture } = require('./exec');
-
-function getList(args) {
-  const res = capture('kubectl', [...args, '-o', 'json']);
-  if (res.status !== 0) return [];
-  try {
-    return JSON.parse(res.stdout).items || [];
-  } catch (e) {
-    return [];
-  }
-}
-
-// Deployment/StatefulSet/DaemonSet all expose ready/desired counts, just under slightly
-// different field names depending on kind.
-function readyCounts(workload) {
-  const status = workload.status || {};
-  const ready = status.readyReplicas ?? status.numberReady ?? 0;
-  const desired = (workload.spec || {}).replicas ?? status.desiredNumberScheduled ?? 0;
-  return { ready, desired };
-}
-
-// Every workload (any kind) in a namespace whose name starts with `prefix`, with ready/desired
-// counts - used to summarize a release's health without needing to know in advance which
-// workload kind(s) the underlying Helm chart happens to use (this is exactly the fragility that
-// bit `localctl status`'s dependency listing once already: Bitnami's Postgres/Redis charts use a
-// StatefulSet, not the Deployment a hand-rolled addon would have used).
-function workloadsWithPrefix(namespace, prefix) {
-  const kinds = ['deployment', 'statefulset', 'daemonset'];
-  return kinds
-    .flatMap((kind) => getList(['get', kind, '-n', namespace]))
-    .filter((w) => w.metadata.name.startsWith(prefix))
-    .map((w) => ({ name: w.metadata.name, ...readyCounts(w) }));
-}
-
-module.exports = { getList, readyCounts, workloadsWithPrefix };
+const { capture } = require('./exec');
+
+function getList(args) {
+  const res = capture('kubectl', [...args, '-o', 'json']);
+  if (res.status !== 0) return [];
+  try {
+    return JSON.parse(res.stdout).items || [];
+  } catch (e) {
+    return [];
+  }
+}
+
+// Deployment/StatefulSet/DaemonSet all expose ready/desired counts, just under slightly
+// different field names depending on kind.
+function readyCounts(workload) {
+  const status = workload.status || {};
+  const ready = status.readyReplicas ?? status.numberReady ?? 0;
+  const desired = (workload.spec || {}).replicas ?? status.desiredNumberScheduled ?? 0;
+  return { ready, desired };
+}
+
+// Every workload (any kind) in a namespace whose name starts with `prefix`, with ready/desired
+// counts - used to summarize a release's health without needing to know in advance which
+// workload kind(s) the underlying Helm chart happens to use (this is exactly the fragility that
+// bit `localctl status`'s dependency listing once already: Bitnami's Postgres/Redis charts use a
+// StatefulSet, not the Deployment a hand-rolled addon would have used).
+function workloadsWithPrefix(namespace, prefix) {
+  const kinds = ['deployment', 'statefulset', 'daemonset'];
+  return kinds
+    .flatMap((kind) => getList(['get', kind, '-n', namespace]))
+    .filter((w) => w.metadata.name.startsWith(prefix))
+    .map((w) => ({ name: w.metadata.name, ...readyCounts(w) }));
+}
+
+module.exports = { getList, readyCounts, workloadsWithPrefix };

package/templates/Tiltfile.tmpl

@@ -1,35 +1,35 @@
-# Generated by `localctl app new`.
-# Most configuration lives in .local/config.json - edit that instead of this file
-# unless you need custom Tilt behavior (extra resources, manual k8s_yaml, etc).
-
-config_json = read_json('.local/config.json')
-
-# Images are built and pushed from your machine to this app's project registry (localhost:5050
-# for the default project - port 5050, not 5000, to dodge macOS Control Center's claim on 5000 -
-# or a project-specific port for another Main project, see docs/architecture.md), but the cluster
-# pulls them back using the registry's in-network name. Resolved per app via `localctl app
-# registry-info` instead of hardcoded, since a project on its own cluster has its own registry.
-registry_info = decode_json(str(local(['localctl', 'app', 'registry-info'], quiet=True)))
-default_registry(registry_info['pushHost'], host_from_cluster=registry_info['clusterHost'])
-
-docker_build(
-    config_json['name'],
-    config_json['build'].get('context', '.'),
-    dockerfile=config_json['build'].get('dockerfile', 'Dockerfile'),
-    live_update=[
-        sync(s['localPath'], s['remotePath'])
-        for s in config_json.get('sync', [])
-    ],
-)
-
-# Manifests are generated by the localctl CLI from .local/config.json so there is a single
-# source of truth for the app's k8s definition.
-k8s_yaml(local(['localctl', 'app', 'generate-manifests']))
-
-port_forwards = ['%s:%s' % (config_json['port'], config_json['port'])]
-debug_cfg = config_json.get('debug', {})
-if debug_cfg.get('enabled'):
-    dp = debug_cfg['port']
-    port_forwards.append('%s:%s' % (dp, dp))
-
-k8s_resource(config_json['name'], port_forwards=port_forwards)
+# Generated by `localctl app new`.
+# Most configuration lives in .local/config.json - edit that instead of this file
+# unless you need custom Tilt behavior (extra resources, manual k8s_yaml, etc).
+
+config_json = read_json('.local/config.json')
+
+# Images are built and pushed from your machine to this app's project registry (localhost:5050
+# for the default project - port 5050, not 5000, to dodge macOS Control Center's claim on 5000 -
+# or a project-specific port for another Main project, see docs/architecture.md), but the cluster
+# pulls them back using the registry's in-network name. Resolved per app via `localctl app
+# registry-info` instead of hardcoded, since a project on its own cluster has its own registry.
+registry_info = decode_json(str(local(['localctl', 'app', 'registry-info'], quiet=True)))
+default_registry(registry_info['pushHost'], host_from_cluster=registry_info['clusterHost'])
+
+docker_build(
+    config_json['name'],
+    config_json['build'].get('context', '.'),
+    dockerfile=config_json['build'].get('dockerfile', 'Dockerfile'),
+    live_update=[
+        sync(s['localPath'], s['remotePath'])
+        for s in config_json.get('sync', [])
+    ],
+)
+
+# Manifests are generated by the localctl CLI from .local/config.json so there is a single
+# source of truth for the app's k8s definition.
+k8s_yaml(local(['localctl', 'app', 'generate-manifests']))
+
+port_forwards = ['%s:%s' % (config_json['port'], config_json['port'])]
+debug_cfg = config_json.get('debug', {})
+if debug_cfg.get('enabled'):
+    dp = debug_cfg['port']
+    port_forwards.append('%s:%s' % (dp, dp))
+
+k8s_resource(config_json['name'], port_forwards=port_forwards)