@woosau/dsh-custom-env 0.1.1 → 0.1.6

package/lib/index.js

@@ -519,8 +519,8 @@ async function cliInstall() {
 }
 
 // src/env-file.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname5, join as join6 } from "node:path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname5, join as join7 } from "node:path";
 import { parseEnv } from "node:util";
 import { resolveDshHome } from "@deepseek-ai/dsh-home-paths";
 
@@ -586,116 +586,14 @@ function isWritableEnvName(name) {
   return ENV_NAME.test(name) && !isBootstrapOnly(name);
 }
 
-// src/env-file.ts
-function envFilePath() {
-  return join6(resolveDshHome(), ".env");
-}
-function readRaw() {
-  const path = envFilePath();
-  return existsSync6(path) ? readFileSync2(path, "utf8") : "";
-}
-function writeEnvFile(content) {
-  const path = envFilePath();
-  mkdirSync2(dirname5(path), { recursive: true });
-  writeFileSync2(path, content, "utf8");
-}
-function encodeValue(value) {
-  if (/^[A-Za-z0-9_./:@+-]*$/u.test(value)) return value;
-  return `"${value.replace(/\\/gu, "\\\\").replace(/"/gu, '\\"').replace(/\n/gu, "\\n")}"`;
-}
-function parseLines(content) {
-  const text = content.replace(/^\uFEFF/u, "");
-  if (text === "") return [];
-  return text.split(/\r?\n/u).map((raw) => {
-    const trimmed = raw.trim();
-    if (trimmed === "" || trimmed.startsWith("#")) return { kind: "other", raw };
-    const match = /^(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=/u.exec(trimmed);
-    if (match?.[1] === void 0) return { kind: "other", raw };
-    return { kind: "assignment", raw, name: match[1] };
-  });
-}
-function serializeLines(lines) {
-  const kept = lines.filter((line) => !(line.kind === "other" && line.raw.trim() === ""));
-  return kept.length === 0 ? "" : `${kept.map((line) => line.raw).join("\n")}
-`;
-}
-function assertWritable(name, value) {
-  if (!isWritableEnvName(name)) {
-    throw new Error(`custom-env: refused bootstrap or invalid name "${name}"`);
-  }
-  if (value === "") {
-    throw new Error(`custom-env: empty value for "${name}"`);
-  }
-}
-function loadEnvMap() {
-  const raw = readRaw().replace(/^\uFEFF/u, "").trim();
-  if (raw === "") return {};
-  let parsed;
-  try {
-    parsed = parseEnv(raw);
-  } catch (error) {
-    throw new Error(`custom-env: invalid dotenv syntax in ${envFilePath()}`, { cause: error });
-  }
-  const out = {};
-  for (const [key, value] of Object.entries(parsed)) {
-    if (typeof value === "string" && value !== "" && isWritableEnvName(key)) out[key] = value;
-  }
-  return out;
-}
-function listEnvEntries() {
-  const path = envFilePath();
-  const exists = existsSync6(path);
-  if (!exists) return { path, exists, entries: [] };
-  const map = loadEnvMap();
-  const entries = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const line of parseLines(readRaw())) {
-    if (line.kind !== "assignment" || line.name === void 0 || seen.has(line.name)) continue;
-    const value = map[line.name];
-    if (value === void 0) continue;
-    seen.add(line.name);
-    entries.push({ name: line.name, value });
-  }
-  return { path, exists, entries };
-}
-function writeEnvEntry(replaceName, name, value) {
-  assertWritable(replaceName, value);
-  assertWritable(name, value);
-  const assignment = `${name}=${encodeValue(value)}`;
-  let replaced = false;
-  const next = [];
-  for (const line of parseLines(readRaw())) {
-    if (line.kind === "assignment" && line.name === replaceName) {
-      replaced = true;
-      next.push({ kind: "assignment", raw: assignment, name });
-      continue;
-    }
-    if (replaceName !== name && line.kind === "assignment" && line.name === name) continue;
-    next.push(line);
-  }
-  if (!replaced) next.push({ kind: "assignment", raw: assignment, name });
-  writeEnvFile(serializeLines(next));
-}
-function removeEnvEntry(name) {
-  if (!isWritableEnvName(name)) {
-    throw new Error(`custom-env: refused bootstrap or invalid name "${name}"`);
-  }
-  if (!existsSync6(envFilePath())) return false;
-  const lines = parseLines(readRaw());
-  const next = lines.filter((line) => !(line.kind === "assignment" && line.name === name));
-  if (next.length === lines.length) return false;
-  writeEnvFile(serializeLines(next));
-  return true;
-}
-
 // src/os-user-env/macos.ts
-import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3, unlinkSync as unlinkSync2, existsSync as existsSync7 } from "node:fs";
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, unlinkSync as unlinkSync2, existsSync as existsSync6 } from "node:fs";
 import { homedir } from "node:os";
-import { join as join7 } from "node:path";
+import { join as join6 } from "node:path";
 import { spawnSync } from "node:child_process";
 var AGENT_LABEL = "ai.dsh.custom-env";
-var AGENT_DIR = () => join7(homedir(), "Library", "LaunchAgents");
-var AGENT_PATH = () => join7(AGENT_DIR(), `${AGENT_LABEL}.plist`);
+var AGENT_DIR = () => join6(homedir(), "Library", "LaunchAgents");
+var AGENT_PATH = () => join6(AGENT_DIR(), `${AGENT_LABEL}.plist`);
 var cached;
 function escapeXml(value) {
   return value.replace(/&/gu, "&amp;").replace(/</gu, "&lt;").replace(/>/gu, "&gt;").replace(/"/gu, "&quot;");
@@ -739,7 +637,7 @@ function ensureCache() {
 function writeAgent(entries) {
   const path = AGENT_PATH();
   if (Object.keys(entries).length === 0) {
-    if (existsSync7(path)) {
+    if (existsSync6(path)) {
       try {
         launchctl(["unload", path]);
       } catch (_error) {
@@ -748,15 +646,20 @@ function writeAgent(entries) {
     }
     return;
   }
-  mkdirSync3(AGENT_DIR(), { recursive: true });
-  writeFileSync3(path, buildPlist(entries), "utf8");
+  mkdirSync2(AGENT_DIR(), { recursive: true });
+  writeFileSync2(path, buildPlist(entries), "utf8");
   try {
     launchctl(["unload", path]);
   } catch (_error) {
   }
   launchctl(["load", path]);
 }
-function persistMacosUserEnv(entries, platform = process.platform) {
+function hasMacosUserEnv(name, platform = process.platform) {
+  if (platform !== "darwin") return false;
+  if (Object.hasOwn(process.env, name)) return true;
+  return Object.hasOwn(ensureCache(), name);
+}
+function writeMacosUserEnv(entries, platform = process.platform) {
   if (platform !== "darwin") return;
   const pairs = Object.entries(entries);
   if (pairs.length === 0) return;
@@ -767,13 +670,15 @@ function persistMacosUserEnv(entries, platform = process.platform) {
   }
   writeAgent(map);
 }
-function removeMacosUserEnv(name, platform = process.platform) {
-  if (platform !== "darwin") return;
+function removeMacosUserEnvs(names, platform = process.platform) {
+  if (platform !== "darwin" || names.length === 0) return;
   const map = ensureCache();
-  delete map[name];
-  try {
-    launchctl(["unsetenv", name]);
-  } catch (_error) {
+  for (const name of names) {
+    delete map[name];
+    try {
+      launchctl(["unsetenv", name]);
+    } catch (_error) {
+    }
   }
   writeAgent(map);
 }
@@ -781,53 +686,59 @@ function removeMacosUserEnv(name, platform = process.platform) {
 // src/os-user-env/windows.ts
 import { createRequire } from "node:module";
 var HKEY_CURRENT_USER = 2147483649;
+var KEY_QUERY_VALUE = 1;
 var KEY_SET_VALUE = 2;
 var REG_SZ = 1;
 var ERROR_SUCCESS = 0;
 var ERROR_FILE_NOT_FOUND = 2;
-var HWND_BROADCAST = 65535;
-var WM_SETTINGCHANGE = 26;
-var SMTO_ABORTIFHUNG = 2;
 var bindings;
 function loadBindings() {
   if (bindings !== void 0) return bindings;
   const require2 = createRequire(import.meta.url);
   const koffi = require2("koffi");
   const advapi32 = koffi.load("advapi32.dll");
-  const user32 = koffi.load("user32.dll");
   bindings = {
     openKey: advapi32.func(
       "long __stdcall RegOpenKeyExW(uintptr_t hKey, const char16_t *subKey, uint32_t options, uint32_t samDesired, _Out_ void **result)"
     ),
+    queryValue: advapi32.func(
+      "long __stdcall RegQueryValueExW(void *hKey, const char16_t *valueName, void *reserved, _Inout_ uint32_t *type, uint8_t *data, _Inout_ uint32_t *cbData)"
+    ),
     setValue: advapi32.func(
       "long __stdcall RegSetValueExW(void *hKey, const char16_t *valueName, uint32_t reserved, uint32_t type, const uint8_t *data, uint32_t cbData)"
     ),
     deleteValue: advapi32.func(
       "long __stdcall RegDeleteValueW(void *hKey, const char16_t *valueName)"
     ),
-    closeKey: advapi32.func("long __stdcall RegCloseKey(void *hKey)"),
-    sendMessageTimeout: user32.func(
-      "intptr_t __stdcall SendMessageTimeoutW(uintptr_t hWnd, uint32_t msg, uintptr_t wParam, const char16_t *lParam, uint32_t flags, uint32_t timeout, _Out_ uintptr_t *result)"
-    )
+    closeKey: advapi32.func("long __stdcall RegCloseKey(void *hKey)")
   };
   return bindings;
 }
 function encodeRegSz(value) {
   return Buffer.from(`${value}\0`, "utf16le");
 }
-function broadcastEnvironmentChange(api) {
-  const broadcastResult = [0];
-  api.sendMessageTimeout(
-    HWND_BROADCAST,
-    WM_SETTINGCHANGE,
-    0,
-    "Environment",
-    SMTO_ABORTIFHUNG,
-    1e3,
-    broadcastResult
-  );
+function hasWindowsUserEnv(name, platform = process.platform) {
+  if (platform !== "win32") return false;
+  const api = loadBindings();
+  const keySlot = [null];
+  const openStatus = api.openKey(HKEY_CURRENT_USER, "Environment", 0, KEY_QUERY_VALUE, keySlot);
+  if (openStatus !== ERROR_SUCCESS) {
+    throw new Error(`custom-env: RegOpenKeyExW failed (Win32 ${openStatus})`);
+  }
+  const hKey = keySlot[0];
+  try {
+    const cbData = [0];
+    const status = api.queryValue(hKey, name, null, null, null, cbData);
+    if (status === ERROR_FILE_NOT_FOUND) return false;
+    if (status !== ERROR_SUCCESS && status !== 234) {
+      throw new Error(`custom-env: RegQueryValueExW(${name}) failed (Win32 ${status})`);
+    }
+    return true;
+  } finally {
+    api.closeKey(hKey);
+  }
 }
-function persistWindowsUserEnv(entries, platform = process.platform) {
+function writeWindowsUserEnv(entries, platform = process.platform) {
   if (platform !== "win32") return;
   const pairs = Object.entries(entries);
   if (pairs.length === 0) return;
@@ -849,10 +760,9 @@ function persistWindowsUserEnv(entries, platform = process.platform) {
   } finally {
     api.closeKey(hKey);
   }
-  broadcastEnvironmentChange(api);
 }
-function removeWindowsUserEnv(name, platform = process.platform) {
-  if (platform !== "win32") return;
+function removeWindowsUserEnvs(names, platform = process.platform) {
+  if (platform !== "win32" || names.length === 0) return;
   const api = loadBindings();
   const keySlot = [null];
   const openStatus = api.openKey(HKEY_CURRENT_USER, "Environment", 0, KEY_SET_VALUE, keySlot);
@@ -861,24 +771,184 @@ function removeWindowsUserEnv(name, platform = process.platform) {
   }
   const hKey = keySlot[0];
   try {
-    const status = api.deleteValue(hKey, name);
-    if (status !== ERROR_SUCCESS && status !== ERROR_FILE_NOT_FOUND) {
-      throw new Error(`custom-env: RegDeleteValueW(${name}) failed (Win32 ${status})`);
+    for (const name of names) {
+      const status = api.deleteValue(hKey, name);
+      if (status !== ERROR_SUCCESS && status !== ERROR_FILE_NOT_FOUND) {
+        throw new Error(`custom-env: RegDeleteValueW(${name}) failed (Win32 ${status})`);
+      }
     }
   } finally {
     api.closeKey(hKey);
   }
-  broadcastEnvironmentChange(api);
 }
 
 // src/os-user-env/index.ts
-function persistUserEnv(entries) {
-  persistWindowsUserEnv(entries);
-  persistMacosUserEnv(entries);
+function hasUserEnv(name) {
+  return hasWindowsUserEnv(name) || hasMacosUserEnv(name);
+}
+function writeUserEnv(entries) {
+  writeWindowsUserEnv(entries);
+  writeMacosUserEnv(entries);
 }
-function removeUserEnv(name) {
-  removeWindowsUserEnv(name);
-  removeMacosUserEnv(name);
+function removeUserEnvs(names) {
+  if (names.length === 0) return;
+  removeWindowsUserEnvs(names);
+  removeMacosUserEnvs(names);
+}
+
+// src/env-file.ts
+function envFilePath() {
+  return join7(resolveDshHome(), ".env");
+}
+function readRaw() {
+  const path = envFilePath();
+  return existsSync7(path) ? readFileSync2(path, "utf8") : "";
+}
+function writeEnvFile(content) {
+  const path = envFilePath();
+  mkdirSync3(dirname5(path), { recursive: true });
+  writeFileSync3(path, content, "utf8");
+}
+function encodeValue(value) {
+  if (/^[A-Za-z0-9_./:@+-]*$/u.test(value)) return value;
+  return `"${value.replace(/\\/gu, "\\\\").replace(/"/gu, '\\"').replace(/\n/gu, "\\n")}"`;
+}
+function parseLines(content) {
+  const text = content.replace(/^\uFEFF/u, "");
+  if (text === "") return [];
+  return text.split(/\r?\n/u).map((raw) => {
+    const trimmed = raw.trim();
+    if (trimmed === "" || trimmed.startsWith("#")) return { kind: "other", raw };
+    const match = /^(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=/u.exec(trimmed);
+    if (match?.[1] === void 0) return { kind: "other", raw };
+    return { kind: "assignment", raw, name: match[1] };
+  });
+}
+function serializeLines(lines) {
+  const kept = lines.filter((line) => !(line.kind === "other" && line.raw.trim() === ""));
+  return kept.length === 0 ? "" : `${kept.map((line) => line.raw).join("\n")}
+`;
+}
+function assertWritableName(name) {
+  if (!isWritableEnvName(name)) {
+    throw new Error(`custom-env: refused bootstrap or invalid name "${name}"`);
+  }
+}
+function readEnvMap() {
+  const raw = readRaw().replace(/^\uFEFF/u, "").trim();
+  if (raw === "") return {};
+  let parsed;
+  try {
+    parsed = parseEnv(raw);
+  } catch (error) {
+    throw new Error(`custom-env: invalid dotenv syntax in ${envFilePath()}`, { cause: error });
+  }
+  const out = {};
+  for (const [key, value] of Object.entries(parsed)) {
+    if (typeof value === "string" && isWritableEnvName(key)) out[key] = value;
+  }
+  return out;
+}
+function listEnvEntries() {
+  const path = envFilePath();
+  const exists = existsSync7(path);
+  if (!exists) return { path, exists, entries: [] };
+  const map = readEnvMap();
+  const entries = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const line of parseLines(readRaw())) {
+    if (line.kind !== "assignment" || line.name === void 0 || seen.has(line.name)) continue;
+    const value = map[line.name];
+    if (value === void 0) continue;
+    seen.add(line.name);
+    entries.push({ name: line.name, value });
+  }
+  return { path, exists, entries };
+}
+function hasEnvKey(name) {
+  return Object.hasOwn(readEnvMap(), name) || hasUserEnv(name);
+}
+function selectEnvWrites(entries, options = {}) {
+  if (entries.length === 0) return [];
+  const lastByName = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    assertWritableName(entry.name);
+    lastByName.set(entry.name, entry.value);
+  }
+  const forceEmpty = options.forceEmpty === true;
+  const selected = [];
+  for (const [name, value] of lastByName) {
+    if (value === "" && !forceEmpty && hasEnvKey(name)) continue;
+    selected.push({ name, value });
+  }
+  return selected;
+}
+function writeEnvEntries(entries, options = {}) {
+  const selected = selectEnvWrites(entries, options);
+  if (selected.length === 0) return selected;
+  const pending = new Map(selected.map((entry) => [entry.name, entry.value]));
+  const next = [];
+  for (const line of parseLines(readRaw())) {
+    if (line.kind === "assignment" && line.name !== void 0 && pending.has(line.name)) {
+      const value = pending.get(line.name);
+      pending.delete(line.name);
+      next.push({
+        kind: "assignment",
+        raw: `${line.name}=${encodeValue(value)}`,
+        name: line.name
+      });
+      continue;
+    }
+    next.push(line);
+  }
+  for (const [name, value] of pending) {
+    next.push({ kind: "assignment", raw: `${name}=${encodeValue(value)}`, name });
+  }
+  writeEnvFile(serializeLines(next));
+  return selected;
+}
+function writeEnvEntry(name, value, options = {}) {
+  return writeEnvEntries([{ name, value }], options).length > 0;
+}
+function renameEnvEntry(from, to, value) {
+  assertWritableName(from);
+  assertWritableName(to);
+  const assignment = `${to}=${encodeValue(value)}`;
+  let replaced = false;
+  const next = [];
+  for (const line of parseLines(readRaw())) {
+    if (line.kind === "assignment" && line.name === from) {
+      replaced = true;
+      next.push({ kind: "assignment", raw: assignment, name: to });
+      continue;
+    }
+    if (line.kind === "assignment" && line.name === to) continue;
+    next.push(line);
+  }
+  if (!replaced) next.push({ kind: "assignment", raw: assignment, name: to });
+  writeEnvFile(serializeLines(next));
+}
+function removeEnvEntries(names) {
+  if (names.length === 0) return 0;
+  const drop = /* @__PURE__ */ new Set();
+  for (const name of names) {
+    assertWritableName(name);
+    drop.add(name);
+  }
+  if (!existsSync7(envFilePath())) return 0;
+  const lines = parseLines(readRaw());
+  let removed = 0;
+  const next = [];
+  for (const line of lines) {
+    if (line.kind === "assignment" && line.name !== void 0 && drop.has(line.name)) {
+      removed += 1;
+      continue;
+    }
+    next.push(line);
+  }
+  if (removed === 0) return 0;
+  writeEnvFile(serializeLines(next));
+  return removed;
 }
 
 // src/types.ts
@@ -893,26 +963,39 @@ function classifyEntry(id, name, value, baselineById) {
 function asMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
-function applyLive(entries) {
+function applyProcessEnv(entries) {
   for (const [key, value] of Object.entries(entries)) process.env[key] = value;
+}
+function applyOsUserEnv(entries) {
+  if (Object.keys(entries).length === 0) return;
   try {
-    persistUserEnv(entries);
+    writeUserEnv(entries);
   } catch (error) {
-    process.stderr.write(`custom-env: failed to persist OS user environment: ${asMessage(error)}
+    process.stderr.write(`custom-env: failed to write OS user environment: ${asMessage(error)}
 `);
   }
 }
-function clearLive(name) {
-  delete process.env[name];
+function writeLive(entries) {
+  applyProcessEnv(entries);
+  applyOsUserEnv(entries);
+}
+function removeLives(names) {
+  if (names.length === 0) return;
+  for (const name of names) delete process.env[name];
   try {
-    removeUserEnv(name);
+    removeUserEnvs(names);
   } catch (error) {
-    process.stderr.write(`custom-env: failed to remove OS user environment ${name}: ${asMessage(error)}
-`);
+    process.stderr.write(
+      `custom-env: failed to remove OS user environment (${names.join(", ")}): ${asMessage(error)}
+`
+    );
   }
 }
-var _cliInstall_dec, _cliStatus_dec, _restore_dec, _deleteEntry_dec, _upsert_dec, _list_dec, _a, _init;
-var CustomEnvController = class extends (_a = TypertRemoteService, _list_dec = [Remote("list")], _upsert_dec = [Remote("upsert")], _deleteEntry_dec = [Remote("deleteEntry")], _restore_dec = [Remote("restore")], _cliStatus_dec = [Remote("cliStatus")], _cliInstall_dec = [Remote("cliInstall")], _a) {
+function removeLive(name) {
+  removeLives([name]);
+}
+var _cliInstall_dec, _cliStatus_dec, _restore_dec, _deleteEntry_dec, _removeVar_dec, _removeVars_dec, _setVar_dec, _setVars_dec, _upsert_dec, _list_dec, _a, _init;
+var CustomEnvController = class extends (_a = TypertRemoteService, _list_dec = [Remote("list")], _upsert_dec = [Remote("upsert")], _setVars_dec = [Remote("setVars")], _setVar_dec = [Remote("setVar")], _removeVars_dec = [Remote("removeVars")], _removeVar_dec = [Remote("removeVar")], _deleteEntry_dec = [Remote("deleteEntry")], _restore_dec = [Remote("restore")], _cliStatus_dec = [Remote("cliStatus")], _cliInstall_dec = [Remote("cliInstall")], _a) {
   constructor(ctx) {
     super(ctx, "customEnv");
     __runInitializers(_init, 5, this);
@@ -920,13 +1003,21 @@ var CustomEnvController = class extends (_a = TypertRemoteService, _list_dec = [
     __publicField(this, "idByName", /* @__PURE__ */ new Map());
     __publicField(this, "nameById", /* @__PURE__ */ new Map());
     __publicField(this, "idSeq", 0);
-    const loaded = loadEnvMap();
+    const loaded = readEnvMap();
     for (const [name, value] of Object.entries(loaded)) {
       const id = this.allocId();
       this.bind(id, name);
       this.baselineById.set(id, { name, value });
     }
-    applyLive(loaded);
+    applyProcessEnv(loaded);
+    if (Object.keys(loaded).length > 0) {
+      const handle = setImmediate(() => {
+        applyOsUserEnv(loaded);
+      });
+      ctx.effect(() => () => {
+        clearImmediate(handle);
+      }, "custom-env: deferred OS env sync");
+    }
   }
   allocId() {
     return `env-${++this.idSeq}`;
@@ -949,21 +1040,25 @@ var CustomEnvController = class extends (_a = TypertRemoteService, _list_dec = [
     }
     return name;
   }
-  /** Persist `name=value` replacing `from` in place; sync process.env / OS. */
-  commit(from, name, value) {
+  /**
+   * Write `name=value` replacing `from` in place; sync process.env / OS.
+   * Empty values create missing keys only, unless `forceEmpty` (restore).
+   */
+  commit(from, name, value, forceEmpty = false) {
     if (!isWritableEnvName(name) || from !== name && !isWritableEnvName(from)) {
       throw new RemoteError("custom-env/invalid-name", `refused name "${name}"`, { name });
     }
-    if (value === "") {
-      throw new RemoteError("custom-env/invalid-value", `empty value for "${name}"`, { name });
-    }
     try {
-      writeEnvEntry(from, name, value);
+      if (from === name) {
+        if (!writeEnvEntry(name, value, { forceEmpty })) return;
+      } else {
+        renameEnvEntry(from, name, value);
+        removeLive(from);
+      }
     } catch (error) {
       throw new RemoteError("custom-env/invalid-name", asMessage(error), { name }, { cause: error });
     }
-    if (from !== name) clearLive(from);
-    applyLive({ [name]: value });
+    writeLive({ [name]: value });
   }
   async list() {
     const { path, exists, entries: raw } = listEnvEntries();
@@ -993,18 +1088,66 @@ var CustomEnvController = class extends (_a = TypertRemoteService, _list_dec = [
     this.bind(id, name);
     return this.list();
   }
-  async deleteEntry(id) {
-    const name = this.requireName(id, id);
-    if (!isWritableEnvName(name)) {
-      throw new RemoteError("custom-env/invalid-name", `refused name "${name}"`, { name });
+  async setVars(entries) {
+    if (entries.length === 0) return;
+    const lastByName = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      if (!isWritableEnvName(entry.name)) {
+        throw new RemoteError("custom-env/invalid-name", `refused name "${entry.name}"`, { name: entry.name });
+      }
+      lastByName.set(entry.name, entry.value);
     }
+    const normalized = [...lastByName].map(([name, value]) => ({ name, value }));
+    let written;
     try {
-      removeEnvEntry(name);
+      written = writeEnvEntries(normalized);
     } catch (error) {
+      const name = normalized[0]?.name ?? "";
       throw new RemoteError("custom-env/invalid-name", asMessage(error), { name }, { cause: error });
     }
-    clearLive(name);
-    this.unbind(id);
+    if (written.length === 0) return;
+    const live = {};
+    for (const entry of written) {
+      live[entry.name] = entry.value;
+      if (!this.idByName.has(entry.name)) this.bind(this.allocId(), entry.name);
+    }
+    writeLive(live);
+  }
+  async setVar(name, value) {
+    await this.setVars([{ name, value }]);
+  }
+  async removeVars(names) {
+    if (names.length === 0) return 0;
+    const unique = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const name of names) {
+      if (!isWritableEnvName(name)) {
+        throw new RemoteError("custom-env/invalid-name", `refused name "${name}"`, { name });
+      }
+      if (seen.has(name)) continue;
+      seen.add(name);
+      unique.push(name);
+    }
+    let removed;
+    try {
+      removed = removeEnvEntries(unique);
+    } catch (error) {
+      const name = unique[0] ?? "";
+      throw new RemoteError("custom-env/invalid-name", asMessage(error), { name }, { cause: error });
+    }
+    removeLives(unique);
+    for (const name of unique) {
+      const id = this.idByName.get(name);
+      if (id !== void 0) this.unbind(id);
+    }
+    return removed;
+  }
+  async removeVar(name) {
+    return await this.removeVars([name]) > 0;
+  }
+  async deleteEntry(id) {
+    const name = this.requireName(id, id);
+    await this.removeVars([name]);
     return this.list();
   }
   async restore(id) {
@@ -1014,9 +1157,9 @@ var CustomEnvController = class extends (_a = TypertRemoteService, _list_dec = [
     }
     const base = this.baselineById.get(id);
     if (base === void 0) return this.deleteEntry(id);
-    if (name === base.name && loadEnvMap()[base.name] === base.value) return this.list();
+    if (name === base.name && readEnvMap()[base.name] === base.value) return this.list();
     try {
-      this.commit(name, base.name, base.value);
+      this.commit(name, base.name, base.value, true);
     } catch (error) {
       if (error instanceof RemoteError) {
         throw new RemoteError("custom-env/restore-failed", error.message, { name }, { cause: error });
@@ -1041,6 +1184,10 @@ var CustomEnvController = class extends (_a = TypertRemoteService, _list_dec = [
 _init = __decoratorStart(_a);
 __decorateElement(_init, 1, "list", _list_dec, CustomEnvController);
 __decorateElement(_init, 1, "upsert", _upsert_dec, CustomEnvController);
+__decorateElement(_init, 1, "setVars", _setVars_dec, CustomEnvController);
+__decorateElement(_init, 1, "setVar", _setVar_dec, CustomEnvController);
+__decorateElement(_init, 1, "removeVars", _removeVars_dec, CustomEnvController);
+__decorateElement(_init, 1, "removeVar", _removeVar_dec, CustomEnvController);
 __decorateElement(_init, 1, "deleteEntry", _deleteEntry_dec, CustomEnvController);
 __decorateElement(_init, 1, "restore", _restore_dec, CustomEnvController);
 __decorateElement(_init, 1, "cliStatus", _cliStatus_dec, CustomEnvController);