@autohq/cli 0.1.99 → 0.1.101

package/dist/agent-bridge.js

@@ -19809,7 +19809,7 @@ function toJsonValue(value2) {
     return null;
   }
   try {
-    return JsonValueSchema2.parse(JSON.parse(JSON.stringify(value2)));
+    return JSON.parse(JSON.stringify(value2));
   } catch {
     return String(value2);
   }

package/dist/index.js

@@ -15332,7 +15332,7 @@ function toJsonValue(value) {
     return null;
   }
   try {
-    return JsonValueSchema2.parse(JSON.parse(JSON.stringify(value)));
+    return JSON.parse(JSON.stringify(value));
   } catch {
     return String(value);
   }
@@ -21761,7 +21761,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@autohq/cli",
-      version: "0.1.99",
+      version: "0.1.101",
       license: "SEE LICENSE IN README.md",
       publishConfig: {
         access: "public"
@@ -29221,6 +29221,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 +29325,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 +29627,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 +29669,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 +29735,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 +29785,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 +29809,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(
@@ -31644,8 +31710,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 +31760,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.99",
+  "version": "0.1.101",
   "license": "SEE LICENSE IN README.md",
   "publishConfig": {
     "access": "public"