@dotenc/cli 0.5.0 → 0.5.2

package/dist/cli.js

@@ -7,7 +7,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@dotenc/cli",
-    version: "0.5.0",
+    version: "0.5.2",
     description: "🔐 Git-native encrypted environments powered by your SSH keys",
     author: "Ivan Filho <i@ivanfilho.com>",
     license: "MIT",
@@ -1011,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();
@@ -1024,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()
   });
 });
 
@@ -1354,8 +1361,9 @@ var defaultDecryptCommandDeps, ansiPattern, stripAnsi = (value) => value.replace
   try {
     const environment = await deps.getEnvironmentByName(environmentName);
     const plaintext = await deps.decryptEnvironmentData(environment);
+    const grantedUsers = Array.from(new Set(environment.keys.map((key) => key.name.trim()).filter((name) => name.length > 0)));
     if (options.json) {
-      writeJson({ ok: true, content: plaintext }, deps);
+      writeJson({ ok: true, content: plaintext, grantedUsers }, deps);
     } else {
       deps.writeStdout(plaintext);
     }
@@ -2092,7 +2100,7 @@ Some useful tips:`);
   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 Claude Code skill:	${chalk13.gray("dotenc tools install-claude-code-skill")}`);
+    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")}`);
@@ -2218,133 +2226,23 @@ var init_textconv = __esm(() => {
   init_getEnvironmentByPath();
 });
 
-// src/commands/tools/install-claude-code-skill.ts
-import { existsSync as existsSync10 } from "node:fs";
-import fs16 from "node:fs/promises";
-import os6 from "node:os";
-import path16 from "node:path";
+// 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_MD_CONTENT = `---
-name: dotenc
-description: Manage dotenc encrypted environments. Use when the user asks about environment variables, secrets, dotenc setup, encrypted environments, adding teammates, rotating keys, or running commands with secrets injected.
-allowed-tools: Bash, Read, Glob, Grep
-argument-hint: [command]
----
-
-## Project context
-
-> If any command below shows an error, dotenc is likely not initialized — suggest running \`dotenc init\` first.
-
-**Current identity:**
-!\`dotenc whoami 2>&1 || true\`
-
-**Available environments:**
-!\`dotenc env list 2>&1 || true\`
-
-**Project public keys:**
-!\`dotenc key list 2>&1 || true\`
-
-## What is dotenc?
-
-dotenc is a Git-native encrypted environment management tool powered by SSH keys. It encrypts environment variables using AES-256-GCM and manages per-user access control using existing SSH key infrastructure. Private keys never leave \`~/.ssh/\`; only public keys are stored in the \`.dotenc/\` project folder. Encrypted files are safe to commit to Git.
-
-## Common workflows
-
-**First-time setup**
-\`\`\`bash
-dotenc init --name alice
-dotenc key add alice --from-ssh ~/.ssh/id_ed25519
-dotenc env create development alice
-dotenc env edit development        # opens editor to add secrets
-\`\`\`
-
-**Onboard a new teammate**
-\`\`\`bash
-dotenc key add bob --from-ssh /path/to/bob_key.pub
-dotenc auth grant development bob
-dotenc auth grant production bob   # only if they need it
-\`\`\`
-
-**Run the app locally with secrets**
-\`\`\`bash
-dotenc dev npm start               # injects development + personal env
-dotenc run -e production node app.js
-\`\`\`
-
-**Rotate keys before someone leaves**
-\`\`\`bash
-dotenc auth revoke production alice
-dotenc auth revoke development alice
-dotenc key remove alice
-dotenc env rotate production       # re-encrypts with remaining keys
-\`\`\`
-
-**Add a CI/CD key**
-\`\`\`bash
-dotenc key add ci --from-file ci_key.pub
-dotenc auth grant production ci
-\`\`\`
-
-## CLI command reference
-
-### Initialization & identity
-
-| Command | Description |
-|---------|-------------|
-| \`dotenc init [--name <name>]\` | Initialize a dotenc project in the current directory |
-| \`dotenc whoami\` | Show your identity, active SSH key, fingerprint, and environment access |
-| \`dotenc config <key> [value] [--remove]\` | Get, set, or remove a global configuration key |
-
-### Environment management
-
-| Command | Description |
-|---------|-------------|
-| \`dotenc env list\` | List all encrypted environments |
-| \`dotenc env create [environment] [publicKey]\` | Create a new encrypted environment |
-| \`dotenc env edit [environment]\` | Edit an environment in your configured editor |
-| \`dotenc env rotate [environment]\` | Rotate the data key for an environment |
-| \`dotenc env decrypt <environment> [--json]\` | Decrypt an environment to stdout |
-| \`dotenc env encrypt <environment> [--stdin] [--json]\` | Encrypt plaintext into an environment file |
-
-### Access control
-
-| Command | Description |
-|---------|-------------|
-| \`dotenc auth list [environment]\` | List public keys with access to an environment |
-| \`dotenc auth grant [environment] [publicKey]\` | Grant a key access to an environment |
-| \`dotenc auth revoke [environment] [publicKey]\` | Revoke a key's access from an environment |
-
-### Key management
-
-| Command | Description |
-|---------|-------------|
-| \`dotenc key list\` | List all public keys in the project |
-| \`dotenc key add [name] [--from-ssh <path>] [-f <file>] [-s <string>]\` | Add a public key to the project |
-| \`dotenc key remove [name]\` | Remove a public key and revoke from all environments |
-
-### Running commands with decrypted variables
-
-| Command | Description |
-|---------|-------------|
-| \`dotenc run -e <env1>[,env2] <command> [args...]\` | Run a command with decrypted environment variables |
-| \`dotenc dev <command> [args...]\` | Shortcut: run with \`development\` + your personal environment |
-
-### Git integration
-
-| Command | Description |
-|---------|-------------|
-| \`dotenc textconv <filepath>\` | Decrypt an environment file for \`git diff\` |
-
-## Guidelines
-
-- **Never expose decrypted secrets in chat output.** Do not run \`dotenc env decrypt\` and display the result. If the user needs to inspect values, suggest \`dotenc env edit\` which opens their editor.
-- **Prefer \`dotenc dev\` / \`dotenc run\`** over manually decrypting and exporting variables.
-- **Warn before destructive operations.** Confirm with the user before running \`dotenc key remove\`, \`dotenc auth revoke\`, or \`dotenc env rotate\`, as these can lock users out of environments.
-- **Always pass arguments explicitly.** All commands support interactive mode when arguments are omitted, but Claude Code is non-interactive — always provide the full command with arguments.
-- **Encrypted files are Git-safe.** Files like \`.env.production.enc\` are meant to be committed; never instruct the user to add them to \`.gitignore\`.
-`, installClaudeCodeSkillCommand = async (options) => {
-  const { scope } = await inquirer10.prompt([
+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",
@@ -2355,48 +2253,68 @@ dotenc auth grant production ci
       ]
     }
   ]);
