autohand-cli 0.8.3 → 0.9.1

package/dist/{chunk-C5IJIM2V.cjs → chunk-L46OUKW5.cjs}

@@ -1,9 +1,12 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 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 _chunkOLSBBZW6cjs = require('./chunk-OLSBBZW6.cjs');
+var _chunkS5JNQIGLcjs = require('./chunk-S5JNQIGL.cjs');
 
 
-var _chunk7BTSG4MEcjs = require('./chunk-7BTSG4ME.cjs');
+var _chunkCK4HAHVYcjs = require('./chunk-CK4HAHVY.cjs');
+
+
+var _chunkSY2P3Z5Wcjs = require('./chunk-SY2P3Z5W.cjs');
 
 // src/commands/hooks.ts
 var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
@@ -38,7 +41,15 @@ var HOOK_EVENTS = [
   "teammate-idle",
   "task-assigned",
   "task-completed",
-  "team-shutdown"
+  "team-shutdown",
+  // Review events
+  "review:start",
+  "review:end",
+  "review:paused",
+  "review:failed",
+  "review:completed",
+  // Mode events
+  "mode-change"
 ];
 var EVENT_DESCRIPTIONS = {
   "session-start": "When a session begins",
@@ -72,7 +83,20 @@ var EVENT_DESCRIPTIONS = {
   "teammate-idle": "When a teammate becomes idle",
   "task-assigned": "When a task is assigned to a teammate",
   "task-completed": "When a task is marked as done",
-  "team-shutdown": "When team cleanup completes"
+  "team-shutdown": "When team cleanup completes",
+  // Review events
+  "review:start": "When a code review begins",
+  "review:end": "When a code review session ends",
+  "review:paused": "When a code review is paused",
+  "review:failed": "When a code review encounters an error",
+  "review:completed": "When a code review finishes successfully",
+  // Mode events
+  "mode-change": "When permission mode changes (unrestricted, yolo, etc.)",
+  // Context lifecycle events
+  "context:compact": "When context is compacted (messages removed/summarized)",
+  "context:overflow": "When context overflow is detected (API 400 error)",
+  "context:warning": "When context usage crosses warning threshold (80%)",
+  "context:critical": "When context usage crosses critical threshold (90%+)"
 };
 var HOOK_ICONS = {
   // Script-based hooks
@@ -141,11 +165,11 @@ function getShortCommand(command) {
 }
 function displayHooksList(allHooks) {
   console.log();
-  console.log(_chalk2.default.bold.cyan(_chunk7BTSG4MEcjs.t.call(void 0, "commands.hooks.title")));
+  console.log(_chalk2.default.bold.cyan(_chunkSY2P3Z5Wcjs.t.call(void 0, "commands.hooks.title")));
   console.log(_chalk2.default.gray("  Lifecycle hooks run shell commands on events"));
   console.log();
   if (allHooks.length === 0) {
-    console.log(_chalk2.default.gray(`  ${_chunk7BTSG4MEcjs.t.call(void 0, "commands.hooks.noHooks")}`));
+    console.log(_chalk2.default.gray(`  ${_chunkSY2P3Z5Wcjs.t.call(void 0, "commands.hooks.noHooks")}`));
     console.log();
     return;
   }
@@ -168,7 +192,13 @@ function displayHooksList(allHooks) {
     "subagent-stop": "\u{1F916}",
     "permission-request": "\u{1F510}",
     "notification": "\u{1F514}",
-    "session-error": "\u274C"
+    "session-error": "\u274C",
+    // Review events
+    "review:start": "\u{1F50D}",
+    "review:end": "\u{1F4CB}",
+    "review:paused": "\u23F8\uFE0F",
+    "review:failed": "\u274C",
+    "review:completed": "\u2705"
   };
   for (const event of HOOK_EVENTS) {
     const eventHooks = hooksByEvent.get(event);
@@ -219,7 +249,7 @@ async function hooks(ctx) {
     const toggleLabel = settings.enabled !== false ? "\u25EF Disable all hooks" : "\u25CF Enable all hooks";
     choices.push({ name: "toggle_global", message: toggleLabel });
   }
-  const actionResult = await _chunkOLSBBZW6cjs.safePrompt.call(void 0, {
+  const actionResult = await _chunkS5JNQIGLcjs.safePrompt.call(void 0, {
     type: "select",
     name: "action",
     message: "Action",
@@ -245,32 +275,32 @@ async function hooks(ctx) {
   return null;
 }
 async function toggleHooksMulti(manager, allHooks) {
-  const choices = allHooks.map((h, i) => {
-    const eventTag = _chalk2.default.dim(`[${h.event}]`);
+  const options = allHooks.map((h, i) => {
+    const eventTag = `[${h.event}]`;
     const desc = h.description || getShortCommand(h.command);
     return {
-      name: String(i),
-      message: `${eventTag} ${desc}`,
+      label: `${eventTag} ${desc}`,
       value: String(i),
-      enabled: h.enabled !== false
+      checked: h.enabled !== false
     };
   });
-  const result = await _chunkOLSBBZW6cjs.safePrompt.call(void 0, {
-    type: "select",
-    name: "selected",
-    message: "Toggle hooks (select to enable/disable)",
-    choices,
-    initial: 0
+  let toggleCount = 0;
+  await _chunkCK4HAHVYcjs.showModal.call(void 0, {
+    title: "Toggle hooks \u2014 spacebar to enable/disable",
+    options,
+    multiSelect: true,
+    onToggle: async (option, _checked) => {
+      const idx = parseInt(option.value, 10);
+      const hook = allHooks[idx];
+      if (!hook) return;
+      const eventHooks = allHooks.filter((h) => h.event === hook.event);
+      const eventIndex = eventHooks.indexOf(hook);
+      await manager.toggleHook(hook.event, eventIndex);
+      toggleCount++;
+    }
   });
-  if (!result) return;
-  const selectedIndex = Number(result.selected);
-  const hook = allHooks[selectedIndex];
-  if (hook) {
-    const eventHooks = allHooks.filter((h) => h.event === hook.event);
-    const eventIndex = eventHooks.indexOf(hook);
-    await manager.toggleHook(hook.event, eventIndex);
-    const newState = hook.enabled === false ? "enabled" : "disabled";
-    console.log(_chalk2.default.green(`  \u2713 Hook ${newState}: ${hook.event}`));
+  if (toggleCount > 0) {
+    console.log(_chalk2.default.green(`  \u2713 Toggled ${toggleCount} hook${toggleCount > 1 ? "s" : ""}`));
   } else {
     console.log(_chalk2.default.gray("  No changes made"));
   }
@@ -281,26 +311,26 @@ async function addHook(manager) {
     name: e,
     message: `${e} ${_chalk2.default.dim(`- ${EVENT_DESCRIPTIONS[e]}`)}`
   }));
-  const eventResult = await _chunkOLSBBZW6cjs.safePrompt.call(void 0, {
+  const eventResult = await _chunkS5JNQIGLcjs.safePrompt.call(void 0, {
     type: "select",
     name: "event",
     message: "Event to hook into",
     choices: eventChoices
   });
   if (!eventResult) return;
-  const commandResult = await _chunkOLSBBZW6cjs.safePrompt.call(void 0, {
+  const commandResult = await _chunkS5JNQIGLcjs.safePrompt.call(void 0, {
     type: "input",
     name: "command",
     message: "Shell command to execute",
     validate: (val) => typeof val === "string" && val.trim().length > 0 || "Command is required"
   });
   if (!commandResult || !commandResult.command) return;
-  const descResult = await _chunkOLSBBZW6cjs.safePrompt.call(void 0, {
+  const descResult = await _chunkS5JNQIGLcjs.safePrompt.call(void 0, {
     type: "input",
     name: "description",
     message: "Description (optional)"
   });
-  const asyncResult = await _chunkOLSBBZW6cjs.safePrompt.call(void 0, {
+  const asyncResult = await _chunkS5JNQIGLcjs.safePrompt.call(void 0, {
     type: "confirm",
     name: "async",
     message: "Run asynchronously (non-blocking)?",
@@ -325,7 +355,7 @@ async function removeHook(manager, allHooks) {
       message: `${eventTag} ${desc2}`
     };
   });
-  const selectResult = await _chunkOLSBBZW6cjs.safePrompt.call(void 0, {
+  const selectResult = await _chunkS5JNQIGLcjs.safePrompt.call(void 0, {
     type: "select",
     name: "hookIndex",
     message: "Select hook to remove",
@@ -337,7 +367,7 @@ async function removeHook(manager, allHooks) {
   const eventHooks = allHooks.filter((h) => h.event === hook.event);
   const eventIndex = eventHooks.indexOf(hook);
   const desc = hook.description || getShortCommand(hook.command);
-  const confirmResult = await _chunkOLSBBZW6cjs.safePrompt.call(void 0, {
+  const confirmResult = await _chunkS5JNQIGLcjs.safePrompt.call(void 0, {
     type: "confirm",
     name: "confirm",
     message: `Remove "${desc}"?`,
@@ -360,7 +390,7 @@ async function testHook(manager, allHooks) {
       message: `${eventTag} ${desc}`
     };
   });
-  const selectResult = await _chunkOLSBBZW6cjs.safePrompt.call(void 0, {
+  const selectResult = await _chunkS5JNQIGLcjs.safePrompt.call(void 0, {
     type: "select",
     name: "hookIndex",
     message: "Select hook to test",
@@ -391,14 +421,15 @@ async function testHook(manager, allHooks) {
 }
 var metadata = {
   command: "/hooks",
-  description: _chunk7BTSG4MEcjs.t.call(void 0, "commands.hooks.description"),
+  description: _chunkSY2P3Z5Wcjs.t.call(void 0, "commands.hooks.description"),
   implemented: true
 };
 
 
 
 
-exports.hooks = hooks; exports.metadata = metadata;
+
+exports.HOOK_EVENTS = HOOK_EVENTS; exports.hooks = hooks; exports.metadata = metadata;
 /**
  * @license
  * Copyright 2025 Autohand AI LLC

package/dist/{chunk-6UJMCWRY.js → chunk-L6OH44HL.js}

@@ -7,6 +7,12 @@ var DEFAULT_MAX_RETRIES = 3;
 var DEFAULT_RETRY_DELAY = 1e3;
 var MAX_FILES_PER_REQUEST = 100;
 var SyncApiClient = class {
+  baseUrl;
+  timeout;
+  maxFileSize;
+  maxTotalSize;
+  maxRetries;
+  retryDelay;
   constructor(config) {
     this.baseUrl = config?.baseUrl || DEFAULT_BASE_URL;
     this.timeout = config?.timeout || DEFAULT_TIMEOUT;
@@ -109,8 +115,7 @@ var SyncApiClient = class {
             "Content-Type": "application/json"
           },
           body: JSON.stringify({
-            // Only include manifest on first batch
-            ...batchIndex === 0 ? { manifest } : {},
+            manifest,
             files: batch
           })
         }
@@ -130,18 +135,22 @@ var SyncApiClient = class {
   /**
    * Upload a file to a pre-signed URL
    */
-  async uploadFile(uploadUrl, content) {
+  async uploadFile(uploadUrl, content, token) {
     if (content.length > this.maxFileSize) {
       throw new Error(`File exceeds max size of ${this.maxFileSize} bytes`);
     }
+    const headers = {
+      "Content-Type": "application/octet-stream",
+      "Content-Length": content.length.toString()
+    };
+    if (token) {
+      headers.Authorization = `Bearer ${token}`;
+    }
     const response = await this.fetchWithRetry(
       uploadUrl,
       {
         method: "PUT",
-        headers: {
-          "Content-Type": "application/octet-stream",
-          "Content-Length": content.length.toString()
-        },
+        headers,
         body: new Uint8Array(content)
       }
     );
@@ -228,10 +237,11 @@ var SyncApiClient = class {
   /**
    * Download a file from a pre-signed URL
    */
-  async downloadFile(downloadUrl) {
+  async downloadFile(downloadUrl, token) {
+    const headers = token ? { Authorization: `Bearer ${token}` } : void 0;
     const response = await this.fetchWithRetry(
       downloadUrl,
-      { method: "GET" }
+      { method: "GET", ...headers ? { headers } : {} }
     );
     if (!response.ok) {
       throw new Error(`Download failed: ${response.status}`);

package/dist/chunk-LANGD5CO.js

@@ -0,0 +1,280 @@
+// src/features/featureRegistry.ts
+var AWS_BEDROCK_PROVIDER_FLAG = "aws_bedrock_provider";
+var FEATURE_REGISTRY = [
+  {
+    id: "mcp",
+    label: "MCP tools",
+    description: "Connect configured Model Context Protocol servers and expose their tools.",
+    stage: "stable",
+    configPath: "mcp.enabled",
+    defaultEnabled: true,
+    requiresRestart: true
+  },
+  {
+    id: "hooks",
+    label: "Lifecycle hooks",
+    description: "Run configured shell hooks around prompts, tools, sessions, and notifications.",
+    stage: "stable",
+    configPath: "hooks.enabled",
+    defaultEnabled: true
+  },
+  {
+    id: "teams",
+    label: "Agent teams",
+    description: "Enable multi-agent team coordination commands and teammate execution.",
+    stage: "experimental",
+    configPath: "teams.enabled",
+    defaultEnabled: true
+  },
+  {
+    id: "community_skills",
+    label: "Community skills",
+    description: "Enable discovery and use of community skill packs.",
+    stage: "stable",
+    configPath: "communitySkills.enabled",
+    defaultEnabled: true
+  },
+  {
+    id: "prompt_suggestions",
+    label: "Prompt suggestions",
+    description: "Show generated next-step suggestions in the interactive prompt placeholder.",
+    stage: "stable",
+    configPath: "ui.promptSuggestions",
+    defaultEnabled: true
+  },
+  {
+    id: "request_queue",
+    label: "Request queue",
+    description: "Allow typing follow-up requests while the agent is still working.",
+    stage: "stable",
+    configPath: "agent.enableRequestQueue",
+    defaultEnabled: true
+  },
+  {
+    id: "thinking_display",
+    label: "Thinking display",
+    description: "Show model thinking or reasoning blocks when the provider returns them.",
+    stage: "stable",
+    configPath: "ui.showThinking",
+    defaultEnabled: true
+  },
+  {
+    id: "completion_notifications",
+    label: "Completion notifications",
+    description: "Show desktop notifications when an agent turn completes.",
+    stage: "stable",
+    configPath: "ui.showCompletionNotification",
+    defaultEnabled: true
+  },
+  {
+    id: "terminal_bell",
+    label: "Terminal bell",
+    description: "Ring the terminal bell when work completes.",
+    stage: "stable",
+    configPath: "ui.terminalBell",
+    defaultEnabled: true
+  },
+  {
+    id: "tool_selection_cache",
+    label: "Tool selection cache",
+    description: "Cache local tool-schema selection for equivalent turns.",
+    stage: "stable",
+    configPath: "agent.toolSelectionCache",
+    defaultEnabled: true
+  },
+  {
+    id: "usage_v2",
+    label: "Usage v2",
+    description: "Show the v2 usage dashboard with model, provider, context, and limit details.",
+    stage: "experimental",
+    configPath: "features.usageV2",
+    defaultEnabled: false
+  },
+  {
+    id: AWS_BEDROCK_PROVIDER_FLAG,
+    label: "AWS Bedrock provider",
+    description: "Enable AWS Bedrock as a first-class model provider.",
+    stage: "experimental",
+    configPath: "features.awsBedrockProvider",
+    defaultEnabled: true,
+    requiresRestart: true
+  },
+  {
+    id: "slash_goal",
+    label: "Slash goal",
+    description: "Enable experimental persistent goals across /goal, --goal, tools, RPC, and ACP.",
+    stage: "experimental",
+    configPath: "features.slashGoal",
+    defaultEnabled: false
+  },
+  {
+    id: "chrome_integration",
+    label: "Chrome integration",
+    description: "Start the browser bridge by default for Chrome extension handoff.",
+    stage: "experimental",
+    configPath: "chrome.enabledByDefault",
+    defaultEnabled: false,
+    requiresRestart: true
+  },
+  {
+    id: "telemetry",
+    label: "Telemetry",
+    description: "Share anonymized product telemetry when explicitly enabled.",
+    stage: "stable",
+    configPath: "telemetry.enabled",
+    defaultEnabled: false
+  }
+];
+function isAwsBedrockProviderEnabled(config) {
+  const definition = FEATURE_REGISTRY.find((feature) => feature.id === AWS_BEDROCK_PROVIDER_FLAG);
+  return config?.features?.awsBedrockProvider ?? definition?.defaultEnabled ?? true;
+}
+var LOCAL_FEATURE_IDS = new Set(FEATURE_REGISTRY.map((feature) => feature.id));
+function isLocalFeatureId(id) {
+  return LOCAL_FEATURE_IDS.has(id);
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function getNestedValue(root, configPath) {
+  let current = root;
+  for (const part of configPath.split(".")) {
+    if (!isRecord(current)) {
+      return void 0;
+    }
+    current = current[part];
+  }
+  return current;
+}
+function setNestedValue(root, configPath, value) {
+  const parts = configPath.split(".");
+  let current = root;
+  for (const part of parts.slice(0, -1)) {
+    const existing = current[part];
+    if (!isRecord(existing)) {
+      current[part] = {};
+    }
+    current = current[part];
+  }
+  current[parts[parts.length - 1]] = value;
+}
+function getRemoteFeatureStates(config, options = {}) {
+  const remoteOverrides = config.features?.remoteOverrides || {};
+  const snapshot = options.remoteSnapshot;
+  if (!snapshot) return [];
+  return snapshot.flags.filter((flag) => !isLocalFeatureId(flag.key)).map((flag) => {
+    const localOverride = remoteOverrides[flag.key] === "off" ? "off" : void 0;
+    return {
+      id: flag.key,
+      label: flag.key,
+      description: `Remote feature flag (${flag.reason})`,
+      stage: "experimental",
+      defaultEnabled: false,
+      enabled: flag.enabled && localOverride !== "off",
+      source: "remote",
+      remoteEnabled: flag.enabled,
+      reason: flag.reason,
+      userOverridable: flag.userOverridable,
+      localOverride,
+      lastEvaluatedAt: snapshot.evaluatedAt
+    };
+  });
+}
+function getFeatureState(config, id, options = {}) {
+  const definition = FEATURE_REGISTRY.find((feature) => feature.id === id);
+  if (definition) {
+    const rawValue = definition.configPath ? getNestedValue(config, definition.configPath) : void 0;
+    return {
+      ...definition,
+      source: "local",
+      enabled: typeof rawValue === "boolean" ? rawValue : definition.defaultEnabled
+    };
+  }
+  return getRemoteFeatureStates(config, options).find((feature) => feature.id === id);
+}
+function listFeatureStates(config, options = {}) {
+  const local = FEATURE_REGISTRY.map((feature) => ({
+    ...feature,
+    source: "local",
+    enabled: getFeatureState(config, feature.id, options)?.enabled ?? feature.defaultEnabled
+  }));
+  return [...local, ...getRemoteFeatureStates(config, options)];
+}
+function setFeatureState(config, id, enabled, options = {}) {
+  const definition = FEATURE_REGISTRY.find((feature) => feature.id === id);
+  if (definition) {
+    if (!definition.configPath) {
+      return { ok: false, error: `Feature "${id}" cannot be changed locally.` };
+    }
+    setNestedValue(config, definition.configPath, enabled);
+    return {
+      ok: true,
+      feature: getFeatureState(config, id, options)
+    };
+  }
+  const remoteFeature = getRemoteFeatureStates(config, options).find((feature) => feature.id === id);
+  if (!remoteFeature) {
+    return { ok: false, error: `Unknown feature "${id}".` };
+  }
+  config.features ||= {};
+  config.features.remoteOverrides ||= {};
+  if (enabled) {
+    delete config.features.remoteOverrides[id];
+    return { ok: true, feature: getFeatureState(config, id, options) };
+  }
+  if (!remoteFeature.userOverridable) {
+    return { ok: false, error: `Feature "${id}" is controlled remotely and cannot be changed locally.` };
+  }
+  config.features.remoteOverrides[id] = "off";
+  return { ok: true, feature: getFeatureState(config, id, options) };
+}
+function formatFeatureList(config, options = {}) {
+  const states = listFeatureStates(config, options);
+  const idWidth = Math.max(...states.map((feature) => feature.id.length), "feature".length);
+  const sourceWidth = Math.max(...states.map((feature) => feature.source.length), "source".length);
+  const stageWidth = Math.max(...states.map((feature) => feature.stage.length), "stage".length);
+  return states.map((feature) => `${feature.id.padEnd(idWidth + 2)}${feature.source.padEnd(sourceWidth + 2)}${feature.stage.padEnd(stageWidth + 2)}${String(feature.enabled)}`).join("\n");
+}
+function formatFeatureStatus(config, id, options = {}) {
+  const feature = getFeatureState(config, id, options);
+  if (!feature) {
+    return `Unknown feature "${id}".`;
+  }
+  const restart = feature.requiresRestart ? "yes" : "no";
+  const lines = [
+    `${feature.id}`,
+    `Label: ${feature.label}`,
+    `Source: ${feature.source}`,
+    `Stage: ${feature.stage}`,
+    `Enabled: ${String(feature.enabled)}`,
+    `Config: ${feature.configPath || "remote"}`,
+    `Default: ${String(feature.defaultEnabled)}`,
+    `Restart required: ${restart}`,
+    `Description: ${feature.description}`
+  ];
+  if (feature.source === "remote") {
+    lines.push(
+      `Remote enabled: ${String(feature.remoteEnabled)}`,
+      `Local override: ${feature.localOverride || "none"}`,
+      `Reason: ${feature.reason || "unknown"}`,
+      `User overridable: ${String(feature.userOverridable !== false)}`,
+      `Last evaluated: ${feature.lastEvaluatedAt || "never"}`
+    );
+  }
+  return lines.join("\n");
+}
+
+export {
+  isAwsBedrockProviderEnabled,
+  isLocalFeatureId,
+  getFeatureState,
+  listFeatureStates,
+  setFeatureState,
+  formatFeatureList,
+  formatFeatureStatus
+};
+/**
+ * @license
+ * Copyright 2026 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */