autohand-cli 0.9.0 → 0.9.1

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

@@ -1,12 +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 _chunk7MU7LWF3cjs = require('./chunk-7MU7LWF3.cjs');
+var _chunkS5JNQIGLcjs = require('./chunk-S5JNQIGL.cjs');
 
 
-var _chunkCH2J4PVEcjs = require('./chunk-CH2J4PVE.cjs');
+var _chunkCK4HAHVYcjs = require('./chunk-CK4HAHVY.cjs');
 
 
-var _chunkCHI52KFRcjs = require('./chunk-CHI52KFR.cjs');
+var _chunkSY2P3Z5Wcjs = require('./chunk-SY2P3Z5W.cjs');
 
 // src/commands/hooks.ts
 var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
@@ -165,11 +165,11 @@ function getShortCommand(command) {
 }
 function displayHooksList(allHooks) {
   console.log();
-  console.log(_chalk2.default.bold.cyan(_chunkCHI52KFRcjs.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(`  ${_chunkCHI52KFRcjs.t.call(void 0, "commands.hooks.noHooks")}`));
+    console.log(_chalk2.default.gray(`  ${_chunkSY2P3Z5Wcjs.t.call(void 0, "commands.hooks.noHooks")}`));
     console.log();
     return;
   }
@@ -249,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 _chunk7MU7LWF3cjs.safePrompt.call(void 0, {
+  const actionResult = await _chunkS5JNQIGLcjs.safePrompt.call(void 0, {
     type: "select",
     name: "action",
     message: "Action",
@@ -285,7 +285,7 @@ async function toggleHooksMulti(manager, allHooks) {
     };
   });
   let toggleCount = 0;
-  await _chunkCH2J4PVEcjs.showModal.call(void 0, {
+  await _chunkCK4HAHVYcjs.showModal.call(void 0, {
     title: "Toggle hooks \u2014 spacebar to enable/disable",
     options,
     multiSelect: true,
@@ -311,26 +311,26 @@ async function addHook(manager) {
     name: e,
     message: `${e} ${_chalk2.default.dim(`- ${EVENT_DESCRIPTIONS[e]}`)}`
   }));
-  const eventResult = await _chunk7MU7LWF3cjs.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 _chunk7MU7LWF3cjs.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 _chunk7MU7LWF3cjs.safePrompt.call(void 0, {
+  const descResult = await _chunkS5JNQIGLcjs.safePrompt.call(void 0, {
     type: "input",
     name: "description",
     message: "Description (optional)"
   });
-  const asyncResult = await _chunk7MU7LWF3cjs.safePrompt.call(void 0, {
+  const asyncResult = await _chunkS5JNQIGLcjs.safePrompt.call(void 0, {
     type: "confirm",
     name: "async",
     message: "Run asynchronously (non-blocking)?",
@@ -355,7 +355,7 @@ async function removeHook(manager, allHooks) {
       message: `${eventTag} ${desc2}`
     };
   });
-  const selectResult = await _chunk7MU7LWF3cjs.safePrompt.call(void 0, {
+  const selectResult = await _chunkS5JNQIGLcjs.safePrompt.call(void 0, {
     type: "select",
     name: "hookIndex",
     message: "Select hook to remove",
@@ -367,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 _chunk7MU7LWF3cjs.safePrompt.call(void 0, {
+  const confirmResult = await _chunkS5JNQIGLcjs.safePrompt.call(void 0, {
     type: "confirm",
     name: "confirm",
     message: `Remove "${desc}"?`,
@@ -390,7 +390,7 @@ async function testHook(manager, allHooks) {
       message: `${eventTag} ${desc}`
     };
   });
-  const selectResult = await _chunk7MU7LWF3cjs.safePrompt.call(void 0, {
+  const selectResult = await _chunkS5JNQIGLcjs.safePrompt.call(void 0, {
     type: "select",
     name: "hookIndex",
     message: "Select hook to test",
@@ -421,7 +421,7 @@ async function testHook(manager, allHooks) {
 }
 var metadata = {
   command: "/hooks",
-  description: _chunkCHI52KFRcjs.t.call(void 0, "commands.hooks.description"),
+  description: _chunkSY2P3Z5Wcjs.t.call(void 0, "commands.hooks.description"),
   implemented: true
 };
 

package/dist/{chunk-Z4LIPMPM.js → chunk-L6OH44HL.js}

@@ -115,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
           })
         }
@@ -136,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)
       }
     );
@@ -234,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
+ */