autohand-cli 0.8.3 → 0.9.1

package/dist/chunk-KJ26T7GM.cjs

@@ -0,0 +1,367 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
+
+var _chunkAQ5PVHOCcjs = require('./chunk-AQ5PVHOC.cjs');
+
+
+var _chunkCK4HAHVYcjs = require('./chunk-CK4HAHVY.cjs');
+
+
+var _chunkX5P6QQOBcjs = require('./chunk-X5P6QQOB.cjs');
+
+
+
+
+
+
+
+var _chunkHK5A54AVcjs = require('./chunk-HK5A54AV.cjs');
+
+
+var _chunkKASXKDF2cjs = require('./chunk-KASXKDF2.cjs');
+
+// src/features/RemoteFeatureFlagManager.ts
+var _crypto = require('crypto'); var _crypto2 = _interopRequireDefault(_crypto);
+var _os = require('os'); var _os2 = _interopRequireDefault(_os);
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+var _fsextra = require('fs-extra'); var _fsextra2 = _interopRequireDefault(_fsextra);
+var FEATURE_FLAG_REQUEST_TIMEOUT_MS = 1500;
+function getApiBaseUrl(config) {
+  return (_optionalChain([config, 'access', _ => _.api, 'optionalAccess', _2 => _2.baseUrl]) || _optionalChain([config, 'access', _3 => _3.telemetry, 'optionalAccess', _4 => _4.apiBaseUrl]) || "https://api.autohand.ai").replace(/\/+$/, "");
+}
+function readDeviceId() {
+  try {
+    _fsextra2.default.ensureDirSync(_path2.default.dirname(_chunkKASXKDF2cjs.AUTOHAND_FILES.deviceId));
+    if (_fsextra2.default.existsSync(_chunkKASXKDF2cjs.AUTOHAND_FILES.deviceId)) {
+      const existing = _fsextra2.default.readFileSync(_chunkKASXKDF2cjs.AUTOHAND_FILES.deviceId, "utf8").trim();
+      if (existing) return existing;
+    }
+    const next = _crypto2.default.randomUUID();
+    _fsextra2.default.writeFileSync(_chunkKASXKDF2cjs.AUTOHAND_FILES.deviceId, next);
+    return next;
+  } catch (e) {
+    return _crypto2.default.randomUUID();
+  }
+}
+function parseSnapshot(value) {
+  if (value.success !== true || !Array.isArray(value.flags)) return null;
+  const flags = [];
+  for (const flag of value.flags) {
+    if (!flag || typeof flag !== "object") continue;
+    const candidate = flag;
+    if (typeof candidate.key !== "string" || typeof candidate.enabled !== "boolean") continue;
+    flags.push({
+      key: candidate.key,
+      enabled: candidate.enabled,
+      reason: typeof candidate.reason === "string" ? candidate.reason : "unknown",
+      userOverridable: candidate.userOverridable !== false
+    });
+  }
+  return {
+    success: true,
+    environment: typeof value.environment === "string" ? value.environment : "production",
+    flags,
+    evaluatedAt: typeof value.evaluatedAt === "string" ? value.evaluatedAt : (/* @__PURE__ */ new Date()).toISOString(),
+    ttlSeconds: typeof value.ttlSeconds === "number" ? value.ttlSeconds : 300
+  };
+}
+function isSnapshotFresh(snapshot) {
+  const evaluatedAt = Date.parse(snapshot.evaluatedAt);
+  if (Number.isNaN(evaluatedAt)) return false;
+  const ttlMs = Math.max(0, snapshot.ttlSeconds) * 1e3;
+  return Date.now() - evaluatedAt < ttlMs;
+}
+function createEvaluationUrl(config, deviceId, clientVersion) {
+  const environment = _optionalChain([config, 'access', _5 => _5.features, 'optionalAccess', _6 => _6.environment]) || "production";
+  const url = new URL(`${getApiBaseUrl(config)}/v1/feature-flags/evaluate`);
+  url.searchParams.set("environment", environment);
+  url.searchParams.set("clientType", "cli");
+  url.searchParams.set("deviceId", deviceId);
+  url.searchParams.set("cliVersion", clientVersion);
+  url.searchParams.set("platform", process.platform);
+  return url;
+}
+async function downloadRemoteFeatureFlags(config, deviceId, clientVersion) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), FEATURE_FLAG_REQUEST_TIMEOUT_MS);
+  try {
+    const response = await fetch(createEvaluationUrl(config, deviceId, clientVersion), { signal: controller.signal });
+    if (!response.ok) return null;
+    return parseSnapshot(await response.json());
+  } catch (e2) {
+    return null;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function writeRemoteFeatureFlagCache(snapshot) {
+  await _fsextra2.default.ensureDir(_path2.default.dirname(_chunkKASXKDF2cjs.AUTOHAND_FILES.featureFlagsCache));
+  await _fsextra2.default.writeJson(_chunkKASXKDF2cjs.AUTOHAND_FILES.featureFlagsCache, snapshot, { spaces: 2 });
+}
+async function loadCachedRemoteFeatureFlags() {
+  try {
+    if (!await _fsextra2.default.pathExists(_chunkKASXKDF2cjs.AUTOHAND_FILES.featureFlagsCache)) {
+      return null;
+    }
+    const data = await _fsextra2.default.readJson(_chunkKASXKDF2cjs.AUTOHAND_FILES.featureFlagsCache);
+    return parseSnapshot(data);
+  } catch (e3) {
+    return null;
+  }
+}
+async function loadRemoteFeatureFlags(config, options = {}) {
+  const cached = await loadCachedRemoteFeatureFlags();
+  if (!options.forceRefresh && cached && isSnapshotFresh(cached)) {
+    return cached;
+  }
+  const downloaded = await downloadRemoteFeatureFlags(config, readDeviceId(), _chunkAQ5PVHOCcjs.package_default.version);
+  if (downloaded) {
+    await writeRemoteFeatureFlagCache(downloaded);
+    return downloaded;
+  }
+  return options.allowCachedFallback === false ? null : cached;
+}
+var RemoteFeatureFlagManager = (_class = class {
+  constructor(config) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);
+    this.config = config;
+    this.apiBaseUrl = getApiBaseUrl(config);
+    this.environment = _optionalChain([config, 'access', _7 => _7.features, 'optionalAccess', _8 => _8.environment]) || "production";
+    this.clientVersion = _chunkAQ5PVHOCcjs.package_default.version;
+  }
+  
+  __init() {this.snapshot = null}
+  __init2() {this.deviceId = readDeviceId()}
+  
+  
+  
+  async refreshFeatureFlags() {
+    const downloaded = await downloadRemoteFeatureFlags(this.config, this.deviceId, this.clientVersion);
+    if (downloaded) {
+      this.snapshot = downloaded;
+      await writeRemoteFeatureFlagCache(downloaded);
+      return;
+    }
+    this.snapshot = await loadCachedRemoteFeatureFlags();
+  }
+  getSnapshot() {
+    return this.snapshot;
+  }
+  isFeatureEnabled(key, localDefault = false) {
+    if (_chunkHK5A54AVcjs.isLocalFeatureId.call(void 0, key)) {
+      return localDefault;
+    }
+    const flag = _optionalChain([this, 'access', _9 => _9.snapshot, 'optionalAccess', _10 => _10.flags, 'access', _11 => _11.find, 'call', _12 => _12((item) => item.key === key)]);
+    if (!flag) return localDefault;
+    if (!flag.enabled) return false;
+    return _optionalChain([this, 'access', _13 => _13.config, 'access', _14 => _14.features, 'optionalAccess', _15 => _15.remoteOverrides, 'optionalAccess', _16 => _16[key]]) !== "off";
+  }
+  async trackFeatureActivation(key, metadata2) {
+    void metadata2;
+    const flag = _optionalChain([this, 'access', _17 => _17.snapshot, 'optionalAccess', _18 => _18.flags, 'access', _19 => _19.find, 'call', _20 => _20((item) => item.key === key)]);
+    if (!flag || !this.isFeatureEnabled(key)) return;
+    try {
+      await fetch(`${this.apiBaseUrl}/v1/feature-flags/events`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          events: [{
+            key,
+            environment: this.environment,
+            eventType: "activation",
+            enabled: true,
+            reason: flag.reason,
+            deviceId: this.deviceId,
+            clientType: "cli",
+            cliVersion: this.clientVersion,
+            platform: process.platform,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          }]
+        })
+      });
+    } catch (e4) {
+    }
+  }
+  getStatus() {
+    return {
+      apiBaseUrl: this.apiBaseUrl,
+      environment: this.environment,
+      deviceId: this.deviceId,
+      platform: process.platform,
+      osVersion: _os2.default.release(),
+      evaluatedAt: _optionalChain([this, 'access', _21 => _21.snapshot, 'optionalAccess', _22 => _22.evaluatedAt]) || null
+    };
+  }
+}, _class);
+
+// src/commands/features.ts
+function renderUsage() {
+  return [
+    "Usage: /features [list|status|enable|disable|refresh]",
+    "",
+    "Commands:",
+    "  /features",
+    "  /features list",
+    "  /features status <feature>",
+    "  /features enable <feature>",
+    "  /features disable <feature>",
+    "  /features refresh"
+  ].join("\n");
+}
+function requireConfig(config) {
+  return _nullishCoalesce(config, () => ( "Config not available."));
+}
+async function setFeatureEnabled(config, featureId, enabled, remoteSnapshot) {
+  if (!featureId) {
+    return renderUsage();
+  }
+  const snapshot = remoteSnapshot === void 0 ? await loadRemoteFeatureFlags(config) : remoteSnapshot;
+  const result = _chunkHK5A54AVcjs.setFeatureState.call(void 0, config, featureId, enabled, { remoteSnapshot: snapshot });
+  if (!result.ok || !result.feature) {
+    return _nullishCoalesce(result.error, () => ( `Unknown feature "${featureId}".`));
+  }
+  await _chunkX5P6QQOBcjs.saveConfig.call(void 0, config);
+  if (result.feature.source === "remote") {
+    if (enabled) {
+      return `Following remote state for ${result.feature.id} (currently ${result.feature.enabled ? "on" : "off"}).`;
+    }
+    return `Disabled ${result.feature.id} locally. Remote state remains ${result.feature.remoteEnabled ? "on" : "off"}.`;
+  }
+  const action = enabled ? "Enabled" : "Disabled";
+  const restartNote = result.feature.requiresRestart ? " Restart Autohand for this to fully apply." : "";
+  return `${action} ${result.feature.id}.${restartNote}`;
+}
+async function showInteractiveFeatures(config, remoteSnapshot) {
+  let toggleCount = 0;
+  const pendingSaves = [];
+  const states = _chunkHK5A54AVcjs.listFeatureStates.call(void 0, config, { remoteSnapshot });
+  const initialStates = new Map(states.map((feature) => [feature.id, feature.enabled]));
+  const finalStates = new Map(initialStates);
+  const restartRequired = new Set(states.filter((feature) => feature.requiresRestart).map((feature) => feature.id));
+  const options = states.map((feature) => ({
+    label: `${feature.id.padEnd(26)} ${feature.source.padEnd(8)} ${feature.stage.padEnd(12)} ${feature.enabled ? "on" : "off"}`,
+    value: feature.id,
+    checked: feature.enabled,
+    description: feature.description
+  }));
+  await _chunkCK4HAHVYcjs.showModal.call(void 0, {
+    title: "Features - space toggles, enter closes",
+    options,
+    multiSelect: true,
+    maxVisible: 12,
+    onToggle: (option, checked) => {
+      const result = _chunkHK5A54AVcjs.setFeatureState.call(void 0, config, option.value, checked, { remoteSnapshot });
+      if (!result.ok) {
+        return;
+      }
+      toggleCount += 1;
+      finalStates.set(option.value, _nullishCoalesce(_optionalChain([result, 'access', _23 => _23.feature, 'optionalAccess', _24 => _24.enabled]), () => ( checked)));
+      pendingSaves.push(_chunkX5P6QQOBcjs.saveConfig.call(void 0, config));
+    }
+  });
+  await Promise.all(pendingSaves);
+  if (toggleCount === 0) {
+    return null;
+  }
+  const enabled = [];
+  const disabled = [];
+  for (const [featureId, initiallyEnabled] of initialStates) {
+    const finallyEnabled = finalStates.get(featureId);
+    if (finallyEnabled === initiallyEnabled || typeof finallyEnabled !== "boolean") {
+      continue;
+    }
+    if (finallyEnabled) {
+      enabled.push(featureId);
+    } else {
+      disabled.push(featureId);
+    }
+  }
+  return formatInteractiveFeatureSummary({
+    enabled,
+    disabled,
+    restartRequired: [...new Set([...enabled, ...disabled].filter((featureId) => restartRequired.has(featureId)))]
+  });
+}
+function formatChangedFeatures(action, featureIds) {
+  if (featureIds.length === 0) {
+    return null;
+  }
+  if (featureIds.length === 1) {
+    return `${action} ${featureIds[0]}.`;
+  }
+  return `${action} ${featureIds.length} features: ${featureIds.join(", ")}.`;
+}
+function formatInteractiveFeatureSummary(changes) {
+  const parts = [
+    formatChangedFeatures("Enabled", changes.enabled),
+    formatChangedFeatures("Disabled", changes.disabled)
+  ].filter((part) => Boolean(part));
+  if (changes.restartRequired.length > 0) {
+    parts.push(`Restart required for: ${changes.restartRequired.join(", ")}.`);
+  }
+  return parts.length > 0 ? parts.join(" ") : null;
+}
+async function features(ctx, args = []) {
+  const required = requireConfig(ctx.config);
+  if (typeof required === "string") {
+    return required;
+  }
+  const subcommand = (_nullishCoalesce(args[0], () => ( ""))).toLowerCase();
+  const featureId = args[1];
+  const forceRefresh = subcommand === "refresh";
+  const remoteSnapshot = await loadRemoteFeatureFlags(required, {
+    forceRefresh,
+    allowCachedFallback: !forceRefresh
+  });
+  switch (subcommand) {
+    case "":
+      return showInteractiveFeatures(required, remoteSnapshot);
+    case "list":
+    case "ls":
+      if (ctx.interactive) {
+        return showInteractiveFeatures(required, remoteSnapshot);
+      }
+      return _chunkHK5A54AVcjs.formatFeatureList.call(void 0, required, { remoteSnapshot });
+    case "status":
+    case "show":
+      return featureId ? _chunkHK5A54AVcjs.formatFeatureStatus.call(void 0, required, featureId, { remoteSnapshot }) : renderUsage();
+    case "enable":
+    case "on":
+      return setFeatureEnabled(required, featureId, true, remoteSnapshot);
+    case "disable":
+    case "off":
+      return setFeatureEnabled(required, featureId, false, remoteSnapshot);
+    case "refresh":
+      if (!remoteSnapshot) {
+        return "No remote feature flags available. Using local feature switches only.";
+      }
+      return `Downloaded ${remoteSnapshot.flags.length} remote feature${remoteSnapshot.flags.length === 1 ? "" : "s"} from ${remoteSnapshot.environment}.`;
+    default:
+      if (_chunkHK5A54AVcjs.getFeatureState.call(void 0, required, subcommand, { remoteSnapshot })) {
+        return _chunkHK5A54AVcjs.formatFeatureStatus.call(void 0, required, subcommand, { remoteSnapshot });
+      }
+      return renderUsage();
+  }
+}
+var metadata = {
+  command: "/features",
+  description: "list and toggle Autohand feature switches",
+  implemented: true,
+  subcommands: [
+    { name: "list", description: "List feature switches and current state" },
+    { name: "status", description: "Show one feature switch" },
+    { name: "enable", description: "Enable a feature switch" },
+    { name: "disable", description: "Disable a feature switch" },
+    { name: "refresh", description: "Download remote feature flags from the Autohand API" }
+  ]
+};
+
+
+
+
+
+
+exports.RemoteFeatureFlagManager = RemoteFeatureFlagManager; exports.setFeatureEnabled = setFeatureEnabled; exports.features = features; exports.metadata = metadata;
+/**
+ * @license
+ * Copyright 2026 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */