@localctl/cli 0.2.0

package/src/lib/projectContext.js

@@ -0,0 +1,32 @@
+const fs = require('fs');
+const path = require('path');
+
+// Same lookup shape as git finding .git, or Claude finding .claude: walk up from a directory
+// looking for the nearest `.local/project.json`, at that directory or any ancestor. This lets a
+// single project.json at a parent folder govern every app subfolder underneath it, or a single
+// `.local` folder hold both the project.json and an app's own config.json together - whichever
+// layout a given repo uses.
+function findProjectFile(startDir) {
+  let dir = startDir;
+  for (;;) {
+    const candidate = path.join(dir, '.local', 'project.json');
+    if (fs.existsSync(candidate)) return candidate;
+    const parent = path.dirname(dir);
+    if (parent === dir) return null; // reached the filesystem root
+    dir = parent;
+  }
+}
+
+// Which profile governs `startDir` - the name from the nearest ancestor's project.json, or
+// "default" if none exists anywhere above it. This is independent of app config resolution
+// (CONFIG_PATH is always just cwd's own .local/config.json) - only the profile/cluster scope
+// walks up.
+function resolveProfileName(startDir = process.cwd()) {
+  const file = findProjectFile(startDir);
+  if (!file) return 'default';
+  const raw = JSON.parse(fs.readFileSync(file, 'utf8'));
+  if (!raw.profile) throw new Error(`${file} is missing a "profile" field.`);
+  return raw.profile;
+}
+
+module.exports = { findProjectFile, resolveProfileName };

package/src/lib/prompt.js

@@ -0,0 +1,97 @@
+const readline = require('readline');
+
+// Deliberately not using rl.question() in a loop: with piped (non-TTY) stdin, all lines can
+// arrive before a later rl.question() call attaches its listener, silently dropping answers.
+// Async-iterating the readline interface instead queues lines correctly either way.
+async function askAll(questions) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: false });
+  const answers = [];
+  let idx = 0;
+  const prompt = (q) => process.stdout.write(`${q.text}${q.def ? ` (${q.def})` : ''}: `);
+
+  prompt(questions[0]);
+  for await (const line of rl) {
+    answers.push(line.trim() || questions[idx].def);
+    idx += 1;
+    if (idx >= questions.length) break;
+    prompt(questions[idx]);
+  }
+  rl.close();
+  return answers;
+}
+
+// Same underlying fix as askAll, but for a wizard whose later questions depend on an earlier
+// answer (so a fixed up-front question list won't do). Manually driving the readline interface's
+// async iterator - rather than attaching a fresh 'line' listener per question - is what actually
+// queues lines correctly under piped stdin; ad hoc listeners are what askAll's comment warns about.
+function makePrompter() {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: false });
+  const iterator = rl[Symbol.asyncIterator]();
+
+  async function ask(text, def) {
+    process.stdout.write(`${text}${def ? ` (${def})` : ''}: `);
+    const { value, done } = await iterator.next();
+    if (done) return def || '';
+    return value.trim() || def || '';
+  }
+
+  return { ask, close: () => rl.close() };
+}
+
+// Same resolve-before-close ordering as the fix in the old uninstall.js confirm(): rl.close()
+// synchronously re-enters the 'close' handler below, which would resolve('') first and win the
+// race if this ran second. Shared now by `uninstall` and `app prune`.
+function confirm(question) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: false });
+    process.stdout.write(question);
+    rl.on('line', (line) => {
+      resolve(line.trim());
+      rl.close();
+    });
+    rl.on('close', () => resolve(''));
+  });
+}
+
+// Reads one line without echoing it back - for secret values, so they don't land in your shell's
+// scrollback or a screen-share. Piped/non-TTY stdin (tests, CI) can't be hidden anyway, so it
+// just falls back to a plain read there instead of failing.
+function promptHidden(question) {
+  return new Promise((resolve) => {
+    if (!process.stdin.isTTY) {
+      const rl = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: false });
+      rl.on('line', (line) => {
+        resolve(line.trim());
+        rl.close();
+      });
+      rl.on('close', () => resolve(''));
+      process.stdout.write(`${question}: `);
+      return;
+    }
+
+    process.stdout.write(`${question}: `);
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding('utf8');
+    let value = '';
+    const onData = (char) => {
+      if (char === '\n' || char === '\r' || char === '') {
+        process.stdin.setRawMode(false);
+        process.stdin.pause();
+        process.stdin.removeListener('data', onData);
+        process.stdout.write('\n');
+        resolve(value);
+        return;
+      }
+      if (char === '') process.exit(130); // Ctrl-C
+      if (char === '' || char === '\b') {
+        value = value.slice(0, -1);
+        return;
+      }
+      value += char;
+    };
+    process.stdin.on('data', onData);
+  });
+}
+
+module.exports = { askAll, makePrompter, confirm, promptHidden };

package/src/lib/toolInstall.js

@@ -0,0 +1,30 @@
+const { commandExists, run } = require('./exec');
+const logger = require('./logger');
+
+// macId: Homebrew formula name. winId: winget package id.
+function installIfMissing(bin, macId, winId) {
+  if (commandExists(bin)) {
+    logger.success(`${bin} already installed`);
+    return;
+  }
+  if (process.platform === 'darwin') {
+    if (!commandExists('brew')) {
+      throw new Error('Homebrew is required to install missing tools. Install from https://brew.sh and re-run.');
+    }
+    logger.step(`Installing ${macId} via brew...`);
+    run('brew', ['install', macId]);
+  } else if (process.platform === 'win32') {
+    if (!commandExists('winget')) {
+      throw new Error('winget is required to install missing tools (ships with modern Windows / App Installer).');
+    }
+    logger.step(`Installing ${bin} via winget...`);
+    run('winget', [
+      'install', '--id', winId, '-e', '--source', 'winget',
+      '--accept-package-agreements', '--accept-source-agreements',
+    ]);
+  } else {
+    throw new Error(`"${bin}" is missing and automatic install isn't supported on this platform. Install it manually.`);
+  }
+}
+
+module.exports = { installIfMissing };

package/src/lib/ui.js

@@ -0,0 +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('✖'),
+};

package/src/lib/workloadReadiness.js

@@ -0,0 +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 };

package/templates/Tiltfile.tmpl

@@ -0,0 +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)