@dotenc/cli 0.4.6 → 0.5.1

package/dist/cli.js

@@ -7,7 +7,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@dotenc/cli",
-    version: "0.4.6",
+    version: "0.5.1",
     description: "🔐 Git-native encrypted environments powered by your SSH keys",
     author: "Ivan Filho <i@ivanfilho.com>",
     license: "MIT",
@@ -21,6 +21,7 @@ var init_package = __esm(() => {
     scripts: {
       dev: "bun src/cli.ts",
       start: "node dist/cli.js",
+      typecheck: "tsc --noEmit -p tsconfig.json",
       build: "bun build src/cli.ts --outdir dist --target node --packages external && { echo '#!/usr/bin/env node'; cat dist/cli.js; } > dist/cli.tmp && mv dist/cli.tmp dist/cli.js",
       "build:binary": "bun run build:binary:darwin-arm64 && bun run build:binary:darwin-x64 && bun run build:binary:linux-x64 && bun run build:binary:linux-arm64 && bun run build:binary:windows-x64",
       "build:binary:darwin-arm64": "bun build src/cli.ts --compile --target=bun-darwin-arm64 --outfile dist/dotenc-darwin-arm64",
@@ -1010,9 +1011,10 @@ import fs7 from "node:fs/promises";
 import os2 from "node:os";
 import path6 from "node:path";
 import { z as z2 } from "zod";
-var homeConfigSchema, getConfigPath = () => path6.join(os2.homedir(), ".dotenc", "config.json"), setHomeConfig = async (config) => {
+var updateConfigSchema, homeConfigSchema, getConfigPath = () => path6.join(os2.homedir(), ".dotenc", "config.json"), setHomeConfig = async (config) => {
   const parsedConfig = homeConfigSchema.parse(config);
   const configPath = getConfigPath();
+  await fs7.mkdir(path6.dirname(configPath), { recursive: true });
   await fs7.writeFile(configPath, JSON.stringify(parsedConfig, null, 2), "utf-8");
 }, getHomeConfig = async () => {
   const configPath = getConfigPath();
@@ -1023,8 +1025,14 @@ var homeConfigSchema, getConfigPath = () => path6.join(os2.homedir(), ".dotenc",
   return {};
 };
 var init_homeConfig = __esm(() => {
+  updateConfigSchema = z2.object({
+    lastCheckedAt: z2.string().nullish(),
+    latestVersion: z2.string().nullish(),
+    notifiedVersion: z2.string().nullish()
+  });
   homeConfigSchema = z2.object({
-    editor: z2.string().nullish()
+    editor: z2.string().nullish(),
+    update: updateConfigSchema.nullish()
   });
 });
 
@@ -1052,8 +1060,8 @@ var getCurrentKeyName = async (deps = { getPrivateKeys, getPublicKeys }) => {
   const { keys: privateKeys } = await deps.getPrivateKeys();
   const publicKeys = await deps.getPublicKeys();
   const privateFingerprints = new Set(privateKeys.map((k) => k.fingerprint));
-  const match = publicKeys.find((pub) => privateFingerprints.has(pub.fingerprint));
-  return match?.name;
+  const matches = publicKeys.filter((pub) => privateFingerprints.has(pub.fingerprint));
+  return matches.map((m) => m.name);
 };
 var init_getCurrentKeyName = __esm(() => {
   init_getPrivateKeys();
@@ -1150,12 +1158,29 @@ var init_run = __esm(() => {
 
 // src/commands/dev.ts
 import chalk8 from "chalk";
-var defaultDevCommandDeps, devCommand = async (command, args, deps = defaultDevCommandDeps) => {
-  const keyName = await deps.getCurrentKeyName();
-  if (!keyName) {
+import inquirer3 from "inquirer";
+var defaultSelect = async (message, choices) => {
+  const { selected } = await inquirer3.prompt([
+    {
+      type: "list",
+      name: "selected",
+      message,
+      choices
+    }
+  ]);
+  return selected;
+}, defaultDevCommandDeps, devCommand = async (command, args, deps = defaultDevCommandDeps) => {
+  const keyNames = await deps.getCurrentKeyName();
+  if (keyNames.length === 0) {
     deps.logError(`${chalk8.red("Error:")} could not resolve your identity. Run ${chalk8.gray("dotenc init")} first.`);
     deps.exit(1);
   }
+  let keyName;
+  if (keyNames.length === 1) {
+    keyName = keyNames[0];
+  } else {
+    keyName = await deps.select("Multiple identities found. Which one do you want to use?", keyNames.map((name) => ({ name, value: name })));
+  }
   await deps.runCommand(command, args, { env: `development,${keyName}` });
 };
 var init_dev = __esm(() => {
@@ -1165,7 +1190,8 @@ var init_dev = __esm(() => {
     getCurrentKeyName,
     runCommand,
     logError: console.error,
-    exit: process.exit
+    exit: process.exit,
+    select: defaultSelect
   };
 });
 
@@ -1207,9 +1233,9 @@ var init_projectConfig = __esm(() => {
 });
 
 // src/prompts/createEnvironment.ts
-import inquirer3 from "inquirer";
+import inquirer4 from "inquirer";
 var createEnvironmentPrompt = async (message, defaultValue) => {
-  const result = await inquirer3.prompt([
+  const result = await inquirer4.prompt([
     {
       type: "input",
       name: "environment",
@@ -1704,9 +1730,9 @@ var setupGitDiff = () => {
 var init_setupGitDiff = () => {};
 
 // src/prompts/inputName.ts
-import inquirer4 from "inquirer";
+import inquirer5 from "inquirer";
 var inputNamePrompt = async (message, defaultValue) => {
-  const result = await inquirer4.prompt([
+  const result = await inquirer5.prompt([
     {
       type: "input",
       name: "name",
@@ -1791,9 +1817,9 @@ function validatePublicKey(key) {
 }
 
 // src/prompts/inputKey.ts
-import inquirer5 from "inquirer";
+import inquirer6 from "inquirer";
 var inputKeyPrompt = async (message, defaultValue) => {
-  const result = await inquirer5.prompt([
+  const result = await inquirer6.prompt([
     {
       type: "password",
       name: "key",
@@ -1813,7 +1839,7 @@ import fs12 from "node:fs/promises";
 import os4 from "node:os";
 import path12 from "node:path";
 import chalk12 from "chalk";
-import inquirer6 from "inquirer";
+import inquirer7 from "inquirer";
 var keyAddCommand = async (nameArg, options) => {
   const { projectId } = await getProjectConfig();
   if (!projectId) {
@@ -1911,7 +1937,7 @@ ${passphraseProtectedKeys.map((k) => `  - ${k}`).join(`
       name: `${key.name} (${key.algorithm})`,
       value: key.name
     }));
-    const modePrompt = await inquirer6.prompt({
+    const modePrompt = await inquirer7.prompt({
       type: "list",
       name: "mode",
       message: "Would you like to add one of your SSH keys or paste a public key?",
@@ -1934,7 +1960,7 @@ ${passphraseProtectedKeys.map((k) => `  - ${k}`).join(`
         process.exit(1);
       }
     } else {
-      const keyPrompt = await inquirer6.prompt({
+      const keyPrompt = await inquirer7.prompt({
         type: "list",
         name: "key",
         message: "Which SSH key do you want to add?",
@@ -1994,7 +2020,7 @@ import fs13 from "node:fs/promises";
 import os5 from "node:os";
 import path13 from "node:path";
 import chalk13 from "chalk";
-import inquirer7 from "inquirer";
+import inquirer8 from "inquirer";
 var initCommand = async (options) => {
   const { keys: privateKeys, passphraseProtectedKeys } = await getPrivateKeys();
   if (!privateKeys.length) {
@@ -2025,7 +2051,7 @@ var initCommand = async (options) => {
   if (privateKeys.length === 1) {
     keyToAdd = privateKeys[0].name;
   } else {
-    const result = await inquirer7.prompt([
+    const result = await inquirer8.prompt([
       {
         type: "list",
         name: "key",
@@ -2072,6 +2098,12 @@ Some useful tips:`);
   console.log(`- To edit your personal environment:	${editCmd}`);
   const devCmd = chalk13.gray("dotenc dev <command>");
   console.log(`- To run with your encrypted env:	${devCmd}`);
+  if (existsSync8(".claude") || existsSync8("CLAUDE.md")) {
+    console.log(`- Install the agent skill:		${chalk13.gray("dotenc tools install-agent-skill")}`);
+  }
+  if (existsSync8(".vscode") || existsSync8(".cursor") || existsSync8(".windsurf")) {
+    console.log(`- Add the editor extension:		${chalk13.gray("dotenc tools install-vscode-extension")}`);
+  }
 };
 var init_init = __esm(() => {
   init_createProject();
@@ -2099,9 +2131,9 @@ var init_list3 = __esm(() => {
 });
 
 // src/prompts/confirm.ts
-import inquirer8 from "inquirer";
+import inquirer9 from "inquirer";
 var confirmPrompt = async (message) => {
-  const result = await inquirer8.prompt([
+  const result = await inquirer9.prompt([
     {
       type: "confirm",
       name: "confirm",
@@ -2193,13 +2225,378 @@ var init_textconv = __esm(() => {
   init_getEnvironmentByPath();
 });
 
+// src/commands/tools/install-agent-skill.ts
+import { spawn as spawn2 } from "node:child_process";
+import chalk15 from "chalk";
+import inquirer10 from "inquirer";
+var SKILL_SOURCE = "ivanfilhoz/dotenc", SKILL_NAME = "dotenc", runNpx = (args) => new Promise((resolve, reject) => {
+  const child = spawn2("npx", args, {
+    stdio: "inherit",
+    shell: process.platform === "win32"
+  });
+  child.on("error", reject);
+  child.on("exit", (code) => resolve(code ?? 1));
+}), defaultDeps, _runInstallAgentSkillCommand = async (options, depsOverrides = {}) => {
+  const deps = {
+    ...defaultDeps,
+    ...depsOverrides
+  };
+  const { scope } = await deps.prompt([
+    {
+      type: "list",
+      name: "scope",
+      message: "Install locally or globally?",
+      choices: [
+        { name: "Locally (this project)", value: "local" },
+        { name: "Globally (all projects)", value: "global" }
+      ]
+    }
+  ]);
+  const args = ["skills", "add", SKILL_SOURCE, "--skill", SKILL_NAME];
+  if (scope === "global") {
+    args.push("-g");
+  }
+  if (options.force) {
+    args.push("-y");
+  }
+  const npxCommand = `npx ${args.join(" ")}`;
+  let exitCode = 0;
+  try {
+    exitCode = await deps.runNpx(args);
+  } catch (error) {
+    deps.logError(`${chalk15.red("Error:")} failed to run ${chalk15.gray(npxCommand)}.`);
+    deps.logError(`${chalk15.red("Details:")} ${error instanceof Error ? error.message : String(error)}`);
+    deps.exit(1);
+  }
+  if (exitCode !== 0) {
+    deps.logError(`${chalk15.red("Error:")} skill installation command exited with code ${exitCode}.`);
+    deps.exit(exitCode);
+  }
+  deps.log(`${chalk15.green("✓")} Agent skill installation completed via ${chalk15.gray(npxCommand)}.`);
+  deps.log(`Run ${chalk15.gray("/dotenc")} in your agent to use it.`);
+}, installAgentSkillCommand = async (options) => {
+  await _runInstallAgentSkillCommand(options);
+};
+var init_install_agent_skill = __esm(() => {
+  defaultDeps = {
+    prompt: inquirer10.prompt,
+    runNpx,
+    log: console.log,
+    logError: console.error,
+    exit: process.exit
+  };
+});
+
+// src/commands/tools/install-vscode-extension.ts
+import { exec, execFile } from "node:child_process";
+import { existsSync as existsSync10 } from "node:fs";
+import fs16 from "node:fs/promises";
+import path16 from "node:path";
+import { promisify } from "node:util";
+import chalk16 from "chalk";
+import inquirer11 from "inquirer";
+async function addToExtensionsJson() {
+  const extensionsJsonPath = path16.join(process.cwd(), ".vscode", "extensions.json");
+  let json = {};
+  if (existsSync10(extensionsJsonPath)) {
+    const content = await fs16.readFile(extensionsJsonPath, "utf-8");
+    try {
+      json = JSON.parse(content);
+    } catch {
+      json = {};
+    }
+  } else {
+    await fs16.mkdir(path16.join(process.cwd(), ".vscode"), { recursive: true });
+  }
+  if (!Array.isArray(json.recommendations)) {
+    json.recommendations = [];
+  }
+  if (!json.recommendations.includes(EXTENSION_ID)) {
+    json.recommendations.push(EXTENSION_ID);
+    await fs16.writeFile(extensionsJsonPath, JSON.stringify(json, null, 2), "utf-8");
+    console.log(`${chalk16.green("✓")} Added dotenc to ${chalk16.gray(".vscode/extensions.json")}`);
+  } else {
+    console.log(`${chalk16.green("✓")} dotenc already in ${chalk16.gray(".vscode/extensions.json")}`);
+  }
+}
+async function which(bin) {
+  try {
+    await execFileAsync("which", [bin]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function detectEditors() {
+  const detected = [];
+  if (existsSync10(path16.join(process.cwd(), ".cursor")))
+    detected.push("cursor");
+  if (existsSync10(path16.join(process.cwd(), ".windsurf")))
+    detected.push("windsurf");
+  if (existsSync10(path16.join(process.cwd(), ".vscode")))
+    detected.push("vscode");
+  const checks = [
+    { key: "cursor", bins: ["cursor"] },
+    { key: "windsurf", bins: ["windsurf"] },
+    { key: "vscode", bins: ["code"] },
+    { key: "vscodium", bins: ["codium", "vscodium"] }
+  ];
+  if (process.platform === "darwin") {
+    const macApps = {
+      cursor: "/Applications/Cursor.app",
+      windsurf: "/Applications/Windsurf.app",
+      vscode: "/Applications/Visual Studio Code.app",
+      vscodium: "/Applications/VSCodium.app"
+    };
+    for (const [key, appPath] of Object.entries(macApps)) {
+      if (!detected.includes(key) && existsSync10(appPath)) {
+        detected.push(key);
+      }
+    }
+  }
+  for (const { key, bins } of checks) {
+    if (detected.includes(key))
+      continue;
+    for (const bin of bins) {
+      if (await which(bin)) {
+        detected.push(key);
+        break;
+      }
+    }
+  }
+  return detected;
+}
+async function openUrl(url) {
+  if (process.platform === "darwin") {
+    await execFileAsync("open", [url]);
+  } else if (process.platform === "win32") {
+    await execAsync(`start ${url}`);
+  } else {
+    await execFileAsync("xdg-open", [url]);
+  }
+}
+async function _runInstallVscodeExtension(getEditors = detectEditors, _openUrl = openUrl) {
+  const editors = await getEditors();
+  await addToExtensionsJson();
+  if (editors.length === 0) {
+    console.log(`
+Install the extension in VS Code: ${chalk16.cyan(EDITOR_PROTOCOL_URLS.vscode)}`);
+    return;
+  }
+  if (editors.length === 1) {
+    const editor = editors[0];
+    const url = EDITOR_PROTOCOL_URLS[editor];
+    const name = EDITOR_NAMES[editor];
+    const { open } = await inquirer11.prompt([
+      {
+        type: "confirm",
+        name: "open",
+        message: `Open extension page in ${name} now?`,
+        default: true
+      }
+    ]);
+    if (open) {
+      try {
+        await _openUrl(url);
+      } catch {
+        console.log(`Open manually: ${chalk16.cyan(url)}`);
+      }
+    } else {
+      console.log(`Install manually: ${chalk16.cyan(url)}`);
+    }
+    return;
+  }
+  console.log(`
+Install the extension in your editor:`);
+  for (const editor of editors) {
+    const name = EDITOR_NAMES[editor] ?? editor;
+    const url = EDITOR_PROTOCOL_URLS[editor];
+    console.log(`  ${name}: ${chalk16.cyan(url)}`);
+  }
+}
+var execFileAsync, execAsync, EXTENSION_ID = "dotenc.dotenc", EDITOR_PROTOCOL_URLS, EDITOR_NAMES, installVscodeExtensionCommand = async () => {
+  await _runInstallVscodeExtension();
+};
+var init_install_vscode_extension = __esm(() => {
+  execFileAsync = promisify(execFile);
+  execAsync = promisify(exec);
+  EDITOR_PROTOCOL_URLS = {
+    vscode: `vscode:extension/${EXTENSION_ID}`,
+    cursor: `cursor:extension/${EXTENSION_ID}`,
+    windsurf: `windsurf:extension/${EXTENSION_ID}`,
+    vscodium: `vscodium:extension/${EXTENSION_ID}`
+  };
+  EDITOR_NAMES = {
+    vscode: "VS Code",
+    cursor: "Cursor",
+    windsurf: "Windsurf",
+    vscodium: "VSCodium"
+  };
+});
+
+// src/helpers/update.ts
+import { realpathSync } from "node:fs";
+var NPM_LATEST_URL = "https://registry.npmjs.org/@dotenc%2fcli/latest", GITHUB_RELEASES_URL = "https://github.com/ivanfilhoz/dotenc/releases", normalizePath = (value) => value.replace(/\\/g, "/").toLowerCase(), safeRealPath = (resolveRealPath, filePath) => {
+  try {
+    return resolveRealPath(filePath);
+  } catch {
+    return filePath;
+  }
+}, detectInstallMethod = (options = {}) => {
+  const execPath = options.execPath ?? process.execPath;
+  const argv = options.argv ?? process.argv;
+  const platform = options.platform ?? process.platform;
+  const resolveRealPath = options.resolveRealPath ?? realpathSync;
+  const scriptPath = argv[1] ?? "";
+  const resolvedPaths = [execPath, scriptPath].filter(Boolean).map((value) => normalizePath(safeRealPath(resolveRealPath, value)));
+  const allPaths = resolvedPaths.join(" ");
+  const normalizedScriptPath = normalizePath(scriptPath);
+  if (allPaths.includes("/cellar/dotenc/") || allPaths.includes("/homebrew/cellar/dotenc/")) {
+    return "homebrew";
+  }
+  if (allPaths.includes("/scoop/apps/dotenc/") || allPaths.includes("/scoop/shims/")) {
+    return "scoop";
+  }
+  if (allPaths.includes("/node_modules/@dotenc/cli/")) {
+    return "npm";
+  }
+  if (normalizedScriptPath.endsWith("/src/cli.ts") || normalizedScriptPath.endsWith("/dist/cli.js") && !allPaths.includes("/node_modules/@dotenc/cli/")) {
+    return "unknown";
+  }
+  if (platform === "win32" && allPaths.includes("/scoop/")) {
+    return "scoop";
+  }
+  return "binary";
+}, parseVersionParts = (version) => {
+  const cleaned = version.trim().replace(/^v/i, "").split("-")[0];
+  if (!cleaned)
+    return null;
+  const parts = cleaned.split(".").map((part) => Number.parseInt(part, 10));
+  if (parts.some((part) => Number.isNaN(part))) {
+    return null;
+  }
+  return parts;
+}, compareVersions = (left, right) => {
+  const leftParts = parseVersionParts(left);
+  const rightParts = parseVersionParts(right);
+  if (!leftParts || !rightParts)
+    return 0;
+  const maxLen = Math.max(leftParts.length, rightParts.length);
+  for (let i = 0;i < maxLen; i += 1) {
+    const leftPart = leftParts[i] ?? 0;
+    const rightPart = rightParts[i] ?? 0;
+    if (leftPart > rightPart)
+      return 1;
+    if (leftPart < rightPart)
+      return -1;
+  }
+  return 0;
+}, isVersionNewer = (candidate, current) => compareVersions(candidate, current) > 0, fetchLatestVersion = async (options = {}) => {
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const timeoutMs = options.timeoutMs ?? 1500;
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetchImpl(NPM_LATEST_URL, {
+      headers: {
+        accept: "application/json"
+      },
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      return null;
+    }
+    const payload = await response.json();
+    return typeof payload.version === "string" ? payload.version : null;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+};
+var init_update = () => {};
+
+// src/commands/update.ts
+import { spawn as spawn3 } from "node:child_process";
+import chalk17 from "chalk";
+var runPackageManagerCommand = (command, args) => new Promise((resolve, reject) => {
+  const child = spawn3(command, args, {
+    stdio: "inherit",
+    shell: process.platform === "win32"
+  });
+  child.on("error", reject);
+  child.on("exit", (code) => resolve(code ?? 1));
+}), defaultDeps2, updateCommands, _runUpdateCommand = async (depsOverrides = {}) => {
+  const deps = {
+    ...defaultDeps2,
+    ...depsOverrides
+  };
+  const method = deps.detectInstallMethod();
+  if (method === "binary") {
+    deps.log(`Standalone binary detected. Download the latest release at ${chalk17.cyan(GITHUB_RELEASES_URL)}.`);
+    return;
+  }
+  if (method === "unknown") {
+    deps.log("Could not determine installation method automatically.");
+    deps.log(`Try one of these commands:`);
+    deps.log(`  ${chalk17.gray("brew upgrade dotenc")}`);
+    deps.log(`  ${chalk17.gray("scoop update dotenc")}`);
+    deps.log(`  ${chalk17.gray("npm install -g @dotenc/cli")}`);
+    deps.log(`Or download from ${chalk17.cyan(GITHUB_RELEASES_URL)}.`);
+    return;
+  }
+  const updater = updateCommands[method];
+  deps.log(`Updating dotenc via ${updater.label}...`);
+  let exitCode = 0;
+  try {
+    exitCode = await deps.runPackageManagerCommand(updater.command, updater.args);
+  } catch (error) {
+    deps.logError(`${chalk17.red("Error:")} failed to run ${chalk17.gray([updater.command, ...updater.args].join(" "))}.`);
+    deps.logError(`${chalk17.red("Details:")} ${error instanceof Error ? error.message : String(error)}`);
+    deps.exit(1);
+  }
+  if (exitCode !== 0) {
+    deps.logError(`${chalk17.red("Error:")} update command exited with code ${exitCode}.`);
+    deps.exit(exitCode);
+  }
+}, updateCommand = async () => {
+  await _runUpdateCommand();
+};
+var init_update2 = __esm(() => {
+  init_update();
+  defaultDeps2 = {
+    detectInstallMethod,
+    runPackageManagerCommand,
+    log: console.log,
+    logError: console.error,
+    exit: process.exit
+  };
+  updateCommands = {
+    homebrew: {
+      command: "brew",
+      args: ["upgrade", "dotenc"],
+      label: "Homebrew"
+    },
+    scoop: {
+      command: "scoop",
+      args: ["update", "dotenc"],
+      label: "Scoop"
+    },
+    npm: {
+      command: "npm",
+      args: ["install", "-g", "@dotenc/cli"],
+      label: "npm"
+    }
+  };
+});
+
 // src/commands/whoami.ts
 var whoamiCommand = async () => {
   const { keys: privateKeys, passphraseProtectedKeys } = await getPrivateKeys();
   const publicKeys = await getPublicKeys();
   const privateFingerprints = new Set(privateKeys.map((k) => k.fingerprint));
-  const matchingPublicKey = publicKeys.find((pub) => privateFingerprints.has(pub.fingerprint));
-  if (!matchingPublicKey) {
+  const matchingPublicKeys = publicKeys.filter((pub) => privateFingerprints.has(pub.fingerprint));
+  if (matchingPublicKeys.length === 0) {
     if (privateKeys.length === 0 && passphraseProtectedKeys.length > 0) {
       console.error(passphraseProtectedKeyError(passphraseProtectedKeys));
     } else {
@@ -2207,28 +2604,34 @@ var whoamiCommand = async () => {
     }
     process.exit(1);
   }
-  const matchingPrivateKey = privateKeys.find((pk) => pk.fingerprint === matchingPublicKey.fingerprint);
-  console.log(`Name: ${matchingPublicKey.name}`);
-  console.log(`Active SSH key: ${matchingPrivateKey?.name ?? "unknown"}`);
-  console.log(`Fingerprint: ${matchingPublicKey.fingerprint}`);
   const environments = await getEnvironments();
-  const authorizedEnvironments = [];
-  for (const envName of environments) {
-    try {
-      const environment = await getEnvironmentByName(envName);
-      const hasAccess = environment.keys.some((key) => key.fingerprint === matchingPublicKey.fingerprint);
-      if (hasAccess) {
-        authorizedEnvironments.push(envName);
+  for (let i = 0;i < matchingPublicKeys.length; i++) {
+    const matchingPublicKey = matchingPublicKeys[i];
+    if (i > 0) {
+      console.log("");
+    }
+    const matchingPrivateKey = privateKeys.find((pk) => pk.fingerprint === matchingPublicKey.fingerprint);
+    console.log(`Name: ${matchingPublicKey.name}`);
+    console.log(`Active SSH key: ${matchingPrivateKey?.name ?? "unknown"}`);
+    console.log(`Fingerprint: ${matchingPublicKey.fingerprint}`);
+    const authorizedEnvironments = [];
+    for (const envName of environments) {
+      try {
+        const environment = await getEnvironmentByName(envName);
+        const hasAccess = environment.keys.some((key) => key.fingerprint === matchingPublicKey.fingerprint);
+        if (hasAccess) {
+          authorizedEnvironments.push(envName);
+        }
+      } catch {}
+    }
+    if (authorizedEnvironments.length > 0) {
+      console.log("Authorized environments:");
+      for (const env of authorizedEnvironments) {
+        console.log(`  - ${env}`);
       }
-    } catch {}
-  }
-  if (authorizedEnvironments.length > 0) {
-    console.log("Authorized environments:");
-    for (const env of authorizedEnvironments) {
-      console.log(`  - ${env}`);
+    } else {
+      console.log("Authorized environments: none");
     }
-  } else {
-    console.log("Authorized environments: none");
   }
 };
 var init_whoami = __esm(() => {
@@ -2239,11 +2642,92 @@ var init_whoami = __esm(() => {
   init_getPublicKeys();
 });
 
+// src/helpers/updateNotifier.ts
+import chalk18 from "chalk";
+var CHECK_INTERVAL_MS, defaultDeps3, shouldSkipCheck = (args, env) => {
+  if (env.DOTENC_SKIP_UPDATE_CHECK === "1") {
+    return true;
+  }
+  const firstArg = args[0];
+  if (!firstArg)
+    return false;
+  return ["update", "--help", "-h", "--version", "-V", "help"].includes(firstArg);
+}, parseTimestamp = (value) => {
+  if (!value)
+    return 0;
+  const parsed = Date.parse(value);
+  return Number.isNaN(parsed) ? 0 : parsed;
+}, persistUpdateState = async (config, updateState, deps) => {
+  try {
+    await deps.setHomeConfig({
+      ...config,
+      update: updateState
+    });
+  } catch {}
+}, maybeNotifyAboutUpdate = async (depsOverrides = {}) => {
+  const deps = {
+    ...defaultDeps3,
+    ...depsOverrides
+  };
+  if (shouldSkipCheck(deps.args, deps.env)) {
+    return;
+  }
+  let config = {};
+  try {
+    config = await deps.getHomeConfig();
+  } catch {
+    config = {};
+  }
+  let updateState = config.update ?? {};
+  let latestVersion = updateState.latestVersion ?? null;
+  const now = deps.now();
+  const lastCheckedAt = parseTimestamp(updateState.lastCheckedAt);
+  const shouldRefresh = !latestVersion || now - lastCheckedAt >= CHECK_INTERVAL_MS;
+  if (shouldRefresh) {
+    const fetchedVersion = await deps.fetchLatestVersion();
+    updateState = {
+      ...updateState,
+      lastCheckedAt: new Date(now).toISOString(),
+      latestVersion: fetchedVersion ?? latestVersion ?? undefined
+    };
+    latestVersion = updateState.latestVersion ?? null;
+    await persistUpdateState(config, updateState, deps);
+  }
+  if (!latestVersion || !isVersionNewer(latestVersion, deps.currentVersion)) {
+    return;
+  }
+  if (updateState.notifiedVersion === latestVersion) {
+    return;
+  }
+  deps.log(`${chalk18.yellow("Update available:")} ${chalk18.gray(`dotenc ${deps.currentVersion}`)} -> ${chalk18.cyan(`dotenc ${latestVersion}`)}. Run ${chalk18.gray("dotenc update")}.`);
+  updateState = {
+    ...updateState,
+    notifiedVersion: latestVersion
+  };
+  await persistUpdateState(config, updateState, deps);
+};
+var init_updateNotifier = __esm(() => {
+  init_package();
+  init_homeConfig();
+  init_update();
+  CHECK_INTERVAL_MS = 6 * 60 * 60 * 1000;
+  defaultDeps3 = {
+    getHomeConfig,
+    setHomeConfig,
+    fetchLatestVersion,
+    currentVersion: package_default.version,
+    now: () => Date.now(),
+    log: console.log,
+    args: process.argv.slice(2),
+    env: process.env
+  };
+});
+
 // src/program.ts
 var exports_program = {};
 import { Command, Option } from "commander";
-var program, env, auth, key;
-var init_program = __esm(() => {
+var program, env, auth, key, tools;
+var init_program = __esm(async () => {
   init_package();
   init_grant();
   init_list();
@@ -2262,7 +2746,11 @@ var init_program = __esm(() => {
   init_remove();
   init_run();
   init_textconv();
+  init_install_agent_skill();
+  init_install_vscode_extension();
+  init_update2();
   init_whoami();
+  init_updateNotifier();
   program = new Command;
   program.name("dotenc").description(package_default.description).version(package_default.version);
   program.command("init").addOption(new Option("-n, --name <name>", "your username for the project")).description("initialize a dotenc project in the current directory").action(initCommand);
@@ -2283,11 +2771,16 @@ var init_program = __esm(() => {
   key.command("add").argument("[name]", "the name of the public key in the project").addOption(new Option("--from-ssh <path>", "add a public key derived from an SSH key file")).addOption(new Option("-f, --from-file <file>", "add the key from a PEM file")).addOption(new Option("-s, --from-string <string>", "add a public key from a string")).description("add a public key to the project").action(keyAddCommand);
   key.command("list").description("list all public keys in the project").action(keyListCommand);
   key.command("remove").argument("[name]", "the name of the public key to remove").description("remove a public key from the project").action(keyRemoveCommand);
+  tools = program.command("tools").description("install editor integrations");
+  tools.command("install-agent-skill").addOption(new Option("--force", "run npx skills in non-interactive mode (-y)")).description("install the agent skill for this project").action(installAgentSkillCommand);
+  tools.command("install-vscode-extension").description("add dotenc to VS Code / Cursor / Windsurf extension recommendations").action(installVscodeExtensionCommand);
   program.command("textconv", { hidden: true }).argument("<filepath>", "path to the encrypted environment file").description("decrypt an environment file for git diff").action(textconvCommand);
+  program.command("update").description("update dotenc based on your installation method").action(updateCommand);
   program.command("whoami").description("show your identity in this project").action(whoamiCommand);
   program.command("config").argument("<key>", "the key to get or set").argument("[value]", "the value to set the key to").addOption(new Option("-r, --remove", "remove a configuration key")).description("manage global configuration").action(configCommand);
+  await maybeNotifyAboutUpdate();
   program.parse();
 });
 
 // src/cli.ts
-Promise.resolve().then(() => init_program());
+init_program();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotenc/cli",
-  "version": "0.4.6",
+  "version": "0.5.1",
   "description": "🔐 Git-native encrypted environments powered by your SSH keys",
   "author": "Ivan Filho <i@ivanfilho.com>",
   "license": "MIT",
@@ -14,6 +14,7 @@
   "scripts": {
     "dev": "bun src/cli.ts",
     "start": "node dist/cli.js",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
     "build": "bun build src/cli.ts --outdir dist --target node --packages external && { echo '#!/usr/bin/env node'; cat dist/cli.js; } > dist/cli.tmp && mv dist/cli.tmp dist/cli.js",
     "build:binary": "bun run build:binary:darwin-arm64 && bun run build:binary:darwin-x64 && bun run build:binary:linux-x64 && bun run build:binary:linux-arm64 && bun run build:binary:windows-x64",
     "build:binary:darwin-arm64": "bun build src/cli.ts --compile --target=bun-darwin-arm64 --outfile dist/dotenc-darwin-arm64",