@autohq/cli 0.1.112 → 0.1.113

package/dist/agent-bridge.js

@@ -26206,7 +26206,7 @@ Object.assign(lookup, {
 // package.json
 var package_default = {
   name: "@autohq/cli",
-  version: "0.1.112",
+  version: "0.1.113",
   license: "SEE LICENSE IN README.md",
   publishConfig: {
     access: "public"

package/dist/index.js

@@ -20275,6 +20275,12 @@ function createApiClient(input) {
   }
   return {
     activeOrganization,
+    /**
+     * Resolve the active org/project selection without requiring one: env vars
+     * first, then config, then single-option discovery (which persists what it
+     * finds). Either field may be undefined when nothing resolves.
+     */
+    resolveActiveSelection,
     requestJson,
     async listPendingInvitations(options = {}) {
       const response = await bootstrapFetch(
@@ -21166,7 +21172,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@autohq/cli",
-      version: "0.1.112",
+      version: "0.1.113",
       license: "SEE LICENSE IN README.md",
       publishConfig: {
         access: "public"
@@ -29612,6 +29618,139 @@ async function confirmDestructiveAction(context, input) {
   }
 }
 
+// src/commands/context-resolution.ts
+async function requireProjectScope(input) {
+  const resolved = await resolveProjectScope(input);
+  if (resolved) {
+    return resolved;
+  }
+  throw new Error(
+    `No project selected. Run \`auto projects use <project>\` or pass ${input.explicitHint}.`
+  );
+}
+async function resolveProjectScope(input) {
+  if (input.identifier?.startsWith("proj_")) {
+    return { projectId: input.identifier, source: "explicit" };
+  }
+  if (input.identifier) {
+    const project = await resolveProject({
+      client: createContextApiClient(input.context),
+      context: input.context,
+      identifier: input.identifier,
+      options: input.options
+    });
+    return {
+      organizationId: project.organizationId,
+      projectId: project.projectId,
+      source: "explicit"
+    };
+  }
+  const selection = await createContextApiClient(
+    input.context
+  ).resolveActiveSelection();
+  if (!selection.projectId) {
+    return void 0;
+  }
+  return {
+    organizationId: selection.organizationId,
+    projectId: selection.projectId,
+    source: "active"
+  };
+}
+function withProjectScope(context, scope) {
+  return {
+    ...context,
+    env: {
+      ...context.env,
+      ...scope.organizationId ? { AUTO_ORGANIZATION_ID: scope.organizationId } : {},
+      AUTO_PROJECT_ID: scope.projectId
+    }
+  };
+}
+async function requireConnection(input) {
+  const client = createContextApiClient(input.context);
+  const response = await client.listConnections({
+    provider: input.provider,
+    apiBaseUrl: apiUrlFromOptions(input.context, input.options)
+  });
+  const grants = response.connections.flatMap(
+    (connection) => connection.grants.filter((grant) => grant.status === "active").map((grant) => ({ name: grant.name, id: grant.id }))
+  );
+  if (input.identifier) {
+    const identifier = input.identifier;
+    const matches = grants.filter(
+      (grant) => grant.name === identifier || grant.id === identifier
+    );
+    if (matches.length === 0) {
+      const inactive = response.connections.flatMap((connection) => connection.grants).find((grant) => grant.name === identifier || grant.id === identifier);
+      if (inactive) {
+        throw new Error(
+          `${input.provider} connection ${identifier} is ${inactive.status}; only active connections can be selected.`
+        );
+      }
+      throw new Error(
+        `No ${input.provider} connection found matching ${identifier}. Run \`auto connections list\` to see available connections.`
+      );
+    }
+    if (matches.length > 1) {
+      throw new Error(
+        `Multiple ${input.provider} connections match ${identifier}; use the connection id.`
+      );
+    }
+    return matches[0];
+  }
+  if (grants.length === 0) {
+    throw new Error(
+      `No ${input.provider} connections found. Run \`auto connect ${input.provider}\` first.`
+    );
+  }
+  if (grants.length > 1) {
+    const names = grants.map((grant) => grant.name).join(", ");
+    throw new Error(
+      `Multiple ${input.provider} connections found: ${names}. Re-run with --connection <name>.`
+    );
+  }
+  return grants[0];
+}
+async function resolveOrganization(input) {
+  const client = createContextApiClient(input.context);
+  const response = await client.listOrganizations({
+    apiBaseUrl: apiUrlFromOptions(input.context, input.options)
+  });
+  return resolveOne(
+    response.organizations.filter(
+      (organization) => matchesOrganization(organization, input.identifier)
+    ),
+    "organization",
+    input.identifier
+  );
+}
+async function resolveProject(input) {
+  const activeOrgId = input.client.getActiveSelection().organizationId;
+  const response = await input.client.listProjects({
+    apiBaseUrl: apiUrlFromOptions(input.context, input.options)
+  });
+  const matches = response.projects.filter(
+    (project) => matchesProject(project, input.identifier) && (!activeOrgId || project.organizationId === activeOrgId)
+  );
+  return resolveOne(matches, "project", input.identifier);
+}
+function matchesOrganization(organization, identifier) {
+  return organization.organizationId === identifier || organization.organizationSlug === identifier || organization.organizationName === identifier;
+}
+function matchesProject(project, identifier) {
+  return project.projectId === identifier || project.projectSlug === identifier || project.projectName === identifier;
+}
+function resolveOne(matches, kind, identifier) {
+  if (matches.length === 0) {
+    throw new Error(`No ${kind} found matching ${identifier}`);
+  }
+  if (matches.length > 1) {
+    throw new Error(`Multiple ${kind}s match ${identifier}; use a slug or ID`);
+  }
+  return matches[0];
+}
+
 // src/commands/connections/format.ts
 function connectionRows(connections, style) {
   const rows = connections.flatMap(
@@ -30163,8 +30302,19 @@ async function connectProviderAction(context, provider, commandOptions) {
       "--token/--stdin are only supported for the telegram provider."
     );
   }
+  const allowScope = await resolveConnectAllowProject(
+    context,
+    provider,
+    commandOptions
+  );
+  const scopedContext = allowScope ? withProjectScope(context, allowScope) : context;
+  const allowProjectId = allowScope?.projectId;
   if (provider === "github") {
-    await connectGithub(context, { ...commandOptions, apiBaseUrl });
+    await connectGithub(scopedContext, {
+      ...commandOptions,
+      allow: allowProjectId,
+      apiBaseUrl
+    });
     return;
   }
   if (provider === "telegram") {
@@ -30173,13 +30323,13 @@ async function connectProviderAction(context, provider, commandOptions) {
     }
     await connectTelegramFlow({
       apiBaseUrl,
-      client: createConnectionServiceClient(context),
+      client: createConnectionServiceClient(scopedContext),
       writeOutput: context.writeOutput,
       prompt: cliTelegramWizardPrompter(context),
       token: commandOptions.token ?? (commandOptions.stdin ? await readTrimmedStream(context.stdin) : void 0),
       name: commandOptions.name,
       validateOnly: commandOptions.validateOnly,
-      allowProjectId: commandOptions.allow,
+      allowProjectId,
       manual: commandOptions.manual
     });
     return;
@@ -30189,9 +30339,9 @@ async function connectProviderAction(context, provider, commandOptions) {
       "--config-refresh-token registers the token once the connection completes; it cannot be combined with --no-wait."
     );
   }
-  const client = createConnectionServiceClient(context);
+  const client = createConnectionServiceClient(scopedContext);
   const result = await client.startConnection(provider, {
-    allowProjectId: commandOptions.allow,
+    allowProjectId,
     apiBaseUrl
   });
   const style = context.io.style;
@@ -30263,6 +30413,23 @@ async function registerConfigTokenAction(context, provider, commandOptions) {
     `${style.label("expires_at")} ${style.dim(result.expiresAt)}`
   );
 }
+async function resolveConnectAllowProject(context, provider, commandOptions) {
+  const scopeInput = {
+    context,
+    options: commandOptions,
+    identifier: commandOptions.allow,
+    explicitHint: "--allow <project>"
+  };
+  const resolved = provider === "github" ? await requireProjectScope(scopeInput) : await resolveProjectScope(scopeInput);
+  if (resolved && resolved.source === "active") {
+    context.writeOutput(
+      context.io.style.dim(
+        `Allowing active project ${resolved.projectId} once the connection completes.`
+      )
+    );
+  }
+  return resolved;
+}
 async function readTrimmedStream(stream) {
   const chunks = [];
   for await (const chunk of stream) {
@@ -30270,25 +30437,42 @@ async function readTrimmedStream(stream) {
   }
   return Buffer.concat(chunks).toString("utf8").trim();
 }
-async function allowConnectionAction(context, provider, projectId, commandOptions) {
-  const result = await createConnectionServiceClient(context).allowConnection(
+async function allowConnectionAction(context, provider, projectIdentifier, commandOptions) {
+  const project = await requireProjectScope({
+    context,
+    options: commandOptions,
+    identifier: projectIdentifier,
+    explicitHint: "a <project> argument"
+  });
+  const scopedContext = withProjectScope(context, project);
+  const connection = await requireConnection({
+    context: scopedContext,
+    options: commandOptions,
     provider,
-    projectId,
-    {
-      connection: commandOptions.connection,
-      apiBaseUrl: apiUrlFromOptions(context, commandOptions)
-    }
-  );
+    identifier: commandOptions.connection
+  });
+  const result = await createConnectionServiceClient(
+    scopedContext
+  ).allowConnection(provider, project.projectId, {
+    connection: connection.name,
+    apiBaseUrl: apiUrlFromOptions(context, commandOptions)
+  });
   context.writeOutput(result.message);
 }
 async function removeConnectionAction(context, provider, commandOptions) {
+  const connection = await requireConnection({
+    context,
+    options: commandOptions,
+    provider,
+    identifier: commandOptions.connection
+  });
   await confirmDestructiveAction(context, {
-    message: `This will remove "${provider}" connection "${commandOptions.connection}".`,
+    message: `This will remove "${provider}" connection "${connection.name}".`,
     yes: commandOptions.yes
   });
   const result = await createConnectionServiceClient(context).removeConnection(
     provider,
-    commandOptions.connection,
+    connection.name,
     {
       apiBaseUrl: apiUrlFromOptions(context, commandOptions)
     }
@@ -30296,19 +30480,32 @@ async function removeConnectionAction(context, provider, commandOptions) {
   context.writeOutput(result.message);
 }
 async function replaceConnectionAction(context, provider, commandOptions) {
+  const connection = await requireConnection({
+    context,
+    options: commandOptions,
+    provider,
+    identifier: commandOptions.connection
+  });
   if (commandOptions.removeFirst) {
     await confirmDestructiveAction(context, {
-      message: `This will remove "${provider}" connection "${commandOptions.connection}" before replacement authorization completes.`,
+      message: `This will remove "${provider}" connection "${connection.name}" before replacement authorization completes.`,
       yes: commandOptions.yes
     });
   }
+  const allowScope = commandOptions.allow ? await requireProjectScope({
+    context,
+    options: commandOptions,
+    identifier: commandOptions.allow,
+    explicitHint: "--allow <project>"
+  }) : void 0;
+  const scopedContext = allowScope ? withProjectScope(context, allowScope) : context;
   const apiBaseUrl = apiUrlFromOptions(context, commandOptions);
-  const client = createConnectionServiceClient(context);
+  const client = createConnectionServiceClient(scopedContext);
   const result = await client.startConnection(provider, {
-    allowProjectId: commandOptions.allow,
+    allowProjectId: allowScope?.projectId,
     apiBaseUrl,
     replace: {
-      connection: commandOptions.connection,
+      connection: connection.name,
       removeFirst: commandOptions.removeFirst === true
     }
   });
@@ -30338,7 +30535,10 @@ function registerConnectionCommands(program, context) {
   connections.command("list").alias("ls").description("List provider connections.").option("--available", "list available providers instead of connections").option("--provider <provider>", "provider name").option("--api-url <url>", "Auto API base URL").option("--api-base-url <url>", "Auto API base URL").action(async (commandOptions) => {
     await listConnectionsAction(context, commandOptions);
   });
-  connections.command("remove").description("Remove an existing provider connection.").argument("<provider>", "provider name").requiredOption("--connection <name>", "connection or grant name to remove").option("-y, --yes", "skip confirmation prompt").option("--api-url <url>", "Auto API base URL").option("--api-base-url <url>", "Auto API base URL").action(async (provider, commandOptions) => {
+  connections.command("remove").description("Remove an existing provider connection.").argument("<provider>", "provider name").option(
+    "--connection <name>",
+    "connection name or id to remove; defaults to the provider's only connection"
+  ).option("-y, --yes", "skip confirmation prompt").option("--api-url <url>", "Auto API base URL").option("--api-base-url <url>", "Auto API base URL").action(async (provider, commandOptions) => {
     await removeConnectionAction(context, provider, commandOptions);
   });
   connections.command("config-token").description(
@@ -30350,19 +30550,25 @@ function registerConnectionCommands(program, context) {
   );
   connections.command("replace").description(
     "Start a replacement flow for an existing provider connection."
-  ).argument("<provider>", "provider name").requiredOption(
+  ).argument("<provider>", "provider name").option(
     "--connection <name>",
-    "connection or grant name to replace"
+    "connection name or id to replace; defaults to the provider's only connection"
   ).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(
+  ).option("-y, --yes", "skip confirmation prompt when using --remove-first").option(
+    "--allow <project>",
+    "project (id, slug, or name) 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(
+  program.command("connect").description("Start a provider connection flow.").argument("<provider>", "provider name").option(
+    "--allow <project>",
+    "project (id, slug, or name) to allow after connecting; defaults to the active project"
+  ).option(
     "--installation <account-or-id>",
     "existing GitHub installation account or id to connect"
   ).option(
@@ -30386,14 +30592,15 @@ function registerConnectionCommands(program, context) {
   ).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(
-    async (provider, projectId, commandOptions) => {
-      await allowConnectionAction(
-        context,
-        provider,
-        projectId,
-        commandOptions
-      );
+  program.command("allow").description("Allow a project to use an existing provider connection.").argument("<provider>", "provider name").argument(
+    "[project]",
+    "project id, slug, or name; defaults to the active project"
+  ).option(
+    "--connection <name>",
+    "connection name or id; defaults to the provider's only connection"
+  ).option("--api-url <url>", "Auto API base URL").option("--api-base-url <url>", "Auto API base URL").action(
+    async (provider, project, commandOptions) => {
+      await allowConnectionAction(context, provider, project, commandOptions);
     }
   );
 }
@@ -30479,7 +30686,6 @@ function registerEditCommands(program, context) {
 
 // src/commands/project-directory.ts
 init_active_project();
-init_file();
 function createDirectoryClient(context) {
   return createContextApiClient(context);
 }
@@ -30501,44 +30707,6 @@ function setActiveOrganization(context, organizationId) {
 function setActiveProject(context, project) {
   persistActiveProject(context.configPath, project);
 }
-async function resolveOrganization(input) {
-  const client = createDirectoryClient(input.context);
-  const response = await client.listOrganizations({
-    apiBaseUrl: apiUrlFromOptions(input.context, input.options)
-  });
-  return resolveOne(
-    response.organizations.filter(
-      (organization) => matchesOrganization(organization, input.identifier)
-    ),
-    "organization",
-    input.identifier
-  );
-}
-async function resolveProject(input) {
-  const activeOrgId = readConfig(input.context.configPath).organizationId;
-  const response = await input.client.listProjects({
-    apiBaseUrl: apiUrlFromOptions(input.context, input.options)
-  });
-  const matches = response.projects.filter(
-    (project) => matchesProject(project, input.identifier) && (!activeOrgId || project.organizationId === activeOrgId)
-  );
-  return resolveOne(matches, "project", input.identifier);
-}
-function matchesOrganization(organization, identifier) {
-  return organization.organizationId === identifier || organization.organizationSlug === identifier || organization.organizationName === identifier;
-}
-function matchesProject(project, identifier) {
-  return project.projectId === identifier || project.projectSlug === identifier || project.projectName === identifier;
-}
-function resolveOne(matches, kind, identifier) {
-  if (matches.length === 0) {
-    throw new Error(`No ${kind} found matching ${identifier}`);
-  }
-  if (matches.length > 1) {
-    throw new Error(`Multiple ${kind}s match ${identifier}; use a slug or ID`);
-  }
-  return matches[0];
-}
 
 // src/commands/invitations/commands.ts
 function registerInvitationCommands(program, context) {
@@ -32081,7 +32249,7 @@ async function setSecret(input) {
     input.name,
     { value },
     {
-      projectId: input.commandOptions.project,
+      projectId: await secretProjectId(input),
       apiBaseUrl: input.commandOptions.apiBaseUrl
     }
   );
@@ -32089,7 +32257,7 @@ async function setSecret(input) {
 }
 async function listSecrets(input) {
   const response = await input.client.listSecrets({
-    projectId: input.commandOptions.project,
+    projectId: await secretProjectId(input),
     apiBaseUrl: input.commandOptions.apiBaseUrl
   });
   if (input.commandOptions.json) {
@@ -32112,11 +32280,23 @@ async function removeSecret(input) {
     yes: input.commandOptions.yes
   });
   const response = await input.client.removeSecret(input.name, {
-    projectId: input.commandOptions.project,
+    projectId: await secretProjectId(input),
     apiBaseUrl: input.commandOptions.apiBaseUrl
   });
   writeRemoveResponse(response, input);
 }
+async function secretProjectId(input) {
+  if (!input.commandOptions.project) {
+    return void 0;
+  }
+  const scope = await requireProjectScope({
+    context: input.context,
+    options: input.commandOptions,
+    identifier: input.commandOptions.project,
+    explicitHint: "--project <project>"
+  });
+  return scope.projectId;
+}
 async function secretValue(input) {
   const sources = [
     input.options.stdin ? "stdin" : void 0,

package/package.json

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