-  const baseDir = scope === "global" ? path16.join(os6.homedir(), ".claude") : path16.join(process.cwd(), ".claude");
-  const skillDir = path16.join(baseDir, "skills", "dotenc");
-  const skillPath = path16.join(skillDir, "SKILL.md");
-  if (existsSync10(skillPath) && !options.force) {
-    console.error(`${chalk15.red("Error:")} Claude Code skill already exists at ${chalk15.gray(skillPath)}.`);
-    console.error(`Run with ${chalk15.gray("--force")} to overwrite.`);
-    process.exit(1);
+  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);
   }
-  await fs16.mkdir(skillDir, { recursive: true });
-  await fs16.writeFile(skillPath, SKILL_MD_CONTENT, "utf-8");
-  console.log(`${chalk15.green("✓")} Claude Code skill installed at ${chalk15.gray(skillPath)}`);
-  console.log(`Run ${chalk15.gray("/dotenc")} in Claude Code to use it.`);
+  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_claude_code_skill = () => {};
+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 existsSync11 } from "node:fs";
-import fs17 from "node:fs/promises";
-import path17 from "node:path";
+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 = path17.join(process.cwd(), ".vscode", "extensions.json");
+  const extensionsJsonPath = path16.join(process.cwd(), ".vscode", "extensions.json");
   let json = {};
-  if (existsSync11(extensionsJsonPath)) {
-    const content = await fs17.readFile(extensionsJsonPath, "utf-8");
+  if (existsSync10(extensionsJsonPath)) {
+    const content = await fs16.readFile(extensionsJsonPath, "utf-8");
     try {
       json = JSON.parse(content);
     } catch {
       json = {};
     }
   } else {
-    await fs17.mkdir(path17.join(process.cwd(), ".vscode"), { recursive: true });
+    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 fs17.writeFile(extensionsJsonPath, JSON.stringify(json, null, 2), "utf-8");
+    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")}`);
@@ -2412,11 +2330,11 @@ async function which(bin) {
 }
 async function detectEditors() {
   const detected = [];
-  if (existsSync11(path17.join(process.cwd(), ".cursor")))
+  if (existsSync10(path16.join(process.cwd(), ".cursor")))
     detected.push("cursor");
-  if (existsSync11(path17.join(process.cwd(), ".windsurf")))
+  if (existsSync10(path16.join(process.cwd(), ".windsurf")))
     detected.push("windsurf");
-  if (existsSync11(path17.join(process.cwd(), ".vscode")))
+  if (existsSync10(path16.join(process.cwd(), ".vscode")))
     detected.push("vscode");
   const checks = [
     { key: "cursor", bins: ["cursor"] },
@@ -2432,7 +2350,7 @@ async function detectEditors() {
       vscodium: "/Applications/VSCodium.app"
     };
     for (const [key, appPath] of Object.entries(macApps)) {
-      if (!detected.includes(key) && existsSync11(appPath)) {
+      if (!detected.includes(key) && existsSync10(appPath)) {
         detected.push(key);
       }
     }
@@ -2517,6 +2435,162 @@ var init_install_vscode_extension = __esm(() => {
   };
 });
 
+// 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();
@@ -2569,11 +2643,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, tools;
-var init_program = __esm(() => {
+var init_program = __esm(async () => {
   init_package();
   init_grant();
   init_list();
@@ -2592,9 +2747,11 @@ var init_program = __esm(() => {
   init_remove();
   init_run();
   init_textconv();
-  init_install_claude_code_skill();
+  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);
@@ -2616,13 +2773,15 @@ var init_program = __esm(() => {
   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-claude-code-skill").addOption(new Option("--force", "overwrite existing installation")).description("install the Claude Code skill for this project").action(installClaudeCodeSkillCommand);
+  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.5.0",
+  "version": "0.5.2",
   "description": "🔐 Git-native encrypted environments powered by your SSH keys",
   "author": "Ivan Filho <i@ivanfilho.com>",
   "license": "MIT",