autohand-cli 0.9.1 → 0.9.2

package/dist/chunk-ZHMYTI5D.cjs

@@ -0,0 +1,529 @@
+"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; }// src/commands/squad.ts
+var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
+var _crypto = require('crypto');
+var _child_process = require('child_process');
+var _fs = require('fs');
+var _promises = require('fs/promises');
+var _os = require('os');
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+var DEFAULT_API_BASE_URL = "https://api.autohand.ai";
+var DEFAULT_CHANNEL = "stable";
+var SQUAD_FEATURE_FLAG = "squad_daemon";
+var REQUIRED_BINARIES = ["squad", "autohand-squad-daemon", "autohand-squad-analytics", "autohand-squad-tray", "autohand-squad-ui"];
+var START_ACTIONS = /* @__PURE__ */ new Set(["start", "open", "restart"]);
+var metadata = {
+  command: "/squad",
+  description: "open and manage the local Autohand Squad runtime",
+  implemented: true
+};
+async function squad(ctx, args = [], deps = {}) {
+  const result = await runSquadCommand(ctx, args, deps);
+  return result.output;
+}
+async function runSquadCommand(ctx, args = [], deps = {}) {
+  const parsed = parseSquadCommand(args);
+  const env = _nullishCoalesce(deps.env, () => ( process.env));
+  const paths = squadPaths(env, deps.homeDir);
+  let runtimeEntitlement;
+  if (START_ACTIONS.has(parsed.action)) {
+    const entitlement = await evaluateSquadEntitlement(ctx.config, deps);
+    if (!entitlement.ok) {
+      return {
+        code: 1,
+        output: _nullishCoalesce(entitlement.message, () => ( _chalk2.default.red("Autohand Squad is not available for this account.")))
+      };
+    }
+    runtimeEntitlement = entitlement;
+    const install = await ensureSquadRuntime(paths, entitlement, deps);
+    if (install.code !== 0) {
+      return install;
+    }
+    await writeRuntimeConfig(paths, ctx.config, entitlement, env);
+  } else if (!hasLocalRuntime(paths)) {
+    return {
+      code: 1,
+      output: [
+        _chalk2.default.yellow("Autohand Squad runtime is not installed."),
+        _chalk2.default.gray("Run `autohand squad` to install and start it after entitlement is verified.")
+      ].join("\n")
+    };
+  }
+  const binary = resolveSquadBinary(paths, env);
+  if (!binary) {
+    return {
+      code: 1,
+      output: _chalk2.default.red(`Squad launcher was not found under ${paths.binDir}.`)
+    };
+  }
+  const runtimeArgs = buildRuntimeArgs(parsed, ctx.workspaceRoot, ctx.config, env, runtimeEntitlement);
+  const runtimeEnv = buildRuntimeEnv(ctx.config, env, runtimeEntitlement);
+  return runRuntime(binary, runtimeArgs, deps, runtimeEnv);
+}
+function parseSquadCommand(args) {
+  const first = _optionalChain([args, 'access', _ => _[0], 'optionalAccess', _2 => _2.toLowerCase, 'call', _3 => _3()]);
+  if (isSquadAction(first)) {
+    return { action: first, passthroughArgs: args.slice(1) };
+  }
+  const openBrowser = !args.includes("--no-open");
+  return {
+    action: openBrowser ? "open" : "start",
+    passthroughArgs: args
+  };
+}
+function isSquadAction(value) {
+  return value === "start" || value === "status" || value === "restart" || value === "stop" || value === "queue" || value === "open" || value === "config";
+}
+function buildRuntimeArgs(parsed, workspaceRoot, config, env, entitlement) {
+  const passthroughArgs = parsed.passthroughArgs.filter((arg) => arg !== "--no-open");
+  const args = [parsed.action, ...passthroughArgs];
+  if ((parsed.action === "open" || parsed.action === "start") && !hasOption(passthroughArgs, "--open-url")) {
+    args.push("--open-url", buildOpenUrl(workspaceRoot, passthroughArgs));
+  }
+  pushOption(args, passthroughArgs, "--api-base-url", apiBaseUrlFromConfig(config, env));
+  pushOption(args, passthroughArgs, "--update-channel", _optionalChain([entitlement, 'optionalAccess', _4 => _4.updateChannel]) || env.AUTOHAND_SQUAD_UPDATE_CHANNEL || DEFAULT_CHANNEL);
+  pushOptionalOption(args, passthroughArgs, "--account-email", _optionalChain([entitlement, 'optionalAccess', _5 => _5.accountEmail]) || _optionalChain([config, 'optionalAccess', _6 => _6.auth, 'optionalAccess', _7 => _7.user, 'optionalAccess', _8 => _8.email]) || env.AUTOHAND_SQUAD_ACCOUNT_EMAIL);
+  pushOptionalOption(args, passthroughArgs, "--plan-state", _optionalChain([entitlement, 'optionalAccess', _9 => _9.planState]) || env.AUTOHAND_SQUAD_PLAN_STATE);
+  pushOption(args, passthroughArgs, "--telemetry-policy", _optionalChain([entitlement, 'optionalAccess', _10 => _10.telemetryPolicy]) || telemetryPolicyFromConfig(config, env));
+  return args;
+}
+function buildOpenUrl(workspaceRoot, args) {
+  const { host, port } = readHostPortArgs(args);
+  const url = new URL(`http://${host}:${port}/conversations/new`);
+  url.searchParams.set("workspace", workspaceRoot);
+  return url.toString();
+}
+function readHostPortArgs(args) {
+  let host = "127.0.0.1";
+  let port = "19821";
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--host" && args[index + 1]) {
+      host = args[index + 1];
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--host=")) {
+      host = arg.slice("--host=".length);
+      continue;
+    }
+    if (arg === "--port" && args[index + 1]) {
+      port = args[index + 1];
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--port=")) {
+      port = arg.slice("--port=".length);
+    }
+  }
+  return { host, port };
+}
+function hasOption(args, name) {
+  return args.some((arg) => arg === name || arg.startsWith(`${name}=`));
+}
+function pushOption(args, passthroughArgs, name, value) {
+  if (!hasOption(passthroughArgs, name)) {
+    args.push(name, value);
+  }
+}
+function pushOptionalOption(args, passthroughArgs, name, value) {
+  if (value && !hasOption(passthroughArgs, name)) {
+    args.push(name, value);
+  }
+}
+async function evaluateSquadEntitlement(config, deps) {
+  const token = _optionalChain([config, 'optionalAccess', _11 => _11.auth, 'optionalAccess', _12 => _12.token]);
+  if (!token) {
+    return {
+      ok: false,
+      updateChannel: DEFAULT_CHANNEL,
+      message: [
+        _chalk2.default.yellow("Sign in to Autohand before starting Squad."),
+        _chalk2.default.gray("Run `autohand login`, then try `autohand squad` again.")
+      ].join("\n")
+    };
+  }
+  const env = _nullishCoalesce(deps.env, () => ( process.env));
+  const apiBaseUrl = apiBaseUrlFromConfig(config, env);
+  const updateChannel = env.AUTOHAND_SQUAD_UPDATE_CHANNEL || DEFAULT_CHANNEL;
+  const fetchImpl = _nullishCoalesce(deps.fetchImpl, () => ( fetch));
+  try {
+    const response = await fetchImpl(`${apiBaseUrl}/v1/squad/entitlement`, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/json"
+      }
+    });
+    const payload = await response.json();
+    if (!response.ok || payload.success === false) {
+      return {
+        ok: false,
+        updateChannel,
+        message: entitlementMessage(payload, "Unable to verify Squad entitlement.")
+      };
+    }
+    const hasPlan = Boolean(
+      _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(payload.activePlan, () => ( payload.planActive)), () => ( payload.hasSquadPlan)), () => ( payload.plan === "squad"))
+    );
+    if (!hasPlan) {
+      return {
+        ok: false,
+        updateChannel,
+        message: [
+          _chalk2.default.yellow("Autohand Squad is not active on this account."),
+          _chalk2.default.gray("Upgrade to an active Squad plan before installing the local daemon.")
+        ].join("\n")
+      };
+    }
+    const flagEnabled = Boolean(
+      _nullishCoalesce(_nullishCoalesce(payload.featureEnabled, () => ( payload.squadDaemonEnabled)), () => ( readNestedFlag(payload, SQUAD_FEATURE_FLAG)))
+    );
+    if (!flagEnabled) {
+      return {
+        ok: false,
+        updateChannel,
+        message: [
+          _chalk2.default.yellow("Autohand Squad daemon is not enabled for this account yet."),
+          _chalk2.default.gray(`Feature flag required: ${SQUAD_FEATURE_FLAG}`)
+        ].join("\n")
+      };
+    }
+    return {
+      ok: true,
+      updateChannel: stringField(payload.updateChannel) || updateChannel,
+      latestAllowedVersion: stringField(payload.latestAllowedVersion) || stringField(payload.latest_allowed_version),
+      manifestUrl: stringField(payload.releaseManifestUrl) || stringField(payload.manifestUrl),
+      accountEmail: stringField(payload.accountEmail) || stringField(payload.email) || _optionalChain([config, 'access', _13 => _13.auth, 'optionalAccess', _14 => _14.user, 'optionalAccess', _15 => _15.email]),
+      planState: stringField(payload.planState) || stringField(payload.plan) || stringField(payload.plan_state),
+      telemetryPolicy: stringField(payload.telemetryPolicy) || stringField(payload.telemetry_policy)
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      updateChannel,
+      message: [
+        _chalk2.default.red("Unable to verify Squad entitlement."),
+        _chalk2.default.gray(error.message)
+      ].join("\n")
+    };
+  }
+}
+async function ensureSquadRuntime(paths, entitlement, deps) {
+  if (hasLocalRuntime(paths) && await isLatestAllowed(paths, entitlement.latestAllowedVersion)) {
+    return { code: 0, output: "" };
+  }
+  const manifest = await fetchReleaseManifest(entitlement, deps);
+  if (!manifest.ok) return manifest;
+  const version = manifestVersion(manifest.value, entitlement);
+  const artifacts = selectRequiredArtifacts(manifest.value);
+  if (!artifacts.ok) return artifacts;
+  const installed = [];
+  await _promises.mkdir.call(void 0, paths.binDir, { recursive: true });
+  for (const artifact of artifacts.value) {
+    const binaryName = artifactBinaryName(artifact);
+    const artifactResult = await downloadArtifact(artifact, deps);
+    if (!artifactResult.ok) return artifactResult;
+    const targetPath = _path2.default.join(paths.binDir, binaryFileName(binaryName));
+    await _promises.writeFile.call(void 0, targetPath, artifactResult.bytes);
+    await _promises.chmod.call(void 0, targetPath, 493);
+    installed.push({
+      binaryName,
+      url: _nullishCoalesce(artifact.url, () => ( "")),
+      sha256: _nullishCoalesce(artifact.sha256, () => ( ""))
+    });
+  }
+  await writeInstallRecord(paths.installJson, {
+    version,
+    channel: manifest.value.channel || entitlement.updateChannel,
+    installedAt: (_nullishCoalesce(_optionalChain([deps, 'access', _16 => _16.now, 'optionalCall', _17 => _17()]), () => ( /* @__PURE__ */ new Date()))).toISOString(),
+    artifacts: installed
+  });
+  return { code: 0, output: "" };
+}
+async function writeRuntimeConfig(paths, config, entitlement, env) {
+  const runtimeConfig = {
+    apiBaseUrl: apiBaseUrlFromConfig(config, env),
+    updateChannel: entitlement.updateChannel,
+    accountEmail: entitlement.accountEmail || _optionalChain([config, 'optionalAccess', _18 => _18.auth, 'optionalAccess', _19 => _19.user, 'optionalAccess', _20 => _20.email]) || env.AUTOHAND_SQUAD_ACCOUNT_EMAIL,
+    planState: entitlement.planState || env.AUTOHAND_SQUAD_PLAN_STATE,
+    telemetryPolicy: entitlement.telemetryPolicy || telemetryPolicyFromConfig(config, env),
+    openUrl: env.AUTOHAND_SQUAD_OPEN_URL,
+    hostedUiUrl: env.AUTOHAND_SQUAD_HOSTED_UI_URL,
+    proxyUrl: env.AUTOHAND_SQUAD_PROXY_URL,
+    apiGatewayUrl: env.AUTOHAND_SQUAD_API_GATEWAY_URL,
+    fixedPort: numberFromEnv(env.AUTOHAND_SQUAD_FIXED_PORT)
+  };
+  await _promises.mkdir.call(void 0, _path2.default.dirname(paths.configJson), { recursive: true });
+  await _promises.writeFile.call(void 0, paths.configJson, `${JSON.stringify(stripUndefined(runtimeConfig), null, 2)}
+`, { mode: 384 });
+}
+async function fetchReleaseManifest(entitlement, deps) {
+  const env = _nullishCoalesce(deps.env, () => ( process.env));
+  const apiBaseUrl = env.AUTOHAND_SQUAD_API_BASE_URL || env.AUTOHAND_API_URL || DEFAULT_API_BASE_URL;
+  const manifestUrl = entitlement.manifestUrl || `${apiBaseUrl.replace(/\/+$/, "")}/v1/squad/releases/${entitlement.updateChannel}/manifest`;
+  try {
+    const response = await (_nullishCoalesce(deps.fetchImpl, () => ( fetch)))(manifestUrl, {
+      headers: { Accept: "application/json" }
+    });
+    const payload = await response.json();
+    if (!response.ok) {
+      return {
+        ok: false,
+        code: 1,
+        output: _chalk2.default.red(`Failed to fetch Squad release manifest: HTTP ${response.status}`)
+      };
+    }
+    return { ok: true, value: payload };
+  } catch (error) {
+    return {
+      ok: false,
+      code: 1,
+      output: [
+        _chalk2.default.red("Failed to fetch Squad release manifest."),
+        _chalk2.default.gray(error.message)
+      ].join("\n")
+    };
+  }
+}
+function selectRequiredArtifacts(manifest) {
+  const artifacts = _nullishCoalesce(manifest.artifacts, () => ( []));
+  const selected = REQUIRED_BINARIES.map((binaryName) => {
+    return artifacts.find((artifact) => {
+      return targetOsMatches(artifact.os) && targetArchMatches(artifact.arch) && artifactBinaryName(artifact) === binaryName;
+    });
+  });
+  if (selected.some((artifact) => !artifact)) {
+    return {
+      ok: false,
+      code: 1,
+      output: [
+        _chalk2.default.red("Squad release manifest does not contain binaries for this OS/arch."),
+        _chalk2.default.gray(`Need: ${REQUIRED_BINARIES.join(", ")} for ${targetOs()}/${targetArch()}`)
+      ].join("\n")
+    };
+  }
+  return { ok: true, value: selected };
+}
+async function downloadArtifact(artifact, deps) {
+  if (!artifact.url || !artifact.sha256) {
+    return { ok: false, code: 1, output: _chalk2.default.red("Invalid Squad artifact manifest entry.") };
+  }
+  try {
+    const response = await (_nullishCoalesce(deps.fetchImpl, () => ( fetch)))(artifact.url);
+    if (!response.ok) {
+      return { ok: false, code: 1, output: _chalk2.default.red(`Failed to download Squad artifact: HTTP ${response.status}`) };
+    }
+    const bytes = Buffer.from(await response.arrayBuffer());
+    const actual = _crypto.createHash.call(void 0, "sha256").update(bytes).digest("hex");
+    if (actual.toLowerCase() !== artifact.sha256.toLowerCase()) {
+      return {
+        ok: false,
+        code: 1,
+        output: _chalk2.default.red(`Checksum mismatch for ${artifactBinaryName(artifact)}.`)
+      };
+    }
+    const signatureError = verifyArtifactSignature(artifact);
+    if (signatureError) {
+      return { ok: false, code: 1, output: _chalk2.default.red(signatureError) };
+    }
+    return { ok: true, bytes };
+  } catch (error) {
+    return {
+      ok: false,
+      code: 1,
+      output: [
+        _chalk2.default.red(`Failed to download ${artifactBinaryName(artifact)}.`),
+        _chalk2.default.gray(error.message)
+      ].join("\n")
+    };
+  }
+}
+function verifyArtifactSignature(artifact) {
+  const signature = artifact.signature;
+  if (!signature) return null;
+  const publicKey = _nullishCoalesce(artifact.publicKey, () => ( artifact.public_key));
+  if (!publicKey) {
+    return `Artifact ${artifactBinaryName(artifact)} is signed but no public key was provided.`;
+  }
+  try {
+    const rawPublicKey = Buffer.from(publicKey, "base64");
+    const spkiPrefix = Buffer.from("302a300506032b6570032100", "hex");
+    const key = _crypto.createPublicKey.call(void 0, {
+      key: Buffer.concat([spkiPrefix, rawPublicKey]),
+      format: "der",
+      type: "spki"
+    });
+    const ok = _crypto.verify.call(void 0, 
+      null,
+      Buffer.from(_nullishCoalesce(artifact.sha256, () => ( ""))),
+      key,
+      Buffer.from(signature, "base64")
+    );
+    return ok ? null : `Signature verification failed for ${artifactBinaryName(artifact)}.`;
+  } catch (error) {
+    return `Signature verification failed for ${artifactBinaryName(artifact)}: ${error.message}`;
+  }
+}
+function runRuntime(binary, args, deps, runtimeEnv) {
+  const spawnProcess = _nullishCoalesce(deps.spawnProcess, () => ( _child_process.spawn));
+  return new Promise((resolve) => {
+    const child = spawnProcess(binary, args, {
+      env: { ...process.env, ..._nullishCoalesce(deps.env, () => ( {})), ...runtimeEnv },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    _optionalChain([child, 'access', _21 => _21.stdout, 'optionalAccess', _22 => _22.on, 'call', _23 => _23("data", (chunk) => {
+      stdout += String(chunk);
+    })]);
+    _optionalChain([child, 'access', _24 => _24.stderr, 'optionalAccess', _25 => _25.on, 'call', _26 => _26("data", (chunk) => {
+      stderr += String(chunk);
+    })]);
+    child.on("error", (error) => {
+      resolve({ code: 1, output: _chalk2.default.red(error.message) });
+    });
+    child.on("close", (code) => {
+      resolve({
+        code: _nullishCoalesce(code, () => ( 0)),
+        output: [stdout.trimEnd(), stderr.trimEnd()].filter(Boolean).join("\n")
+      });
+    });
+  });
+}
+function hasLocalRuntime(paths) {
+  return REQUIRED_BINARIES.every((binaryName) => _fs.existsSync.call(void 0, _path2.default.join(paths.binDir, binaryFileName(binaryName))));
+}
+async function isLatestAllowed(paths, latestAllowedVersion) {
+  if (!latestAllowedVersion) return true;
+  try {
+    const record = JSON.parse(await _promises.readFile.call(void 0, paths.installJson, "utf8"));
+    return record.version === latestAllowedVersion;
+  } catch (e) {
+    return false;
+  }
+}
+function resolveSquadBinary(paths, env) {
+  const explicit = env.AUTOHAND_SQUAD_BIN;
+  if (explicit && _fs.existsSync.call(void 0, explicit)) return explicit;
+  const installed = _path2.default.join(paths.binDir, binaryFileName("squad"));
+  if (_fs.existsSync.call(void 0, installed)) return installed;
+  return findOnPath(binaryFileName("squad"), env.PATH);
+}
+function findOnPath(binaryName, pathValue) {
+  for (const entry of (_nullishCoalesce(pathValue, () => ( ""))).split(_path2.default.delimiter)) {
+    if (!entry) continue;
+    const candidate = _path2.default.join(entry, binaryName);
+    if (_fs.existsSync.call(void 0, candidate)) return candidate;
+  }
+  return null;
+}
+function squadPaths(env, homeDir = _os.homedir.call(void 0, )) {
+  const root = env.AUTOHAND_SQUAD_HOME || _path2.default.join(env.AUTOHAND_HOME || _path2.default.join(homeDir, ".autohand"), "squad");
+  return {
+    root,
+    binDir: _path2.default.join(root, "bin"),
+    configJson: _path2.default.join(root, "config.json"),
+    installJson: _path2.default.join(root, "install.json")
+  };
+}
+async function writeInstallRecord(filePath, record) {
+  await _promises.mkdir.call(void 0, _path2.default.dirname(filePath), { recursive: true });
+  await _promises.writeFile.call(void 0, filePath, `${JSON.stringify(record, null, 2)}
+`);
+}
+function manifestVersion(manifest, entitlement) {
+  return manifest.latestAllowedVersion || manifest.latest_allowed_version || manifest.version || entitlement.latestAllowedVersion || "0.0.0";
+}
+function artifactBinaryName(artifact) {
+  const value = artifact.binaryName || artifact.binary_name || "autohand-squad-daemon";
+  return isRequiredBinary(value) ? value : "autohand-squad-daemon";
+}
+function isRequiredBinary(value) {
+  return REQUIRED_BINARIES.includes(value);
+}
+function binaryFileName(binaryName) {
+  return process.platform === "win32" ? `${binaryName}.exe` : binaryName;
+}
+function targetOs() {
+  return _os.platform.call(void 0, );
+}
+function targetArch() {
+  return _os.arch.call(void 0, );
+}
+function targetOsMatches(value) {
+  return value === targetOs();
+}
+function targetArchMatches(value) {
+  const arch = targetArch();
+  return value === arch || arch === "x64" && value === "x86_64" || arch === "arm64" && value === "aarch64";
+}
+function apiBaseUrlFromConfig(config, env) {
+  const configApi = config ? _optionalChain([config, 'access', _27 => _27.api, 'optionalAccess', _28 => _28.baseUrl]) : void 0;
+  return (env.AUTOHAND_SQUAD_API_BASE_URL || env.AUTOHAND_API_URL || configApi || _optionalChain([config, 'optionalAccess', _29 => _29.telemetry, 'optionalAccess', _30 => _30.apiBaseUrl]) || DEFAULT_API_BASE_URL).replace(/\/+$/, "");
+}
+function buildRuntimeEnv(config, env, entitlement) {
+  return stripUndefined({
+    AUTOHAND_SQUAD_API_BASE_URL: apiBaseUrlFromConfig(config, env),
+    AUTOHAND_SQUAD_UPDATE_CHANNEL: _optionalChain([entitlement, 'optionalAccess', _31 => _31.updateChannel]) || env.AUTOHAND_SQUAD_UPDATE_CHANNEL || DEFAULT_CHANNEL,
+    AUTOHAND_SQUAD_ACCOUNT_EMAIL: _optionalChain([entitlement, 'optionalAccess', _32 => _32.accountEmail]) || _optionalChain([config, 'optionalAccess', _33 => _33.auth, 'optionalAccess', _34 => _34.user, 'optionalAccess', _35 => _35.email]) || env.AUTOHAND_SQUAD_ACCOUNT_EMAIL,
+    AUTOHAND_SQUAD_PLAN_STATE: _optionalChain([entitlement, 'optionalAccess', _36 => _36.planState]) || env.AUTOHAND_SQUAD_PLAN_STATE,
+    AUTOHAND_SQUAD_TELEMETRY_POLICY: _optionalChain([entitlement, 'optionalAccess', _37 => _37.telemetryPolicy]) || telemetryPolicyFromConfig(config, env),
+    AUTOHAND_SQUAD_API_AUTH_TOKEN: _optionalChain([config, 'optionalAccess', _38 => _38.auth, 'optionalAccess', _39 => _39.token]) || env.AUTOHAND_SQUAD_API_AUTH_TOKEN || env.AUTOHAND_SQUAD_AUTH_TOKEN || env.AUTOHAND_TOKEN,
+    AUTOHAND_SQUAD_COMPANY_SECRET: env.AUTOHAND_SQUAD_COMPANY_SECRET || _optionalChain([config, 'optionalAccess', _40 => _40.api, 'optionalAccess', _41 => _41.companySecret]) || _optionalChain([config, 'optionalAccess', _42 => _42.telemetry, 'optionalAccess', _43 => _43.companySecret]) || env.AUTOHAND_SECRET
+  });
+}
+function telemetryPolicyFromConfig(config, env) {
+  if (env.AUTOHAND_SQUAD_TELEMETRY_POLICY) return env.AUTOHAND_SQUAD_TELEMETRY_POLICY;
+  return _optionalChain([config, 'optionalAccess', _44 => _44.telemetry, 'optionalAccess', _45 => _45.enabled]) === false ? "disabled" : "local-buffered";
+}
+function numberFromEnv(value) {
+  if (!value) return void 0;
+  const parsed = Number(value);
+  return Number.isInteger(parsed) && parsed > 0 && parsed <= 65535 ? parsed : void 0;
+}
+function stripUndefined(input) {
+  return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== void 0));
+}
+function entitlementMessage(payload, fallback) {
+  const message = stringField(payload.message) || stringField(payload.error) || fallback;
+  return [_chalk2.default.red(message), _chalk2.default.gray("Squad was not installed.")].join("\n");
+}
+function readNestedFlag(payload, flag) {
+  const featureFlags = payload.featureFlags;
+  if (featureFlags && typeof featureFlags === "object" && !Array.isArray(featureFlags)) {
+    return featureFlags[flag];
+  }
+  const flags = payload.flags;
+  if (flags && typeof flags === "object" && !Array.isArray(flags)) {
+    return flags[flag];
+  }
+  if (Array.isArray(flags)) {
+    return flags.some((entry) => {
+      return Boolean(entry) && typeof entry === "object" && entry.key === flag && entry.enabled === true;
+    });
+  }
+  return void 0;
+}
+function stringField(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+async function pathIsExecutable(filePath) {
+  try {
+    await _promises.access.call(void 0, filePath, _fs.constants.X_OK);
+    return true;
+  } catch (e2) {
+    return false;
+  }
+}
+
+
+
+
+
+
+
+exports.metadata = metadata; exports.squad = squad; exports.runSquadCommand = runSquadCommand; exports.parseSquadCommand = parseSquadCommand; exports.pathIsExecutable = pathIsExecutable;
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/{chunk-4567QNRB.js → chunk-ZLR2TFBC.js}

@@ -408,6 +408,9 @@ var NVIDIAProvider = class {
   getName() {
     return "nvidia";
   }
+  getCapabilities() {
+    return { nativeToolCalling: true };
+  }
   setModel(model) {
     this.model = model;
     this.client.setDefaultModel(model);