@autohq/cli 0.1.100 → 0.1.102

package/dist/agent-bridge.js

@@ -21815,13 +21815,14 @@ var ProjectApplyResourceSchema = external_exports.discriminatedUnion("kind", [
   ToolApplyDocumentSchema,
   SessionApplyDocumentSchema
 ]);
+var PROJECT_RESOURCE_KINDS = [
+  RESOURCE_KIND_ENVIRONMENT,
+  RESOURCE_KIND_PROFILE,
+  RESOURCE_KIND_TOOL,
+  RESOURCE_KIND_SESSION
+];
 var ProjectDeleteResourceSchema = external_exports.object({
-  kind: external_exports.enum([
-    RESOURCE_KIND_ENVIRONMENT,
-    RESOURCE_KIND_PROFILE,
-    RESOURCE_KIND_TOOL,
-    RESOURCE_KIND_SESSION
-  ]),
+  kind: external_exports.enum(PROJECT_RESOURCE_KINDS),
   name: external_exports.string().trim().min(1)
 });
 var AVATAR_ASSET_CONTENT_TYPES = ["image/png", "image/jpeg"];

package/dist/index.js

@@ -17628,7 +17628,7 @@ var init_sessions = __esm({
 });
 
 // ../../packages/schemas/src/project-resources.ts
-var EnvironmentApplyDocumentSchema, ProfileApplyDocumentSchema, ToolApplyDocumentSchema, SessionApplyDocumentSchema, ProjectApplyResourceSchema, ProjectDeleteResourceSchema, AVATAR_ASSET_CONTENT_TYPES, MAX_AVATAR_ASSET_BASE64_LENGTH, ProjectApplyAssetSchema, ProjectApplyAssetsSchema, ProjectApplyRequestSchema, ProjectApplySystemConfigSchema, ProjectAppliedResourceSchema, ProjectApplyDiagnosticSchema, ProjectApplyResponseSchema;
+var EnvironmentApplyDocumentSchema, ProfileApplyDocumentSchema, ToolApplyDocumentSchema, SessionApplyDocumentSchema, ProjectApplyResourceSchema, PROJECT_RESOURCE_KINDS, ProjectDeleteResourceSchema, AVATAR_ASSET_CONTENT_TYPES, MAX_AVATAR_ASSET_BASE64_LENGTH, ProjectApplyAssetSchema, ProjectApplyAssetsSchema, ProjectApplyRequestSchema, ProjectApplySystemConfigSchema, ProjectAppliedResourceSchema, ProjectApplyDiagnosticSchema, ProjectApplyResponseSchema;
 var init_project_resources = __esm({
   "../../packages/schemas/src/project-resources.ts"() {
     "use strict";
@@ -17655,13 +17655,14 @@ var init_project_resources = __esm({
       ToolApplyDocumentSchema,
       SessionApplyDocumentSchema
     ]);
+    PROJECT_RESOURCE_KINDS = [
+      RESOURCE_KIND_ENVIRONMENT,
+      RESOURCE_KIND_PROFILE,
+      RESOURCE_KIND_TOOL,
+      RESOURCE_KIND_SESSION
+    ];
     ProjectDeleteResourceSchema = external_exports.object({
-      kind: external_exports.enum([
-        RESOURCE_KIND_ENVIRONMENT,
-        RESOURCE_KIND_PROFILE,
-        RESOURCE_KIND_TOOL,
-        RESOURCE_KIND_SESSION
-      ]),
+      kind: external_exports.enum(PROJECT_RESOURCE_KINDS),
       name: external_exports.string().trim().min(1)
     });
     AVATAR_ASSET_CONTENT_TYPES = ["image/png", "image/jpeg"];
@@ -20373,14 +20374,25 @@ var init_client = __esm({
 // src/lib/browser.ts
 import { spawn } from "child_process";
 function openBrowser(url2) {
-  const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
-  const args = process.platform === "win32" ? ["/c", "start", "", url2] : [url2];
-  const child = spawn(command, args, {
+  const child = spawn(openCommand(), openArgs(url2), {
     detached: true,
     stdio: "ignore"
   });
   child.unref();
 }
+function openCommand() {
+  switch (process.platform) {
+    case "darwin":
+      return "open";
+    case "win32":
+      return "cmd";
+    default:
+      return "xdg-open";
+  }
+}
+function openArgs(url2) {
+  return process.platform === "win32" ? ["/c", "start", "", url2] : [url2];
+}
 var init_browser = __esm({
   "src/lib/browser.ts"() {
     "use strict";
@@ -21482,6 +21494,48 @@ var init_login = __esm({
   }
 });
 
+// src/lib/resources.ts
+function parseProjectResourceReference(resource) {
+  const [kind, name, extra] = resource.split("/");
+  if (!kind || !name || extra) {
+    throw new Error('Resource must be formatted as "kind/name"');
+  }
+  if (!PROJECT_RESOURCE_KINDS.includes(kind)) {
+    throw new Error(
+      `Unsupported resource kind "${kind}"; supported kinds are ${PROJECT_RESOURCE_KINDS.map((value) => `"${value}"`).join(", ")}`
+    );
+  }
+  return { kind, name };
+}
+async function listProjectResources2(client, kind, options) {
+  switch (kind) {
+    case RESOURCE_KIND_ENVIRONMENT:
+      return (await client.listEnvironments(options)).environments;
+    case RESOURCE_KIND_PROFILE:
+      return (await client.listProfiles(options)).profiles;
+    case RESOURCE_KIND_TOOL:
+      return (await client.listTools(options)).tools;
+    case RESOURCE_KIND_SESSION:
+      return (await client.listSessions(options)).sessions;
+  }
+}
+async function requireProjectResource(client, reference, options) {
+  const resources = await listProjectResources2(client, reference.kind, options);
+  const resource = resources.find(
+    (item) => item.metadata.name === reference.name
+  );
+  if (!resource) {
+    throw new Error(`Resource not found: ${reference.kind}/${reference.name}`);
+  }
+  return resource;
+}
+var init_resources3 = __esm({
+  "src/lib/resources.ts"() {
+    "use strict";
+    init_src();
+  }
+});
+
 // src/commands/edit/actions.ts
 import { spawn as spawn2 } from "child_process";
 import { mkdtempSync, readFileSync as readFileSync4, rmSync, writeFileSync as writeFileSync3 } from "fs";
@@ -21489,13 +21543,13 @@ import { tmpdir } from "os";
 import { join as join5 } from "path";
 import { parseAllDocuments as parseYamlDocuments2, stringify as stringify2 } from "yaml";
 async function editResource(input) {
-  const reference = parseEditableResource(input.resource);
+  const reference = parseProjectResourceReference(input.resource);
   const editor = resolveEditor({
     canFallbackToVi: input.canFallbackToVi,
     env: input.env,
     explicit: input.commandOptions.editor
   });
-  const current = await getEditableResource(input.client, reference, {
+  const current = await requireProjectResource(input.client, reference, {
     apiBaseUrl: input.commandOptions.apiBaseUrl
   });
   const document = editableResourceDocument(reference.kind, current);
@@ -21543,18 +21597,6 @@ Edited file retained at ${filePath}`);
     }
   }
 }
-function parseEditableResource(resource) {
-  const [kind, name, extra] = resource.split("/");
-  if (!kind || !name || extra) {
-    throw new Error('Resource must be formatted as "kind/name"');
-  }
-  if (!RESOURCE_KINDS3.includes(kind)) {
-    throw new Error(
-      `Unsupported resource kind "${kind}"; supported kinds are ${RESOURCE_KINDS3.map((value) => `"${value}"`).join(", ")}`
-    );
-  }
-  return { kind, name };
-}
 function resolveEditor(input) {
   const explicit = input.explicit?.trim();
   if (explicit) {
@@ -21629,44 +21671,12 @@ function editableResourceDocument(kind, resource) {
     spec: resource.spec
   };
 }
-async function getEditableResource(client, reference, options) {
-  const resources = await listEditableResources(
-    client,
-    reference.kind,
-    options
-  );
-  const resource = resources.find(
-    (item) => item.metadata.name === reference.name
-  );
-  if (!resource) {
-    throw new Error(`Resource not found: ${reference.kind}/${reference.name}`);
-  }
-  return resource;
-}
-async function listEditableResources(client, kind, options) {
-  switch (kind) {
-    case RESOURCE_KIND_ENVIRONMENT:
-      return (await client.listEnvironments(options)).environments;
-    case RESOURCE_KIND_PROFILE:
-      return (await client.listProfiles(options)).profiles;
-    case RESOURCE_KIND_TOOL:
-      return (await client.listTools(options)).tools;
-    case RESOURCE_KIND_SESSION:
-      return (await client.listSessions(options)).sessions;
-  }
-}
-var RESOURCE_KINDS3;
 var init_actions2 = __esm({
   "src/commands/edit/actions.ts"() {
     "use strict";
     init_src();
+    init_resources3();
     init_actions();
-    RESOURCE_KINDS3 = [
-      RESOURCE_KIND_ENVIRONMENT,
-      RESOURCE_KIND_PROFILE,
-      RESOURCE_KIND_TOOL,
-      RESOURCE_KIND_SESSION
-    ];
   }
 });
 
@@ -21761,7 +21771,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@autohq/cli",
-      version: "0.1.100",
+      version: "0.1.102",
       license: "SEE LICENSE IN README.md",
       publishConfig: {
         access: "public"
@@ -29221,6 +29231,66 @@ function createGithubConnectionApi(context) {
   };
 }
 
+// src/commands/connections/wait.ts
+init_browser();
+var ConnectionWaitTimeoutError = class extends Error {
+};
+async function finishConnectionAuthorization(input) {
+  const knownGrantIds = input.wait ? await activeGrantIds(input) : void 0;
+  if (input.openInBrowser) {
+    (input.openBrowser ?? openBrowser)(input.authorizationUrl);
+  }
+  if (!knownGrantIds) {
+    return void 0;
+  }
+  input.writeOutput(
+    `Waiting for the ${input.provider} authorization to complete in the browser...`
+  );
+  return waitForNewGrant(input, knownGrantIds);
+}
+var POLL_INTERVAL_MS = 2e3;
+var POLL_TIMEOUT_MS = 5 * 6e4;
+async function activeGrantIds(input) {
+  const result = await input.client.listConnections({
+    provider: input.provider,
+    apiBaseUrl: input.apiBaseUrl
+  });
+  return new Set(
+    result.connections.flatMap(
+      (connection) => connection.grants.map((grant) => grant.id)
+    )
+  );
+}
+async function waitForNewGrant(input, knownGrantIds) {
+  const sleep3 = input.sleep ?? ((ms) => new Promise((resolve2) => setTimeout(resolve2, ms)));
+  const now3 = input.now ?? Date.now;
+  const deadline = now3() + (input.pollTimeoutMs ?? POLL_TIMEOUT_MS);
+  while (now3() < deadline) {
+    await sleep3(input.pollIntervalMs ?? POLL_INTERVAL_MS);
+    const result = await input.client.listConnections({
+      provider: input.provider,
+      apiBaseUrl: input.apiBaseUrl
+    });
+    for (const connection of result.connections) {
+      for (const grant of connection.grants) {
+        if (knownGrantIds.has(grant.id)) {
+          continue;
+        }
+        input.writeOutput(
+          `connected ${input.provider} connection/${grant.name} account/${connection.externalAccount.loginOrName}`
+        );
+        return {
+          connection: grant.name,
+          account: connection.externalAccount.loginOrName
+        };
+      }
+    }
+  }
+  throw new ConnectionWaitTimeoutError(
+    `Timed out waiting for the ${input.provider} connection to complete. The authorization may still land (or may have re-authorized an existing connection); check \`auto connections list --provider ${input.provider}\`, or re-run with --no-wait to skip waiting.`
+  );
+}
+
 // src/commands/connections/github.ts
 async function connectGithub(context, commandOptions) {
   const githubApi = createGithubConnectionApi(context);
@@ -29265,17 +29335,25 @@ async function connectGithub(context, commandOptions) {
   await startGithubInstallFlow(context, commandOptions);
 }
 async function startGithubInstallFlow(context, commandOptions) {
-  const result = await createConnectionServiceClient(context).startConnection(
-    "github",
-    {
-      allowProjectId: commandOptions.allow,
-      apiBaseUrl: commandOptions.apiBaseUrl
-    }
-  );
+  const client = createConnectionServiceClient(context);
+  const result = await client.startConnection("github", {
+    allowProjectId: commandOptions.allow,
+    apiBaseUrl: commandOptions.apiBaseUrl
+  });
   context.writeOutput(result.message);
-  if (result.authorizationUrl) {
-    context.writeOutput(`authorization_url ${result.authorizationUrl}`);
+  if (!result.authorizationUrl) {
+    return;
   }
+  context.writeOutput(`authorization_url ${result.authorizationUrl}`);
+  await finishConnectionAuthorization({
+    apiBaseUrl: commandOptions.apiBaseUrl,
+    authorizationUrl: result.authorizationUrl,
+    client,
+    provider: "github",
+    openInBrowser: commandOptions.browser !== false && context.io.isTTY,
+    wait: commandOptions.wait !== false,
+    writeOutput: context.writeOutput
+  });
 }
 async function selectGithubInstallation(input) {
   if (input.selector) {
@@ -29559,27 +29637,40 @@ async function connectProviderAction(context, provider, commandOptions) {
     });
     return;
   }
+  if (commandOptions.configRefreshToken && commandOptions.wait === false) {
+    throw new Error(
+      "--config-refresh-token registers the token once the connection completes; it cannot be combined with --no-wait."
+    );
+  }
   const client = createConnectionServiceClient(context);
-  const knownGrants = commandOptions.configRefreshToken ? await slackGrantNames(client, apiBaseUrl) : void 0;
   const result = await client.startConnection(provider, {
     allowProjectId: commandOptions.allow,
     apiBaseUrl
   });
   context.writeOutput(result.message);
-  if (result.authorizationUrl) {
-    context.writeOutput(`authorization_url ${result.authorizationUrl}`);
+  if (!result.authorizationUrl) {
+    return;
   }
-  if (commandOptions.configRefreshToken && knownGrants) {
-    context.writeOutput(
-      "Waiting for the Slack connection to complete before registering the config token..."
-    );
-    const connection = await waitForNewSlackGrant(
-      client,
-      apiBaseUrl,
-      knownGrants
-    );
+  context.writeOutput(`authorization_url ${result.authorizationUrl}`);
+  const connected = await finishConnectionAuthorization({
+    apiBaseUrl,
+    authorizationUrl: result.authorizationUrl,
+    client,
+    provider,
+    openInBrowser: commandOptions.browser !== false && context.io.isTTY,
+    wait: commandOptions.wait !== false,
+    writeOutput: context.writeOutput
+  }).catch((error51) => {
+    if (error51 instanceof ConnectionWaitTimeoutError && commandOptions.configRefreshToken) {
+      throw new Error(
+        `${error51.message} Register the config token afterwards with \`auto connections config-token slack\`.`
+      );
+    }
+    throw error51;
+  });
+  if (commandOptions.configRefreshToken && connected) {
     const registered = await client.registerSlackConfigToken({
-      connection,
+      connection: connected.connection,
       refreshToken: commandOptions.configRefreshToken,
       apiBaseUrl
     });
@@ -29588,36 +29679,6 @@ async function connectProviderAction(context, provider, commandOptions) {
     );
   }
 }
-var NEW_GRANT_POLL_INTERVAL_MS = 2e3;
-var NEW_GRANT_POLL_TIMEOUT_MS = 5 * 6e4;
-async function slackGrantNames(client, apiBaseUrl) {
-  const result = await client.listConnections({
-    provider: "slack",
-    apiBaseUrl
-  });
-  return new Set(
-    result.connections.flatMap(
-      (connection) => connection.grants.map((grant) => grant.name)
-    )
-  );
-}
-async function waitForNewSlackGrant(client, apiBaseUrl, knownGrants) {
-  const deadline = Date.now() + NEW_GRANT_POLL_TIMEOUT_MS;
-  while (Date.now() < deadline) {
-    await new Promise(
-      (resolve2) => setTimeout(resolve2, NEW_GRANT_POLL_INTERVAL_MS)
-    );
-    const current = await slackGrantNames(client, apiBaseUrl);
-    for (const name of current) {
-      if (!knownGrants.has(name)) {
-        return name;
-      }
-    }
-  }
-  throw new Error(
-    "Timed out waiting for the Slack connection to complete. Register the config token afterwards with `auto connections config-token slack`."
-  );
-}
 async function registerConfigTokenAction(context, provider, commandOptions) {
   if (provider !== "slack") {
     throw new Error(
@@ -29684,21 +29745,30 @@ async function replaceConnectionAction(context, provider, commandOptions) {
       yes: commandOptions.yes
     });
   }
-  const result = await createConnectionServiceClient(context).startConnection(
-    provider,
-    {
-      allowProjectId: commandOptions.allow,
-      apiBaseUrl: apiUrlFromOptions(context, commandOptions),
-      replace: {
-        connection: commandOptions.connection,
-        removeFirst: commandOptions.removeFirst === true
-      }
+  const apiBaseUrl = apiUrlFromOptions(context, commandOptions);
+  const client = createConnectionServiceClient(context);
+  const result = await client.startConnection(provider, {
+    allowProjectId: commandOptions.allow,
+    apiBaseUrl,
+    replace: {
+      connection: commandOptions.connection,
+      removeFirst: commandOptions.removeFirst === true
     }
-  );
+  });
   context.writeOutput(result.message);
-  if (result.authorizationUrl) {
-    context.writeOutput(`authorization_url ${result.authorizationUrl}`);
+  if (!result.authorizationUrl) {
+    return;
   }
+  context.writeOutput(`authorization_url ${result.authorizationUrl}`);
+  await finishConnectionAuthorization({
+    apiBaseUrl,
+    authorizationUrl: result.authorizationUrl,
+    client,
+    provider,
+    openInBrowser: commandOptions.browser !== false && context.io.isTTY,
+    wait: commandOptions.wait !== false,
+    writeOutput: context.writeOutput
+  });
 }
 
 // src/commands/connections/commands.ts
@@ -29725,7 +29795,10 @@ function registerConnectionCommands(program, context) {
   ).option(
     "--remove-first",
     "remove the old connection before the replacement authorization completes"
-  ).option("-y, --yes", "skip confirmation prompt when using --remove-first").option("--allow <project>", "project id to allow after connecting").option("--api-url <url>", "Auto API base URL").option("--api-base-url <url>", "Auto API base URL").action(async (provider, commandOptions) => {
+  ).option("-y, --yes", "skip confirmation prompt when using --remove-first").option("--allow <project>", "project id to allow after connecting").option(
+    "--no-wait",
+    "print the authorization URL and exit without waiting for the replacement to complete"
+  ).option("--no-browser", "do not open the authorization URL in a browser").option("--api-url <url>", "Auto API base URL").option("--api-base-url <url>", "Auto API base URL").action(async (provider, commandOptions) => {
     await replaceConnectionAction(context, provider, commandOptions);
   });
   program.command("connect").description("Start a provider connection flow.").argument("<provider>", "provider name").option("--allow <project>", "project id to allow after connecting").option(
@@ -29746,7 +29819,10 @@ function registerConnectionCommands(program, context) {
   ).option(
     "--manual",
     "print the setup steps instead of the interactive wizard (telegram only)"
-  ).option("--api-url <url>", "Auto API base URL").option("--api-base-url <url>", "Auto API base URL").action(async (provider, commandOptions) => {
+  ).option(
+    "--no-wait",
+    "print the authorization URL and exit without waiting for the connection to complete"
+  ).option("--no-browser", "do not open the authorization URL in a browser").option("--api-url <url>", "Auto API base URL").option("--api-base-url <url>", "Auto API base URL").action(async (provider, commandOptions) => {
     await connectProviderAction(context, provider, commandOptions);
   });
   program.command("allow").description("Allow a project to use an existing provider connection.").argument("<provider>", "provider name").argument("<project>", "project id").option("--connection <name>", "specific connection or grant name").option("--api-url <url>", "Auto API base URL").option("--api-base-url <url>", "Auto API base URL").action(
@@ -29762,15 +29838,9 @@ function registerConnectionCommands(program, context) {
 }
 
 // src/commands/delete/actions.ts
-init_src();
-var RESOURCE_KINDS = [
-  RESOURCE_KIND_ENVIRONMENT,
-  RESOURCE_KIND_PROFILE,
-  RESOURCE_KIND_TOOL,
-  RESOURCE_KIND_SESSION
-];
+init_resources3();
 async function deleteResource(input) {
-  const request = parseDeleteResource(input.resource);
+  const request = parseProjectResourceReference(input.resource);
   const response = await input.client.deleteProjectResource(request, {
     apiBaseUrl: input.commandOptions.apiBaseUrl
   });
@@ -29782,18 +29852,6 @@ async function deleteResource(input) {
     `deleted ${response.deleted.kind}/${response.deleted.name}`
   );
 }
-function parseDeleteResource(resource) {
-  const [kind, name, extra] = resource.split("/");
-  if (!kind || !name || extra) {
-    throw new Error('Resource must be formatted as "kind/name"');
-  }
-  if (!RESOURCE_KINDS.includes(kind)) {
-    throw new Error(
-      `Unsupported resource kind "${kind}"; supported kinds are ${RESOURCE_KINDS.map((value) => `"${value}"`).join(", ")}`
-    );
-  }
-  return { kind, name };
-}
 
 // src/commands/delete/commands.ts
 function registerDeleteCommands(program, context) {
@@ -29815,55 +29873,15 @@ function registerDeleteCommands(program, context) {
 }
 
 // src/commands/describe/actions.ts
-init_src();
+init_resources3();
 import { stringify } from "yaml";
-var RESOURCE_KINDS2 = [
-  RESOURCE_KIND_ENVIRONMENT,
-  RESOURCE_KIND_PROFILE,
-  RESOURCE_KIND_TOOL,
-  RESOURCE_KIND_SESSION
-];
 async function inspectResource(input) {
-  const request = parseInspectResource(input.resource);
-  const resource = await getResource(input.client, request, {
+  const request = parseProjectResourceReference(input.resource);
+  const resource = await requireProjectResource(input.client, request, {
     apiBaseUrl: input.commandOptions.apiBaseUrl
   });
   input.writeOutput(stringify(resource.spec).trimEnd());
 }
-function parseInspectResource(resource) {
-  const [kind, name, extra] = resource.split("/");
-  if (!kind || !name || extra) {
-    throw new Error('Resource must be formatted as "kind/name"');
-  }
-  if (!RESOURCE_KINDS2.includes(kind)) {
-    throw new Error(
-      `Unsupported resource kind "${kind}"; supported kinds are ${RESOURCE_KINDS2.map((value) => `"${value}"`).join(", ")}`
-    );
-  }
-  return { kind, name };
-}
-async function getResource(client, request, options) {
-  const resources = await listResources(client, request.kind, options);
-  const resource = resources.find(
-    (item) => item.metadata.name === request.name
-  );
-  if (!resource) {
-    throw new Error(`Resource not found: ${request.kind}/${request.name}`);
-  }
-  return resource;
-}
-async function listResources(client, kind, options) {
-  switch (kind) {
-    case RESOURCE_KIND_ENVIRONMENT:
-      return (await client.listEnvironments(options)).environments;
-    case RESOURCE_KIND_PROFILE:
-      return (await client.listProfiles(options)).profiles;
-    case RESOURCE_KIND_TOOL:
-      return (await client.listTools(options)).tools;
-    case RESOURCE_KIND_SESSION:
-      return (await client.listSessions(options)).sessions;
-  }
-}
 
 // src/commands/describe/commands.ts
 function registerDescribeCommands(program, context) {
@@ -31070,7 +31088,7 @@ function formatToolsText(result, writeLine) {
   }
   for (const exchange of result.exchanges) {
     const duration4 = exchange.durationMs === null ? "-" : `${exchange.durationMs}ms`;
-    const outcome = exchange.isError === null ? "pending" : exchange.isError ? "ERR" : "ok";
+    const outcome = exchangeOutcome(exchange.isError);
     writeLine(
       `${exchange.callSequence} ${exchange.name} ${duration4} ${outcome}: ${preview(exchange.input)}`
     );
@@ -31081,6 +31099,12 @@ function formatToolsText(result, writeLine) {
     );
   }
 }
+function exchangeOutcome(isError) {
+  if (isError === null) {
+    return "pending";
+  }
+  return isError ? "ERR" : "ok";
+}
 async function handleRunsTriggers(context, runId, options = {}) {
   const client = createContextApiClient(context);
   const response = await client.listRunTriggers(runId, {
@@ -31644,8 +31668,8 @@ init_browser();
 import { existsSync as existsSync2, mkdtempSync as mkdtempSync2, writeFileSync as writeFileSync4 } from "fs";
 import { homedir as homedir3, tmpdir as tmpdir2 } from "os";
 import { join as join6 } from "path";
-var POLL_INTERVAL_MS = 2e3;
-var POLL_TIMEOUT_MS = 5 * 6e4;
+var POLL_INTERVAL_MS2 = 2e3;
+var POLL_TIMEOUT_MS2 = 5 * 6e4;
 var SLACK_APPS_URL = "https://api.slack.com/apps";
 async function connectSessionPresence2(input) {
   const options = { apiBaseUrl: input.apiBaseUrl };
@@ -31694,8 +31718,8 @@ async function connectSessionPresence2(input) {
   const sleep3 = input.sleep ?? ((ms) => new Promise((resolve2) => setTimeout(resolve2, ms)));
   const openBrowser2 = input.openBrowser ?? openBrowser;
   const now3 = input.now ?? Date.now;
-  const pollIntervalMs = input.pollIntervalMs ?? POLL_INTERVAL_MS;
-  const pollTimeoutMs = input.pollTimeoutMs ?? POLL_TIMEOUT_MS;
+  const pollIntervalMs = input.pollIntervalMs ?? POLL_INTERVAL_MS2;
+  const pollTimeoutMs = input.pollTimeoutMs ?? POLL_TIMEOUT_MS2;
   for (const pending of result.pending) {
     const telegram = Boolean(pending.suggestedUsername);
     input.writeOutput(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autohq/cli",
-  "version": "0.1.100",
+  "version": "0.1.102",
   "license": "SEE LICENSE IN README.md",
   "publishConfig": {
     "access": "public"