kubepile 0.0.4 → 0.0.6

package/README.md

@@ -13,6 +13,31 @@ Kubepile lets you maintain individual, per-provider kubeconfigs in a
 `~/.config/kubepile` directory, and compile them into a single, merged
 kubeconfig.
 
+Kubepile exposes a tiny set of commands to manage your configs:
+
+* [`compile`](#compile): compile your Kubepile configs into a merged kubeconfig
+* [`source`](#source): set a specific context as your default for the current
+  shell
+* [`split`](#split): decompile an existing, messy kubeconfig into nice, clean
+  Kubepile configs
+
+## Install
+
+```sh
+npm install -g kubepile
+```
+
+Kubepile also includes a small shell helper that you need to install once:
+
+```sh
+kubepile install
+```
+
+Once you've installed the shell helper, either start a new shell or re-source
+your `.zshrc`/`.bashrc`/`.profile`/etc. Kubepile supports Zsh, Bash, and Fish.
+
+## Kubepile configs
+
 Each `*.yaml` file is a normal kubeconfig. You can paste in kubeconfigs from
 providers without converting them to a kubepile-specific schema. During
 `compile`, kubepile reads every file and merges its `clusters`, `users`, and
@@ -28,13 +53,9 @@ intentionally fail compilation with a helpful message explaining which file
 broke the kubepile rules.
 
 Kubepile will never set a `current-context`, out of the design belief that
-`current-context` is a dangerous footgun in multi-cluster setups.
-
-## Install
-
-```sh
-npm install -g kubepile
-```
+setting a global, cross-shell-session `current-context` is a dangerous footgun
+in multi-cluster setups. Instead, use `kubepile source <context>` to
+temporarily set a default context for your current shell session.
 
 ## Compile
 
@@ -65,28 +86,41 @@ Running `kubepile` with no command prints help.
 
 ## Source
 
-`kubepile source <context>` switches your current shell to one context by
-creating a temporary kubeconfig containing only that context and exporting
-`KUBECONFIG` to point at it. It also prefixes your shell prompt with the context
-name.
+`kubepile source <context>` switches your current shell to use a specific
+Kubernetes context by default by creating a temporary kubeconfig with that
+context set as the current-context, and exporting `KUBECONFIG` to point at it.
+It also prefixes your shell prompt with the context name.
+
+```sh
+kubepile source prod
+# Your shell prompt is now:
+# (prod) WHATEVER_YOUR_OLD_PROMPT_WAS
+# All kubectl commands will use the prod context
+```
+
+To list available contexts:
+
+```sh
+kubepile source --list
+```
 
-Shells do not let child processes modify the parent shell environment, so this
-requires installing a small shell function first:
+To switch to a different context, just run the `source` command with a new
+context:
 
 ```sh
-kubepile install
+kubepile source dev
 ```
 
-Then start a new shell and run:
+Note that this requires installing the shell helpers listed in the
+installation instructions. If you haven't installed them yet, install them
+with:
 
 ```sh
-kubepile source prod
+kubepile install
 ```
 
-`kubepile install` installs only for your current shell. It supports bash, zsh,
-and fish. The installed function proxies every normal command to the real
-`kubepile` binary with `command kubepile`, so it follows whatever `kubepile` is
-currently on your `PATH` after tools like `nvm` update it.
+And re-source your main shell config (such as e.g. a `.zshrc`) or start a new
+shell.
 
 ## Split
 

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "kubepile",
-    "version": "0.0.4",
+    "version": "0.0.6",
     "description": "Compile and split kubeconfig files from ~/.config/kubepile.",
     "type": "module",
     "main": "./dist/src/kubepile.js",

package/dist/src/cli.js

@@ -4,7 +4,7 @@ import { createInterface } from "node:readline/promises";
 import { Command } from "@commander-js/extra-typings";
 import packageJson from "../package.json" with { type: "json" };
 import { compileToKubeConfig, defaultKubeConfigPath, defaultKubepileDir, splitKubeConfigFile, } from "./kubepile.js";
-import { generateShellCommand, installShellIntegration, } from "./shell.js";
+import { generateShellCommand, installShellIntegration, listSourceContextNames, } from "./shell.js";
 const program = createProgram();
 if (process.argv.slice(2).length === 0) {
     program.outputHelp();
@@ -100,8 +100,19 @@ Defaults:
     program
         .command("source")
         .description("Switch to one kube context in the current shell.")
-        .argument("<context>", "context name to source")
-        .action(() => {
+        .argument("[context]", "context name to source")
+        .option("--list", "list available contexts")
+        .action(async (context, options) => {
+        if (options.list) {
+            const contextNames = await listSourceContextNames();
+            if (contextNames.length > 0) {
+                process.stdout.write(`${contextNames.join("\n")}\n`);
+            }
+            return;
+        }
+        if (!context) {
+            throw new Error("kubepile source requires a context name or --list.");
+        }
         throw new Error("kubepile source requires shell integration. Run `kubepile install`, start a new shell, then run `kubepile source <context>`.");
     });
     return program;

package/dist/src/shell.d.ts

@@ -9,6 +9,9 @@ export interface GenerateShellCommandResult {
     kubeConfigPath: string;
     shellCommand: string;
 }
+export interface ListSourceContextNamesOptions {
+    sourcePath?: string;
+}
 export interface InstallShellIntegrationOptions {
     shell?: ShellKind;
     rcFile?: string;
@@ -20,6 +23,7 @@ export interface InstallShellIntegrationResult {
     updated: boolean;
 }
 export declare function generateShellCommand(contextName: string, options?: GenerateShellCommandOptions): Promise<GenerateShellCommandResult>;
+export declare function listSourceContextNames(options?: ListSourceContextNamesOptions): Promise<string[]>;
 export declare function installShellIntegration(options?: InstallShellIntegrationOptions): Promise<InstallShellIntegrationResult>;
 export declare function detectCurrentShell(shellPath?: string | undefined): ShellKind;
 export declare function shellRcFile(shell: ShellKind, homeDir?: string): Promise<string>;

package/dist/src/shell.js

@@ -1,16 +1,22 @@
 import { mkdir, mkdtemp, readFile, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { defaultKubeConfigPath, extractContextConfig, readKubeConfigFile, serializeKubeConfig, } from "./kubepile.js";
+import { defaultKubeConfigPath, readKubeConfigFile, serializeKubeConfig, } from "./kubepile.js";
 const SHELL_BLOCK_START = "# >>> kubepile shell integration >>>";
 const SHELL_BLOCK_END = "# <<< kubepile shell integration <<<";
 export async function generateShellCommand(contextName, options = {}) {
     const sourcePath = options.sourcePath ?? defaultKubeConfigPath();
     const shell = options.shell ?? "posix";
     const sourceConfig = await readKubeConfigFile(sourcePath);
-    const contextConfig = extractContextConfig(sourceConfig, contextName, sourcePath);
+    const contextConfig = {
+        ...sourceConfig,
+        "current-context": contextName,
+    };
     const tempRoot = await mkdtemp(path.join(options.tempDir ?? os.tmpdir(), "kubepile-source-"));
     const kubeConfigPath = path.join(tempRoot, "config");
+    if (!contextNamesFromConfig(sourceConfig, sourcePath).includes(contextName)) {
+        throw new Error(`${sourcePath} does not contain context "${contextName}"`);
+    }
     await writeFile(kubeConfigPath, serializeKubeConfig(contextConfig), {
         encoding: "utf8",
         mode: 0o600,
@@ -22,6 +28,10 @@ export async function generateShellCommand(contextName, options = {}) {
             : posixSourceCommand(contextName, kubeConfigPath),
     };
 }
+export async function listSourceContextNames(options = {}) {
+    const sourcePath = options.sourcePath ?? defaultKubeConfigPath();
+    return contextNamesFromConfig(await readKubeConfigFile(sourcePath), sourcePath);
+}
 export async function installShellIntegration(options = {}) {
     const shell = options.shell ?? detectCurrentShell();
     const rcFile = options.rcFile ?? await shellRcFile(shell, options.homeDir ?? os.homedir());
@@ -79,6 +89,12 @@ function posixIntegrationFunction(shell) {
     return `kubepile() {
   if [ "$1" = "source" ]; then
     shift
+    for arg in "$@"; do
+      if [ "$arg" = "--list" ]; then
+        command \\kubepile source "$@"
+        return
+      fi
+    done
     eval "$(command \\kubepile generate-shell-command --shell ${shell} "$@")"
   else
     command \\kubepile "$@"
@@ -89,7 +105,11 @@ function fishIntegrationFunction() {
     return `function kubepile
   if test (count $argv) -gt 0; and test "$argv[1]" = "source"
     set -e argv[1]
-    command kubepile generate-shell-command --shell fish $argv | source
+    if contains -- --list $argv
+      command kubepile source $argv
+    else
+      command kubepile generate-shell-command --shell fish $argv | source
+    end
   else
     command kubepile $argv
   end
@@ -150,6 +170,20 @@ async function firstExistingPath(filePaths) {
     }
     return undefined;
 }
+function contextNamesFromConfig(config, sourcePath) {
+    if (config.contexts === undefined) {
+        return [];
+    }
+    if (!Array.isArray(config.contexts)) {
+        throw new Error(`${sourcePath} contexts must be an array`);
+    }
+    return config.contexts.map((context) => {
+        if (typeof context.name !== "string" || context.name.length === 0) {
+            throw new Error(`${sourcePath} context name must be a non-empty string`);
+        }
+        return context.name;
+    });
+}
 function escapeRegExp(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kubepile",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "Compile and split kubeconfig files from ~/.config/kubepile.",
   "type": "module",
   "main": "./dist/src/kubepile.js",