kubepile 0.0.3 → 0.0.5

package/README.md

@@ -36,6 +36,15 @@ Kubepile will never set a `current-context`, out of the design belief that
 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.
+
 ## Compile
 
 ```sh
@@ -63,6 +72,38 @@ kubepile compile --no-backup
 
 Running `kubepile` with no command prints help.
 
+## Source
+
+`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 switch to a different context, just run the `source` command with a new
+context:
+
+```sh
+kubepile source dev
+```
+
+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 install
+```
+
+And re-source your main shell config (such as e.g. a `.zshrc`) or start a new
+shell.
+
 ## Split
 
 Do you already have a giant unmaintainable mess of a kubeconfig? No worries!

package/dist/package.json

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

package/dist/src/cli.js

@@ -4,6 +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";
 const program = createProgram();
 if (process.argv.slice(2).length === 0) {
     program.outputHelp();
@@ -73,5 +74,35 @@ Defaults:
         });
         process.stdout.write(`Wrote ${result.writtenFiles.length} kubeconfig file(s) into ${result.outputDir}\n`);
     });
+    program
+        .command("install")
+        .description("Install the kubepile shell function for the current shell.")
+        .action(async () => {
+        const result = await installShellIntegration();
+        const action = result.updated ? "Installed" : "Updated";
+        process.stdout.write(`${action} kubepile shell integration in ${result.rcFile}\n`);
+        process.stdout.write("Start a new shell, then run: kubepile source <context>\n");
+    });
+    program
+        .command("generate-shell-command")
+        .description("Generate shell code for kubepile source. Usually called by the installed shell function.")
+        .argument("<context>", "context name to source")
+        .option("--source <file>", "source kubeconfig path")
+        .option("--shell <shell>", "shell command format: bash, zsh, or fish", "bash")
+        .action(async (context, options) => {
+        const shell = options.shell === "fish" ? "fish" : "posix";
+        const result = await generateShellCommand(context, {
+            sourcePath: options.source,
+            shell,
+        });
+        process.stdout.write(`${result.shellCommand}\n`);
+    });
+    program
+        .command("source")
+        .description("Switch to one kube context in the current shell.")
+        .argument("<context>", "context name to source")
+        .action(() => {
+        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/kubepile.d.ts

@@ -61,6 +61,7 @@ export declare function buildMergedConfig(options?: CompileOptions): Promise<{
 export declare function compileToKubeConfig(options?: CompileToFileOptions): Promise<CompileResult>;
 export declare function splitKubeConfigFile(options?: SplitOptions): Promise<SplitResult>;
 export declare function splitKubeConfig(config: KubeConfig, sourceLabel?: string): SplitConfig[];
+export declare function extractContextConfig(config: KubeConfig, contextName: string, sourceLabel?: string): KubeConfig;
 export declare function readKubeConfigFile(filePath: string): Promise<KubeConfig>;
 export declare function parseKubeConfig(source: string, sourceLabel?: string): KubeConfig;
 export declare function serializeKubeConfig(config: KubeConfig): string;

package/dist/src/kubepile.js

@@ -163,6 +163,16 @@ export function splitKubeConfig(config, sourceLabel = "kubeconfig") {
         };
     });
 }
+export function extractContextConfig(config, contextName, sourceLabel = "kubeconfig") {
+    const splitConfig = splitKubeConfig(config, sourceLabel).find((candidate) => candidate.contextName === contextName);
+    if (!splitConfig) {
+        throw new Error(`${sourceLabel} does not contain context "${contextName}"`);
+    }
+    return {
+        ...splitConfig.config,
+        "current-context": contextName,
+    };
+}
 export async function readKubeConfigFile(filePath) {
     const source = await readFile(filePath, "utf8");
     return parseKubeConfig(source, filePath);

package/dist/src/shell.d.ts

@@ -0,0 +1,27 @@
+export type ShellKind = "bash" | "zsh" | "fish";
+export type ShellCommandKind = "posix" | "fish";
+export interface GenerateShellCommandOptions {
+    sourcePath?: string;
+    shell?: ShellCommandKind;
+    tempDir?: string;
+}
+export interface GenerateShellCommandResult {
+    kubeConfigPath: string;
+    shellCommand: string;
+}
+export interface InstallShellIntegrationOptions {
+    shell?: ShellKind;
+    rcFile?: string;
+    homeDir?: string;
+}
+export interface InstallShellIntegrationResult {
+    shell: ShellKind;
+    rcFile: string;
+    updated: boolean;
+}
+export declare function generateShellCommand(contextName: string, options?: GenerateShellCommandOptions): Promise<GenerateShellCommandResult>;
+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>;
+export declare function shellIntegrationBlock(shell: ShellKind): string;
+export declare function upsertShellIntegrationBlock(existing: string, block: string): string;

package/dist/src/shell.js

@@ -0,0 +1,161 @@
+import { mkdir, mkdtemp, readFile, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+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 = {
+        ...sourceConfig,
+        "current-context": contextName,
+    };
+    const tempRoot = await mkdtemp(path.join(options.tempDir ?? os.tmpdir(), "kubepile-source-"));
+    const kubeConfigPath = path.join(tempRoot, "config");
+    if (!sourceConfig.contexts?.some((context) => context.name === contextName)) {
+        throw new Error(`${sourcePath} does not contain context "${contextName}"`);
+    }
+    await writeFile(kubeConfigPath, serializeKubeConfig(contextConfig), {
+        encoding: "utf8",
+        mode: 0o600,
+    });
+    return {
+        kubeConfigPath,
+        shellCommand: shell === "fish"
+            ? fishSourceCommand(contextName, kubeConfigPath)
+            : posixSourceCommand(contextName, kubeConfigPath),
+    };
+}
+export async function installShellIntegration(options = {}) {
+    const shell = options.shell ?? detectCurrentShell();
+    const rcFile = options.rcFile ?? await shellRcFile(shell, options.homeDir ?? os.homedir());
+    const block = shellIntegrationBlock(shell);
+    const existing = await readTextIfExists(rcFile);
+    const next = upsertShellIntegrationBlock(existing, block);
+    await mkdir(path.dirname(rcFile), { recursive: true });
+    await writeFile(rcFile, next, "utf8");
+    return {
+        shell,
+        rcFile,
+        updated: next !== existing,
+    };
+}
+export function detectCurrentShell(shellPath = process.env.SHELL) {
+    const shellName = shellPath ? path.basename(shellPath) : "";
+    if (shellName === "bash" || shellName === "zsh" || shellName === "fish") {
+        return shellName;
+    }
+    throw new Error(`Unsupported shell "${shellPath ?? ""}". Supported shells: bash, zsh, fish.`);
+}
+export async function shellRcFile(shell, homeDir = os.homedir()) {
+    if (shell === "zsh") {
+        return path.join(homeDir, ".zshrc");
+    }
+    if (shell === "fish") {
+        return path.join(homeDir, ".config", "fish", "config.fish");
+    }
+    const bashCandidates = [
+        path.join(homeDir, ".bashrc"),
+        path.join(homeDir, ".bash_profile"),
+        path.join(homeDir, ".bash_login"),
+        path.join(homeDir, ".profile"),
+    ];
+    return await firstExistingPath(bashCandidates) ?? bashCandidates[0];
+}
+export function shellIntegrationBlock(shell) {
+    return [
+        SHELL_BLOCK_START,
+        shell === "fish" ? fishIntegrationFunction() : posixIntegrationFunction(shell),
+        SHELL_BLOCK_END,
+        "",
+    ].join("\n");
+}
+export function upsertShellIntegrationBlock(existing, block) {
+    const blockPattern = new RegExp(`${escapeRegExp(SHELL_BLOCK_START)}\\n[\\s\\S]*?\\n${escapeRegExp(SHELL_BLOCK_END)}\\n?`);
+    const normalizedBlock = block.endsWith("\n") ? block : `${block}\n`;
+    if (blockPattern.test(existing)) {
+        return existing.replace(blockPattern, normalizedBlock);
+    }
+    const separator = existing.length === 0 || existing.endsWith("\n") ? "" : "\n";
+    return `${existing}${separator}${normalizedBlock}`;
+}
+function posixIntegrationFunction(shell) {
+    return `kubepile() {
+  if [ "$1" = "source" ]; then
+    shift
+    eval "$(command \\kubepile generate-shell-command --shell ${shell} "$@")"
+  else
+    command \\kubepile "$@"
+  fi
+}`;
+}
+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
+  else
+    command kubepile $argv
+  end
+end`;
+}
+function posixSourceCommand(contextName, kubeConfigPath) {
+    return [
+        `export KUBECONFIG=${shellQuote(kubeConfigPath)}`,
+        "if [ -z \"${KUBEPILE_OLD_PS1+x}\" ]; then",
+        "  export KUBEPILE_OLD_PS1=${PS1-}",
+        "fi",
+        `export PS1=${shellQuote(`(${contextName}) `)}"$KUBEPILE_OLD_PS1"`,
+    ].join("\n");
+}
+function fishSourceCommand(contextName, kubeConfigPath) {
+    return [
+        `set -gx KUBECONFIG ${fishQuote(kubeConfigPath)}`,
+        "if not set -q KUBEPILE_OLD_PROMPT",
+        "  functions -c fish_prompt KUBEPILE_OLD_PROMPT",
+        "end",
+        "function fish_prompt",
+        `  printf ${fishQuote(`(${contextName}) `)}`,
+        "  KUBEPILE_OLD_PROMPT",
+        "end",
+    ].join("\n");
+}
+function shellQuote(value) {
+    if (/^[A-Za-z0-9_./:=@%+-]+$/.test(value)) {
+        return value;
+    }
+    return `'${value.replaceAll("'", "'\\''")}'`;
+}
+function fishQuote(value) {
+    return `'${value.replaceAll("\\", "\\\\").replaceAll("'", "\\'")}'`;
+}
+async function readTextIfExists(filePath) {
+    try {
+        return await readFile(filePath, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return "";
+        }
+        throw error;
+    }
+}
+async function firstExistingPath(filePaths) {
+    for (const filePath of filePaths) {
+        try {
+            await readFile(filePath, "utf8");
+            return filePath;
+        }
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                throw error;
+            }
+        }
+    }
+    return undefined;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/package.json

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